@yorozu/utils 0.1.1

package/lib/index.d.ts

@@ -0,0 +1,468 @@
+type TypesAreEqual<T, V> = (() => T) extends () => V ? ((() => V) extends () => T ? true : false) : false;
+
+declare function unknownToError(err: unknown): Error;
+declare class NotImplementedError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+declare function throwNotImplemented(message?: string, options?: ErrorOptions): never;
+declare function throwUnreachable(): never;
+
+type NoneToVoidFunction = () => void;
+type AnyFunction = (...args: any[]) => any;
+type AnyToVoidFunction = (...args: any[]) => void;
+type AnyToNever<T> = any extends T ? never : T;
+type MaybePromise<T> = Promise<T> | T;
+type MaybeArray<T> = Array<T> | T;
+type Values<T> = T[keyof T];
+type Truthy<T> = T extends false | "" | 0 | null | undefined ? never : T;
+type UnsafeMutate<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOfUnion<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;
+type UnionToTuple<U, Acc extends Array<any> = [], L = LastOfUnion<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, L>, [L, ...Acc]>;
+
+type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | AnyToNever<BigInt64Array> | AnyToNever<BigUint64Array>;
+
+declare function compare<T extends TypedArray>(a: T, b: T): -1 | 0 | 1;
+declare function equal<T extends TypedArray>(a: T, b: T): boolean;
+
+declare function indexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start?: number): number;
+declare function indexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+declare function lastIndexOf(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number, start: number): number;
+declare function lastIndexOf(haystack: BigInt64Array | BigUint64Array, needle: bigint, start?: number): number;
+declare function indexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+declare function lastIndexOfArray<T extends TypedArray>(haystack: T, needle: T, start?: number): number;
+declare function includes(haystack: Exclude<TypedArray, BigInt64Array | BigUint64Array>, needle: number): boolean;
+declare function includes(haystack: BigInt64Array | BigUint64Array, needle: bigint): boolean;
+declare function includesArray<T extends TypedArray>(haystack: T, needle: T): boolean;
+
+declare function toDataView(buf: TypedArray): DataView;
+declare function view<R extends TypedArray>(ctor: {
+    new (buffer: ArrayBufferLike, byteOffset: number, byteLength: number): R;
+    BYTES_PER_ELEMENT: number;
+}, buf: ArrayBufferView): R;
+declare function getPlatformByteOrder(): "little" | "big";
+declare namespace getPlatformByteOrder {
+    var _cachedByteOrder: boolean | null;
+}
+
+type index$1_TypedArray = TypedArray;
+declare const index$1_compare: typeof compare;
+declare const index$1_equal: typeof equal;
+declare const index$1_getPlatformByteOrder: typeof getPlatformByteOrder;
+declare const index$1_includes: typeof includes;
+declare const index$1_includesArray: typeof includesArray;
+declare const index$1_indexOf: typeof indexOf;
+declare const index$1_indexOfArray: typeof indexOfArray;
+declare const index$1_lastIndexOf: typeof lastIndexOf;
+declare const index$1_lastIndexOfArray: typeof lastIndexOfArray;
+declare const index$1_toDataView: typeof toDataView;
+declare const index$1_view: typeof view;
+declare namespace index$1 {
+  export { type index$1_TypedArray as TypedArray, index$1_compare as compare, index$1_equal as equal, index$1_getPlatformByteOrder as getPlatformByteOrder, index$1_includes as includes, index$1_includesArray as includesArray, index$1_indexOf as indexOf, index$1_indexOfArray as indexOfArray, index$1_lastIndexOf as lastIndexOf, index$1_lastIndexOfArray as lastIndexOfArray, index$1_toDataView as toDataView, index$1_view as view };
+}
+
+declare function concat(bufs: Array<Uint8Array>): Uint8Array;
+declare function concat2(a: ArrayLike<number>, b: ArrayLike<number>): Uint8Array;
+declare function concat3(a: ArrayLike<number>, b: ArrayLike<number>, c: ArrayLike<number>): Uint8Array;
+
+declare const empty: Uint8Array;
+declare function clone(buf: Uint8Array): Uint8Array;
+declare function readNthBit(byte: number, bit: number): number;
+
+declare class BufferPool {
+    #private;
+    readonly size: number;
+    readonly maxAllocSize: number;
+    constructor(size?: number);
+    allocate(size: number): Uint8Array;
+    reset(): void;
+}
+declare function setDefaultPool(size: number): void;
+declare function allocate(size: number): Uint8Array;
+declare function allocateWith(init: ArrayLike<number>): Uint8Array;
+
+declare function reverse(buffer: Uint8Array): void;
+declare function toReversed(buffer: ArrayLike<number>): Uint8Array;
+
+declare function swap16(buf: Uint8Array): void;
+declare function swap32(buf: Uint8Array): void;
+declare function swap64(buf: Uint8Array): void;
+declare function swapNibbles(buf: Uint8Array): void;
+
+declare function xor(data: Uint8Array, key: Uint8Array): Uint8Array;
+declare function xorInPlace(data: Uint8Array, key: Uint8Array): void;
+
+type index_BufferPool = BufferPool;
+declare const index_BufferPool: typeof BufferPool;
+declare const index_allocate: typeof allocate;
+declare const index_allocateWith: typeof allocateWith;
+declare const index_clone: typeof clone;
+declare const index_concat: typeof concat;
+declare const index_concat2: typeof concat2;
+declare const index_concat3: typeof concat3;
+declare const index_empty: typeof empty;
+declare const index_readNthBit: typeof readNthBit;
+declare const index_reverse: typeof reverse;
+declare const index_setDefaultPool: typeof setDefaultPool;
+declare const index_swap16: typeof swap16;
+declare const index_swap32: typeof swap32;
+declare const index_swap64: typeof swap64;
+declare const index_swapNibbles: typeof swapNibbles;
+declare const index_toReversed: typeof toReversed;
+declare const index_xor: typeof xor;
+declare const index_xorInPlace: typeof xorInPlace;
+declare namespace index {
+  export { index_BufferPool as BufferPool, index_allocate as allocate, index_allocateWith as allocateWith, index_clone as clone, index_concat as concat, index_concat2 as concat2, index_concat3 as concat3, index_empty as empty, index_readNthBit as readNthBit, index_reverse as reverse, index_setDefaultPool as setDefaultPool, index_swap16 as swap16, index_swap32 as swap32, index_swap64 as swap64, index_swapNibbles as swapNibbles, index_toReversed as toReversed, index_xor as xor, index_xorInPlace as xorInPlace };
+}
+
+declare function toBytes(value: bigint, length?: number, le?: boolean): Uint8Array;
+declare function fromBytes(buffer: Uint8Array, le?: boolean): bigint;
+
+declare function bitLength(n: bigint): number;
+declare function twoMultiplicity(n: bigint): bigint;
+declare function min2(a: bigint, b: bigint): bigint;
+declare function min(...args: Array<bigint>): bigint;
+declare function max2(a: bigint, b: bigint): bigint;
+declare function max(...args: Array<bigint>): bigint;
+declare function abs(a: bigint): bigint;
+declare function euclideanGcd(a: bigint, b: bigint): bigint;
+declare function modPowBinary(base: bigint, exp: bigint, mod: bigint): bigint;
+declare function modInv(a: bigint, n: bigint): bigint;
+
+declare const lookup: Map<number, number>;
+declare const encodeLookup: Map<number, number>;
+declare function decode$1(data: string, url?: boolean): Uint8Array;
+declare function encode$1(bytes: Uint8Array, url?: boolean): string;
+declare function encodedLength$2(n: number): number;
+declare function decodedLength$1(n: number): number;
+
+declare const base64_encodeLookup: typeof encodeLookup;
+declare const base64_lookup: typeof lookup;
+declare namespace base64 {
+  export { decode$1 as decode, decodedLength$1 as decodedLength, encode$1 as encode, base64_encodeLookup as encodeLookup, encodedLength$2 as encodedLength, base64_lookup as lookup };
+}
+
+declare function encode(buf: Uint8Array): string;
+declare function decode(data: string): Uint8Array;
+declare function encodedLength$1(n: number): number;
+declare function decodedLength(n: number): number;
+
+declare const hex_decode: typeof decode;
+declare const hex_decodedLength: typeof decodedLength;
+declare const hex_encode: typeof encode;
+declare namespace hex {
+  export { hex_decode as decode, hex_decodedLength as decodedLength, hex_encode as encode, encodedLength$1 as encodedLength };
+}
+
+declare const encoder: TextEncoder;
+declare const decoder: TextDecoder;
+declare function encodedLength(data: string): number;
+
+declare const utf8_decoder: typeof decoder;
+declare const utf8_encodedLength: typeof encodedLength;
+declare const utf8_encoder: typeof encoder;
+declare namespace utf8 {
+  export { utf8_decoder as decoder, utf8_encodedLength as encodedLength, utf8_encoder as encoder };
+}
+
+declare function enumerate<T>(iterable: Iterable<T>): IterableIterator<[number, T]>;
+
+declare const brand: unique symbol;
+type Brand<T, Name extends string> = T & {
+    [brand]: Name;
+};
+
+declare function assert(condition: boolean, message?: unknown): asserts condition;
+declare function assertHashKey<Obj extends object, Key extends string>(obj: Obj, key: Key): asserts obj is Obj & Record<Key, unknown>;
+declare function unsafeCastType<T>(value: unknown): asserts value is T;
+declare function assertNotNull<T>(value: T): asserts value is Exclude<T, null | undefined>;
+declare function asNonNull<T>(value: null extends T ? T : undefined extends T ? T : Brand<"type is not nullable", "TypeError">): Exclude<T, null | undefined>;
+declare function assertMatches(str: string, regex: RegExp): RegExpMatchArray;
+
+type Middleware<C, R = void> = (ctx: C, next: (ctx: C) => Promise<R>) => Promise<R>;
+type ComposedMiddleware<C, R = void> = (ctx: C) => Promise<R>;
+declare function composeMiddlewares<C, R = void>(middlewares: Array<Middleware<C, R>>, final: ComposedMiddleware<C, R>): ComposedMiddleware<C, R>;
+declare function composeMiddlewares<C, R = void>(middlewares: Array<Middleware<C, R>>): Middleware<C, R>;
+
+declare const isNotUndefined: <T>(val: T) => val is Exclude<T, undefined>;
+declare const isNotNull: <T>(val: T) => val is Exclude<T, null>;
+declare const isBoolean: (val: any) => val is boolean;
+declare const isTruthy: <T>(val: T) => val is Truthy<T>;
+declare const isFalsy: <T>(val: T) => val is Exclude<T, Truthy<T>>;
+declare const isFunction: (val: any) => val is AnyFunction;
+declare const isNumber: (val: any) => val is number;
+declare const isString: (val: unknown) => val is string;
+declare const isSymbol: (val: any) => val is symbol;
+declare const isBigInt: (val: any) => val is bigint;
+declare const isObject: (val: any) => val is object;
+
+declare function noop(): void;
+
+declare function objectKeys<T extends object>(obj: T): Array<`${keyof T & (string | number | boolean | null | undefined)}`>;
+declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
+declare function clearUndefinedInPlace<T extends object>(obj: T): void;
+type MergeInsertions<T> = T extends object ? {
+    [K in keyof T]: MergeInsertions<T[K]>;
+} : T;
+type DeepMerge<F, S> = MergeInsertions<{
+    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
+}>;
+interface DeepMergeOptions {
+    undefined?: "replace" | "ignore";
+    properties?: "replace" | "ignore";
+    arrays?: "replace" | "ignore" | "merge";
+    objects?: "replace" | "ignore" | "merge";
+}
+declare function deepMerge<T extends object = object>(into: T, from: MaybeArray<T>, options?: DeepMergeOptions): T;
+declare function deepMerge<T extends object = object, S extends object = T>(into: T, from: MaybeArray<S>, options?: DeepMergeOptions): DeepMerge<T, S>;
+
+declare function splitOnce(str: string, separator: string): [string, string];
+declare function assertStartsWith(str: string, prefix: string): asserts str is `${typeof prefix}${string}`;
+declare function assertsEndsWith(str: string, suffix: string): asserts str is `${string}${typeof suffix}`;
+
+type Timer = Brand<object, "Timer">;
+type Interval = Brand<object, "Interval">;
+declare const setTimeoutWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Timer;
+declare const setIntervalWrap: <T extends (...args: any[]) => any>(fn: T, ms: number, ...args: Parameters<T>) => Interval;
+declare const clearTimeoutWrap: (timer?: Timer) => void;
+declare const clearIntervalWrap: (timer?: Interval) => void;
+
+type timers_Interval = Interval;
+type timers_Timer = Timer;
+declare namespace timers {
+  export { type timers_Interval as Interval, type timers_Timer as Timer, clearIntervalWrap as clearInterval, clearTimeoutWrap as clearTimeout, setIntervalWrap as setInterval, setTimeoutWrap as setTimeout };
+}
+
+declare class AsyncInterval {
+    #private;
+    constructor(handler: (abortSignal: AbortSignal) => Promise<void>, interval: number);
+    start(after?: number): void;
+    startNow(): void;
+    stop(): void;
+    onError(handler: (err: unknown) => void): void;
+}
+
+declare class AsyncLock {
+    private _queue;
+    acquire(): Promise<void>;
+    release(): void;
+    with<T>(func: () => Promise<T>): Promise<T>;
+}
+
+declare class CustomMap<ExternalKey, InternalKey, V> implements Map<ExternalKey, V> {
+    #private;
+    readonly clear: Map<ExternalKey, V>["clear"];
+    constructor(externalToInternal: (key: ExternalKey) => InternalKey, internalToExternal: (key: InternalKey) => ExternalKey);
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    getInternalMap(): Map<InternalKey, V>;
+    delete(key: ExternalKey): boolean;
+    forEach(cb: (value: V, key: ExternalKey, map: Map<ExternalKey, V>) => void, thisArg?: any): void;
+    get(key: ExternalKey): V | undefined;
+    has(key: ExternalKey): boolean;
+    set(key: ExternalKey, value: V): this;
+    getOrInsert(key: ExternalKey, value: V): ReturnType<Map<ExternalKey, V>["getOrInsert"]>;
+    getOrInsertComputed(key: ExternalKey, callback: (key: ExternalKey) => V): ReturnType<Map<ExternalKey, V>["getOrInsertComputed"]>;
+    entries(): ReturnType<Map<ExternalKey, V>["entries"]>;
+    keys(): ReturnType<Map<ExternalKey, V>["keys"]>;
+    values(): ReturnType<Map<ExternalKey, V>["values"]>;
+    [Symbol.iterator](): ReturnType<Map<ExternalKey, V>["entries"]>;
+}
+
+declare class CustomSet<ExternalKey, InternalKey> implements Set<ExternalKey> {
+    #private;
+    readonly clear: Set<ExternalKey>["clear"];
+    constructor(externalToInternal: (key: ExternalKey) => InternalKey, internalToExternal: (key: InternalKey) => ExternalKey);
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    add(value: ExternalKey): this;
+    delete(value: ExternalKey): boolean;
+    forEach(cb: (value: ExternalKey, value2: ExternalKey, set: Set<ExternalKey>) => void, thisArg?: any): void;
+    has(value: ExternalKey): boolean;
+    entries(): ReturnType<Set<ExternalKey>["entries"]>;
+    keys(): ReturnType<Set<ExternalKey>["keys"]>;
+    values(): ReturnType<Set<ExternalKey>["values"]>;
+    union<U>(other: Set<U>): Set<ExternalKey | U>;
+    intersection<U>(other: Set<U>): Set<ExternalKey & U>;
+    difference<U>(other: ReadonlySetLike<ExternalKey & U>): Set<ExternalKey>;
+    symmetricDifference<U>(other: Set<U>): Set<ExternalKey | U>;
+    isSubsetOf(other: ReadonlySetLike<ExternalKey>): boolean;
+    isSupersetOf(other: Set<ExternalKey>): boolean;
+    isDisjointFrom(other: Set<ExternalKey>): boolean;
+    [Symbol.iterator](): ReturnType<Set<ExternalKey>["keys"]>;
+    getInternalSet(): Set<InternalKey>;
+}
+
+interface DequeOptions {
+    capacity?: number;
+}
+declare class Deque<T> {
+    #private;
+    protected _list: Array<T | undefined>;
+    protected _head: number;
+    protected _tail: number;
+    protected _capacityMask: number;
+    protected _capacity?: number;
+    constructor(array?: ArrayLike<T>, options?: DequeOptions);
+    get length(): number;
+    isEmpty(): boolean;
+    at(index: number): T | undefined;
+    peekFront(): T | undefined;
+    peekBack(): T | undefined;
+    pushFront(item: T): number;
+    pushBack(item: T): number;
+    popFront(): T | undefined;
+    popBack(): T | undefined;
+    removeOne(idx: number): T | undefined;
+    removeBy(predicate: (item: T) => boolean): void;
+    clear(): void;
+    indexOf(item: T): number;
+    findIndex(predicate: (item: T) => boolean): number;
+    find(predicate: (item: T) => boolean): T | undefined;
+    includes(item: T): boolean;
+    toArray(): Array<T>;
+    [Symbol.iterator](): Iterator<T>;
+}
+
+interface TwoWayLinkedList<K, V> {
+    key: K;
+    value: V;
+    prev?: TwoWayLinkedList<K, V>;
+    next?: TwoWayLinkedList<K, V>;
+}
+declare class LruMap<K, V> {
+    #private;
+    constructor(capacity: number, MapImpl?: new () => Map<K, TwoWayLinkedList<K, V>>);
+    get size(): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    clear(): void;
+}
+
+declare class LruSet<T> {
+    #private;
+    constructor(capacity: number, SetImpl?: new () => Set<T>);
+    get size(): number;
+    add(value: T): void;
+    has(value: T): boolean;
+    clear(): void;
+}
+
+declare class AsyncQueue<T> {
+    #private;
+    readonly queue: Deque<T>;
+    readonly maxSize: number | undefined;
+    constructor(from?: ArrayLike<T> | Deque<T>, maxSize?: number);
+    get length(): number;
+    get isFull(): boolean;
+    get remainingCapacity(): number;
+    get ended(): boolean;
+    enqueue(item: T): Promise<void>;
+    tryEnqueue(item: T): boolean;
+    end(): void;
+    peek(): T | undefined;
+    next(): T | undefined;
+    nextOrWait(): Promise<T | undefined>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+declare class Emitter<T> {
+    #private;
+    get length(): number;
+    add(listener: (value: T) => void): void;
+    forwardTo(emitter: Emitter<T>): void;
+    remove(listener: (value: T) => void): void;
+    emit(value: T): void;
+    once(listener: (value: T) => void): void;
+    listeners(): readonly ((value: T) => void)[];
+    clear(): void;
+}
+
+interface AsyncResourceContext<T> {
+    readonly current: T | null;
+    readonly currentFetchedAt: number;
+    readonly currentExpiresAt: number;
+    readonly isBackground: boolean;
+    readonly abort: AbortSignal | null;
+}
+interface AsyncResourceOptions<T> {
+    autoReload?: boolean;
+    authReloadAfter?: number;
+    swr?: boolean;
+    swrValidator?: (ctx: AsyncResourceContext<T>) => boolean;
+    fetcher: (ctx: AsyncResourceContext<T>) => Promise<{
+        data: T;
+        expiresIn: number;
+    }>;
+    onError?: (err: unknown, ctx: AsyncResourceContext<T>) => void;
+}
+declare class AsyncResource<T> {
+    #private;
+    readonly options: AsyncResourceOptions<T>;
+    readonly onUpdated: Emitter<AsyncResourceContext<T>>;
+    constructor(options: AsyncResourceOptions<T>);
+    get isStale(): boolean;
+    setData(data: T, expiresIn: number): void;
+    update(force?: boolean): Promise<void>;
+    get(): Promise<T | null>;
+    getCached(): T | null;
+    destroy(): void;
+}
+
+declare class ConditionVariable {
+    #private;
+    wait(): Promise<void>;
+    notify(): void;
+}
+
+declare class Deferred<T = void> {
+    readonly resolve: (value: T) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly promise: Promise<T>;
+    constructor();
+}
+declare class DeferredTracked<T = void> {
+    #private;
+    readonly promise: Promise<T>;
+    readonly status: {
+        type: "pending";
+    } | {
+        type: "fulfilled";
+        value: T;
+    } | {
+        type: "rejected";
+        reason: unknown;
+    };
+    constructor();
+    get result(): T | undefined;
+    get error(): unknown | undefined;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}
+
+interface AsyncPoolOptions<T> {
+    limit?: number;
+    signal?: AbortSignal;
+    onErrorStrategy?: (item: T, index: number, error: unknown) => MaybePromise<"ignore" | "collect" | "throw">;
+}
+declare class ErrorInfo<T> {
+    readonly item: T;
+    readonly index: number;
+    readonly error: unknown;
+    constructor(item: T, index: number, error: unknown);
+}
+declare class AggregateError<T> extends Error {
+    readonly errors: Array<ErrorInfo<T>>;
+    constructor(errors: Array<ErrorInfo<T>>);
+}
+declare function asyncPool<T>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<T | void>, options?: AsyncPoolOptions<T>): Promise<void>;
+declare function parallelMap<T, R>(iterable: Iterable<T> | AsyncIterable<T>, executor: (item: T, index: number) => MaybePromise<R>, options?: AsyncPoolOptions<T>): Promise<Array<R>>;
+
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+
+export { AggregateError, type AnyFunction, type AnyToNever, type AnyToVoidFunction, AsyncInterval, AsyncLock, type AsyncPoolOptions, AsyncQueue, AsyncResource, type AsyncResourceContext, type AsyncResourceOptions, type ComposedMiddleware, ConditionVariable, CustomMap, CustomSet, type DeepMerge, type DeepMergeOptions, Deferred, DeferredTracked, Deque, type DequeOptions, Emitter, type LastOfUnion, LruMap, LruSet, type MaybeArray, type MaybePromise, type MergeInsertions, type Middleware, type NoneToVoidFunction, NotImplementedError, type Truthy, type TypedArray, type TypesAreEqual, type UnionToIntersection, type UnionToTuple, type UnsafeMutate, type Values, abs, asNonNull, assert, assertHashKey, assertMatches, assertNotNull, assertStartsWith, assertsEndsWith, asyncPool, base64, bitLength, clearUndefinedInPlace, composeMiddlewares, deepMerge, enumerate, euclideanGcd, fromBytes, hex, isBigInt, isBoolean, isFalsy, isFunction, isNotNull, isNotUndefined, isNumber, isObject, isString, isSymbol, isTruthy, max, max2, min, min2, modInv, modPowBinary, noop, objectEntries, objectKeys, parallelMap, sleep, splitOnce, throwNotImplemented, throwUnreachable, timers, toBytes, twoMultiplicity, index$1 as typed, index as u8, unknownToError, unsafeCastType, utf8 };