byterover-cli 3.10.0 → 3.10.2

package/node_modules/zustand/esm/react.mjs

@@ -0,0 +1,22 @@
+import React from 'react';
+import { createStore } from 'zustand/vanilla';
+
+const identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = React.useSyncExternalStore(
+    api.subscribe,
+    React.useCallback(() => selector(api.getState()), [api, selector]),
+    React.useCallback(() => selector(api.getInitialState()), [api, selector])
+  );
+  React.useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = ((createState) => createState ? createImpl(createState) : createImpl);
+
+export { create, useStore };

package/node_modules/zustand/esm/shallow.d.mts

@@ -0,0 +1,2 @@
+export { shallow } from 'zustand/vanilla/shallow';
+export { useShallow } from 'zustand/react/shallow';

package/node_modules/zustand/esm/shallow.mjs

@@ -0,0 +1,2 @@
+export { shallow } from 'zustand/vanilla/shallow';
+export { useShallow } from 'zustand/react/shallow';

package/node_modules/zustand/esm/traditional.d.mts

@@ -0,0 +1,14 @@
+import type { ExtractState, Mutate, StateCreator, StoreApi, StoreMutatorIdentifier } from 'zustand/vanilla';
+type ReadonlyStoreApi<T> = Pick<StoreApi<T>, 'getState' | 'getInitialState' | 'subscribe'>;
+export declare function useStoreWithEqualityFn<S extends ReadonlyStoreApi<unknown>>(api: S): ExtractState<S>;
+export declare function useStoreWithEqualityFn<S extends ReadonlyStoreApi<unknown>, U>(api: S, selector: (state: ExtractState<S>) => U, equalityFn?: (a: U, b: U) => boolean): U;
+export type UseBoundStoreWithEqualityFn<S extends 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 {};

package/node_modules/zustand/esm/traditional.mjs

@@ -0,0 +1,26 @@
+import React from 'react';
+import useSyncExternalStoreExports from 'use-sync-external-store/shim/with-selector.js';
+import { createStore } from 'zustand/vanilla';
+
+const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports;
+const identity = (arg) => arg;
+function useStoreWithEqualityFn(api, selector = identity, equalityFn) {
+  const slice = useSyncExternalStoreWithSelector(
+    api.subscribe,
+    api.getState,
+    api.getInitialState,
+    selector,
+    equalityFn
+  );
+  React.useDebugValue(slice);
+  return slice;
+}
+const createWithEqualityFnImpl = (createState, defaultEqualityFn) => {
+  const api = createStore(createState);
+  const useBoundStoreWithEqualityFn = (selector, equalityFn = defaultEqualityFn) => useStoreWithEqualityFn(api, selector, equalityFn);
+  Object.assign(useBoundStoreWithEqualityFn, api);
+  return useBoundStoreWithEqualityFn;
+};
+const createWithEqualityFn = ((createState, defaultEqualityFn) => createState ? createWithEqualityFnImpl(createState, defaultEqualityFn) : createWithEqualityFnImpl);
+
+export { createWithEqualityFn, useStoreWithEqualityFn };

package/node_modules/zustand/esm/vanilla/shallow.d.mts

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

package/node_modules/zustand/esm/vanilla/shallow.mjs

@@ -0,0 +1,55 @@
+const isIterable = (obj) => Symbol.iterator in obj;
+const hasIterableEntries = (value) => (
+  // HACK: avoid checking entries type
+  "entries" in value
+);
+const compareEntries = (valueA, valueB) => {
+  const mapA = valueA instanceof Map ? valueA : new Map(valueA.entries());
+  const mapB = valueB instanceof Map ? valueB : new Map(valueB.entries());
+  if (mapA.size !== mapB.size) {
+    return false;
+  }
+  for (const [key, value] of mapA) {
+    if (!mapB.has(key) || !Object.is(value, mapB.get(key))) {
+      return false;
+    }
+  }
+  return true;
+};
+const compareIterables = (valueA, valueB) => {
+  const iteratorA = valueA[Symbol.iterator]();
+  const iteratorB = valueB[Symbol.iterator]();
+  let nextA = iteratorA.next();
+  let nextB = iteratorB.next();
+  while (!nextA.done && !nextB.done) {
+    if (!Object.is(nextA.value, nextB.value)) {
+      return false;
+    }
+    nextA = iteratorA.next();
+    nextB = iteratorB.next();
+  }
+  return !!nextA.done && !!nextB.done;
+};
+function shallow(valueA, valueB) {
+  if (Object.is(valueA, valueB)) {
+    return true;
+  }
+  if (typeof valueA !== "object" || valueA === null || typeof valueB !== "object" || valueB === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(valueA) !== Object.getPrototypeOf(valueB)) {
+    return false;
+  }
+  if (isIterable(valueA) && isIterable(valueB)) {
+    if (hasIterableEntries(valueA) && hasIterableEntries(valueB)) {
+      return compareEntries(valueA, valueB);
+    }
+    return compareIterables(valueA, valueB);
+  }
+  return compareEntries(
+    { entries: () => Object.entries(valueA) },
+    { entries: () => Object.entries(valueB) }
+  );
+}
+
+export { shallow };

