import { a as AsyncFactory, c as Factory, d as JsonObject, f as JsonPrimitive, h as PrimitiveType, i as Arrayable, l as Fn, m as Optional, n as TransformJsonData, o as Awaitable, p as JsonValue, r as parseJson, s as Ctor, t as ParesJsonOption, u as JsonArray } from "./parse-ChhDUw7P.mjs";
import { nanoid } from "nanoid";

//#region src/algorithm/compress.d.ts
/**
 * Use [fflate](https://github.com/101arrowz/fflate/) to compress text
 *
 * @param text
 * @returns
 */
declare function compressText(text: string): Promise<string>;
/**
 * Use [fflate](https://github.com/101arrowz/fflate/) to decompress text
 *
 * @param compressedText
 * @returns
 */
declare function decompressText(compressedText: string): Promise<string>;
//#endregion
//#region src/algorithm/encoding.d.ts
declare function jsonToBase64(data: unknown): string;
declare function base64ToJson(data: string): any;
//#endregion
//#region src/types/object.d.ts
/**
 *
 * @example
 *
 * ```ts
 * interface Target {
 *  a: string
 *  b: number
 *  c: boolean
 *  d: string[]
 * }
 *
 * type a = ExtractObjectKeys<Target, number | string> // => 'a' | 'b'
 * type b = ExtractObjectKeys<Target, Iterable<any>> // => 'a' | 'd'
 * type c = ExtractObjectKeys<Target, Iterable<any>, string> // => 'd'
 * ```
 */
type ExtractObjectKeys<T extends {}, TrueCondition, FalseCondition = never> = { [key in keyof T]: T[key] extends FalseCondition ? never : T[key] extends TrueCondition ? key : never }[keyof T];
type EmptyObject = {};
type PlainObject<T = string> = Record<string, T>;
type ObjectValues<E extends Record<string, string | number | boolean | null | undefined>> = E[keyof E];
type DeepPartial<T> = T extends Record<string | number, unknown> ? { [Key in keyof T]?: DeepPartial<T[Key]> } : Optional<T>;
type DeepRequired<T> = T extends Record<string | number, unknown> ? { [Key in keyof T]: DeepRequired<T[Key]> } : NonNullable<T>;
//#endregion
//#region src/algorithm/tree.d.ts
type TreeVisitCallback<T> = (node: T, parentNode?: T) => void | boolean;
/**
 *
 * DFS (Deep-first search)
 *
 * @param nodes
 * @param cb return true to stop
 * @param childrenKey default is `'children'`
 */
declare function traverse<T extends {}, Key extends keyof T>(nodes: Arrayable<T>,
/**
 * @returns return true to stop
 */

cb: TreeVisitCallback<T>, childrenKey?: Key): void;
/**
 *
 * @param childrenKey default is `'children'`
 */
declare function findNodeInTree<T extends {}, Key extends keyof T>(nodes: Arrayable<T>, predicate: TreeVisitCallback<T>, childrenKey?: Key): T | undefined;
declare function filterTreeNodes<T extends {}, Key extends keyof T>(nodes: Arrayable<T>, predicate: TreeVisitCallback<T>, childrenKey?: Key): T[];
//#endregion
//#region src/core/array.d.ts
/**
 * Ensure to return a list of element T.
 *
 * @param arr
 * @returns
 */
declare const ensureArray: <T>(arr?: Arrayable<T>) => T[];
declare const remove: <T>(arr: T[], predicate: T | ((item: T, index: number) => boolean)) => T[];
//#endregion
//#region src/core/createPromise.d.ts
declare function createPromise<T>(): PromiseWithResolvers<T>;
//#endregion
//#region src/core/misc.d.ts
declare function noop(): void;
declare function has<T extends {}>(o: T, name: string | symbol | number): boolean;
//#endregion
//#region src/core/sleep.d.ts
type SleepResult = Promise<void> & {
  cancel: () => void;
};
/**
 * promise timeout, support cancel
 *
 * @param timeout
 * @returns
 */
