@nanawan/shared 3.18.2 → 3.18.4

package/lib/index.d.cts

@@ -0,0 +1,490 @@
+//#region node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist/types.d.ts
+type Version1Options = {
+  node?: Uint8Array;
+  clockseq?: number;
+  random?: Uint8Array;
+  rng?: () => Uint8Array;
+  msecs?: number;
+  nsecs?: number;
+  _v6?: boolean;
+};
+type Version4Options = {
+  random?: Uint8Array;
+  rng?: () => Uint8Array;
+};
+type Version6Options = Version1Options;
+//#endregion
+//#region node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist/v4.d.ts
+declare function v4(options?: Version4Options, buf?: undefined, offset?: number): string;
+declare function v4<TBuf extends Uint8Array = Uint8Array>(options: Version4Options | undefined, buf: TBuf, offset?: number): TBuf;
+//#endregion
+//#region node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist/v6.d.ts
+declare function v6(options?: Version6Options, buf?: undefined, offset?: number): string;
+declare function v6<TBuf extends Uint8Array = Uint8Array>(options: Version6Options | undefined, buf: TBuf, offset?: number): TBuf;
+//#endregion
+//#region node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/index.d.ts
+declare type EventType = string | symbol;
+declare type Handler<T = unknown> = (event: T) => void;
+declare type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+declare type EventHandlerList<T = unknown> = Array<Handler<T>>;
+declare type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+declare type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+interface Emitter<Events extends Record<EventType, unknown>> {
+  all: EventHandlerMap<Events>;
+  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+  on(type: '*', handler: WildcardHandler<Events>): void;
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+  off(type: '*', handler: WildcardHandler<Events>): void;
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+declare function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
+//#endregion
+//#region node_modules/.pnpm/parattail@2.0.14_@voidzero-dev+vite-plus-core@0.1.18_@types+node@20.19.43_esbuild@0.25._ebc6d1ebc6d151a5c6f2c711e62b0de3/node_modules/parattail/dist/index.d.mts
+//#region src/array/at.d.ts
+declare function at<T>(arr: T[], index: number): T | undefined; //#endregion
+//#region src/array/chunk.d.ts
+declare function chunk<T>(arr: T[], size?: number): T[][]; //#endregion
+//#region src/array/removeItem.d.ts
+declare function removeItem<T>(arr: T[], item: T): T[] | undefined; //#endregion
+//#region src/array/removeItemBy.d.ts
+declare function removeItemBy<T>(arr: T[], fn: (v: T) => any): T[] | undefined; //#endregion
+//#region src/array/removeItemsBy.d.ts
+declare function removeItemsBy<T>(arr: T[], fn: (v: T) => any): T[]; //#endregion
+//#region src/array/toggleItem.d.ts
+declare function toggleItem<T>(arr: T[], item: T): T[]; //#endregion
+//#region src/array/uniq.d.ts
+declare function uniq<T>(arr: T[]): T[]; //#endregion
+//#region src/array/uniqBy.d.ts
+declare function uniqBy<T>(arr: T[], fn: (a: T, b: T) => any): T[]; //#endregion
+//#region src/array/find.d.ts
+declare function find<T>(arr: T[], fn: (item: T, index: number, array: T[]) => any, from?: 'start' | 'end'): [T, number] | [null, -1]; //#endregion
+//#region src/array/shuffle.d.ts
+declare function shuffle<T>(arr: T[]): T[]; //#endregion
+//#region src/array/removeArrayBlank.d.ts
+declare function removeArrayBlank<T>(arr: (T | null | undefined)[]): T[]; //#endregion
+//#region src/array/removeArrayEmpty.d.ts
+declare function removeArrayEmpty<T>(arr: (T | null | undefined | '')[]): T[]; //#endregion
+//#region src/array/normalizeToArray.d.ts
+declare function normalizeToArray<T>(value: T | T[]): T[]; //#endregion
+//#region src/array/difference.d.ts
+declare function difference<T>(arr: T[], ...values: T[][]): T[]; //#endregion
+//#region src/array/differenceWith.d.ts
+type Fn$4<T> = (a: T, b: T) => any;
+declare function differenceWith<T>(arr: T[], ...values: [...T[][], fn: Fn$4<T>]): T[]; //#endregion
+//#region src/array/intersection.d.ts
+declare function intersection<T>(...values: T[][]): T[]; //#endregion
+//#region src/array/intersectionWith.d.ts
+type Fn$3<T> = (a: T, b: T) => any;
+declare function intersectionWith<T>(...values: [...T[][], fn: Fn$3<T>]): T[]; //#endregion
+//#region src/array/groupBy.d.ts
+type Fn$2<T, K> = (val: T) => K;
+declare function groupBy<T, K extends PropertyKey>(arr: T[], fn: Fn$2<T, K>): Record<K, T[]>; //#endregion
+//#region src/array/xor.d.ts
+declare function xor<T>(...values: T[][]): T[]; //#endregion
+//#region src/array/xorWith.d.ts
+type Fn$1<T> = (a: T, b: T) => any;
+declare function xorWith<T>(...values: [...T[][], fn: Fn$1<T>]): T[]; //#endregion
+//#region src/object/pick.d.ts
+declare function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K>; //#endregion
+//#region src/object/pickBy.d.ts
+declare function pickBy<T extends object>(object: T, fn: (value: any, key: keyof T) => any): Partial<T>; //#endregion
+//#region src/object/omit.d.ts
+declare function omit<T extends object, K extends keyof T>(object: T, keys: K[]): Omit<T, K>; //#endregion
+//#region src/object/omitBy.d.ts
+declare function omitBy<T extends object>(object: T, fn: (value: any, key: keyof T) => any): Partial<T>; //#endregion
+//#region src/object/deriveKey.d.ts
+type DeriveKeyMap<T extends object> = Partial<Record<keyof T, PropertyKey>>;
+type DeriveKeyResult<T extends object, M extends DeriveKeyMap<T>> = T & { [K in keyof M as M[K] extends PropertyKey ? M[K] : never]: K extends keyof T ? T[K] : never };
+declare function deriveKey<T extends object, M extends DeriveKeyMap<T>>(object: T, mapping: M): DeriveKeyResult<T, M>; //#endregion
+//#region src/object/rekey.d.ts
+type RekeyMap<T extends object> = Partial<Record<keyof T, PropertyKey>>;
+type RekeyResult<T extends object, M extends RekeyMap<T>> = Omit<T, keyof M> & { [K in keyof M as M[K] extends PropertyKey ? M[K] : never]: K extends keyof T ? T[K] : never };
+declare function rekey<T extends object, M extends RekeyMap<T>>(object: T, mapping: M): RekeyResult<T, M>; //#endregion
+//#region src/object/mapObject.d.ts
+declare function mapObject<K extends PropertyKey, V, NK extends PropertyKey = K, NV = V>(object: Record<K, V>, fn: (key: K, value: V) => [PropertyKey, NV] | undefined): Record<NK, NV>; //#endregion
+//#region src/object/promiseWithResolvers.d.ts
+type PromiseWithResolvers<T> = {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+};
+declare function promiseWithResolvers<T>(): PromiseWithResolvers<T>; //#endregion
+//#region src/object/set.d.ts
+declare function set<T extends object | any[]>(object: T, path: (string | number)[], value: any): void; //#endregion
+//#region src/object/objectKeys.d.ts
+declare function objectKeys<T extends object>(object: T): `${keyof T & string}`[]; //#endregion
+//#region src/object/objectEntries.d.ts
+declare function objectEntries<T extends object>(object: T): [keyof T & string, T[keyof T & string]][];
+//#endregion
+//#region src/util/cancelAnimationFrame.d.ts
+declare function cancelAnimationFrame(handle: number): void; //#endregion
+//#region src/util/classes.d.ts
+type ClassName = string | undefined | null;
+type Classes = (ClassName | [any, ClassName, ClassName?])[];
+declare function classes(...classes: Classes): any[]; //#endregion
+//#region src/util/copyText.d.ts
+declare function copyText(value: string): void; //#endregion
+//#region src/util/createNamespaceFn.d.ts
+type BEM<S extends string | undefined, N extends string, NC extends string> = S extends undefined ? NC : S extends `$--${infer CM}` ? `${N}--${CM}` : S extends `--${infer M}` ? `${NC}--${M}` : `${NC}__${S}`;
+declare function createNamespaceFn<N extends string>(namespace: N): <C extends string>(name: C) => {
+  name: string;
+  n: <S extends string | undefined = undefined>(suffix?: S | undefined) => BEM<S, N, `${N}-${C}`>;
+  classes: typeof classes;
+}; //#endregion
+//#region src/util/doubleRaf.d.ts
+declare function doubleRaf(): Promise<unknown>; //#endregion
+//#region src/util/getAllParentScroller.d.ts
+declare function getAllParentScroller(el: HTMLElement): (HTMLElement | Window)[]; //#endregion
+//#region src/util/getParentScroller.d.ts
+declare function getParentScroller(el: HTMLElement): HTMLElement | Window; //#endregion
+//#region src/util/getRect.d.ts
+declare function getRect(element: Element | Window): DOMRect; //#endregion
+//#region src/util/getScrollLeft.d.ts
+declare function getScrollLeft(element: Element | Window): number; //#endregion
+//#region src/util/getScrollTop.d.ts
+declare function getScrollTop(element: Element | Window): number; //#endregion
+//#region src/util/getStyle.d.ts
+declare function getStyle(element: Element): CSSStyleDeclaration; //#endregion
+//#region src/util/inViewport.d.ts
+declare function inViewport(element: HTMLElement): boolean; //#endregion
+//#region src/util/prettyJSONObject.d.ts
+declare function prettyJSONObject(jsonObject: Record<string, any>): string; //#endregion
+//#region src/util/preventDefault.d.ts
+declare function preventDefault(event: Event): void; //#endregion
+//#region src/util/raf.d.ts
+declare function raf(): Promise<unknown>; //#endregion
+//#region src/util/requestAnimationFrame.d.ts
+declare function requestAnimationFrame(fn: FrameRequestCallback): number; //#endregion
+//#region src/util/storage.d.ts
+interface Storage extends globalThis.Storage {
+  set(key: string, value: any): void;
+  get(key: string): any;
+  remove(key: string): void;
+}
+interface CookieAttributes {
+  expires?: number | Date | undefined;
+  path?: string | undefined;
+  domain?: string | undefined;
+  secure?: boolean | undefined;
+  sameSite?: 'strict' | 'Strict' | 'lax' | 'Lax' | 'none' | 'None' | undefined;
+  [property: string]: any;
+}
+interface CookieStorage {
+  set(key: string, value: any, options?: CookieAttributes): void;
+  get(key: string): any;
+  remove(key: string, options?: CookieAttributes): void;
+}
+declare function createStorage(storage: globalThis.Storage): Storage;
+declare function createCookieStorage(options?: CookieAttributes): CookieStorage;
+declare const sessionStorage: Storage;
+declare const localStorage: Storage; //#endregion
+//#region src/util/tryParseJSON.d.ts
+declare function tryParseJSON<T>(json: string): T | undefined; //#endregion
+//#region src/util/download.d.ts
+declare function download(val: string | Blob | File, filename?: string): void; //#endregion
+//#region src/util/enumOf.d.ts
+type ValueOf<T> = T[keyof T];
+type EnumOfValue = string | number | boolean;
+type EnumOfStringOrGetter = string | (() => string);
+type EnumOfValueObject = {
+  value: EnumOfValue;
+  label?: EnumOfStringOrGetter;
+  description?: EnumOfStringOrGetter;
+};
+type EnumOfConfigValue = EnumOfValue | (EnumOfValueObject & Record<string, unknown>);
+type EnumOfNormalizeToOption<V> = V extends {
+  value: unknown;
+} ? V : {
+  value: V;
+  label?: EnumOfStringOrGetter;
+  description?: EnumOfStringOrGetter;
+};
+type EnumOfResolvedField<V> = V extends ((...args: any[]) => infer R) ? R : V;
+type EnumOfResolvedOption<O> = O extends unknown ? { [K in keyof O]: EnumOfResolvedField<O[K]> } : never;
+type EnumOfExtractOptionShape<T extends Record<string, EnumOfConfigValue>> = EnumOfResolvedOption<EnumOfNormalizeToOption<ValueOf<T>>>;
+type EnumOfExtractValues<T extends object> = { [P in keyof T]: T[P] extends {
+  value: infer V;
+} ? V : T[P] };
+type EnumOfKeyForValue<T extends object, V> = { [K in keyof T]: EnumOfExtractValues<T>[K] extends V ? (V extends EnumOfExtractValues<T>[K] ? K : never) : never }[keyof T];
+type EnumOfOptionForValue<T extends Record<string, EnumOfConfigValue>, Value> = Value extends infer V ? EnumOfKeyForValue<T, V> extends keyof T ? EnumOfResolvedOption<EnumOfNormalizeToOption<T[EnumOfKeyForValue<T, V>]>> : EnumOfExtractOptionShape<T> : never;
+type EnumOfResultMethods<V, T extends Record<string, EnumOfConfigValue>> = {
+  values(): V[];
+  label(v: V): string;
+  labels(): string[];
+  description(v: V): string;
+  descriptions(): string[];
+  option<Value extends V>(v: Value): EnumOfOptionForValue<T, Value>;
+  options(): EnumOfExtractOptionShape<T>[];
+};
+type EnumOfResult<T extends Record<string, EnumOfConfigValue>> = EnumOfExtractValues<T> & EnumOfResultMethods<ValueOf<EnumOfExtractValues<T>>, T>;
+declare function enumOf<const T extends Record<string, EnumOfConfigValue>>(config: T): EnumOfResult<T>;
+type EnumOf<T extends {
+  values: () => any[];
+}> = ReturnType<T['values']>[number]; //#endregion
+//#region src/util/motion.d.ts
+interface MotionOptions {
+  from: number;
+  to: number;
+  duration?: number;
+  frame?: ({
+    value,
+    done
+  }: {
+    value: number;
+    done: boolean;
+  }) => void;
+  timingFunction?: (v: number) => number;
+  onStateChange?: (state: MotionState) => void;
+}
+type MotionState = 'running' | 'paused' | 'pending' | 'finished';
+interface Motion {
+  start: () => void;
+  pause: () => void;
+  reset: () => void;
+  getState: () => MotionState;
+}
+declare function motion(options: MotionOptions): Motion; //#endregion
+//#region src/util/duration.d.ts
+interface DurationContext {
+  years(value: number): this;
+  months(value: number): this;
+  weeks(value: number): this;
+  days(value: number): this;
+  hours(value: number): this;
+  minutes(value: number): this;
+  seconds(value: number): this;
+  milliseconds(value: number): this;
+  valueOf(options?: {
+    milliseconds: boolean;
+  }): number;
+}
+declare function duration(): DurationContext; //#endregion
+//#region src/util/createCacheManager.d.ts
+interface CreateCacheManagerOptions {
+  ttl?: number;
+}
+declare function createCacheManager<T = any>(options?: CreateCacheManagerOptions): {
+  has: (key: any) => boolean;
+  get: (key: any) => T | undefined;
+  set: (key: any, value: T, options?: {
+    ttl: number;
+  }) => void;
+  remove: (key: any) => boolean;
+  clear: () => void;
+}; //#endregion
+//#region src/util/navigation.d.ts
+interface NavigationTarget {
+  to: string;
+  query?: Record<string, any>;
+  hash?: string;
+}
+declare function buildNavigationUrl(target: string | NavigationTarget): string;
+declare const navigation: {
+  push(target: string | NavigationTarget): void;
+  replace(target: string | NavigationTarget): void;
+  open(target: string | NavigationTarget): void;
+  back(): void;
+  go(delta: number): void;
+}; //#endregion
+//#region src/function/call.d.ts
+declare function call<P extends any[], R>(fn?: ((...arg: P) => R) | ((...arg: P) => R)[] | null, ...args: P): R | R[] | undefined; //#endregion
+//#region src/function/tryCall.d.ts
+declare function tryCall<Args extends any[], T>(fn: (...args: Args) => T, ...args: Args): [unknown, undefined] | [undefined, T]; //#endregion
+//#region src/function/tryAsyncCall.d.ts
+declare function tryAsyncCall<Args extends any[], T>(fn: (...args: Args) => Promise<T>, ...args: Args): Promise<[unknown, undefined] | [undefined, T]>; //#endregion
+//#region src/function/once.d.ts
+declare function once<F extends (...args: any[]) => any>(fn: F): (this: unknown, ...args: Parameters<F>) => ReturnType<F>; //#endregion
+//#region src/function/debounce.d.ts
+declare function debounce<F extends (...args: any[]) => any>(fn: F, delay?: number): (this: unknown, ...args: Parameters<F>) => void; //#endregion
+//#region src/function/throttle.d.ts
+declare function throttle<F extends (...args: any[]) => any>(fn: F, delay?: number): (this: unknown, ...args: Parameters<F>) => void; //#endregion
+//#region src/function/NOOP.d.ts
+declare function NOOP(): void; //#endregion
+//#region src/function/callOrReturn.d.ts
+declare function callOrReturn<T, A extends any[]>(fnOrValue: T | ((...args: A) => T), ...args: A): T; //#endregion
+//#region src/general/getGlobalThis.d.ts
+declare function getGlobalThis(): typeof globalThis; //#endregion
+//#region src/general/hasOwn.d.ts
+declare function hasOwn<T extends object>(val: T, key: PropertyKey): key is keyof T; //#endregion
+//#region src/general/inBrowser.d.ts
+declare function inBrowser(): boolean; //#endregion
+//#region src/general/inMobile.d.ts
+declare function inMobile(): boolean; //#endregion
+//#region src/general/isArray.d.ts
+declare function isArray(val: unknown): val is any[]; //#endregion
+//#region src/general/isArrayBuffer.d.ts
+declare function isArrayBuffer(val: unknown): val is ArrayBuffer; //#endregion
+//#region src/general/isBoolean.d.ts
+declare function isBoolean(val: unknown): val is boolean; //#endregion
+//#region src/general/isDataView.d.ts
+declare function isDataView(val: unknown): val is DataView; //#endregion
+//#region src/general/isDate.d.ts
+declare function isDate(val: unknown): val is Date; //#endregion
+//#region src/general/isDOMException.d.ts
+declare function isDOMException(val: unknown): val is DOMException; //#endregion
+//#region src/general/isEmpty.d.ts
+declare function isEmpty(val: unknown): boolean; //#endregion
+//#region src/general/isEqual.d.ts
+declare function isEqual(value: any, other: any): boolean; //#endregion
+//#region src/general/isEqualWith.d.ts
+declare function isEqualWith(value: any, other: any, fn: (value: any, other: any) => any): boolean; //#endregion
+//#region src/general/isError.d.ts
+declare function isError(val: unknown): val is Error; //#endregion
+//#region src/general/isFunction.d.ts
+declare function isFunction(val: unknown): val is Function; //#endregion
+//#region src/general/isMap.d.ts
+declare function isMap(val: unknown): val is Map<any, any>; //#endregion
+//#region src/general/isNonEmptyArray.d.ts
+declare function isNonEmptyArray(val: unknown): val is any[]; //#endregion
+//#region src/general/isNullish.d.ts
+declare function isNullish(val: unknown): val is null | undefined; //#endregion
+//#region src/general/isNumber.d.ts
+declare function isNumber(val: unknown): val is number; //#endregion
+//#region src/general/isNumeric.d.ts
+declare function isNumeric(val: unknown): val is number | string; //#endregion
+//#region src/general/isObject.d.ts
+declare function isObject(val: unknown): val is Record<string, any>; //#endregion
+//#region src/general/isPlainObject.d.ts
+declare function isPlainObject(val: unknown): val is Record<string, any>; //#endregion
+//#region src/general/isPromise.d.ts
+declare function isPromise<T = any>(val: unknown): val is Promise<T>; //#endregion
+//#region src/general/isRegExp.d.ts
+declare function isRegExp(val: unknown): val is RegExp; //#endregion
+//#region src/general/isSet.d.ts
+declare function isSet(val: unknown): val is Set<any>; //#endregion
+//#region src/general/isString.d.ts
+declare function isString(val: unknown): val is string; //#endregion
+//#region src/general/isSymbol.d.ts
+declare function isSymbol(val: unknown): val is symbol; //#endregion
+//#region src/general/isTruthy.d.ts
+declare function isTruthy<T>(v: T): v is NonNullable<T>; //#endregion
+//#region src/general/isTypedArray.d.ts
+declare function isTypedArray(val: unknown): val is Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array; //#endregion
+//#region src/general/isWeakMap.d.ts
+declare function isWeakMap(val: unknown): val is WeakMap<any, any>; //#endregion
+//#region src/general/isWeakSet.d.ts
+declare function isWeakSet(val: unknown): val is WeakSet<any>; //#endregion
+//#region src/general/isWindow.d.ts
+declare function isWindow(val: unknown): val is Window; //#endregion
+//#region src/general/supportTouch.d.ts
+declare function supportTouch(): boolean; //#endregion
+//#region src/general/toRawType.d.ts
+declare function toRawType(value: unknown): string; //#endregion
+//#region src/general/toTypeString.d.ts
+declare const objectToString: typeof Object.prototype.toString;
+declare function toTypeString(value: unknown): string; //#endregion
+//#region src/general/isFile.d.ts
+declare function isFile(val: unknown): val is File; //#endregion
+//#region src/general/isBlob.d.ts
+declare function isBlob(val: unknown): val is Blob; //#endregion
+//#region src/general/isPrimitive.d.ts
+declare function isPrimitive(val: unknown): boolean; //#endregion
+//#region src/general/isEmptyPlainObject.d.ts
+declare function isEmptyPlainObject(val: unknown): val is Record<string, any>; //#endregion
+//#region src/general/assert.d.ts
+//#endregion
+//#region src/general/hasDuplicates.d.ts
+declare function hasDuplicates<T>(arr: T[]): boolean; //#endregion
+//#region src/general/hasDuplicatesBy.d.ts
+declare function hasDuplicatesBy<T>(arr: T[], fn: (a: T, b: T) => any): boolean; //#endregion
+//#region src/number/clamp.d.ts
+declare function clamp(num: number, min: number, max: number): number; //#endregion
+//#region src/number/clampArrayRange.d.ts
+declare function clampArrayRange(index: number, arr: unknown[]): number; //#endregion
+//#region src/number/delay.d.ts
+declare function delay(time: number): Promise<void>; //#endregion
+//#region src/number/randomNumber.d.ts
+declare function randomNumber(min?: number, max?: number): number; //#endregion
+//#region src/number/times.d.ts
+declare function times<T>(num: number, fn: (index: number) => T): T[]; //#endregion
+//#region src/number/toNumber.d.ts
+declare function toNumber(val: number | string | boolean | undefined | null): number; //#endregion
+//#region src/number/genNumberKey.d.ts
+declare function genNumberKey(): number; //#endregion
+//#region src/string/maskString.d.ts
+interface MaskStringOptions {
+  prefix?: number;
+  suffix?: number;
+  mask?: string;
+  maskLength?: number;
+}
+declare function maskString(text: string, {
+  prefix,
+  suffix,
+  mask,
+  maskLength
+}?: MaskStringOptions): string; //#endregion
+//#region src/string/camelize.d.ts
+declare function camelize(s: string): string; //#endregion
+//#region src/string/ensurePrefix.d.ts
+declare function ensurePrefix(s: string, prefix: string): string; //#endregion
+//#region src/string/ensureSuffix.d.ts
+declare function ensureSuffix(s: string, suffix: string): string; //#endregion
+//#region src/string/genStringKey.d.ts
+declare function genStringKey(): string; //#endregion
+//#region src/string/kebabCase.d.ts
+declare function kebabCase(s: string): string; //#endregion
+//#region src/string/pascalCase.d.ts
+declare function pascalCase(s: string): string; //#endregion
+//#region src/string/lowerFirst.d.ts
+declare function lowerFirst(s: string): string; //#endregion
+//#region src/string/upperFirst.d.ts
+declare function upperFirst(s: string): string; //#endregion
+//#region src/string/randomColor.d.ts
+declare function randomColor(): string; //#endregion
+//#region src/string/randomString.d.ts
+declare function randomString(length?: number): string; //#endregion
+//#region src/string/slash.d.ts
+declare function slash(path: string): string; //#endregion
+//#region src/collection/cloneDeep.d.ts
+declare function cloneDeep<T>(value: T): T; //#endregion
+//#region src/collection/cloneDeepWith.d.ts
+declare function cloneDeepWith<T>(value: T, fn: (value: any) => any): T; //#endregion
+//#region src/collection/merge.d.ts
+declare function merge<T extends Record<string, any>, K extends Record<string, any>>(object: T, ...sources: K[]): T & K; //#endregion
+//#region src/collection/mergeWith.d.ts
+type Fn = (objValue: any, srcValue: any, key: string | number | symbol, object?: any, source?: any) => any;
+declare function mergeWith<T extends Record<string, any>, K extends Record<string, any>>(object: T, ...sources: [...K[], fn: Fn]): T & K; //#endregion
+//#region src/file/toArrayBuffer.d.ts
+declare function toArrayBuffer(file: File): Promise<ArrayBuffer>; //#endregion
+//#region src/file/toDataURL.d.ts
+declare function toDataURL(file: File): Promise<string>; //#endregion
+//#region src/file/toText.d.ts
+declare function toText(file: File): Promise<string>; //#endregion
+//#region src/math/maxBy.d.ts
+declare function maxBy<T>(arr: T[], fn: (val: T) => number): T; //#endregion
+//#region src/math/minBy.d.ts
+declare function minBy<T>(arr: T[], fn: (val: T) => number): T; //#endregion
+//#region src/math/sum.d.ts
+declare function sum(arr: number[]): number; //#endregion
+//#region src/math/sumBy.d.ts
+declare function sumBy<T>(arr: T[], fn: (val: T) => number): number; //#endregion
+//#region src/math/sumHash.d.ts
+declare function sumHash(value: any): string; //#endregion
+//#region src/math/mean.d.ts
+declare function mean(arr: number[]): number; //#endregion
+//#region src/math/meanBy.d.ts
+declare function meanBy<T>(arr: T[], fn: (val: T) => number): number; //#endregion
+//#region src/math/sample.d.ts
+declare function sample<T>(arr: T[]): T | undefined; //#endregion
+//#region src/math/round.d.ts
+declare function round(val: number, precision?: number): number;
+declare function baseRound(val: number, precision: number, fn: (val: number) => number): number; //#endregion
+//#region src/math/floor.d.ts
+declare function floor(val: number, precision?: number): number; //#endregion
+//#region src/math/ceil.d.ts
+declare function ceil(val: number, precision?: number): number;
+//#endregion
+//#region src/index.d.ts
+declare function assert(condition: boolean, source: string, message: string): asserts condition;
+declare function warn(source: string, message: string): void;
+declare function error(source: string, message: string): void;
+declare const isURL: (val: string | undefined | null) => boolean;
+//#endregion
+export { BEM, ClassName, Classes, CookieAttributes, CookieStorage, CreateCacheManagerOptions, DurationContext, Emitter, EnumOf, EnumOfConfigValue, EnumOfExtractOptionShape, EnumOfExtractValues, EnumOfKeyForValue, EnumOfNormalizeToOption, EnumOfOptionForValue, EnumOfResolvedField, EnumOfResolvedOption, EnumOfResult, EnumOfResultMethods, EnumOfStringOrGetter, EnumOfValue, EnumOfValueObject, EventHandlerList, EventHandlerMap, EventType, Handler, MaskStringOptions, Motion, MotionOptions, MotionState, NOOP, NavigationTarget, PromiseWithResolvers, Storage, WildCardEventHandlerList, WildcardHandler, assert, at, baseRound, buildNavigationUrl, call, callOrReturn, camelize, cancelAnimationFrame, ceil, chunk, clamp, clampArrayRange, classes, cloneDeep, cloneDeepWith, copyText, createCacheManager, createCookieStorage, createNamespaceFn, createStorage, debounce, delay, deriveKey, difference, differenceWith, doubleRaf, download, duration, ensurePrefix, ensureSuffix, enumOf, error, find, floor, genNumberKey, genStringKey, getAllParentScroller, getGlobalThis, getParentScroller, getRect, getScrollLeft, getScrollTop, getStyle, groupBy, hasDuplicates, hasDuplicatesBy, hasOwn, inBrowser, inMobile, inViewport, intersection, intersectionWith, isArray, isArrayBuffer, isBlob, isBoolean, isDOMException, isDataView, isDate, isEmpty, isEmptyPlainObject, isEqual, isEqualWith, isError, isFile, isFunction, isMap, isNonEmptyArray, isNullish, isNumber, isNumeric, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTruthy, isTypedArray, isURL, isWeakMap, isWeakSet, isWindow, kebabCase, localStorage, lowerFirst, mapObject, maskString, maxBy, mean, meanBy, merge, mergeWith, minBy, mitt, motion, navigation, normalizeToArray, objectEntries, objectKeys, objectToString, omit, omitBy, once, pascalCase, pick, pickBy, prettyJSONObject, preventDefault, promiseWithResolvers, raf, randomColor, randomNumber, randomString, rekey, removeArrayBlank, removeArrayEmpty, removeItem, removeItemBy, removeItemsBy, requestAnimationFrame, round, sample, sessionStorage, set, shuffle, slash, sum, sumBy, sumHash, supportTouch, throttle, times, toArrayBuffer, toDataURL, toNumber, toRawType, toText, toTypeString, toggleItem, tryAsyncCall, tryCall, tryParseJSON, uniq, uniqBy, upperFirst, v4 as uuid, v6 as uuidV6, warn, xor, xorWith };

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from "parattail";
+
+//#region src/index.d.ts
+declare function assert(condition: boolean, source: string, message: string): asserts condition;
+declare function warn(source: string, message: string): void;
+declare function error(source: string, message: string): void;
+declare const isURL: (val: string | undefined | null) => boolean;
+//#endregion
+export { assert, error, isURL, warn };

package/lib/index.js

@@ -0,0 +1,18 @@
+import { assert as assert$1 } from "parattail";
+export * from "parattail";
+//#region src/index.ts
+function assert(condition, source, message) {
+	return assert$1(condition, `Pui [${source}]: ${message}`);
+}
+function warn(source, message) {
+	console.warn(`Pui [${source}]: ${message}`);
+}
+function error(source, message) {
+	console.error(`Pui [${source}]: ${message}`);
+}
+const isURL = (val) => {
+	if (!val) return false;
+	return /^(http)|(\.*\/)/.test(val);
+};
+//#endregion
+export { assert, error, isURL, warn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanawan/shared",
-  "version": "3.18.2",
+  "version": "3.18.4",
   "description": "shared utils of pui",
   "keywords": [
     "shared",
@@ -36,11 +36,11 @@
     "dev": "vp pack --watch"
   },
   "dependencies": {
-    "rattail": "catalog:"
+    "parattail": " ^2.0.15"
   },
   "devDependencies": {
-    "@types/node": "catalog:",
-    "typescript": "catalog:",
-    "vite-plus": "catalog:"
+    "@types/node": "^20.19.0",
+    "typescript": "5.6.3",
+    "vite-plus": "0.1.18"
   }
 }