package/node_modules/zustand/esm/vanilla.d.mts

@@ -0,0 +1,31 @@
+type SetStateInternal<T> = {
+    _(partial: T | Partial<T> | {
+        _(state: T): T | Partial<T>;
+    }['_'], replace?: false): void;
+    _(state: T | {
+        _(state: T): T;
+    }['_'], replace: true): void;
+}['_'];
+export interface StoreApi<T> {
+    setState: SetStateInternal<T>;
+    getState: () => T;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+}
+export type ExtractState<S> = S extends {
+    getState: () => infer T;
+} ? T : never;
+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;
+export {};

package/node_modules/zustand/esm/vanilla.mjs

@@ -0,0 +1,24 @@
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+
+export { createStore };

package/node_modules/zustand/index.d.ts

@@ -0,0 +1,2 @@
+export * from 'zustand/vanilla';
+export * from 'zustand/react';

package/node_modules/zustand/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var react = require('zustand/react');
+
+
+
+Object.keys(vanilla).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return vanilla[k]; }
+	});
+});
+Object.keys(react).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return react[k]; }
+	});
+});

package/node_modules/zustand/middleware/combine.d.ts

@@ -0,0 +1,4 @@
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+type Write<T, U> = Omit<T, keyof U> & U;
+export declare function combine<T extends object, U extends object, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = []>(initialState: T, create: StateCreator<T, Mps, Mcs, U>): StateCreator<Write<T, U>, Mps, Mcs>;
+export {};

package/node_modules/zustand/middleware/devtools.d.ts

