@tstdl/base 0.92.123 → 0.92.124

package/types.d.ts

@@ -1,214 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
-import type { Signal } from './signals/api.js';
-export type ObjectLiteral = {};
-export type Function<P extends any[] = any[], R = any> = (...params: P) => R;
-export type PrimitiveTypeMap = {
-    string: string;
-    number: number;
-    boolean: boolean;
-    bigint: bigint;
-    symbol: symbol;
-    object: object;
-    function: Function;
-    undefined: undefined;
-};
-export type PrimitiveTypeString<T extends PrimitiveTypeMap[keyof PrimitiveTypeMap] = PrimitiveTypeMap[keyof PrimitiveTypeMap]> = Simplify<keyof PickBy<PrimitiveTypeMap, T>>;
-export type PrimitiveType<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> = Simplify<PrimitiveTypeMap[T]>;
-export type Nested<T> = T | NestedObject<T> | NestedArray<T>;
-export type NestedObject<T> = {
-    [key: string]: Nested<T>;
-};
-export type NestedArray<T> = T[];
-export type FilledArray<T> = [T, ...(T)[]];
-export type FilledReadonlyArray<T> = readonly [T, ...(T)[]];
-export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
-export type PrimitiveValue = Primitive | PrimitiveObject | PrimitiveArray;
-export type PrimitiveObject = {
-    [key: string]: PrimitiveValue;
-};
-export type PrimitiveArray = PrimitiveValue[];
-export type BuiltIn = Primitive | RegExp | Date | Function;
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-export type Json = JsonPrimitive | JsonObject | JsonArray;
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonObject = {
-    [key: string]: Json;
-};
-export type JsonArray = Json[] | readonly Json[];
-export type UndefinableJson = JsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
-export type UndefinableJsonInnerNode = UndefinableJsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
-export type UndefinableJsonPrimitive = JsonPrimitive | undefined;
-export type UndefinableJsonObject = {
-    [key: string]: UndefinableJsonInnerNode;
-};
-export type UndefinableJsonArray = UndefinableJsonInnerNode[] | readonly UndefinableJsonInnerNode[];
-export type ArrayItem<T extends readonly any[]> = T extends readonly (infer U)[] ? U : never;
-export type Enumeration = EnumerationArray | EnumerationObject;
-export type EnumerationArray = readonly [string | number, ...(string | number)[]];
-export type EnumerationObject<V extends string | number = string | number> = Record<string, V>;
-export type EnumerationKey<T extends EnumerationObject = EnumerationObject> = Extract<keyof T, string>;
-export type EnumerationMap<T extends EnumerationObject = EnumerationObject> = SimplifyObject<{
-    [P in EnumerationKey<T>]: (T[P] extends number ? (`${T[P]}` extends `${infer U extends number}` ? U : never) : T[P]) | T[P];
-}>;
-export type EnumerationValue<T extends Enumeration = Enumeration> = T extends EnumerationObject ? SimplifyDeep<EnumerationMap<T>[keyof EnumerationMap<T>]> : T extends EnumerationArray ? T[number] : never;
-export type EnumerationEntry<T extends EnumerationObject = EnumerationObject> = {
-    [P in EnumerationKey<T>]: [P, EnumerationMap<T>[P]];
-}[EnumerationKey<T>];
-type EnumerationEntriesHelper<T extends EnumerationObject = EnumerationObject, Tuple = UnionToTuple<EnumerationKey<T>>> = {
-    [P in keyof Tuple]: [Tuple[P], Tuple[P] extends EnumerationKey<T> ? EnumerationMap<T>[Tuple[P]] : never];
-};
-export type EnumerationEntries<T extends EnumerationObject = EnumerationObject> = EnumerationEntriesHelper<T> extends (infer U)[] ? U[] : never;
-export type Type<T = any, Arguments extends any[] = any> = Constructor<T, Arguments> & {
-    prototype: T;
-};
-export type Constructor<T = any, Arguments extends any[] = any[]> = new (...args: Arguments) => T;
-export type AbstractType<T = any, Arguments extends any[] = any[]> = AbstractConstructor<T, Arguments> & {
-    prototype: T;
-};
-export type AbstractConstructor<T = any, Arguments extends any[] = any> = abstract new (...args: Arguments) => T;
-export type ReturnTypeOrT<T> = T extends (...args: any) => infer R ? R : T;
-export type Cast<X, Y> = X extends Y ? X : Y;
-export type Record<K extends PropertyKey = PropertyKey, V = any> = {
-    [P in K]: V;
-};
-export type DeepRecord<K extends PropertyKey = PropertyKey, V = any> = {
-    [P in K]: V | DeepRecord<K, V>;
-};
-export type StringMap<T = any> = Record<string, T>;
-export type NumberMap<T = any> = Record<number, T>;
-export type StringNumberMap<T = any> = {
-    [key: string]: T;
-    [key: number]: T;
-};
-export type OneOrMany<T> = T | readonly T[];
-export type WritableOneOrMany<T> = T | T[];
-type FromEntriesEntryValue<T extends readonly (readonly [any, any])[], K> = Extract<T[number], readonly [K, any]>[1];
-export type FromEntries<T> = T extends readonly (readonly [infer Key, any])[] ? {
-    [K in Cast<Key, PropertyKey>]: Fallback<FromEntriesEntryValue<T, K>, T[number][1]>;
-} : never;
-export type Writable<T> = T extends readonly (infer U)[] ? U[] : {
-    -readonly [P in keyof T]: T[P];
-};
-export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[] : {
-    -readonly [P in keyof T]: DeepWritable<T[P]>;
-};
-export type RequiredKeys<T> = {
-    [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? never : K;
-}[keyof T];
-export type OptionalKeys<T> = {
-    [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? K : never;
-}[keyof T];
-export type TypedOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-export type TypedExtract<T, U extends T> = T extends U ? T : never;
-export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
-export type OmitNever<T extends Record> = {
-    [K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-export type BaseType<T extends Exclude<Primitive, null | undefined>> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T extends null ? null : T extends undefined ? undefined : never;
-export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<A & B & C & D & E & F & G & H & I & J, keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>>>;
-/**
- * Omit properties from a type that extend from a specific type.
- */
-export type OmitBy<T, V> = Omit<T, {
-    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
-}[keyof T]>;
-/**
- * Normalize properties of a type that allow `undefined` to make them optional.
- */
-export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
-export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
-    [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
-}>;
-export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;
-export type Simplify<T> = T extends BuiltIn ? T : T extends readonly any[] ? SimplifyArray<T> : T extends Record ? SimplifyObject<T> : T;
-export type SimplifyObject<T extends Record> = {
-    [K in keyof T]: T[K];
-} & {};
-export type SimplifyArray<T extends readonly any[]> = {
-    [I in keyof T]: Simplify<T[I]>;
-};
-export type SimplifyDeep<T> = T extends BuiltIn ? T : T extends readonly any[] ? {
-    [I in keyof T]: SimplifyDeep<T[I]>;
-} : T extends Record ? {
-    [K in keyof T]: SimplifyDeep<T[K]>;
-} & {} : T;
-export type SimplifiedLiteralUnion<Literal extends Primitive, Base extends Primitive = BaseType<Exclude<Literal, null | undefined>>> = If<IsEqual<Literal, Base>, Literal, LiteralUnion<Literal, Base>>;
-export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection : never;
-export type UnionToTuple<T, Tuple extends any[] = []> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? UnionToTuple<Exclude<T, R>, [R, ...Tuple]> : Tuple;
-export type UndefinableObject<T extends Record> = {
-    [K in keyof T]: T[K] | undefined;
-};
-/**
- * Pick properties from a type that extend from a specific type.
- */
-export type PickBy<T, V> = Pick<T, {
-    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
-}[keyof T]>;
-export type NonNullable<T> = T extends null ? never : T;
-export type NonUndefinable<T> = T extends undefined ? never : T;
-export type NonNullOrUndefinable<T> = T extends null | undefined ? never : T;
-/**
- * Makes optional properties required and removes null and undefined
- */
-export type DeepNonNullable<T> = T extends Record ? {
-    [P in keyof T]-?: DeepNonNullable<T[P]>;
-} : NonNullable<T>;
-export type IfAny<T, Then, Else = never> = true extends (false & T) ? Then : Else;
-export type IfUnknown<T, Then, Else = never> = unknown extends T ? Then : Else;
-export type IsAny<T> = IfAny<T, true, false>;
-export type IsUnknown<T> = IfUnknown<T, true, false>;
-export type If<B extends boolean, Then, Else> = B extends true ? Then : Else;
-export type Not<T extends boolean> = T extends true ? false : true;
-export type Fallback<T, F> = [T] extends [never] ? F : T;
-export type PartialProperty<T, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
-export type TypeOf<T extends object, P extends keyof T> = T[P];
-export type PropertyOf<T extends object, P extends keyof T> = Property<Of<T>, P>;
-export type Property<T extends object, P extends keyof T> = {
-    [P2 in keyof T[P]]: T[P][P2];
-};
-export type Of<T> = T;
-export type PropertiesOfType<T, U> = keyof PickBy<T, U>;
-export type Flatten<T> = T extends readonly (infer R)[] ? R : T;
-export type DeepFlatten<T> = T extends readonly (infer R)[] ? DeepFlatten<R> : T extends Record ? {
-    [P in keyof T]: DeepFlatten<T[P]>;
-} : T;
-export type DeepArray<T> = (T | DeepArray<T>)[];
-export type DeepReadonly<T> = T extends BuiltIn ? T : T extends (any[] | readonly any[]) ? DeepReadonlyArray<T[number]> : DeepReadonlyObject<T>;
-export type DeepReadonlyObject<T> = {
-    readonly [P in keyof T]: DeepReadonly<T[P]>;
-};
-export type DeepReadonlyArray<T> = readonly DeepReadonly<T>[];
-export type ReplaceKey<T, K extends keyof T, U> = SimplifyObject<{
-    [P in keyof T]: P extends K ? U : T[P];
-}>;
-export type DeepPartial<T> = T extends BuiltIn ? T : T extends any[] ? DeepPartialArray<T[number]> : T extends readonly any[] ? Readonly<DeepPartialArray<T[number]>> : DeepPartialObject<T>;
-export type DeepPartialObject<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};
-export type DeepPartialArray<T> = DeepPartial<T>[];
-export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export type BinaryData = ArrayBuffer | ArrayBufferView;
-export type Paths<T extends Record> = T extends object ? {
-    [K in keyof T]-?: K extends string | number ? `${K}` | `${K}.${Paths<T[K]>}` : never;
-}[keyof T] : never;
-export type TypeFromPath<T extends Record, Path extends Paths<T> | string> = {
-    [K in Path]: K extends keyof T ? T[K] : K extends `${infer P}.${infer S}` ? T[P] extends Record ? TypeFromPath<T[P], S> : never : never;
-}[Path];
-export type ConstructorParameterDecorator = (target: object, propertyKey: undefined, parameterIndex: number) => void;
-export type ReactiveValue<T> = T | Signal<T> | Observable<T>;
-export type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;
-type PickOmitDeepSelection<T> = T extends (infer U)[] ? (boolean | PickOmitDeepSelection<U>) : T extends Record<any> ? (boolean | {
-    [P in keyof T]?: PickOmitDeepSelection<T[P]>;
-}) : boolean;
-export type PickDeepSelection<T> = PickOmitDeepSelection<T>;
-export type OmitDeepSelection<T> = PickOmitDeepSelection<T>;
-export type PickDeep<T, S extends PickDeepSelection<T>> = T extends Record<any> ? Simplify<{
-    [P in keyof S as S[P] extends (true | Record<any>) ? P : never]: S[P] extends true ? T[Extract<P, keyof T>] : T[Extract<P, keyof T>] extends (infer U)[] ? S[P] extends PickDeepSelection<U> ? PickDeep<U, S[P]>[] : never : S[P] extends Record<any> ? S[P] extends PickDeepSelection<T[Extract<P, keyof T>]> ? PickDeep<T[Extract<P, keyof T>], S[P]> : never : never;
-}> : T;
-export type OmitDeep<T, S extends OmitDeepSelection<T>> = T extends Record<any> ? Simplify<{
-    [P in keyof T as true extends S[Extract<P, keyof S>] ? never : P]: [
-        S[Extract<P, keyof S>]
-    ] extends ([false] | [never]) ? T[P] : S[Extract<P, keyof S>] extends Record<any> ? T[P] extends (infer U)[] ? S[Extract<P, keyof S>] extends OmitDeepSelection<U> ? OmitDeep<U, S[Extract<P, keyof S>]>[] : never : S[Extract<P, keyof S>] extends OmitDeepSelection<T[P]> ? OmitDeep<T[P], S[Extract<P, keyof S>]> : never : never;
-}> : T;
-export {};

package/utils/async-iterable-helpers/take-until.d.ts

@@ -1,3 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/token.js';
-import type { AnyIterable } from '../any-iterable-iterator.js';
-export declare function takeUntilAsync<T>(iterable: AnyIterable<T>, cancellationSignal: CancellationSignal): AsyncIterableIterator<T>;

package/utils/backoff.d.ts

@@ -1,77 +0,0 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import { CancellationToken } from '../cancellation/token.js';
-export type BackoffStrategy = 'linear' | 'exponential';
-export type BackoffOptions = {
-    /**
-     * how to increase delay
-     */
-    strategy: BackoffStrategy;
-    /**
-     * delay to start with
-     */
-    initialDelay: number;
-    /**
-     * amount to increase/multiply delay by/with
-     */
-    increase: number;
-    /**
-     * miaxmum time to back off
-     */
-    maximumDelay?: number;
-};
-export type BackoffLoopController = {
-    /**
-     * backoff before next iteration
-     */
-    backoff: () => void;
-    /**
-     * break out of loop
-     */
-    break: () => void;
-};
-export type BackoffLoopFunction = (controller: BackoffLoopController) => void | Promise<void>;
-/**
- * @param continueToken token to continue loop immediately
- */
-export type BackoffGeneratorYield = (continueToken?: CancellationToken) => void;
-export declare class BackoffHelper {
-    private readonly strategy;
-    private readonly initialDelay;
-    private readonly increase;
-    private readonly maximumDelay;
-    private delay;
-    constructor({ strategy, initialDelay, increase, maximumDelay }: BackoffOptions);
-    reset(): void;
-    backoff(): number;
-}
-/**
- * runs a function until token is set or controller returns and automatically backsoff if function throws. Warning: swallows errors
- * @param options backoff options
- * @param cancellationToken token to cancel loop
- * @param loopFunction function to call
- */
-export declare function autoBackoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationSignal?: CancellationSignal;
-    errorHandler?: (error: Error) => void;
-}): Promise<void>;
-/**
- * runs a function until token is set or controller returns.
- * @param options backoff options
- * @param cancellationToken signal to cancel loop
- * @param loopFunction function to call
- */
-export declare function backoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationSignal?: CancellationSignal;
-}): Promise<void>;
-/**
- * generates endless function which, when called, backs off next iteration
- * @param options backoff options
- * @param cancellationSignal signal to cancel loop
- * @example
- * for await (const backoff of backoffGenerator(options, token)) {
- *  if (iWantToBackoff) {
- *    backoff();
- *  }
- * }
- */
-export declare function backoffGenerator(options: BackoffOptions, cancellationSignal: CancellationSignal): AsyncIterableIterator<BackoffGeneratorYield>;

