init

mc_test/node_modules/zustand/ts3.4/esm/context.d.ts

@@ -0,0 +1,25 @@
+import ReactExports from 'react';
+import { ReactNode } from 'react';
+import { StoreApi } from 'zustand';
+type UseContextStore<S extends StoreApi<unknown>> = {
+    (): ExtractState<S>;
+    <U>(selector: (state: ExtractState<S>) => U, equalityFn?: (a: U, b: U) => boolean): U;
+};
+type ExtractState<S> = S extends {
+    getState: () => infer T;
+} ? T : never;
+type WithoutCallSignature<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * @deprecated Use `createStore` and `useStore` for context usage
+ */
+declare function createContext<S extends StoreApi<unknown>>(): {
+    Provider: ({ createStore, children, }: {
+        createStore: () => S;
+        children: ReactNode;
+    }) => ReactExports.FunctionComponentElement<ReactExports.ProviderProps<S | undefined>>;
+    useStore: UseContextStore<S>;
+    useStoreApi: () => WithoutCallSignature<S>;
+};
+export default createContext;

mc_test/node_modules/zustand/ts3.4/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './vanilla';
+export * from './react';
+export { default } from './react';

mc_test/node_modules/zustand/ts3.4/esm/middleware.d.ts

@@ -0,0 +1,5 @@
+export * from './middleware/redux';
+export * from './middleware/devtools';
+export * from './middleware/subscribeWithSelector';
+export * from './middleware/combine';
+export * from './middleware/persist';

mc_test/node_modules/zustand/ts3.4/esm/middleware/combine.d.ts

@@ -0,0 +1,13 @@
+import { StateCreator, StoreMutatorIdentifier } from '../vanilla';
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type Combine = <T extends object, U extends object, Mps extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mcs extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+]>(initialState: T, additionalStateCreator: StateCreator<T, Mps, Mcs, U>) => StateCreator<Write<T, U>, Mps, Mcs>;
+export declare const combine: Combine;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/middleware/devtools.d.ts

@@ -0,0 +1,102 @@
+import { StateCreator, StoreApi, StoreMutatorIdentifier } from '../vanilla';
+type Config = Parameters<(Window extends {
+    __REDUX_DEVTOOLS_EXTENSION__?: infer T;
+} ? T : {
+    connect: (param: any) => any;
+})['connect']>[0];
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        'zustand/devtools': WithDevtools<S>;
+    }
+}
+type Cast<T, U> = T extends U ? T : U;
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type TakeTwo<T> = T extends {
+    length: 0;
+} ? [
+    undefined,
+    undefined
+] : T extends {
+    length: 1;
+} ? [
+    /*a0*/ ...Cast<T, unknown[]>,
+    /*a1*/ undefined
+] : T extends {
+    length: 0 | 1;
+} ? [
+    /*a0*/ ...Cast<T, unknown[]>,
+    /*a1*/ undefined
+] : T extends {
+    length: 2;
+} ? T : T extends {
+    length: 1 | 2;
+} ? T : T extends {
+    length: 0 | 1 | 2;
+} ? T : T extends [
+    infer A0,
+    infer A1,
+    ...unknown[]
+] ? [
+    A0,
+    A1
+] : T extends [
+    infer A0,
+    (infer A1)?,
+    ...unknown[]
+] ? [
+    A0,
+    A1?
+] : T extends [
+    (infer A0)?,
+    (infer A1)?,
+    ...unknown[]
+] ? [
+    A0?,
+    A1?
+] : never;
+type WithDevtools<S> = Write<S, StoreDevtools<S>>;
+type StoreDevtools<S> = S extends {
+    setState: (...a: infer Sa) => infer Sr;
+} ? {
+    setState<A extends string | {
+        type: string;
+    }>(...a: [
+        /*a*/ ...TakeTwo<Sa>,
+        /*action*/ A
+    ]): Sr;
+} : never;
+export interface DevtoolsOptions extends Config {
+    name?: string;
+    enabled?: boolean;
+    anonymousActionType?: string;
+    store?: string;
+}
+type Devtools = <T, Mps extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mcs extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+]>(initializer: StateCreator<T, [
+    ...Mps,
+    [
+        'zustand/devtools',
+        never
+    ]
+], Mcs>, devtoolsOptions?: DevtoolsOptions) => StateCreator<T, Mps, [
+    [
+        'zustand/devtools',
+        never
+    ],
+    ...Mcs
+]>;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        'zustand/devtools': WithDevtools<S>;
+    }
+}
+export type NamedSet<T> = WithDevtools<StoreApi<T>>['setState'];
+export declare const devtools: Devtools;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/middleware/immer.d.ts