@@ -0,0 +1,58 @@
+import type { StateCreator, StoreApi, StoreMutatorIdentifier } from 'zustand/vanilla';
+type Config = Parameters<(Window extends {
+    __REDUX_DEVTOOLS_EXTENSION__?: infer T;
+} ? T : {
+    connect: (param: object) => object;
+})['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> = Omit<T, keyof U> & U;
+type TakeTwo<T> = T extends {
+    length: 0;
+} ? [undefined, undefined] : T extends {
+    length: 1;
+} ? [...args0: Cast<T, unknown[]>, arg1: undefined] : T extends {
+    length: 0 | 1;
+} ? [...args0: Cast<T, unknown[]>, arg1: 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 Action = string | {
+    type: string;
+    [x: string | number | symbol]: unknown;
+};
+type StoreDevtools<S> = S extends {
+    setState: {
+        (...args: infer Sa1): infer Sr1;
+        (...args: infer Sa2): infer Sr2;
+    };
+} ? {
+    setState(...args: [...args: TakeTwo<Sa1>, action?: Action]): Sr1;
+    setState(...args: [...args: TakeTwo<Sa2>, action?: Action]): Sr2;
+    devtools: {
+        cleanup: () => void;
+    };
+} : 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][] = [], U = T>(initializer: StateCreator<T, [...Mps, ['zustand/devtools', never]], Mcs, U>, 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 {};

package/node_modules/zustand/middleware/immer.d.ts

@@ -0,0 +1,29 @@
+import type { Draft } from 'immer';
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+type Immer = <T, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = [], U = T>(initializer: StateCreator<T, [...Mps, ['zustand/immer', never]], Mcs, U>) => StateCreator<T, Mps, [['zustand/immer', never], ...Mcs], U>;
+declare module '../vanilla' {
+    interface StoreMutators<S, A> {
+        ['zustand/immer']: WithImmer<S>;
+    }
+}
+type Write<T, U> = Omit<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 SetStateType<T extends unknown[]> = Exclude<T[0], (...args: any[]) => any>;
+type WithImmer<S> = Write<S, StoreImmer<S>>;
+type StoreImmer<S> = S extends {
+    setState: infer SetState;
+} ? SetState extends {
+    (...args: infer A1): infer Sr1;
+    (...args: infer A2): infer Sr2;
+} ? {
+    setState(nextStateOrUpdater: SetStateType<A2> | Partial<SetStateType<A2>> | ((state: Draft<SetStateType<A2>>) => void), shouldReplace?: false, ...args: SkipTwo<A1>): Sr1;
+    setState(nextStateOrUpdater: SetStateType<A2> | ((state: Draft<SetStateType<A2>>) => void), shouldReplace: true, ...args: SkipTwo<A2>): Sr2;
+} : never : never;
+export declare const immer: Immer;
+export {};

package/node_modules/zustand/middleware/immer.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var immer$1 = require('immer');
+
+const immerImpl = (initializer) => (set, get, store) => {
+  store.setState = (updater, replace, ...args) => {
+    const nextState = typeof updater === "function" ? immer$1.produce(updater) : updater;
+    return set(nextState, replace, ...args);
+  };
+  return initializer(store.setState, get, store);
+};
+const immer = immerImpl;
+
+exports.immer = immer;

package/node_modules/zustand/middleware/persist.d.ts

@@ -0,0 +1,99 @@
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+export interface StateStorage<R = unknown> {
+    getItem: (name: string) => string | null | Promise<string | null>;
+    setItem: (name: string, value: string) => R;
+    removeItem: (name: string) => R;
+}
+export type StorageValue<S> = {
+    state: S;
+    version?: number;
+};
+export interface PersistStorage<S, R = unknown> {
+    getItem: (name: string) => StorageValue<S> | null | Promise<StorageValue<S> | null>;
+    setItem: (name: string, value: StorageValue<S>) => R;
+    removeItem: (name: string) => R;
+}
+type JsonStorageOptions = {
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare function createJSONStorage<S, R = unknown>(getStorage: () => StateStorage<R>, options?: JsonStorageOptions): PersistStorage<S, unknown> | undefined;
+export interface PersistOptions<S, PersistedState = S, PersistReturn = unknown> {
+    /** Name of the storage (must be unique) */
+    name: string;
+    /**
+     * Use a custom persist storage.
+     *
+     * Combining `createJSONStorage` helps creating a persist storage
+     * with JSON.parse and JSON.stringify.
+     *
+     * @default createJSONStorage(() => window.localStorage)
+     */
+    storage?: PersistStorage<PersistedState, PersistReturn> | 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, Pr> = S extends {
+    getState: () => infer T;
+    setState: {
+        (...args: infer Sa1): infer Sr1;
+        (...args: infer Sa2): infer Sr2;
+    };
+} ? {
+    setState(...args: Sa1): Sr1 | Pr;
+    setState(...args: Sa2): Sr2 | Pr;
+    persist: {
+        setOptions: (options: Partial<PersistOptions<T, Ps, Pr>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: PersistListener<T>) => () => void;
+        onFinishHydration: (fn: PersistListener<T>) => () => void;
+        getOptions: () => Partial<PersistOptions<T, Ps, Pr>>;
+    };
+} : never;
+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> = Omit<T, keyof U> & U;
+type WithPersist<S, A> = Write<S, StorePersist<S, A, unknown>>;
+export declare const persist: Persist;
+export {};

package/node_modules/zustand/middleware/redux.d.ts

@@ -0,0 +1,21 @@
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+type Write<T, U> = Omit<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 {};

package/node_modules/zustand/middleware/ssrSafe.d.ts

@@ -0,0 +1,2 @@
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+export declare function ssrSafe<T extends object, U extends object, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = []>(config: StateCreator<T, Mps, Mcs, U>, isSSR?: boolean): StateCreator<T, Mps, Mcs, U>;

package/node_modules/zustand/middleware/subscribeWithSelector.d.ts

@@ -0,0 +1,25 @@
+import type { StateCreator, StoreMutatorIdentifier } from 'zustand/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> = Omit<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 {};

package/node_modules/zustand/middleware.d.ts

@@ -0,0 +1,6 @@
+export { redux } from './middleware/redux';
+export { devtools, type DevtoolsOptions, type NamedSet, } from './middleware/devtools';
+export { subscribeWithSelector } from './middleware/subscribeWithSelector';
+export { combine } from './middleware/combine';
+export { persist, createJSONStorage, type StateStorage, type StorageValue, type PersistStorage, type PersistOptions, } from './middleware/persist';
+export { ssrSafe as unstable_ssrSafe } from './middleware/ssrSafe';