declare function sleep(timeout?: number): SleepResult;
//#endregion
//#region src/dep-injection/container.d.ts
interface BindConfig {
  singleton?: boolean;
}
type MaybeConstructor<T> = (new () => T) | (() => T) | T;
declare class Container<CtorMap extends {}> {
  #private;
  bind<K extends keyof CtorMap>(key: K, ctor: MaybeConstructor<CtorMap[K]>, config?: BindConfig): void;
  get<K extends keyof CtorMap>(key: K, opt?: {
    target?: unknown;
  }): CtorMap[K];
  /**
   * Only support standard decorator https://github.com/tc39/proposal-decorators#class-fields
   */
  inject<K extends keyof CtorMap>(key: K): (_: unknown, _ctx: ClassFieldDecoratorContext<unknown, CtorMap[K]>) => (_initialValue: unknown) => CtorMap[K];
  /**
   * Only support standard decorator https://github.com/tc39/proposal-decorators#class-fields
   */
  lazyInject<K extends keyof CtorMap>(key: K): (_: unknown, ctx: ClassFieldDecoratorContext<unknown, CtorMap[K]>) => void;
  clear<K extends keyof CtorMap>(key?: K): void;
}
//#endregion
//#region src/events/types.d.ts
type Listener<T extends unknown[] = unknown[]> = (...value: T) => void;
//#endregion
//#region src/events/EventEmitter.d.ts
/**
 * @example
 * ```ts
 * type Events = {
 *  test: []
 *  foo: [a: number]
 *  bar: [a: number, b: string]
 * }
 *
 * const event = new EventEmitter<Events>()
 *
 * event.on('test', () => console.log('test'))
 *
 * event.emit('test')
 *
 * event.off('test')
 *
 * ```
 */
declare class EventEmitter<Events extends Record<string, any>> {
  #private;
  events(): { [K in keyof Events]?: Listener<Events[K]>[] };
  events<K extends keyof Events>(event: K): NonNullable<Listener<Events[K]>[]>;
  /**
   * Add a callback to the specified event.
   * @param event Event type
   * @param listener Callback
   * @returns Remove the callback.
   */
  on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): () => void;
  /**
   * Add a callback to the specified event, only execute once.
   *
   * @param event Event type
   * @param listener Callback
   * @returns Remove the callback.
   */
  once<K extends keyof Events>(event: K, listener: Listener<Events[K]>): () => boolean;
  /**
   * Remove all listeners of all events.
   */
  off(): boolean;
  /**
   *
   * Remove all listeners of the event.
   * @param event Event type
   */
  off<K extends keyof Events>(event: K): boolean;
  /**
   * Remove the listener of the event.
   *
   * @param event Event type
   * @param listener  Callback
   * @returns Return true if listener is existed, otherwise return false.
   */
  off<K extends keyof Events>(event: K, listener: Listener<Events[K]>): boolean;
  /**
   * Trigger the event by event type.
   *
   * @param event Event type
   * @param args Arguments that apply to the callback.
   */
  emit<K extends keyof Events>(event: K, ...args: Events[K]): void;
}
//#endregion
//#region src/events/SimpleEventEmitter.d.ts
declare class SimpleEventEmitter<Args extends unknown[] = []> {
  #private;
  on(listener: Listener<Args>): () => void;
  off(listener: Listener<Args>): void;
  clear(): void;
  emit(...args: Args): void;
}
//#endregion
//#region src/fp/chain.d.ts
interface IChainable<In = unknown> {
  input: In;
  fns: Fn[];
  pipe<Out>(fn: (i: In) => Out): Out extends Promise<unknown> ? IAsyncChainable<Out> : IChainable<Out>;
  exec(): In;
}
interface IAsyncChainable<In = unknown> {
  input: In;
  fns: Fn[];
  pipe<Out>(fn: (i: Awaited<In>) => Out): IAsyncChainable<Out>;
  exec(): Promise<Awaited<In>>;
}
/**
 *
 * @example
 *
 * ```ts
 * const plusOne = (n: number) => n + 1
 * const toString = (n: number) => n.toString()
 *
 * const s = chain(0)
 *  .pipe(plusOne)
 *  .pipe(toString)
 *  .exec()
 *
 * console.log(s) // => '1'
 * ```
 *
 * @param input
 * @returns
 */