@@ -0,0 +1,60 @@
+import { Draft } from 'immer';
+import { StateCreator, StoreMutatorIdentifier } from '../vanilla';
+type Immer = <T, Mps extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mcs extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+]>(initializer: StateCreator<T, [
+    ...Mps,
+    [
+        'zustand/immer',
+        never
+    ]
+], Mcs>) => StateCreator<T, Mps, [
+    [
+        'zustand/immer',
+        never
+    ],
+    ...Mcs
+]>;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        ['zustand/immer']: WithImmer<S>;
+    }
+}
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type SkipTwo<T> = T extends {
+    length: 0;
+} ? [
+] : T extends {
+    length: 1;
+} ? [
+] : T extends {
+    length: 0 | 1;
+} ? [
+] : T extends [
+    unknown,
+    unknown,
+    ...infer A
+] ? A : T extends [
+    unknown,
+    unknown?,
+    ...infer A
+] ? A : T extends [
+    unknown?,
+    unknown?,
+    ...infer A
+] ? A : never;
+type WithImmer<S> = Write<S, StoreImmer<S>>;
+type StoreImmer<S> = S extends {
+    getState: () => infer T;
+    setState: infer SetState;
+} ? SetState extends (...a: infer A) => infer Sr ? {
+    setState(nextStateOrUpdater: T | Partial<T> | ((state: Draft<T>) => void), shouldReplace?: boolean | undefined, ...a: SkipTwo<A>): Sr;
+} : never : never;
+export declare const immer: Immer;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/middleware/persist.d.ts

@@ -0,0 +1,139 @@
+import { StateCreator, StoreMutatorIdentifier } from '../vanilla';
+export interface StateStorage {
+    getItem: (name: string) => string | null | Promise<string | null>;
+    setItem: (name: string, value: string) => unknown | Promise<unknown>;
+    removeItem: (name: string) => unknown | Promise<unknown>;
+}
+export type StorageValue<S> = {
+    state: S;
+    version?: number;
+};
+export interface PersistStorage<S> {
+    getItem: (name: string) => StorageValue<S> | null | Promise<StorageValue<S> | null>;
+    setItem: (name: string, value: StorageValue<S>) => unknown | Promise<unknown>;
+    removeItem: (name: string) => unknown | Promise<unknown>;
+}
+type JsonStorageOptions = {
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare function createJSONStorage<S>(getStorage: () => StateStorage, options?: JsonStorageOptions): PersistStorage<S> | undefined;
+export interface PersistOptions<S, PersistedState = S> {
+    /** Name of the storage (must be unique) */
+    name: string;
+    /**
+     * @deprecated Use `storage` instead.
+     * A function returning a storage.
+     * The storage must fit `window.localStorage`'s api (or an async version of it).
+     * For example the storage could be `AsyncStorage` from React Native.
+     *
+     * @default () => localStorage
+     */
+    getStorage?: () => StateStorage;
+    /**
+     * @deprecated Use `storage` instead.
+     * Use a custom serializer.
+     * The returned string will be stored in the storage.
+     *
+     * @default JSON.stringify
+     */
+    serialize?: (state: StorageValue<S>) => string | Promise<string>;
+    /**
+     * @deprecated Use `storage` instead.
+     * Use a custom deserializer.
+     * Must return an object matching StorageValue<S>
+     *
+     * @param str The storage's current value.
+     * @default JSON.parse
+     */
+    deserialize?: (str: string) => StorageValue<PersistedState> | Promise<StorageValue<PersistedState>>;
+    /**
+     * Use a custom persist storage.
+     *
+     * Combining `createJSONStorage` helps creating a persist storage
+     * with JSON.parse and JSON.stringify.
+     *
+     * @default createJSONStorage(() => localStorage)
+     */
+    storage?: PersistStorage<PersistedState> | undefined;
+    /**
+     * Filter the persisted value.
+     *
+     * @params state The state's value
+     */
+    partialize?: (state: S) => PersistedState;
+    /**
+     * A function returning another (optional) function.
+     * The main function will be called before the state rehydration.
+     * The returned function will be called after the state rehydration or when an error occurred.
+     */
+    onRehydrateStorage?: (state: S) => ((state?: S, error?: unknown) => void) | void;
+    /**
+     * If the stored state's version mismatch the one specified here, the storage will not be used.
+     * This is useful when adding a breaking change to your store.
+     */
+    version?: number;
+    /**
+     * A function to perform persisted state migration.
+     * This function will be called when persisted state versions mismatch with the one specified here.
+     */
+    migrate?: (persistedState: unknown, version: number) => PersistedState | Promise<PersistedState>;
+    /**
+     * A function to perform custom hydration merges when combining the stored state with the current one.
+     * By default, this function does a shallow merge.
+     */
+    merge?: (persistedState: unknown, currentState: S) => S;
+    /**
+     * An optional boolean that will prevent the persist middleware from triggering hydration on initialization,
+     * This allows you to call `rehydrate()` at a specific point in your apps rendering life-cycle.
+     *
+     * This is useful in SSR application.
+     *
+     * @default false
+     */
+    skipHydration?: boolean;
+}
+type PersistListener<S> = (state: S) => void;
+type StorePersist<S, Ps> = {
+    persist: {
+        setOptions: (options: Partial<PersistOptions<S, Ps>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: PersistListener<S>) => () => void;
+        onFinishHydration: (fn: PersistListener<S>) => () => void;
+        getOptions: () => Partial<PersistOptions<S, Ps>>;
+    };
+};
+type Persist = <T, Mps extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mcs extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], U = T>(initializer: StateCreator<T, [
+    ...Mps,
+    [
+        'zustand/persist',
+        unknown
+    ]
+], Mcs>, options: PersistOptions<T, U>) => StateCreator<T, Mps, [
+    [
+        'zustand/persist',
+        U
+    ],
+    ...Mcs
+]>;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        'zustand/persist': WithPersist<S, A>;
+    }
+}
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type WithPersist<S, A> = S extends {
+    getState: () => infer T;
+} ? Write<S, StorePersist<T, A>> : never;
+export declare const persist: Persist;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/middleware/redux.d.ts