package/utils/binary.d.ts

@@ -1,16 +0,0 @@
-import type { BinaryData, Type } from '../types.js';
-/**
- * Get ArrayBuffer from binary data
- * @param data data to get ArrayBuffer from
- * @param clone force cloning (might still clone if datas underlying buffer is larger than its view)
- */
-export declare function toArrayBuffer(data: BinaryData, clone?: boolean): ArrayBufferLike;
-/**
- * Convert to Uint8Array
- * @param data binary data
- * @param clone whether to clone buffer or not
- */
-export declare function toUint8Array(data: BinaryData, clone?: boolean): Uint8Array;
-export declare function concatArrayBuffers(buffers: ArrayBufferLike[]): ArrayBufferLike;
-export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: T[], totalLength?: number): T;
-export declare function concatArrayBufferViews<T extends ArrayBufferView>(arrays: ArrayBufferView[], targetType: Type<T, [ArrayBufferLike, number, number]>, totalLength?: number): T;

package/utils/cryptography.d.ts

@@ -1,122 +0,0 @@
-import type { BinaryData, TypedExtract } from '../types.js';
-import type { ReadonlyTuple } from 'type-fest';
-export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
-export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
-export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
-export type SymmetricAlgorithm = `AES-${AesMode}`;
-export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
-export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
-export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
-export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
-export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
-export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-export type Key = JsonWebKey | BinaryData;
-export type ScryptOptions = {
-    cost?: number;
-    blockSize?: number;
-    parallelization?: number;
-    maximumMemory?: number;
-};
-export interface CryptionResult {
-    toBuffer(): Promise<ArrayBuffer>;
-    toHex(): Promise<string>;
-    toBase64(): Promise<string>;
-    toBase64Url(): Promise<string>;
-    toZBase32(): Promise<string>;
-}
-export interface DecryptionResult extends CryptionResult {
-    toUtf8(): Promise<string>;
-}
-export type DigestResult = CryptionResult;
-export type SignResult = CryptionResult;
-/**
- * Encrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData | string): CryptionResult;
-/**
- * Decrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to decrypt
- */
-export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData): DecryptionResult;
-/**
- * Hashes data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData | string): DigestResult;
-/**
- * Signs data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to sign
- */
-export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData | string): SignResult;
-/**
- * Verifies data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param signature signature
- * @param data data to verify using provided signature
- */
-export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData | string, data: BinaryData | string): Promise<boolean>;
-/**
- * Imports a HMAC CryptoKey
- * @param algorithm hash algorithm
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports a CryptoKey for symmetric encryption
- * @param algorithm symmetric algorithm
- * @param length key length
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports an ECDSA CryptoKey
- * @param curve ECDSA curve
- * @param key JWK or DER encoded key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a pbkdf2 CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importPbkdf2Key(key: BinaryData | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Generates a new ECDSA CryptoKeyPair
- * @param curve ECDSA cruve to use
- * @param extractable whether the key can be used for exportKey
- * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
- */
-export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolean, usages?: TypedExtract<KeyUsage, 'sign' | 'verify'>[]): Promise<CryptoKeyPair>;
-/**
- * Generates a pbkdf2 CryptoKey
- * @param extractable whether the key can be used for exportKey
- */
-export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
-/**
- * Derive byte array from key
- * @param length length in bytes
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- */
-export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array>;
-/**
- * Derive multiply byte arrays from key
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
- * @param count how many Uint8Arrays to derive
- */
-export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array, Lengths['length']>>;
-export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array, C>>;

