@idlebox/common 1.3.35 → 1.4.0

package/lib/esm/__create_index.generated.d.mts

@@ -1,1229 +0,0 @@
-export declare function addDisposableEventListener<T extends Function>(target: IEventHostObject<T> | IEventEmitterObject<T>, type: string, options: IEventListenerOptions, handler: T): IDisposable;
-
-export declare function addDisposableEventListener<T extends Function>(target: IEventHostObject<T> | IEventEmitterObject<T>, type: string, handler: T): IDisposable;
-
-export declare function analyzePath(p: string): IPathInfo;
-
-/**
- * Compare two array, returns the difference from `before` to `after`
- * @public
- */
-export declare function arrayDiff<T>(_before: readonly T[], after: readonly T[]): {
-    add: T[];
-    del: T[];
-    same: T[];
-};
-
-/**
- * Returns a new array without duplicate values
- * @public
- */
-export declare function arrayUnique<T>(arr: readonly T[]): T[];
-
-/**
- * Removes duplicate values from an array
- * @public
- */
-export declare function arrayUniqueReference(arr: any[]): void;
-
-/**
- * Assert function must have oneof displayName/name property
- */
-export declare function assertFunctionHasName(func: MaybeNamedFunction): void;
-
-/**
- * assert value is not null or undefined or NaN
- * @public
- */
-export declare function assertNotNull<T>(val: T | null | undefined): T;
-
-export declare function assertSerializable(value: any): void;
-
-/**
- * like CallbackList, but async
- */
-export declare class AsyncCallbackList<Argument extends unknown[]> {
-    protected list: MyAsyncCallback<Argument>[];
-    protected running: boolean;
-    constructor();
-    count(): number;
-    reset(): void;
-    /**
-     * @param name optional name of `item` (will assign displayName to `item`)
-     * @returns function list length
-     */
-    add(item: MyAsyncCallback<Argument>, name?: string): number;
-    /**
-     * @returns if removed: return `item`; if did not exists: return null
-     */
-    remove(item: MyAsyncCallback<Argument>): null | MyAsyncCallback<Argument>;
-    /**
-     * Stop run if one callback return `true`
-     * @returns {boolean} true if one callback return true
-     */
-    run(...argument: Argument): Promise<boolean>;
-}
-
-/**
- * Async version of Disposable
- * @public
- */
-declare class AsyncDisposable_2 implements IAsyncDisposable, IDisposableEvents {
-    private readonly _disposables;
-    protected readonly _onDisposeError: Emitter<Error>;
-    readonly onDisposeError: EventRegister<Error>;
-    protected readonly _onBeforeDispose: Emitter<void>;
-    readonly onBeforeDispose: EventRegister<void>;
-    private _disposed?;
-    get hasDisposed(): boolean;
-    /**
-     * @throws if already disposed
-     */
-    assertNotDisposed(): void;
-    /**
-     * register a disposable object
-     */
-    _register<T extends IAsyncDisposable>(d: T): T;
-    _register<T extends IAsyncDisposable & IDisposableEvents>(d: T, autoDereference?: boolean): T;
-    _unregister(d: IAsyncDisposable): boolean;
-    dispose(): Promise<void>;
-}
-export { AsyncDisposable_2 as AsyncDisposable }
-
-/**
- * Convert Iterator into Promise, resolve with the last value from Iterator
- */
-export declare function awaitIterator<T>(generator: Iterator<T>): Promise<T>;
-
-/**
- * Auto bind `this` to class method
- */
-export declare const bindThis: MethodDecorator;
-
-/**
- * Manage a list of callback
- */
-export declare class CallbackList<Argument extends unknown[]> {
-    protected list: MyCallback<Argument>[];
-    protected running: boolean;
-    protected stop: boolean;
-    constructor();
-    count(): number;
-    /**
-     * remove all callback
-     */
-    reset(): void;
-    /**
-     * @param name optional name of `item` (will assign displayName to `item`)
-     * @returns function list length
-     */
-    add(item: MyCallback<Argument>, name?: string): number;
-    /**
-     * @returns if removed: return `item`; if did not exists: return null
-     */
-    remove(item: MyCallback<Argument>): null | MyCallback<Argument>;
-    /**
-     * in a callback, call this.stopRun() to stop remain callbacks (not by return false)
-     * @returns {boolean} true if every callback called, false if stop in middle
-     */
-    run(...argument: Argument): boolean;
-    stopRun(): void;
-}
-
-/** @public */
-export declare function camelCase(str: string): string;
-
-/**
- * Error when cancel() is called
- * @public
- */
-export declare class CanceledError extends Error {
-    constructor();
-}
-
-/** @public */
-export declare interface CancellationToken {
-    readonly isCancellationRequested: boolean;
-    onCancellationRequested(callback: EventHandler<void>): IDisposable;
-}
-
-/** @public */
-export declare class CancellationTokenSource extends DisposableOnce implements IDisposable {
-    private readonly driver;
-    readonly token: CancellationToken;
-    constructor();
-    cancel(): void;
-    _dispose(): void;
-}
-
-export declare enum ColorKind {
-    DISABLE = 0,
-    TERMINAL = 1,
-    WEB = 2,
-    DETECT = 3
-}
-
-export declare function concatStringType<T0 extends string>(t0: T0): `${T0}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string>(t0: T0, t1: T1): `${T0}${T1}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string>(t0: T0, t1: T1, t2: T2): `${T0}${T1}${T2}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string>(t0: T0, t1: T1, t2: T2, t3: T3): `${T0}${T1}${T2}${T3}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4): `${T0}${T1}${T2}${T3}${T4}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): `${T0}${T1}${T2}${T3}${T4}${T5}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string, T16 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string, T16 extends string, T17 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}${T17}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string, T16 extends string, T17 extends string, T18 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}${T17}${T18}`;
-
-export declare function concatStringType<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string, T16 extends string, T17 extends string, T18 extends string, T19 extends string>(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19): `${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}${T17}${T18}${T19}`;
-
-export declare function convertCatchedError(e: unknown): Error;
-
-/**
- * Get a symbol singleton, if not exists, create it
- *
- * this is very like Symbol.for, but not real global symbol
- * @public
- */
-export declare function createSymbol(category: string, name: string): symbol;
-
-/**
- * Like a Set, but use custom compare function insteadof ===
- */
-export declare class CustomSet<Type = string> {
-    protected registry: Type[];
-    private finder;
-    constructor(finder?: Finder<Type>);
-    setFinder(finder: Finder<Type>): void;
-    has(item: Type): boolean;
-    add(item: Type): boolean;
-    /**
-     * @returns all added values
-     */
-    addAll(items: Type[]): Type[];
-    delete(item: Type): boolean;
-    /**
-     * @returns all deleted values
-     */
-    deleteAll(items: Type[]): Type[];
-    clear(): void;
-    get length(): number;
-    get size(): number;
-    [Symbol.iterator](): Iterator<Type>;
-    keys(): Iterator<Type>;
-    values(): Iterator<Type>;
-    toArray(): Type[];
-}
-
-export declare type DeepNonNullable<T> = T extends Primitive ? T : T extends ReadonlyArray<infer U> | Array<infer U> ? DeepNonNullableArray<U> : T extends ReadonlyMap<infer K, infer V> | Map<infer K, infer V> ? DeepNonNullableMap<K, V> : T extends ReadonlySet<infer M> ? DeepNonNullableSet<M> : DeepNonNullableObject<T>;
-
-declare type DeepNonNullableArray<T> = Array<DeepNonNullable<T>>;
-
-declare type DeepNonNullableMap<K, V> = Map<DeepNonNullable<K>, DeepNonNullable<V>>;
-
-declare type DeepNonNullableObject<T> = {
-    [K in keyof T]-?: NonNullable<T[K]>;
-};
-
-declare type DeepNonNullableSet<T> = Set<DeepNonNullable<T>>;
-
-export declare type DeepPartial<T> = T extends Primitive ? T : T extends ReadonlyArray<infer U> ? DeepPartialArray<U> : T extends ReadonlyMap<infer K, infer V> ? DeepPartialMap<K, V> : T extends ReadonlySet<infer M> ? DeepPartialSet<M> : DeepPartialObject<T>;
-
-declare type DeepPartialArray<T> = Array<DeepPartial<T>>;
-
-declare type DeepPartialMap<K, V> = Map<DeepPartial<K>, DeepPartial<V>>;
-
-declare type DeepPartialObject<T> = {
-    [K in keyof T]?: DeepPartial<T[K]>;
-};
-
-declare type DeepPartialSet<T> = Set<DeepPartial<T>>;
-
-export declare type DeepReadonly<T> = T extends Primitive ? T : T extends Array<infer U> ? DeepReadonlyArray<U> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;
-
-declare type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>;
-
-declare type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
-
-declare type DeepReadonlyObject<T> = {
-    readonly [K in keyof T]: DeepReadonly<T[K]>;
-};
-
-declare type DeepReadonlySet<T> = ReadonlySet<DeepReadonly<T>>;
-
-export declare type DeepWriteable<T> = T extends Primitive ? T : T extends ReadonlyArray<infer U> ? DeepWriteableArray<U> : T extends ReadonlyMap<infer K, infer V> ? DeepWriteableMap<K, V> : T extends ReadonlySet<infer M> ? DeepWriteableSet<M> : DeepWriteableObject<T>;
-
-declare type DeepWriteableArray<T> = Array<DeepWriteable<T>>;
-
-declare type DeepWriteableMap<K, V> = Map<DeepWriteable<K>, DeepWriteable<V>>;
-
-declare type DeepWriteableObject<T> = {
-    -readonly [K in keyof T]: DeepWriteable<T[K]>;
-};
-
-declare type DeepWriteableSet<T> = Set<DeepWriteable<T>>;
-
-/**
- * a promise can resolve or reject later
- * @public
- */
-export declare class DeferredPromise<T, PT = any> {
-    readonly p: Promise<T> & IProgressHolder<T, PT>;
-    private _completeCallback;
-    private _errorCallback;
-    private _state;
-    private _progressList?;
-    constructor();
-    notify(progress: PT): this;
-    progress(fn: ProgressCallback<PT>): void;
-    get completed(): boolean;
-    get resolved(): boolean;
-    get rejected(): boolean;
-    /**
-     * resolve the promise
-     */
-    complete(value: T): void;
-    /**
-     * reject the promise
-     */
-    error(err: any): void;
-    /**
-     * reject the promise with CancelError
-     */
-    cancel(): void;
-    /**
-     * Convert promise into deferred
-     * returns a DeferredPromise, resolve when prev resolve, reject when prev reject
-     */
-    static wrap(prev: Promise<any>): DeferredPromise<unknown, any>;
-}
-
-export declare function definePublicConstant(object: any, propertyKey: string | symbol, value: any): void;
-
-/**
- * remember arguments after run
- * run all later added function with memorized argument
- */
-export declare class DelayCallbackList<Argument extends unknown[]> {
-    private delayArgument?;
-    private delayComplete;
-    protected list?: MyDelayCallback<Argument>[];
-    count(): number;
-    add(item: MyDelayCallback<Argument>, name?: string): void;
-    run(argument: Argument): void;
-}
-
-/**
- * Delete a symbol from window/global object
- * @public
- */
-export declare function deleteSymbol(category: string, name: string): void;
-
-/**
- * Standalone disposable class, can use as instance or base class.
- */
-declare class Disposable_2 implements IDisposable, IDisposableEvents {
-    private readonly _disposables;
-    protected readonly _onDisposeError: Emitter<Error>;
-    readonly onDisposeError: EventRegister<Error>;
-    protected readonly _onBeforeDispose: Emitter<void>;
-    readonly onBeforeDispose: EventRegister<void>;
-    private _disposed?;
-    get hasDisposed(): boolean;
-    /**
-     * @throws if already disposed
-     */
-    assertNotDisposed(): void;
-    /**
-     * register a disposable object
-     */
-    _register<T extends IDisposable>(d: T): T;
-    _register<T extends IDisposable & IDisposableEvents>(d: T, autoDereference?: boolean): T;
-    _unregister(d: IDisposable): boolean;
-    dispose(): void;
-}
-export { Disposable_2 as Disposable }
-
-export declare abstract class DisposableOnce implements IDisposable {
-    private _disposed?;
-    get hasDisposed(): boolean;
-    dispose(): void;
-    protected abstract _dispose(): void;
-}
-
-/**
- * Error when call dispose() twice
- */
-export declare class DisposedError extends Error {
-    readonly previous: Error;
-    readonly inspectString: string;
-    constructor(object: any, previous: Error);
-    tryCreateConsoleWarning(): Promise<void>;
-}
-
-/**
- * Dispose the global disposable store
- * this function must be manually called by user, when registerGlobalLifecycle is used
- *
- * @throws when call twice
- */
-export declare function disposeGlobal(): Promise<void>;
-
-/**
- * 事件注册对象
- * @public
- */
-export declare class Emitter<T> implements IDisposable {
-    protected readonly _callbacks: EventHandler<T>[];
-    constructor();
-    /**
-     * @returns 当前注册回调数量
-     */
-    listenerCount(): number;
-    /**
-     * 触发本事件
-     * @param data 回调数据
-     */
-    fire(data: T): void;
-    /**
-     * 与 `fire()`相同，但是忽略任何错误，并且即便出错也继续执行全部callback
-     */
-    fireNoError(data: T): void;
-    /**
-     * 获取handle()方法的引用
-     */
-    get register(): EventRegister<T>;
-    /**
-     * 注册本事件的新回调
-     * @param callback 回调函数
-     */
-    handle(callback: EventHandler<T>): IDisposable;
-    dispose(): void;
-}
-
-/**
- * Same as disposeGlobal, but do not throw by duplicate call
- */
-export declare function ensureDisposeGlobal(): Promise<void>;
-
-export declare function ensureGlobalObject<T>(symbol: string, constructor: () => T): T;
-
-declare interface ErrorOptions_2 {
-    cause?: unknown;
-}
-
-/** @public */
-export declare function escapeRegExp(str: string): string;
-
-export declare interface EventHandler<T> {
-    (data: T): void;
-}
-
-export declare interface EventRegister<T> {
-    (callback: EventHandler<T>): IDisposable;
-}
-
-/**
- * A map, will throw error when try to get not exists key
- */
-export declare class ExtendMap<K, V> extends Map<K, V> {
-    /**
-     * Get value from map, if not exists, throw an error
-     */
-    get(id: K): V;
-    /**
-     * Get value from map, if not exists, return def instead (not insert it into map)
-     */
-    get(id: K, def: V): V;
-    /**
-     * Get a value, if not exists, call init() and set to map
-     */
-    entry(id: K, init: (id: K) => V): V;
-}
-
-/** Find the index of given item */
-export declare interface Finder<Type> {
-    (this: Type[], item: Type): number;
-}
-
-/**
- * @deprecated Use Promise.allSettled instead
- */
-export declare function finishAllPromise<T>(ps: Promise<T>[]): Promise<PromiseResultArray<T>>;
-
-/**
- * Takes ms
- */
-export declare function fromTimeStamp(timestamp: number): Date;
-
-/**
- * Get displayName/name of a function
- */
-export declare function functionName(func: Function): string;
-
-/**
- * Get nth line of Error.stack
- * @returns {string} if frame greater than max, return ''
- */
-export declare function getErrorFrame(e: Error, frame: number): string;
-
-/**
- * Returns ms
- */
-export declare function getTimeStamp(date: Date): number;
-
-export declare function getTypeOf(value: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "function" | "null" | "Promise" | "Error" | "DOM" | "EventTarget" | "datetime" | "regexp" | "unknown";
-
-/**
- * globalThis when supported.
- * if not, window in browser, global in nodejs
- * @public
- */
-export declare const globalObject: any;
-
-/**
- * Same with globalSingletonStrong, but save instance in a WeakMap, so it maybe delete by gc if no reference
- * @public
- */
-export declare function globalSingleton<T>(symbol: symbol | string, constructor: () => T): T;
-
-/**
- * Same with globalSingletonStrong, but save instance in a WeakMap, so it maybe delete by gc if no reference
- * @public
- */
-export declare function globalSingleton<T>(symbol: symbol | string): T | undefined;
-
-/**
- * Delete a key from window/global space
- * use with care
- * @public
- */
-export declare function globalSingletonDelete(symbol: symbol | string): void;
-
-/**
- * Get an singleton instance from window/global space
- * if symbol did not exists, create it and assign to window/global
- * @public
- */
-export declare function globalSingletonStrong<T>(symbol: symbol | string, constructor: () => T): T;
-
-/**
- * Get an singleton instance from window/global space
- * @public
- */
-export declare function globalSingletonStrong<T>(symbol: symbol | string): T | undefined;
-
-export declare const hasGlobal: boolean;
-
-export declare const hasProcess: boolean;
-
-export declare const hasWindow: boolean;
-
-export declare function hookClass<TC extends IConstructorOf<T>, T>(target: TC): IHooks<T, TC>;
-
-export declare const hookClassSymbol: unique symbol;
-
-export declare namespace humanDate {
-    /**
-     * Format: HH:mm:ss
-     */
-    export function time(date: Date | string | number): string;
-    /**
-     * Format: YYYY-MM-dd
-     *
-     * separator can change
-     */
-    export function date(date: Date | string | number, sp?: string): string;
-    /**
-     * Format: YYYY-MM-dd HH:mm:ss
-     */
-    export function datetime(date: Date | string | number): string;
-    export interface ITimeFormatter {
-        (s: number): string;
-    }
-    export interface IFormatters {
-        s: ITimeFormatter;
-        m: ITimeFormatter;
-        h: ITimeFormatter;
-        d: ITimeFormatter;
-    }
-    /**
-     * set format for time delta
-     */
-    export function setLocaleFormatter(formatter: Partial<IFormatters>): void;
-    /**
-     * format time delta (in ms) to string, like: '1d'
-     * when ms<=0, returns '0s'
-     *
-     * format can set by `setLocaleFormatter`
-     * day is the largest unit
-     */
-    export function deltaTiny(ms: number): string;
-    /**
-     * format time delta (in ms) to string, like: '1d10m42s'
-     * when ms<=0, returns '0s'
-     *
-     * format can set by `setLocaleFormatter`
-     * day is the largest unit
-     */
-    export function delta(ms: number): string;
-}
-
-/**
- * Convert bytes to largest unit, with binary prefix unit (1024), eg: 211.293GiB
- * @public
- */
-export declare function humanSize(bytes: number, fixed?: number): string;
-
-/**
- * Convert bytes to largest unit, with SI prefix unit (1000), eg: 211.293GB
- * @public
- */
-export declare function humanSizeSI(bytes: number, fixed?: number): string;
-
-/** @deprecated */
-export declare function humanSpeed(bps: number): string;
-
-/**
- * @public
- */
-export declare interface IArrayUpdate<T> {
-    add: T[];
-    del: T[];
-    same: T[];
-}
-
-/** @public */
-export declare interface IAsyncDisposable {
-    dispose(): void | Promise<void>;
-}
-
-declare interface IConstructorOf<T> extends Object {
-    new (...args: any[]): T;
-}
-
-/** @public */
-export declare interface IDisposable {
-    dispose(): void;
-}
-
-/**
- * @private
- */
-export declare interface IDisposableEvents {
-    onDisposeError: EventRegister<Error>;
-    onBeforeDispose: EventRegister<void>;
-    readonly hasDisposed: boolean;
-}
-
-export declare interface IEventEmitterObject<T extends Function> {
-    addListener(type: string, handler: T): any;
-    removeListener(type: string, handler: T): any;
-}
-
-export declare interface IEventHostObject<T extends Function> {
-    addEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
-    removeEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
-}
-
-export declare interface IEventListenerOptions {
-    capture?: boolean;
-    once?: boolean;
-    passive?: boolean;
-}
-
-export declare type IFsmRuleMap<StateType, EventType> = MapLike_2<StateType, MapLike_2<EventType, StateType>>;
-
-declare interface IHooks<T, TC> {
-    afterConstruct?: ((obj: T) => void)[];
-    beforeConstruct?: ((obj: TC) => T | void)[];
-}
-
-/**
- * Decorater version of `initOnRead`
- * @see initOnRead
- */
-export declare function init<O, T extends keyof O>(init: InitFunc<O, O[T]>): PropertyDecorator;
-
-/** @public */
-export declare interface InitFunc<O, T> {
-    (this: O): T;
-}
-
-/**
- * Define property on target, call init it when first use, them memorize
- * @public
- */
-export declare function initOnRead<O, T extends keyof O>(target: any, propertyKey: T, init: InitFunc<O, O[T]>): void;
-
-declare type IOverrides = Record<string, string | IOverridesObject>;
-
-declare interface IOverridesObject {
-    [packageName: string]: IOverrides;
-}
-
-export declare interface IPackageJson {
-    name: string;
-    version: string;
-    main: string;
-    module: string;
-    browser: string;
-    description: string;
-    keywords: string[];
-    homepage: string;
-    bugs: StructString<{
-        url: string;
-        email: string;
-    }>;
-    license: string;
-    author: Person;
-    contributors: Person[];
-    funding: MaybeArray<StringOr<{
-        type: string;
-        url: string;
-    }>>;
-    files: string[];
-    bin: StringOr<Record<string, string>>;
-    man: MaybeArray<string>;
-    directories: {
-        bin: string;
-        man: string;
-        [name: string]: string;
-    };
-    repository: StructString<{
-        type: string;
-        url: string;
-        directory: string;
-    }>;
-    scripts: Record<string, string>;
-    config: Record<string, any>;
-    overrides: IOverrides;
-    engines: Record<string, string>;
-    os: string[];
-    cpu: string[];
-    private: boolean;
-    publishConfig: Record<string, any>;
-    workspaces: string[];
-    exports: string | Record<string, string | Record<string, string>>;
-    dependencies: Record<string, string>;
-    devDependencies: Record<string, string>;
-    optionalDependencies: Record<string, string>;
-    bundleDependencies: string[];
-    peerDependencies: Record<string, string>;
-    peerDependenciesMeta: Record<string, {
-        optional: true;
-        [option: string]: any;
-    }>;
-    [field: string]: any;
-}
-
-export declare interface IPathInfo {
-    kind: PathKind;
-    prefix?: string;
-    path: string;
-    url?: URL;
-}
-
-export declare interface IProgressHolder<T, PT> {
-    progress(fn: ProgressCallback<PT>): Promise<T> & IProgressHolder<T, PT>;
-}
-
-export declare const is32Bit: boolean;
-
-export declare let is64Bit: boolean;
-
-/**
- * return true if a path is absolute:
- *   - /xxxx
- *   - \xxxx
- *   - c:/
- *   - c:\
- *   - http://
- */
-export declare function isAbsolute(path: string): boolean;
-
-/**
- * is the two array EXACTLY same
- * @public
- */
-export declare function isArraySame<T>(a1: readonly T[], a2: readonly T[]): boolean;
-
-/** @public */
-export declare function isCanceledError(error: any): boolean;
-
-/**
- * Check if a date is NaN
- */
-export declare function isDateInvalid(date: Date): boolean;
-
-export declare function isDisposedError(error: any): boolean;
-
-export declare let isElectron: boolean;
-
-export declare let isElectronMain: boolean;
-
-export declare let isElectronRenderer: boolean;
-
-export declare let isElectronSandbox: boolean;
-
-export declare let isLinux: boolean;
-
-export declare let isMacintosh: boolean;
-
-export declare let isNative: boolean;
-
-/**
- * Should ensure a and b is none-null before call this
- * @returns true when a and b has EXACTLY same keys and values
- */
-export declare function isObjectSame(a: any, b: any): boolean;
-
-/**
- * Should ensure a and b is none-null before call this
- * @returns true when a and b has EXACTLY same keys and values, recursive compare all object values
- */
-export declare function isObjectSameRecursive(a: any, b: any): boolean;
-
-export declare function isScalar(value: any): value is ScalarTypes;
-
-export declare function isSerializable(value: any): SerializableKind;
-
-export declare interface IStateChangeEvent<StateType, EventType> {
-    from: StateType;
-    to: StateType;
-    reason: EventType;
-}
-
-/** @public */
-export declare function isTimeoutError(error: Error): error is TimeoutError;
-
-export declare let isWeb: boolean;
-
-export declare let isWindows: boolean;
-
-export declare interface IUniqueIdFactory<T> {
-    (item: T): string;
-}
-
-export declare const KnownError: typeof KnownErrorNode;
-
-declare abstract class KnownErrorAbstract extends Error {
-    protected static debugMode: boolean;
-    static debug(enabled?: boolean): void;
-    static is(e: any): e is KnownErrorAbstract;
-}
-
-declare class KnownErrorNode extends KnownErrorAbstract {
-    constructor(message: string, consopt?: ErrorOptions_2);
-}
-
-/**
- * lowercase first char
- * @public
- */
-export declare function lcfirst<T extends string>(str: T): Uncapitalize<T>;
-
-/** @public */
-export declare function linux_case(str: string): string;
-
-/** @public */
-export declare function linux_case_hyphen(str: string): string;
-
-export declare interface MapLike<V> {
-    [id: string]: V;
-}
-
-declare type MapLike_2<K, V> = Pick<Map<K, V>, 'get' | 'has' | 'keys'>;
-
-declare type MaybeArray<T> = T | T[];
-
-export declare interface MaybeNamedFunction extends Function {
-    displayName?: string;
-}
-
-/**
- * Decorate class method/getter
- *
- * remember first return value of method/getter, directlly return memorized value when call it again
- */
-export declare const memo: MethodDecorator;
-
-/**
- * 会记住上次fire的内容，并在每个新的handler注册时立即调用一次的Emitter
- * 显然，这会对fire的内容保留一个引用，可以调用forget()取消
- * @public
- */
-export declare class MemorizedEmitter<T> extends Emitter<T> {
-    private _memo?;
-    private _is_memo;
-    fire(data: T): void;
-    fireNoError(data: T): void;
-    handle(callback: EventHandler<T>): IDisposable;
-    forget(): void;
-    dispose(): void;
-}
-
-export declare const memorizeValueSymbol: unique symbol;
-
-export declare interface MyAsyncCallback<Argument extends unknown[]> {
-    displayName?: string;
-    (...param: Argument): Promise<void | undefined | boolean> | void | undefined | boolean;
-}
-
-export declare interface MyCallback<Argument extends unknown[]> {
-    displayName?: string;
-    (...param: Argument): any;
-}
-
-export declare interface MyDelayCallback<Argument extends unknown[]> {
-    displayName?: string;
-    (...param: Argument): void;
-}
-
-/**
- * Function with displayName
- */
-export declare interface NamedFunction extends Function {
-    displayName: string;
-}
-
-/**
- * Set displayName of a function
- */
-export declare function nameFunction<T extends Function>(name: string, func: T): T & NamedFunction;
-
-export declare function nextDay(d: Date, n?: number): Date;
-
-export declare function nextHour(d: Date, n?: number): Date;
-
-export declare function nextMinute(d: Date, n?: number): Date;
-
-export declare function nextMonth(d: Date, n?: number): Date;
-
-export declare function nextSecond(d: Date, n?: number): Date;
-
-export declare function nextWeek(d: Date, n?: number): Date;
-
-export declare function nextYear(d: Date, n?: number): Date;
-
-/**
- * ensure a value is an array
- * @public
- */
-export declare function normalizeArray<T>(input: T | T[]): T[];
-
-/**
- * replace // to /
- * replace \ to /
- * remove ending /
- */
-export declare function normalizePath(p: string): string;
-
-/**
- * Get deep child property of an object
- * @param path object path seprate by "."
- */
-export declare function objectPath(obj: object, path: string): any;
-
-export declare const oneDay = 86400000;
-
-export declare const oneHour = 1440000;
-
-export declare const oneMinute = 60000;
-
-export declare const oneSecond = 1000;
-
-export declare const oneWeek = 604800000;
-
-/**
- * Pad number to two digits string, used in time format
- * @public
- */
-export declare function pad2(s: number): string;
-
-export declare class PathArray extends TypePathArrayAbstract {
-}
-
-/**
- * Work on "PATH"-like values, but always use / insteadof \
- */
-declare abstract class PathArrayAbstract extends Set<string> {
-    private readonly sep;
-    constructor(init: string, sep?: ':' | ';');
-    abstract normalize(path: string): string;
-    split(pathArrStr: string): string[];
-    toString(): string;
-    /**
-     * @returns an array with `part` append to every element
-     */
-    join(part: string): string[];
-}
-
-export declare class PathArrayPosix extends PathArrayAbstract {
-    normalize(path: string): string;
-    add(paths: string): this;
-    delete(paths: string): boolean;
-    has(path: string): boolean;
-}
-
-export declare class PathArrayWindows extends PathArrayAbstract {
-    private readonly caseMap;
-    normalize(path: string): string;
-    clear(): void;
-    add(paths: string): this;
-    delete(paths: string): boolean;
-    has(path: string): boolean;
-    values(): IterableIterator<string>;
-}
-
-export declare enum PathKind {
-    url = 0,
-    unc = 1,
-    win = 2,
-    cifs = 3,
-    unix = 4,
-    relative = 5
-}
-
-declare type Person = StructString<{
-    name: string;
-    email: string;
-    url: string;
-}>;
-
-export declare function prettyFormatError(e: Error, withMessage?: boolean): string;
-
-export declare function prettyPrintError(type: string, e: Error): void;
-
-export declare type Primitive = undefined | null | boolean | string | number | Function | bigint;
-
-export declare type ProgressCallback<T = any> = (value: T) => void;
-
-/**
- * resolve with true when `p` resolve
- * resolve with false when `p` reject (and drop error)
- */
-export declare function promiseBool(p: Promise<any>): Promise<boolean>;
-
-export declare class PromiseCollection {
-    protected readonly promiseList: Record<string, DeferredPromise<any>>;
-    size(): number;
-    create(id: string): Promise<any> & IProgressHolder<any, any>;
-    has(id: string): boolean;
-    done(id: string, data: any): void;
-    error(id: string, e: Error): void;
-    dispose(): void;
-}
-
-/** @deprecated */
-export declare interface PromiseResultArray<T> {
-    count: number;
-    fulfilledResult: T[];
-    fulfilled: number[];
-    rejectedResult: Error[];
-    rejected: number[];
-}
-
-export declare function RegexpFinder(this: RegExp[], item: RegExp): number;
-
-/**
- * Add object into global disposable store, it will be dispose when call to `disposeGlobal`
- */
-export declare function registerGlobalLifecycle(object: IDisposable): void;
-
-export declare function relativePath(from: string, to: string): string;
-
-declare type ScalarTypes = bigint | number | Number | boolean | Boolean | string | String | symbol | undefined | null | Date | RegExp | Function;
-
-export declare const sepList: string;
-
-export declare enum SerializableKind {
-    Invalid = 0,
-    Primitive = 1,
-    Manual = 2,
-    Other = 3
-}
-
-export declare function setErrorLogRoot(_root: string): void;
-
-export declare class SimpleStateMachine<StateType, EventType> {
-    protected currentState: StateType;
-    protected readonly rules: IFsmRuleMap<StateType, EventType>;
-    private readonly _onStateChange;
-    readonly onStateChange: EventRegister<IStateChangeEvent<StateType, EventType>>;
-    constructor(rules: IFsmRuleMap<StateType, EventType>, init_state: StateType);
-    protected moveTo(state: StateType): void;
-    getName(): StateType;
-    change(event: EventType): void;
-}
-
-export declare function singleton(type?: SingletonType): ClassDecorator;
-
-export declare const singletonSymbol: unique symbol;
-
-export declare enum SingletonType {
-    Throw = 0,
-    Return = 1
-}
-
-/**
- * @returns promise resolve after specific time
- */
-export declare function sleep(ms: number): Promise<void>;
-
-/**
- * Sort string array alphabet order
- *
- * to be used in <arr>.sort()
- * @public
- */
-export declare function sortByString(a: string, b: string): number;
-
-declare type StringOr<Object> = string | Object;
-
-declare type StructString<Object> = string | Object;
-
-/**
- * assert value is not null or undefined or NaN
- * @throws Value is null or undefined
- * @public
- */
-export declare function throwNull<T>(val: T): NonNullable<T>;
-
-/**
- * @returns promise reject with TimeoutError after specific time
- */
-export declare function timeout(ms: number, error?: string): Promise<never>;
-
-/**
- * Error when timeout() done
- * @public
- */
-export declare class TimeoutError extends Error {
-    constructor(time: number, what?: string);
-}
-
-export declare function timeoutPromise<T>(ms: number, p: Promise<T>): Promise<T>;
-
-export declare function timeoutPromise<T>(ms: number, message: string, p: Promise<T>): Promise<T>;
-
-export declare function timeoutPromise<T, PT = any>(ms: number, p: DeferredPromise<T, PT>): DeferredPromise<T, PT>;
-
-export declare function timeoutPromise<T, PT = any>(ms: number, message: string, p: DeferredPromise<T, PT>): DeferredPromise<T, PT>;
-
-export declare class TimeoutPromiseCollection extends PromiseCollection {
-    private readonly defaultTimeoutMs;
-    constructor(defaultTimeoutMs?: number);
-    create(id: string, timeoutMs?: number, timeoutMsg?: string): Promise<any> & IProgressHolder<any, any>;
-}
-
-/**
- * Convert "dispose function" to disposable object
- * @public
- */
-export declare function toDisposable(fn: () => void): IDisposable;
-
-/**
- * try to call `inspect` method of an object, if not exists, call `toString`.
- * @returns {string}
- */
-export declare function tryInspect(object: any): any;
-
-declare const TypePathArrayAbstract: typeof PathArrayPosix;
-
-/**
- * Uppercase first char
- * @public
- */
-export declare function ucfirst<T extends string>(str: T): Capitalize<T>;
-
-/**
- * Returns a function to be used in <arr>.filter()
- *
- * the returned function can use multiple times, it will remember all values inter multiple arrays
- *
- * @param {IUniqueIdFactory} idFactory function takes an array element, return it's id to be compare with each other
- * @public
- */
-export declare function uniqueFilter<T>(idFactory?: IUniqueIdFactory<T>): (item: T) => boolean;
-
-declare interface Unsubscribable {
-    unsubscribe(): void;
-}
-
-export declare function unsubscribableToDisposable(subscription: Unsubscribable): {
-    dispose: () => void;
-};
-
-export declare type ValueCallback<T = any> = (value: T | Promise<T>) => void;
-
-export declare abstract class WrappedConsole {
-    info: Console['info'];
-    log: Console['log'];
-    success: Console['log'];
-    debug: Console['debug'];
-    error: Console['error'];
-    trace: Console['trace'];
-    warn: Console['warn'];
-    assert: Console['assert'];
-    time: Console['time'];
-    timeEnd: Console['timeEnd'];
-    timeLog: Console['timeLog'];
-    count: Console['count'];
-    countReset: Console['countReset'];
-    group: Console['group'];
-    groupCollapsed: Console['groupCollapsed'];
-    groupEnd: Console['groupEnd'];
-    table: Console['table'];
-    dir: Console['dir'];
-    clear: Console['clear'];
-    protected readonly title: string;
-    protected readonly parent: Console;
-    protected readonly bind: boolean;
-    constructor(title: string, { parent, bind }?: WrappedConsoleOptions);
-    protected wrap<T extends keyof Omit<Console & {
-        Console: any;
-    }, 'Console'>>(original: T): Function;
-    private wrapSimple;
-    private wrapExtra;
-    protected createPrefix(message: string): string;
-    private wrapMessageAt;
-    private convertObjectArg;
-    protected abstract processColorLabel(normalizedArguments: any[], messageLoc: number, level: string, prefix: string): void;
-    protected uncolor(args: any[], pos: number, prefix: string, postfix: string): void;
-}
-
-export declare interface WrappedConsoleOptions {
-    parent?: Console;
-    bind?: boolean;
-}
-
-export declare function x(): number;
-
-export { }