@@ -0,0 +1,30 @@
+import { StateCreator, StoreMutatorIdentifier } from '../vanilla';
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type Action = {
+    type: string;
+};
+type StoreRedux<A> = {
+    dispatch: (a: A) => A;
+    dispatchFromDevtools: true;
+};
+type ReduxState<A> = {
+    dispatch: StoreRedux<A>['dispatch'];
+};
+type WithRedux<S, A> = Write<S, StoreRedux<A>>;
+type Redux = <T, A extends Action, Cms extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+]>(reducer: (state: T, action: A) => T, initialState: T) => StateCreator<Write<T, ReduxState<A>>, Cms, [
+    [
+        'zustand/redux',
+        A
+    ]
+]>;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        'zustand/redux': WithRedux<S, A>;
+    }
+}
+export declare const redux: Redux;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/middleware/subscribeWithSelector.d.ts

@@ -0,0 +1,42 @@
+import { StateCreator, StoreMutatorIdentifier } from '../vanilla';
+type SubscribeWithSelector = <T, Mps extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mcs extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+]>(initializer: StateCreator<T, [
+    ...Mps,
+    [
+        'zustand/subscribeWithSelector',
+        never
+    ]
+], Mcs>) => StateCreator<T, Mps, [
+    [
+        'zustand/subscribeWithSelector',
+        never
+    ],
+    ...Mcs
+]>;
+type Write<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type WithSelectorSubscribe<S> = S extends {
+    getState: () => infer T;
+} ? Write<S, StoreSubscribeWithSelector<T>> : never;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        ['zustand/subscribeWithSelector']: WithSelectorSubscribe<S>;
+    }
+}
+type StoreSubscribeWithSelector<T> = {
+    subscribe: {
+        (listener: (selectedState: T, previousSelectedState: T) => void): () => void;
+        <U>(selector: (state: T) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: (a: U, b: U) => boolean;
+            fireImmediately?: boolean;
+        }): () => void;
+    };
+};
+export declare const subscribeWithSelector: SubscribeWithSelector;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/react.d.ts