package/utils/encoding.d.ts

@@ -1,36 +0,0 @@
-import type { BinaryData } from '../types.js';
-/**
- * Encodes text to utf8
- * @param text text to encode
- * @returns utf8 encoded text
- */
-export declare function encodeUtf8(text: string): Uint8Array;
-/**
- * Encodes text stream to utf8 bytes stream
- */
-export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
-/**
- * Decodes buffer to string
- * @param buffer buffer to decode
- * @param encoding encoding, defaults to utf8
- * @returns decoded string
- */
-export declare function decodeText(buffer: BinaryData, encoding?: string, options?: TextDecoderOptions): string;
-/**
- * Transforms binary stream to string stream
- * @param encoding encoding, defaults to utf8
- * @returns stream of decoded string
- */
-export declare function decodeTextStream(encoding?: string, options?: TextDecoderOptions): TransformStream<BinaryData, string>;
-/**
- * Encodes buffer to hex
- * @param buffer buffer to encode
- * @returns hex encoded string
- */
-export declare function encodeHex(buffer: BinaryData): string;
-/**
- * Decodes hex string to buffer
- * @param hex hex string to decode
- * @returns decoded buffer
- */
-export declare function decodeHex(hex: string): Uint8Array;

package/utils/enum.d.ts

@@ -1,9 +0,0 @@
-import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types.js';
-export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): EnumerationKey<T>;
-export declare function enumEntries<T extends EnumerationObject>(enumeration: T): EnumerationEntries<T>;
-export declare function enumKeys<T extends EnumerationObject>(enumeration: T): EnumerationKey<T>[];
-export declare function enumValues<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>[];
-export declare function randomEnumValue<T extends EnumerationObject>(enumeration: T): EnumerationValue<T>;
-export declare function reversedEnum<T extends EnumerationObject>(enumeration: T): {
-    [P in keyof T as T[P]]: P;
-};

