@tstdl/base 0.92.123 → 0.92.124

package/types/theme/theme-service.d.ts

@@ -0,0 +1,43 @@
+import { type Observable } from 'rxjs';
+export type CalculatedPalette<Colors extends string = string> = {
+    [Color in Colors]: ColorTonesWithRgb;
+};
+export type CalculatedTheme<Colors extends string = string> = {
+    palette: CalculatedPalette<Colors>;
+};
+export type Theme<Colors extends string = string> = {
+    palette: Palette<Colors>;
+};
+export type Palette<Colors extends string = string> = {
+    [Color in Colors]: string | ColorTones;
+};
+export type ColorTones = {
+    base: string;
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+};
+export type ColorTonesWithRgb = ColorTones & {
+    [Tone in keyof ColorTones as `${Tone}Rgb`]: string;
+};
+export declare const themeColorTones: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+export declare const DEFAULT_THEME: import("../../injector/token.js").InjectionToken<Theme<string>, never>;
+export declare class ThemeService<Colors extends string = string> {
+    private readonly themeSubject;
+    private readonly calculatedThemeSubject;
+    private readonly defaultTheme;
+    readonly colors: Colors[];
+    readonly theme$: Observable<Theme<Colors>>;
+    readonly calculatedTheme$: Observable<CalculatedTheme<Colors>>;
+    get theme(): Theme<Colors>;
+    get calculatedTheme(): CalculatedTheme<Colors>;
+    constructor(defaultTheme: Theme<Colors>);
+    setTheme(theme?: Theme<Colors> | undefined): void;
+}

package/types/threading/thread-pool.d.ts

@@ -0,0 +1,20 @@
+import type * as NodeWorkerThreads from 'node:worker_threads';
+import type { LiteralUnion } from 'type-fest';
+import type { AsyncDisposable } from '../../disposable/index.js';
+import { disposeAsync } from '../../disposable/index.js';
+import type { Logger } from '../../logger/index.js';
+import type { ThreadWorker } from './thread-worker.js';
+export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
+    threadCount?: number;
+};
+export declare class ThreadPool implements AsyncDisposable {
+    private readonly pool;
+    readonly url: string | URL;
+    readonly options: ThreadOptions | undefined;
+    constructor(url: string | URL, logger: Logger, options?: ThreadOptions);
+    dispose(): Promise<void>;
+    [disposeAsync](): Promise<void>;
+    getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+    process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    private spawn;
+}

package/types/tools/fetch-mime-types.d.ts

@@ -0,0 +1 @@
+export {};

package/types/types/geo-json.d.ts

@@ -0,0 +1,36 @@
+import type { JsonObject } from '../../types.js';
+export type Position = [longitude: number, latitude: number, elevation?: number];
+export type GeoJsonObject<Type extends string> = {
+    type: Type;
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number];
+};
+export type Point = GeoJsonObject<'Point'> & {
+    coordinates: Position;
+};
+export type LineString = GeoJsonObject<'LineString'> & {
+    coordinates: Position[];
+};
+export type Polygon = GeoJsonObject<'Polygon'> & {
+    coordinates: Position[][];
+};
+export type MultiPoint = GeoJsonObject<'MultiPoint'> & {
+    coordinates: Position[];
+};
+export type MultiLineString = GeoJsonObject<'MultiLineString'> & {
+    coordinates: Position[][];
+};
+export type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
+    coordinates: Position[][][];
+};
+export type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
+    geometries: Geometry[];
+};
+export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
+export type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
+    id?: string | number;
+    geometry: G;
+    properties: P;
+};
+export type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
+    features: Feature<G, P>[];
+};

package/types/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './geo-json.js';
+export type * from './tagged.js';

package/types/types/tagged.d.ts

@@ -0,0 +1,16 @@
+import type { Record } from '../../types.js';
+export declare const tag: unique symbol;
+export declare const type: unique symbol;
+export type TagContainer<Type, Token> = {
+    readonly [tag]?: Token;
+    readonly [type]?: Type;
+};
+export type Tag<Type, Token extends PropertyKey, TagMetadata> = TagContainer<Type, Record<Token, TagMetadata>>;
+export type HasTag<T, Token = unknown> = T extends TagContainer<unknown, Token> ? true : false;
+export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, TagMetadata = unknown> = Type & Tag<Type, TagName, TagMetadata>;
+export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
+export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
+export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
+export type UntaggedDeep<T> = Untagged<T> extends any[] | Record ? {
+    [P in keyof Untagged<T>]: UntaggedDeep<Untagged<T>[P]>;
+} : Untagged<T>;

package/types/types.d.ts

@@ -0,0 +1,215 @@
+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 TypedExclude<T, U extends T> = T extends U ? never : T;
+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/types/utils/async-hook/async-hook.d.ts

@@ -0,0 +1,9 @@
+export type AsyncHook<T, C = never, R = unknown> = {
+    register: (handler: AsyncHookHandler<T, C, R>) => AsyncHookHandlerRegistration;
+    trigger: [C] extends [never] ? ((value: T) => Promise<R[]>) : ((value: T, context: C) => Promise<R[]>);
+};
+export type AsyncHookHandler<T, C, R> = [C] extends [never] ? ((value: T) => R | Promise<R>) : ((value: T, context: C) => R | Promise<R>);
+export type AsyncHookHandlerRegistration = {
+    unregister: () => void;
+};
+export declare function asyncHook<T, C = never, R = unknown>(): AsyncHook<T, C, R>;

package/types/utils/async-hook/index.d.ts

@@ -0,0 +1 @@
+export * from './async-hook.js';

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

@@ -0,0 +1,3 @@
+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/types/utils/backoff.d.ts

@@ -0,0 +1,77 @@
+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/types/utils/binary.d.ts

@@ -0,0 +1,16 @@
+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/types/utils/cryptography.d.ts

@@ -0,0 +1,122 @@
+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/types/utils/encoding.d.ts

@@ -0,0 +1,36 @@
+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/types/utils/enum.d.ts

@@ -0,0 +1,9 @@
+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/types/utils/equals.d.ts

@@ -0,0 +1,30 @@
+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 {};