@@ -0,0 +1,48 @@
+import { Mutate, StateCreator, StoreApi, StoreMutatorIdentifier } from './vanilla';
+type ExtractState<S> = S extends {
+    getState: () => infer T;
+} ? T : never;
+type ReadonlyStoreApi<T> = Pick<StoreApi<T>, 'getState' | 'getInitialState' | 'subscribe'>;
+type WithReact<S extends ReadonlyStoreApi<unknown>> = S & {
+    /** @deprecated please use api.getInitialState() */
+    getServerState?: () => ExtractState<S>;
+};
+export declare function useStore<S extends WithReact<ReadonlyStoreApi<unknown>>>(api: S): ExtractState<S>;
+export declare function useStore<S extends WithReact<ReadonlyStoreApi<unknown>>, U>(api: S, selector: (state: ExtractState<S>) => U): U;
+/**
+ * @deprecated The usage with three arguments is deprecated. Use `useStoreWithEqualityFn` from 'zustand/traditional'. The usage with one or two arguments is not deprecated.
+ * https://github.com/pmndrs/zustand/discussions/1937
+ */
+export declare function useStore<S extends WithReact<ReadonlyStoreApi<unknown>>, U>(api: S, selector: (state: ExtractState<S>) => U, equalityFn: ((a: U, b: U) => boolean) | undefined): U;
+export type UseBoundStore<S extends WithReact<ReadonlyStoreApi<unknown>>> = {
+    (): ExtractState<S>;
+    <U>(selector: (state: ExtractState<S>) => U): U;
+    /**
+     * @deprecated Use `createWithEqualityFn` from 'zustand/traditional'
+     */
+    <U>(selector: (state: ExtractState<S>) => U, equalityFn: (a: U, b: U) => boolean): U;
+} & S;
+type Create = {
+    <T, Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>): UseBoundStore<Mutate<StoreApi<T>, Mos>>;
+    <T>(): <Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>) => UseBoundStore<Mutate<StoreApi<T>, Mos>>;
+    /**
+     * @deprecated Use `useStore` hook to bind store
+     */
+    <S extends StoreApi<unknown>>(store: S): UseBoundStore<S>;
+};
+export declare const create: Create;
+/**
+ * @deprecated Use `import { create } from 'zustand'`
+ */
+declare const _default: Create;
+export default _default;

mc_test/node_modules/zustand/ts3.4/esm/react/shallow.d.ts

@@ -0,0 +1 @@
+export declare function useShallow<S, U>(selector: (state: S) => U): (state: S) => U;

mc_test/node_modules/zustand/ts3.4/esm/shallow.d.ts

@@ -0,0 +1,7 @@
+import { shallow } from './vanilla/shallow';
+/**
+ * @deprecated Use `import { shallow } from 'zustand/shallow'`
+ */
+declare const _default: typeof shallow;
+export default _default;
+export { shallow };

mc_test/node_modules/zustand/ts3.4/esm/traditional.d.ts

@@ -0,0 +1,31 @@
+import { Mutate, StateCreator, StoreApi, StoreMutatorIdentifier } from './vanilla';
+type ExtractState<S> = S extends {
+    getState: () => infer T;
+} ? T : never;
+type ReadonlyStoreApi<T> = Pick<StoreApi<T>, 'getState' | 'getInitialState' | 'subscribe'>;
+type WithReact<S extends ReadonlyStoreApi<unknown>> = S & {
+    /** @deprecated please use api.getInitialState() */
+    getServerState?: () => ExtractState<S>;
+};
+export declare function useStoreWithEqualityFn<S extends WithReact<ReadonlyStoreApi<unknown>>>(api: S): ExtractState<S>;
+export declare function useStoreWithEqualityFn<S extends WithReact<ReadonlyStoreApi<unknown>>, U>(api: S, selector: (state: ExtractState<S>) => U, equalityFn?: (a: U, b: U) => boolean): U;
+export type UseBoundStoreWithEqualityFn<S extends WithReact<ReadonlyStoreApi<unknown>>> = {
+    (): ExtractState<S>;
+    <U>(selector: (state: ExtractState<S>) => U, equalityFn?: (a: U, b: U) => boolean): U;
+} & S;
+type CreateWithEqualityFn = {
+    <T, Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>, defaultEqualityFn?: <U>(a: U, b: U) => boolean): UseBoundStoreWithEqualityFn<Mutate<StoreApi<T>, Mos>>;
+    <T>(): <Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>, defaultEqualityFn?: <U>(a: U, b: U) => boolean) => UseBoundStoreWithEqualityFn<Mutate<StoreApi<T>, Mos>>;
+};
+export declare const createWithEqualityFn: CreateWithEqualityFn;
+export {};

