@cmtlyt/lingshu-toolkit 0.3.0 → 0.5.0

package/dist/shared/logger/index.d.ts

@@ -1,5 +1,10 @@
 type Logger = {
     [K in keyof Omit<Console, 'table'> as Console[K] extends (...args: any[]) => any ? K : never]: Console[K] extends (...args: [any, ...infer AS]) => infer R ? (fnName: string, ...args: AS) => R : never;
 };
+declare global {
+    var $$lingshu$$: {
+        disableLogger: boolean;
+    };
+}
 export declare const logger: Logger;
 export {};

package/dist/shared/logger/index.js

@@ -1,5 +1,6 @@
 const logger = new Proxy(console, {
     get (target, prop, receiver) {
+        if ((globalThis.$$lingshu$$ || {}).disableLogger) return ()=>void 0;
         const oldLog = Reflect.get(target, prop, receiver).bind(console);
         return (fnName, ...args)=>{
             oldLog(`[@cmtlyt/lingshu-toolkit#${fnName}]:`, ...args);

package/dist/shared/throw-error/index.d.ts

@@ -1,2 +1,3 @@
+export declare function createError(fnName: string, message: string, ErrorClass?: ErrorConstructor): Error;
 export declare function throwError(fnName: string, message: string, ErrorClass?: ErrorConstructor): never;
 export declare function throwType(fnName: string, message: string): never;

package/dist/shared/throw-error/index.js

@@ -1,7 +1,10 @@
+function createError(fnName, message, ErrorClass = Error) {
+    return new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+}
 function throwError(fnName, message, ErrorClass = Error) {
-    throw new ErrorClass(`[@cmtlyt/lingshu-toolkit#${fnName}]: ${message}`);
+    throw createError(fnName, message, ErrorClass);
 }
 function throwType(fnName, message) {
     throwError(fnName, message, TypeError);
 }
-export { throwError, throwType };
+export { createError, throwError, throwType };

package/dist/shared/try-call/index.d.ts

@@ -0,0 +1,22 @@
+type TryCallResultValue<R, E> = Awaited<[E] extends [never] ? R : R | E>;
+type TryCallResult<R, E> = [R] extends [never] ? E : R extends PromiseLike<infer P> ? Promise<TryCallResultValue<P, E>> : TryCallResultValue<R, E>;
+type TryCallFinalArgs<R, E> = TryCallResultValue<R, E> | Error;
+/**
+ * 包装一个拦截错误的函数
+ *
+ * @platform web, node, webworker
+ *
+ * @param cb 回调函数
+ * @param onError 错误处理函数
+ */
+export declare function tryCallFunc<A extends any[], R, E = never>(cb: (...args: A) => R, onError?: ((err: any) => E) | null, onFinal?: (result: TryCallFinalArgs<R, E>) => void): (...args: A) => TryCallResult<R, E>;
+/**
+ * 尝试调用函数
+ *
+ * @platform web, node, webworker
+ *
+ * @param cb 回调函数
+ * @param onError 错误处理函数
+ */
+export declare function tryCall<R, E = never>(this: any, cb: () => R, onError?: ((err: any) => E) | null, onFinal?: (result: TryCallFinalArgs<R, E>) => void): TryCallResult<R, E>;
+export {};

package/dist/shared/try-call/index.js

@@ -0,0 +1,59 @@
+import { throwType } from "../throw-error/index.js";
+import { isFunction, isPromiseLike } from "../utils/verify.js";
+const EMPTY = Symbol('EMPTY');
+function tryCallFunc(cb, onError, onFinal) {
+    if (!isFunction(cb)) throwType('tryCallFunc', 'callback is not a function');
+    const catchFn = (self, ctx, error)=>{
+        if (isFunction(onError)) try {
+            ctx.errorResult = Reflect.apply(onError, self, [
+                error
+            ]);
+        } catch (err) {
+            ctx.error = err;
+        }
+        else ctx.error = error;
+        return ctx.errorResult;
+    };
+    const finallyFn = (self, ctx, result)=>{
+        try {
+            if (ctx.error !== EMPTY) throw ctx.error;
+        } finally{
+            if (isFunction(onFinal)) if (ctx.errorResult !== EMPTY) Reflect.apply(onFinal, self, [
+                ctx.errorResult
+            ]);
+            else if (ctx.error !== EMPTY) Reflect.apply(onFinal, self, [
+                ctx.error
+            ]);
+            else Reflect.apply(onFinal, self, [
+                result
+            ]);
+        }
+    };
+    return function(...args) {
+        const ctx = {
+            oriResult: EMPTY,
+            errorResult: EMPTY,
+            error: EMPTY
+        };
+        const asyncFn = async ()=>{
+            try {
+                ctx.oriResult = Reflect.apply(cb, this, args);
+                return ctx.oriResult;
+            } catch (error) {
+                return catchFn(this, ctx, error);
+            }
+        };
+        const fnPromise = asyncFn().catch((error)=>catchFn(this, ctx, error));
+        if (isPromiseLike(ctx.oriResult)) return fnPromise.then((result)=>{
+            finallyFn(this, ctx, result);
+            return result;
+        });
+        finallyFn(this, ctx, ctx.oriResult);
+        return ctx.oriResult !== EMPTY ? ctx.oriResult : ctx.errorResult;
+    };
+}
+function tryCall(cb, onError, onFinal) {
+    if (!isFunction(cb)) throwType('tryCall', 'callback is not a function');
+    return tryCallFunc(cb, onError, onFinal).call(this);
+}
+export { tryCall, tryCallFunc };

package/dist/shared/try-call/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/types/base.d.ts

@@ -6,3 +6,8 @@ export type IsBasicType<T> = T extends number | string | boolean | symbol | bigi
 export type Printify<T> = T extends any[] ? T : [T] extends [never] ? T : {
     [K in keyof T]: T[K];
 };
+export type PickRequired<T, K extends keyof T> = Printify<Omit<T, K> & Required<Pick<T, K>>>;
+export type Func<A extends any[], R = any> = (...args: A) => R;
+export type AnyFunc = (...args: any[]) => any;
+export type UnULCase<T extends string> = T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${UnULCase<R>}` : Uppercase<T> | Lowercase<T>;
+export type Cast<X, Y> = X extends Y ? X : Y;

package/dist/shared/types/pack.d.ts

@@ -3,7 +3,7 @@ export type Pack<T> = {
     [__PACK__]: T;
 };
 export type Unpack<T extends Pack<any>> = T extends Pack<infer U> ? U : never;
-export type SafeUnpack<T extends Pack<any>> = T extends Pack<infer U> ? U : T;
+export type SafeUnpack<T> = T extends Pack<infer U> ? U : T;
 export type IsPack<T> = Pack<any> extends T ? true : false;
 export type HasPack<T> = (T extends any[] ? HasPack<T[number]> : IsPack<T>) extends false ? false : true;
 export {};

package/dist/shared/utils/__test__/base.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils/__test__/verify.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils/base.d.ts

@@ -0,0 +1,3 @@
+export declare const noop: () => undefined;
+export declare const identity: <T>(_v: T) => T;
+export declare function getType(_v: any): string;

package/dist/shared/utils/base.js

@@ -0,0 +1,6 @@
+const noop = ()=>void 0;
+const identity = (_v)=>_v;
+function getType(_v) {
+    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+}
+export { getType, identity, noop };

package/dist/shared/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './verify';

package/dist/shared/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./verify.js";

package/dist/shared/utils/verify.d.ts

@@ -0,0 +1,53 @@
+import type { AnyFunc, UnULCase } from '../types/base';
+/** 判断是一个 symbol */
+export declare function isSymbol(_v: unknown): _v is symbol;
+/** 判断是一个 undefined */
+export declare function isUndef(_v: unknown): _v is undefined;
+/** 判断是一个 null */
+export declare function isNull(_v: unknown): _v is null;
+/** 判断是一个 null 或者 undefined */
+export declare function isNullOrUndef(_v: unknown): _v is null | undefined;
+/** 判断是一个 NaN */
+export declare function isNaN(_v: unknown): _v is number;
+/** 判断是一个 plain symbol */
+export declare function isPlainSymbol(_v: unknown): _v is symbol;
+/** 判断是一个对象 (数组也返回 true) */
+export declare function isObject(_v: unknown): _v is object;
+/** 判断是一个非数组对象 */
+export declare function isPlainObject(_v: unknown): _v is object;
+/** 判断是一个数组 */
+export declare function isArray(_v: unknown): _v is any[];
+/** 判断是否为空数组 */
+export declare function isEmptyArray(_v: unknown): _v is [];
+/** 判断是一个字符串 */
+export declare function isString(_v: unknown): _v is string;
+/** 判断是一个空字符串 */
+export declare function isEmptyString(_v: unknown): _v is '';
+/** 判断是一个数字 */
+export declare function isNumber(_v: unknown): _v is number;
+/** 判断是一个纯数字 (排除 NaN) */
+export declare function isPlainNumber(_v: unknown): _v is number;
+/** 判断是一个合法的对象 key */
+export declare function isPropertyKey(_v: unknown): _v is PropertyKey;
+/** 判断是一个布尔值 */
+export declare function isBoolean(_v: unknown): _v is boolean;
+/** 判断是一个 true 值 */
+export declare function isTrue(_v: unknown): _v is true | UnULCase<'true'>;
+/** 判断是一个 false 值 */
+export declare function isFalse(_v: unknown): _v is false | UnULCase<'false'>;
+/**
+ * 判断是一个真值
+ *
+ * @warn 字符串 'false' 等满足 isFalse 判断的字符串也会被视为真值
+ */
+export declare function isTruthy<T>(_v: T): _v is Exclude<T, false | 0 | '' | null | undefined>;
+/**
+ * 判断是一个非值
+ *
+ * @warn 字符串 'false' 等满足 isFalse 判断的字符串不会被视为非值
+ */
+export declare function isFalsy(_v: unknown): _v is false | 0 | '' | null | undefined;
+/** 判断是一个函数 */
+export declare function isFunction(_v: unknown): _v is AnyFunc;
+/** 判断是一个 Promise */
+export declare function isPromiseLike(_v: unknown): _v is PromiseLike<any>;

package/dist/shared/utils/verify.js

@@ -0,0 +1,67 @@
+function isSymbol(_v) {
+    return 'symbol' == typeof _v;
+}
+function isUndef(_v) {
+    return void 0 === _v;
+}
+function isNull(_v) {
+    return null === _v;
+}
+function isNullOrUndef(_v) {
+    return isNull(_v) || isUndef(_v);
+}
+function verify_isNaN(_v) {
+    return Number.isNaN(_v);
+}
+function isPlainSymbol(_v) {
+    return isSymbol(_v) && isUndef(Symbol.keyFor(_v));
+}
+function isObject(_v) {
+    return 'object' == typeof _v && !isNull(_v);
+}
+function isPlainObject(_v) {
+    return isObject(_v) && !isArray(_v);
+}
+function isArray(_v) {
+    return Array.isArray(_v);
+}
+function isEmptyArray(_v) {
+    return isArray(_v) && 0 === _v.length;
+}
+function isString(_v) {
+    return 'string' == typeof _v;
+}
+function isEmptyString(_v) {
+    return isString(_v) && 0 === _v.length;
+}
+function isNumber(_v) {
+    return 'number' == typeof _v;
+}
+function isPlainNumber(_v) {
+    return isNumber(_v) && !verify_isNaN(_v);
+}
+function isPropertyKey(_v) {
+    return isString(_v) || isNumber(_v) || isSymbol(_v);
+}
+function isBoolean(_v) {
+    return 'boolean' == typeof _v;
+}
+function isTrue(_v) {
+    return true === _v || isString(_v) && 'true' === _v.toLowerCase();
+}
+function isFalse(_v) {
+    return false === _v || isString(_v) && 'false' === _v.toLowerCase();
+}
+function isTruthy(_v) {
+    return !!_v;
+}
+function isFalsy(_v) {
+    return !(verify_isNaN(_v) || _v);
+}
+function isFunction(_v) {
+    return 'function' == typeof _v;
+}
+function isPromiseLike(_v) {
+    return isObject(_v) && isFunction(_v.then);
+}
+export { isArray, isBoolean, isEmptyArray, isEmptyString, isFalse, isFalsy, isFunction, verify_isNaN as isNaN, isNull, isNullOrUndef, isNumber, isObject, isPlainNumber, isPlainObject, isPlainSymbol, isPromiseLike, isPropertyKey, isString, isSymbol, isTrue, isTruthy, isUndef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmtlyt/lingshu-toolkit",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/shared.js",
   "module": "./dist/shared.js",
@@ -41,10 +41,11 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.8",
-    "@cmtlyt/unplugin-shadcn-registry-generate": "^0.1.3",
+    "@cmtlyt/unplugin-shadcn-registry-generate": "^0.1.5",
     "@commitlint/cli": "^20.3.1",
     "@commitlint/config-conventional": "^20.3.1",
     "@rslib/core": "^0.19.3",
+    "@rspress/core": "^2.0.8",
     "@types/node": "^24.10.9",
     "@types/react": "^19.2.9",
     "@vitejs/plugin-react": "^5.1.2",
@@ -52,15 +53,16 @@
     "@vitest/browser-playwright": "4.0.18",
     "@vitest/coverage-v8": "4.0.18",
     "@vitest/ui": "4.0.18",
+    "changelogithub": "^14.0.0",
     "cross-env": "^10.1.0",
     "esno": "^4.8.0",
     "husky": "^9.1.7",
     "jsdom": "^27.4.0",
     "lint-staged": "^16.2.7",
+    "msw": "^2.12.14",
     "playwright": "^1.58.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "rspress": "^1.47.1",
     "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^6.0.4",
     "vitest": "4.0.18",
@@ -75,10 +77,11 @@
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": ">=18.0.0"
+      "version": ">=22.12.0"
     },
     "packageManager": {
-      "name": "pnpm"
+      "name": "pnpm",
+      "version": ">=10.2.0"
     }
   },
   "publishConfig": {
@@ -118,8 +121,8 @@
     "preview:docs": "rspress preview",
     "format": "biome format --write",
     "test": "vitest --config=vitest.project.config.ts --coverage.enabled --ui",
-    "test:ci": "cross-env gen_file_disabled=true vitest run --config=vitest.project.config.ts",
-    "test:lib:ci": "cross-env gen_file_disabled=true vitest run",
+    "test:ci": "cross-env skip_type_check=true gen_file_disabled=true vitest run --config=vitest.project.config.ts",
+    "test:lib:ci": "cross-env skip_type_check=true gen_file_disabled=true vitest run",
     "test:lib": "vitest --coverage.enabled --ui",
     "script:gen-file": "esno scripts/gen-file.ts"
   }

package/dist/607.js

@@ -1,311 +0,0 @@
-import { dataHandler, logger, $dt, throwError, $t, throwType } from "./707.js";
-function withResolvers() {
-    return 'function' == typeof Promise.withResolvers ? Promise.withResolvers() : (()=>{
-        const resolver = {
-            promise: null,
-            resolve: null,
-            reject: null
-        };
-        resolver.promise = new Promise((resolve, reject)=>{
-            resolver.resolve = resolve;
-            resolver.reject = reject;
-        });
-        return resolver;
-    })();
-}
-const noop = ()=>void 0;
-const identity = (_v)=>_v;
-function getType(_v) {
-    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
-}
-function getNextValueHandler(from, to, valueFormatter) {
-    const type = getType(from);
-    const context = {
-        progress: 0,
-        valueFormatter
-    };
-    const baseNextValue = (_from, _to)=>{
-        const { valueFormatter: formatter, progress } = context;
-        if ('number' !== getType(_from)) return _from;
-        return formatter(_from + (_to - _from) * progress);
-    };
-    const arrayHandler = (_from, _to)=>{
-        const result = Array.from(_from, (item, idx)=>{
-            if (Array.isArray(item)) return arrayHandler(item, _to[idx]);
-            if ('object' === getType(item)) return objectHandler(item, _to[idx]);
-            return baseNextValue(item, _to[idx]);
-        });
-        return result;
-    };
-    const objectHandler = (_from, _to)=>{
-        const result = {};
-        const keys = Reflect.ownKeys(_from);
-        for(let i = 0; i < keys.length; i++){
-            const key = keys[i];
-            const fromValue = _from[key];
-            const toValue = _to[key];
-            if (Array.isArray(_from[key])) result[key] = arrayHandler(fromValue, toValue);
-            else if ('object' === getType(fromValue)) result[key] = objectHandler(fromValue, toValue);
-            else result[key] = baseNextValue(fromValue, toValue);
-        }
-        return result;
-    };
-    let nextValueHandler = baseNextValue;
-    if ('array' === type) nextValueHandler = arrayHandler;
-    else if ('object' === type) nextValueHandler = objectHandler;
-    return (progress)=>{
-        context.progress = progress;
-        return nextValueHandler(from, to);
-    };
-}
-function matchValid(from, to, valueParser) {
-    const fromType = getType(from);
-    const toType = getType(to);
-    if (fromType !== toType) throwType('animation/stepAnimation', 'from and to must be the same type');
-    if ('array' === fromType) {
-        if (from.length !== to.length) throwType('animation/stepAnimation', 'from and to must be the same length');
-        const result = [
-            Array.from({
-                length: from.length
-            }),
-            Array.from({
-                length: to.length
-            })
-        ];
-        for(let i = 0; i < from.length; i++){
-            const [fromItem, toItem] = matchValid(from[i], to[i], valueParser);
-            result[0][i] = fromItem;
-            result[1][i] = toItem;
-        }
-        return result;
-    }
-    if ('object' === fromType) {
-        const toKeys = Reflect.ownKeys(to);
-        const fromKeys = new Set(Reflect.ownKeys(from));
-        const result = [
-            {},
-            {}
-        ];
-        for(let i = 0; i < toKeys.length; i++){
-            const key = toKeys[i];
-            if (!fromKeys.has(key)) throwType('animation/stepAnimation', `from does not have this key: ${String(key)}`);
-            const [fromItem, toItem] = matchValid(from[key], to[key], valueParser);
-            result[0][key] = fromItem;
-            result[1][key] = toItem;
-        }
-        return result;
-    }
-    if ('number' !== fromType) return [
-        valueParser(from),
-        valueParser(to)
-    ];
-    return [
-        from,
-        to
-    ];
-}
-function createNextTick(resolvers, rcSignal) {
-    const nextTick = (()=>{
-        if ('function' == typeof globalThis.requestAnimationFrame) return globalThis.requestAnimationFrame;
-        return (callback)=>setTimeout(callback, 16);
-    })();
-    return (callback)=>{
-        if (rcSignal.stopSignal) return true;
-        nextTick(()=>tryRun(callback, resolvers, (error)=>{
-                rcSignal.stop();
-                resolvers.reject(error);
-            }));
-        return false;
-    };
-}
-async function tryRun(callback, resolvers, customErrorHandler) {
-    return new Promise((resolve, reject)=>{
-        const result = callback();
-        if (result && 'function' == typeof result.then) return result.then(resolve, reject);
-        resolve();
-    }).catch(customErrorHandler || resolvers.reject);
-}
-function createRunningControllerSignal(startFn, options) {
-    const { onStart, onStop, onClear } = options;
-    const resolvers = withResolvers();
-    const ctrl = {
-        stopSignal: true,
-        resolvers,
-        stop: ()=>{
-            ctrl.stopSignal = true;
-            onStop();
-        },
-        start: ()=>{
-            ctrl.stopSignal = false;
-            onStart();
-            startFn();
-        },
-        clear: ()=>{
-            ctrl.stopSignal = true;
-            onClear();
-            resolvers.resolve(true);
-        }
-    };
-    return ctrl;
-}
-function* stepAnimation(from, to, step, options = {}) {
-    if (!Number.isInteger(step) || step <= 0) throwError('stepAnimation', 'step must be a positive integer', RangeError);
-    const { parser: valueParser = identity, formatter: valueFormatter = identity } = options;
-    const [validFrom, validTo] = matchValid(from, to, valueParser);
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
-    for(let i = 0; i <= step; i++){
-        const value = getNextValue(i / step);
-        yield value;
-    }
-}
-const validInfo = $dt({
-    autoStart: $t.boolean(true),
-    easing: $t["function"](()=>identity),
-    onStart: $t["function"](()=>noop),
-    onStop: $t["function"](()=>noop),
-    onClear: $t["function"](()=>noop),
-    onUpdate: $t["function"](()=>noop),
-    onComplete: $t["function"](()=>noop),
-    formatter: $t["function"](()=>identity),
-    parser: $t["function"](()=>identity)
-});
-function animation(from, to, duration, options = {}) {
-    if (duration <= 0 || !Number.isInteger(duration)) throwError('animation', 'duration must be a positive integer', RangeError);
-    const validOptions = dataHandler(options, validInfo, {
-        unwrap: true
-    });
-    const [validFrom, validTo] = matchValid(from, to, validOptions.parser);
-    const { autoStart, easing, onComplete, onUpdate, formatter: valueFormatter } = validOptions;
-    const getNextValue = getNextValueHandler(validFrom, validTo, valueFormatter);
-    let startTime = 0;
-    let hasStarted = false;
-    const rcSignal = createRunningControllerSignal(()=>{
-        const now = performance.now();
-        startTime += now;
-        const stopFlag = nextTick(tick);
-        if (stopFlag) {
-            startTime -= performance.now();
-            return;
-        }
-        if (!hasStarted) {
-            onUpdate(getNextValue(0));
-            hasStarted = true;
-        }
-    }, validOptions);
-    const { resolvers } = rcSignal;
-    const nextTick = createNextTick(resolvers, rcSignal);
-    const tick = ()=>{
-        const elapsed = performance.now() - startTime;
-        const progress = easing(Math.min(elapsed / duration, 1));
-        const value = getNextValue(progress);
-        onUpdate(value);
-        if (elapsed < duration) {
-            const stopFlag = nextTick(tick);
-            if (stopFlag) startTime = -elapsed;
-        } else {
-            onComplete();
-            resolvers.resolve(false);
-        }
-    };
-    if (false !== autoStart) rcSignal.start();
-    return {
-        promise: resolvers.promise,
-        stop: rcSignal.stop,
-        start: rcSignal.start,
-        clear: rcSignal.clear
-    };
-}
-function getEmpty(_v) {
-    return Array.isArray(_v) ? [] : {};
-}
-function valueCheck(_v) {
-    return Array.isArray(_v) || 'object' == typeof _v;
-}
-function conditionMerge(...input) {
-    const conditionItems = (input.length > 1 ? input : input[0]).map((item)=>{
-        let result = null;
-        if (Array.isArray(item)) {
-            const [condition, value, fullback] = item;
-            result = {
-                condition,
-                value,
-                fullback
-            };
-        } else if (Object.getOwnPropertyDescriptor(item, 'condition')) result = item;
-        else throwType('conditionMerge', 'input must be an ConditionItem');
-        const validValue = valueCheck(result.value);
-        const validFullback = void 0 === result.fullback || valueCheck(result.fullback);
-        if (!(validValue && validFullback)) throwType('conditionMerge', 'value and fullback must be an array or object');
-        return result;
-    });
-    const result = getEmpty(conditionItems[0].value);
-    const mergeFn = Array.isArray(result) ? (a1, a2)=>Reflect.apply(Array.prototype.splice.bind(a1, a1.length, 0), null, a2) : Object.assign;
-    for(let i = 0, item = conditionItems[i]; i < conditionItems.length; item = conditionItems[++i])mergeFn(result, item.condition ? item.value : item.fullback || getEmpty(item.value));
-    return result;
-}
-const create_storage_handler_validInfo = $dt({
-    storageKey: 'validString',
-    storageType: $t["enum"]([
-        'local',
-        'session',
-        'memory'
-    ], 'local'),
-    autoSaveInterval: $t.number(0)
-});
-const memoryStorage = {
-    data: {},
-    getItem (key) {
-        return this.data[key];
-    },
-    setItem (key, value) {
-        this.data[key] = value;
-    },
-    removeItem (key) {
-        delete this.data[key];
-    }
-};
-function getStorage(storageType) {
-    try {
-        if ('memory' === storageType) return memoryStorage;
-        return 'local' === storageType ? localStorage : sessionStorage;
-    } catch  {
-        logger.warn('createStorage', 'Failed to access localStorage or sessionStorage, using memoryStorage instead.');
-        return memoryStorage;
-    }
-}
-const CLEAR_FLAG = Symbol('cleared');
-function createStorageHandler(storageKey, initialData, options = {}) {
-    const { storageKey: validStorageKey, storageType, autoSaveInterval } = dataHandler({
-        storageKey,
-        ...options
-    }, create_storage_handler_validInfo, {
-        unwrap: true
-    });
-    const storage = getStorage(storageType);
-    const storageData = storage.getItem(validStorageKey);
-    const context = {
-        data: storageData ? JSON.parse(storageData) : initialData || {}
-    };
-    return {
-        get (key) {
-            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
-            if (null == key) return context.data;
-            return context.data[key];
-        },
-        set (value, key) {
-            if (context.data === CLEAR_FLAG) throwError('createStorageHandler', 'Storage has been cleared.');
-            if (null == key) context.data = value;
-            else context.data[key] = value;
-            if (autoSaveInterval > 0) setTimeout(()=>{
-                storage.setItem(validStorageKey, JSON.stringify(context.data));
-            }, autoSaveInterval);
-            else storage.setItem(validStorageKey, JSON.stringify(context.data));
-        },
-        clear () {
-            context.data = CLEAR_FLAG;
-            storage.removeItem(validStorageKey);
-        }
-    };
-}
-Symbol('__PACK__');
-export { animation, conditionMerge, createStorageHandler, stepAnimation, withResolvers };