declare function chain<T>(input: T): IChainable<T>;
//#endregion
//#region src/fp/types.d.ts
type IComposeResult<T extends Fn> = T & {
  exec(...params: Parameters<T>): ReturnType<T>;
};
//#endregion
//#region src/fp/compose.d.ts
/**
 * Compose multiple functions into single function
 *
 * @example
 *
 * ```ts
 * const plusOne = (n: number) => n + 1
 * const toString = (n: number) => n.toString()
 *
 * const plusOneThenToString = compose(plusOne, toString)
 * plusOneThenToString(0) // '1'
 * ```
 *
 * @param fns
 * @returns
 */
declare function compose(...fns: Fn[]): IComposeResult<Fn>;
//#endregion
//#region src/is/is.d.ts
/**
 * check target if is a Class or not.
 *
 * @param target
 * @returns
 */
declare function isCls(target: unknown): target is Ctor;
/**
 * check target if is a number or not
 * @param target
 * @returns
 */
declare function isNumber(target: unknown): target is number;
/**
 * check {@link target} if is a symbol or not
 */
declare function isSymbol(target: unknown): target is symbol;
/**
 * check target if is a string or not
 * @param target
 * @returns
 */
declare function isString(target: unknown): target is string;
/**
 * if target is a boolean, or not
 * @param target
 * @returns
 */
declare function isBoolean(target: unknown): target is boolean;
/**
 * return true when {@link target} is a function, but not a class.
 */
declare function isFn(target: unknown): target is Fn;
/**
 * if target is an array, or not
 * @param target
 * @returns
 */
declare function isArray<T = unknown>(target: unknown): target is Array<T>;
/**
 * if target is a object and not null
 * @param target
 * @returns
 */
declare function isObject(target: unknown): target is Record<string, unknown>;
/**
 * - if target is array or Set or Map, check if it's size is 0
 * - if target is object, check if it has any properties
 * - if target is string, check if it's length is 0
 * - if target is null or undefined, return true
 * - other wise, return false
 * @param target
 */
declare function isEmpty(target: number | bigint | boolean | Fn): false;
declare function isEmpty(target: unknown): boolean;
/**
 * if target is an object and iterable
 *
 * @example
 * ```ts
 * iterable([]) // => true
 * iterable('23') // => false
 * ```
 *
 * @param target
 * @returns
 */
declare function isIterable<V>(target: unknown): target is Iterable<V>;
/**
 * if target is an object and async iterable
 *
 * @example
 * ```ts
 * const asyncIter = async function* () {
 *  yield 1
 * }
 * iterable(asyncIter) // => true
 * iterable([]) // => false
 * iterable('23') // => false
 * ```
 *
 * @param target
 * @returns
 */
declare function isAsyncIterable<V>(target: unknown): target is AsyncIterable<V>;
/**
 * if target is null or undefined
 * @param target
 * @returns
 */
declare function isNullish(target: unknown): target is null | undefined;
/**
 * if target is a primitive value
 * @param target
 * @returns
 */
declare function isPrimitive(target: unknown): target is PrimitiveType;
/**
 * if target is a promise
 *
 * @param target
 * @returns
 */
declare function isPromise<T = unknown>(target: unknown): target is Promise<T>;
/**
 * if target is a promise like object
 *
 * @param target
 * @returns
 */
declare function isPromiseLike<T = unknown>(target: unknown): target is PromiseLike<T>;
//#endregion
//#region src/logger/createLogger.d.ts
type LoggerLevel = 'info' | 'warn' | 'error';
interface LoggerWriteOption {
  level: LoggerLevel;
  namespace?: string;
}
type LoggerWriteFn = (opt: LoggerWriteOption, formatter?: string, ...params: unknown[]) => void;
interface LoggerOption {
  write?: LoggerWriteFn;
}
/**
 * create a simple logger, support print prefix, and enable/disable.
 *
 * @param prefix
 * @returns
 */