package/utils/equals.d.ts

@@ -1,30 +0,0 @@
-import type { BinaryData } from '../types.js';
-import type { Comparator } from './sort.js';
-export interface Equals<T = unknown> {
-    [Equals.symbol](other: T): boolean;
-}
-declare const equalsSymbol: unique symbol;
-export declare const Equals: {
-    readonly symbol: typeof equalsSymbol;
-};
-export type ArrayEqualsComparator<A, B> = (a: A, b: B) => boolean;
-export type ArrayEqualsOptions<A, B> = {
-    sort?: Comparator<A | B>;
-    comparator?: ArrayEqualsComparator<A, B>;
-};
-export declare function strictEquals(a: any, b: any): boolean;
-export declare function arrayEquals<A, B>(a: readonly A[], b: readonly B[], options?: ArrayEqualsOptions<A, B>): boolean;
-export type EqualsOptions = {
-    deep?: boolean;
-    arrayDeep?: boolean;
-    sortArray?: boolean;
-    coerceStrings?: boolean;
-    checkPrototype?: boolean;
-};
-export declare function equals(a: any, b: any, options?: EqualsOptions): boolean;
-export declare function equals(a: any, b: any, options?: EqualsOptions, __internal?: any): boolean;
-/**
- * compares to binary types for equal content
- */
-export declare function binaryEquals(bufferA: BinaryData, bufferB: BinaryData): boolean;
-export {};