mc_test/node_modules/zustand/ts3.4/esm/vanilla.d.ts

@@ -0,0 +1,106 @@
+type SetStateInternal<T> = {
+    _(partial: T | Partial<T> | {
+        _(state: T): T | Partial<T>;
+    }['_'], replace?: boolean | undefined): void;
+}['_'];
+export interface StoreApi<T> {
+    setState: SetStateInternal<T>;
+    getState: () => T;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    /**
+     * @deprecated Use `unsubscribe` returned by `subscribe`
+     */
+    destroy: () => void;
+}
+type Get<T, K, F> = K extends keyof T ? T[K] : F;
+export type Mutate<S, Ms> = number extends Ms['length' & keyof Ms] ? S : Ms extends [
+] ? S : Ms extends [
+    [
+        infer Mi,
+        infer Ma
+    ],
+    ...infer Mrs
+] ? Mutate<StoreMutators<S, Ma>[Mi & StoreMutatorIdentifier], Mrs> : never;
+export type StateCreator<T, Mis extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], Mos extends [
+    StoreMutatorIdentifier,
+    unknown
+][] = [
+], U = T> = ((setState: Get<Mutate<StoreApi<T>, Mis>, 'setState', never>, getState: Get<Mutate<StoreApi<T>, Mis>, 'getState', never>, store: Mutate<StoreApi<T>, Mis>) => U) & {
+    $$storeMutators?: Mos;
+};
+export interface StoreMutators<S, A> {
+}
+export type StoreMutatorIdentifier = keyof StoreMutators<unknown, unknown>;
+type CreateStore = {
+    <T, Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>): Mutate<StoreApi<T>, Mos>;
+    <T>(): <Mos extends [
+        StoreMutatorIdentifier,
+        unknown
+    ][] = [
+    ]>(initializer: StateCreator<T, [
+    ], Mos>) => Mutate<StoreApi<T>, Mos>;
+};
+export declare const createStore: CreateStore;
+/**
+ * @deprecated Use `import { createStore } from 'zustand/vanilla'`
+ */
+declare const _default: CreateStore;
+export default _default;
+/**
+ * @deprecated Use `unknown` instead of `State`
+ */
+export type State = unknown;
+/**
+ * @deprecated Use `Partial<T> | ((s: T) => Partial<T>)` instead of `PartialState<T>`
+ */
+export type PartialState<T extends State> = Partial<T> | ((state: T) => Partial<T>);
+/**
+ * @deprecated Use `(s: T) => U` instead of `StateSelector<T, U>`
+ */
+export type StateSelector<T extends State, U> = (state: T) => U;
+/**
+ * @deprecated Use `(a: T, b: T) => boolean` instead of `EqualityChecker<T>`
+ */
+export type EqualityChecker<T> = (state: T, newState: T) => boolean;
+/**
+ * @deprecated Use `(state: T, previousState: T) => void` instead of `StateListener<T>`
+ */
+export type StateListener<T> = (state: T, previousState: T) => void;
+/**
+ * @deprecated Use `(slice: T, previousSlice: T) => void` instead of `StateSliceListener<T>`.
+ */
+export type StateSliceListener<T> = (slice: T, previousSlice: T) => void;
+/**
+ * @deprecated Use `(listener: (state: T) => void) => void` instead of `Subscribe<T>`.
+ */
+export type Subscribe<T extends State> = {
+    (listener: (state: T, previousState: T) => void): () => void;
+};
+/**
+ * @deprecated You might be looking for `StateCreator`, if not then
+ * use `StoreApi<T>['setState']` instead of `SetState<T>`.
+ */
+export type SetState<T extends State> = {
+    _(partial: T | Partial<T> | {
+        _(state: T): T | Partial<T>;
+    }['_'], replace?: boolean | undefined): void;
+}['_'];
+/**
+ * @deprecated You might be looking for `StateCreator`, if not then
+ * use `StoreApi<T>['getState']` instead of `GetState<T>`.
+ */
+export type GetState<T extends State> = () => T;
+/**
+ * @deprecated Use `StoreApi<T>['destroy']` instead of `Destroy`.
+ */
+export type Destroy = () => void;

mc_test/node_modules/zustand/ts3.4/esm/vanilla/shallow.d.ts

@@ -0,0 +1 @@
+export declare function shallow<T>(objA: T, objB: T): boolean;