declare function createLogger(namespace?: string, opt?: LoggerOption): {
  log: (formatter?: string, ...params: unknown[]) => void;
  info: (formatter?: string, ...params: unknown[]) => void;
  warn: (formatter?: string, ...params: unknown[]) => void;
  error: (formatter?: string, ...params: unknown[]) => void;
  isEnabled: boolean;
  enable(): void;
  disable(): void;
};
type Logger = ReturnType<typeof createLogger>;
interface ILogger {
  log: (formatter?: string, ...params: unknown[]) => void;
  info: (formatter?: string, ...params: unknown[]) => void;
  warn: (formatter?: string, ...params: unknown[]) => void;
  error: (formatter?: string, ...params: unknown[]) => void;
}
//#endregion
//#region src/math/number.d.ts
/**
 * like {@link Number.prototype.toFixed}, but return a number instead of string.
 * @param num
 * @param fractionDigits
 * @returns
 */
declare function toFixed(num: number | string, fractionDigits: number): number;
/**
 * ensure value is between [min, max].
 *
 * @param value
 * @param min
 * @param max
 * @returns
 */
declare function clamp(value: number, min: number, max: number): number;
/**
 * like {@link Math.round}, but support specify fraction digits.
 * @param value
 * @param fractionDigits
 * @returns
 */
declare function round(value: number, fractionDigits: number): number;
/**
 * Convert value to the range [start, end)
 *
 * @param value
 * @param start
 * @param end
 * @returns
 */
declare function normalizeToRange(value: number, start: number, end: number): number;
//#endregion
//#region src/math/sum.d.ts
/**
 * calculate the sum of arr
 *
 * @param arr
 * @returns
 */
declare function sum(...arr: number[]): number;
//#endregion
//#region src/migration/core.d.ts
interface UpgradeConfig {
  version: number;
  upgrade: (data: any) => Awaitable<VersionedData>;
}
interface MigrationOption {
  upgrades: UpgradeConfig[];
}
interface VersionedData {
  version: number;
}
declare function execMigration(data: Optional<unknown>, option: MigrationOption): Promise<unknown>;
//#endregion
//#region src/options/index.d.ts
interface SimpleOption<T = string> {
  label?: string;
  value: T;
  [key: string]: unknown;
}
type GetSimpleOptionValue<T> = T extends SimpleOption<infer V> ? V : unknown;
declare function getOptionByLabel<T extends SimpleOption>(options: T[], label?: string): T | undefined;
declare function getOptionByValue<T extends SimpleOption>(options: T[], value?: GetSimpleOptionValue<T>): T | undefined;
declare function getOptionLabelByValue<T extends SimpleOption>(options: T[], value?: GetSimpleOptionValue<T>): string | undefined;
//#endregion
//#region src/pool/createPool.d.ts
interface PoolOption {
  /**
   * @default 10
   */
  maximize: number;
}
/**
 * create a simple request pool, it will limit the max request count.
 *
 * @param request
 * @param opt
 * @returns
 */