package/utils/event-loop.d.ts

@@ -1,4 +0,0 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import type { Logger } from '../logger/index.js';
-export declare function measureEventLoopDelay(): Promise<number>;
-export declare function runEventLoopWatcher(logger: Logger, cancellationSignal: CancellationSignal): void;

package/utils/format-error.d.ts

@@ -1,24 +0,0 @@
-import type { UndefinableJson } from '../types.js';
-export type FormatErrorOptions = {
-    /**
-     * Include error name in message
-     */
-    includeName?: boolean;
-    /**
-     * Include all error properties beside name and message
-     */
-    includeRest?: boolean | 'if-no-extra-info';
-    /**
-     * Include extraInfo from errors implementing {@link ErrorExtraInfo}
-     */
-    includeExtraInfo?: boolean;
-    /**
-     * Include stack trace
-     */
-    includeStack?: boolean;
-};
-export interface ErrorExtraInfo {
-    /** Format extra data (without message and stack) as JSON */
-    getExtraInfo(): UndefinableJson | undefined;
-}
-export declare function formatError(error: any, options?: FormatErrorOptions): string;

package/utils/function/index.d.ts

@@ -1,2 +0,0 @@
-export * from './memoize.js';
-export * from './throttle.js';

package/utils/function/memoize.d.ts

@@ -1,18 +0,0 @@
-import type { Constructor } from '../../types.js';
-export type MemoizeOptions = {
-    /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
-    weak?: boolean;
-};
-/**
- * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
- * @param fn function memoize
- * @returns memoized function
- */ export declare function memoize<Fn extends (...parameters: any[]) => any>(fn: Fn, options?: MemoizeOptions): Fn;
-/**
- * Memoizes a function with a single parameter. Faster than {@link memoize}
- * @param fn function memoize
- * @returns memoized function
- */
-export declare function memoizeSingle<Fn extends (parameter: any) => any>(fn: Fn, options?: MemoizeOptions): Fn;
-export declare function memoizeClass<T extends Constructor>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
-export declare function memoizeClassSingle<T extends Constructor<any, [any]>>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;

package/utils/iterable-helpers/take-until.d.ts

@@ -1,2 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/token.js';
-export declare function takeUntil<T>(iterable: Iterable<T>, cancellationSignal: CancellationSignal): IterableIterator<T>;

package/utils/jwt.d.ts

@@ -1,32 +0,0 @@
-import type { OneOrMany, StringMap } from '../types.js';
-import type { Key } from './cryptography.js';
-export type JwtTokenAlgorithm = 'HS256' | 'HS384' | 'HS512';
-export type JwtTokenHeader<T extends StringMap = StringMap> = {
-    alg: JwtTokenAlgorithm;
-    typ: 'JWT';
-} & T;
-export type JwtToken<TPayload = StringMap, THeader extends JwtTokenHeader = JwtTokenHeader> = {
-    readonly header: THeader;
-    readonly payload: TPayload;
-};
-export type JwtTokenParseResult<T extends JwtToken = JwtToken> = {
-    raw: string;
-    token: T;
-    encoded: {
-        header: string;
-        payload: string;
-        signature: string;
-    };
-    bytes: {
-        header: Uint8Array;
-        payload: Uint8Array;
-        signature: Uint8Array;
-    };
-    string: {
-        header: string;
-        payload: string;
-    };
-};
-export declare function parseJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string): JwtTokenParseResult<T>;
-export declare function createJwtTokenString<T extends JwtToken = JwtToken>(jwtToken: T, key: Key | string): Promise<string>;
-export declare function parseAndValidateJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string, allowedAlgorithms: OneOrMany<JwtTokenAlgorithm>, key: Key | string): Promise<T>;