declare function createPool<T extends Fn>(request: T, opt?: Partial<PoolOption>): (this: unknown, ...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
//#endregion
//#region src/print/table.d.ts
interface TextTableOption {
  /**
   * @default "-"
   */
  headLine?: string;
  highlight?: (cell: TableCellType) => string;
}
type TableCellType = Optional<string | number | boolean>;
declare function textTable(input: TableCellType[][], opt?: TextTableOption): string[][];
interface TextTableToStringOption extends TextTableOption {}
declare function textTableToString(input: TableCellType[][], opt?: TextTableToStringOption): string;
declare function uniformTable(table: TableCellType[][], opt?: TextTableOption): string[][];
//#endregion
//#region src/rpc/types.d.ts
interface Procedure {
  [key: string]: Procedure | Fn;
}
interface CommunicationAdapter<T extends CommunicationProtocol = CommunicationProtocol> {
  /**
   *
   * @param receiveCallback Return true if the data is valid message
   */
  registerReceiveCallback(receiveCallback: Fn<boolean, [data: T]>): void;
  send(data: T): void;
}
declare enum MessageFlag {
  Default = 0,
  /**
   * Remote response
   */
  Response = 1
}
interface CommunicationProtocol {
  /**
   * ID
   */
  _: string;
  /**
   * Flags
   */
  f: number;
  /**
   * Key path
   */
  k?: string[];
  /**
   * Arguments
   */
  a?: unknown[];
  /**
   * Error
   */
  e?: string;
  /**
   * Response data
   */
  d?: unknown;
  /**
   * Namespcae
   */
  n?: string;
}
//#endregion
//#region src/rpc/adaptor/messageChannel.d.ts
declare function createMessageChannelAdaptor(m: MessagePort): CommunicationAdapter<CommunicationProtocol>;
//#endregion
//#region src/rpc/adaptor/worker.d.ts
declare function createWorkerAdaptor(m?: Worker): CommunicationAdapter<CommunicationProtocol>;
//#endregion
//#region src/rpc/core.d.ts
interface RPCCommonOption {
  namespace?: string;
  adaptor: CommunicationAdapter;
}
interface RPCServerOption<M> extends RPCCommonOption {
  methods: M;
}
declare function createRPCServer<M extends Procedure>(opt: RPCServerOption<M>): {
  methods: M;
};
type Promisify<T> = { [K in keyof T]: T[K] extends Fn<infer R, infer P> ? (...args: P) => Promise<R> : Promisify<T[K]> };
interface ClientOptions extends RPCCommonOption {
  /**
   * Timeout in milliseconds
   * @default 2000
   */
  timeout?: number;
}
declare function createRPCClient<T extends Procedure>(t: ClientOptions): Promisify<T>;
//#endregion
//#region src/sandbox/eval.d.ts
interface MakeSaferEvalOption {
  /**
   * @default ['console']
   */
  allowedGlobalKeys?: string[];
  /**
   * Extends global objects
   */
  globals?: Record<string, unknown>;
  /**
   * If allow side effects is true, then it will use global version of that function,
   * which may cause memory leak if not clear the side effect.
   *
   * By default, it will create a side effect free version of those function.
   *
   * @todo not implement
   */
  allowSideEffects?: {
    /**
     * Auto call clearTimeout after execution is done
     */
    setTimeout?: boolean;
    /**
     * Auto call clearInterval after execution is done
     */
    setInterval?: boolean;
    /**
     * Auto call cancelAnimationFrame after execution is done
     */
    requestAnimationFrame?: boolean;
    /**
     * Auto call cancelIdleCallback after execution is done
     */
    requestIdleCallback?: boolean;
    /**
     * This will create a AbortController for all fetch calls, and it will
     * call abort() after execution is done
     */
    fetch?: boolean;
  };
}
/**
 *
 * It use {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/AsyncFunction AsyncFunction}
 * to create a more safe runtime, it default only enable a very small set of global objects.
 *
 * If you want to enable more global objects. You can change `allowedGlobalKeys`.
 *
 * @example
 *
 * ```ts
 * const saferEval = createSaferEval()
 * const $ctx = { a: 0 }
 *
 * await saferEval('$ctx', '$.a = 1')($ctx)
 *
 * expect($ctx.a).toBe(1)
 * ```
 */
declare function createSaferEval(opt?: MakeSaferEvalOption): <T extends Fn>(...parameters: string[]) => (...args: Parameters<T>) => Promise<ReturnType<T>>;
//#endregion
//#region src/string/style.d.ts
declare function PascalCase(str: string): string;
declare function camelCase(str: string): string;
declare function snake_case(str: string): string;
declare function kebab$case(str: string): string;
//#endregion
//#region src/url/utils.d.ts
/**
 * Parse url, return false if input is not valid.
 *
 */
declare function parseURL(input: string | URL, base?: string): false | URL;
/**
 * Update searchParams by query with encodeURIComponent
 *
 * @example
 * ```ts
 * withQuery('http://example.com', { a: 1, b: false, c: 'xx' }) // => http://example.com?a=1&b=false&c=xx
 * ```
 *
 */
declare function withQuery(input: string | URL, query: Record<string, any>): URL;
//#endregion
//#region src/utils/makePair.d.ts
interface PairConfig<T extends Fn> {
  __default?: T;
  [key: string]: Optional<T>;
}
/**
 * eg.
 *
 * ```ts
 * const handler = makePair({
 *  __default() {
 *    return 'cool'
 *  },
 *  100() {
 *    return 100
 *  },
 *  xxx() {
 *    return 200
 *  },
 * })
 *
 * expect(handler('100')).toEqual(100)
 * expect(handler('xxx')).toEqual(200)
 * expect(handler('hhhh')).toEqual('cool')
 * ```
 * @param config
 * @returns
 */
declare function makePair<T extends Fn>(config: PairConfig<T>): (type: string, ...args: Parameters<T>) => Optional<ReturnType<T>>;
interface PairDictConfig<T> {
  __default?: T;
  [key: string]: Optional<T>;
}
/**
 * eg.
 *
 * ```ts
 * const handler = makeDictPair({
 *  __default: 'cool',
 *  100: 100,
 *  xxx: 200,
 * })
 *
 * expect(handler('100')).toEqual(100)
 * expect(handler('xxx')).toEqual(200)
 * expect(handler('200')).toEqual('cool')
 * ```
 * @param config
 * @returns
 */
declare function makeDictPair<T>(config: PairDictConfig<T>): (type: string) => Optional<T>;
//#endregion
//#region src/utils/platform.d.ts
declare const isWeb: boolean;
declare const isNode: boolean;
//#endregion
//#region src/utils/toValue.d.ts
declare function toValue<T>(valueOrFn: Factory<T>): T;
//#endregion
export { Arrayable, AsyncFactory, Awaitable, BindConfig, ClientOptions, CommunicationAdapter, CommunicationProtocol, Container, Ctor, DeepPartial, DeepRequired, EmptyObject, EventEmitter, ExtractObjectKeys, Factory, Fn, GetSimpleOptionValue, IAsyncChainable, IChainable, ILogger, JsonArray, JsonObject, JsonPrimitive, JsonValue, Listener, Logger, LoggerLevel, LoggerOption, LoggerWriteFn, LoggerWriteOption, MakeSaferEvalOption, MessageFlag, MigrationOption, ObjectValues, Optional, PairConfig, PairDictConfig, ParesJsonOption, PascalCase, PlainObject, PoolOption, PrimitiveType, Procedure, RPCCommonOption, RPCServerOption, SimpleEventEmitter, SimpleOption, SleepResult, TableCellType, TextTableOption, TextTableToStringOption, TransformJsonData, UpgradeConfig, VersionedData, base64ToJson, camelCase, chain, clamp, compose, compressText, createLogger, createMessageChannelAdaptor, createPool, createPromise, createRPCClient, createRPCServer, createSaferEval, createWorkerAdaptor, decompressText, ensureArray, execMigration, filterTreeNodes, findNodeInTree, getOptionByLabel, getOptionByValue, getOptionLabelByValue, has, isArray, isAsyncIterable, isBoolean, isCls, isEmpty, isFn, isIterable, isNode, isNullish, isNumber, isObject, isPrimitive, isPromise, isPromiseLike, isString, isSymbol, isWeb, jsonToBase64, kebab$case, makeDictPair, makePair, nanoid, noop, normalizeToRange, parseJson, parseURL, remove, round, sleep, snake_case, sum, textTable, textTableToString, toFixed, toValue, traverse, uniformTable, withQuery };
//# sourceMappingURL=index.d.mts.map