@tstdl/base 0.81.34 → 0.82.0

package/templates/providers/file.provider-template.d.ts

@@ -2,10 +2,10 @@ import type { Injectable } from "../../container";
 import { resolveArgumentType } from "../../container";
 import { Template } from '../template.model';
 import { TemplateProvider } from '../template.provider';
-export declare type FileTemplateProviderConfig = {
+export type FileTemplateProviderConfig = {
     basePath?: string;
 };
-export declare type FileTemplateProviderArgument = string;
+export type FileTemplateProviderArgument = string;
 export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
 export declare class FileTemplateProvider extends TemplateProvider implements Injectable<FileTemplateProviderArgument> {
     private readonly basePath;

package/templates/providers/file.provider-template.js

@@ -29,6 +29,7 @@ let FileTemplateProvider = class FileTemplateProvider extends template_provider_
         this.basePath = path.resolve(basePath);
     }
     async get(key) {
+        var _a;
         if (!keyPattern.test(key)) {
             throw new bad_request_error_1.BadRequestError('Illegal template key. Only a-z, A-Z, 0-9, _ and - are allowed.');
         }
@@ -36,7 +37,7 @@ let FileTemplateProvider = class FileTemplateProvider extends template_provider_
         if (!filePath.startsWith(this.basePath)) {
             throw new bad_request_error_1.BadRequestError(`Illegal file path. Must be inside "${this.basePath}".`);
         }
-        const templateModule = await Promise.resolve().then(() => require(filePath));
+        const templateModule = await (_a = filePath, Promise.resolve().then(() => require(_a)));
         const fileContent = templateModule.default;
         return schema_1.Schema.parse(template_model_1.Template, fileContent);
     }

package/templates/providers/file.provider-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"file.provider-template.js","sourceRoot":"","sources":["../../../source/templates/providers/file.provider-template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,+CAAwE;AACxE,qEAA4D;AAC5D,yCAAkC;AAClC,6BAA6B;AAC7B,sDAA6C;AAC7C,4DAAwD;AAQ3C,QAAA,0BAA0B,GAA+B,EAAE,CAAC;AAEzE,MAAM,UAAU,GAAG,aAAa,CAAC;AAK1B,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,oCAAgB;IACvC,QAAQ,CAAS;IAEzB,CAAC,+BAAmB,CAAC,CAA+B;IAC7D,YAAyB,QAAgB;QACvC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,mCAAe,CAAC,gEAAgE,CAAC,CAAC;SAC7F;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,MAAM,IAAI,mCAAe,CAAC,sCAAsC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;SACpF;QAED,MAAM,cAAc,GAAG,2CAAa,QAAQ,EAAyB,CAAC;QACtE,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC;QAC3C,OAAO,eAAM,CAAC,KAAK,CAAC,yBAAQ,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAzBY,oBAAoB;IAHhC,IAAA,qBAAS,EAAC;QACT,uBAAuB,EAAE,GAAG,EAAE,CAAC,kCAA0B,CAAC,QAAQ;KACnE,CAAC;IAKa,WAAA,IAAA,qBAAS,GAAE,CAAA;;GAJb,oBAAoB,CAyBhC;AAzBY,oDAAoB;AA2BjC,SAAgB,6BAA6B,CAAC,SAA8C,EAAE;IAC5F,kCAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,kCAA0B,CAAC,QAAQ,CAAC;AAC/F,CAAC;AAFD,sEAEC"}
+{"version":3,"file":"file.provider-template.js","sourceRoot":"","sources":["../../../source/templates/providers/file.provider-template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,+CAAwE;AACxE,qEAA4D;AAC5D,yCAAkC;AAClC,6BAA6B;AAC7B,sDAA6C;AAC7C,4DAAwD;AAQ3C,QAAA,0BAA0B,GAA+B,EAAE,CAAC;AAEzE,MAAM,UAAU,GAAG,aAAa,CAAC;AAK1B,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,oCAAgB;IACvC,QAAQ,CAAS;IAEzB,CAAC,+BAAmB,CAAC,CAA+B;IAC7D,YAAyB,QAAgB;QACvC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW;;QACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,mCAAe,CAAC,gEAAgE,CAAC,CAAC;SAC7F;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,MAAM,IAAI,mCAAe,CAAC,sCAAsC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;SACpF;QAED,MAAM,cAAc,GAAG,YAAa,QAAQ,4CAAyB,CAAC;QACtE,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC;QAC3C,OAAO,eAAM,CAAC,KAAK,CAAC,yBAAQ,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAzBY,oBAAoB;IAHhC,IAAA,qBAAS,EAAC;QACT,uBAAuB,EAAE,GAAG,EAAE,CAAC,kCAA0B,CAAC,QAAQ;KACnE,CAAC;IAKa,WAAA,IAAA,qBAAS,GAAE,CAAA;;GAJb,oBAAoB,CAyBhC;AAzBY,oDAAoB;AA2BjC,SAAgB,6BAA6B,CAAC,SAA8C,EAAE;IAC5F,kCAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,kCAA0B,CAAC,QAAQ,CAAC;AAC/F,CAAC;AAFD,sEAEC"}

package/templates/renderers/handlebars.template-renderer.d.ts

@@ -4,15 +4,15 @@ import { TemplateResolverProvider } from '../template-resolver.provider';
 import type { TemplateField } from '../template.model';
 import type { TemplateRenderObject } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type HandlebarsTemplateHelperOptionsLocationItem = {
+export type HandlebarsTemplateHelperOptionsLocationItem = {
     line: number;
     column: number;
 };
-export declare type HandlebarsTemplateHelperOptionsLocation = {
+export type HandlebarsTemplateHelperOptionsLocation = {
     start: HandlebarsTemplateHelperOptionsLocationItem;
     end: HandlebarsTemplateHelperOptionsLocationItem;
 };
-export declare type HandlebarsTemplateHelperOptions = {
+export type HandlebarsTemplateHelperOptions = {
     name: string;
     location?: HandlebarsTemplateHelperOptionsLocation;
     data?: Record<string>;
@@ -21,17 +21,17 @@ export declare type HandlebarsTemplateHelperOptions = {
     fn?: handlebars.TemplateDelegate;
     inverse?: handlebars.TemplateDelegate;
 };
-export declare type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
-export declare type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
-export declare type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | handlebars.TemplateDelegate;
-export declare type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
-export declare type HandlebarsRendererOptions = {
+export type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
+export type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
+export type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | handlebars.TemplateDelegate;
+export type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
+export type HandlebarsRendererOptions = {
     strict?: boolean;
     preventIndent?: boolean;
     helpers?: HandlebarsTemplateHelpersObject;
     partials?: HandlebarsTemplatePartialsObject;
 };
-export declare type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
+export type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
 export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
     private readonly templateResolverProvider;
     private readonly compileHandlebarsTemplate;

package/templates/renderers/mjml.template-renderer.d.ts

@@ -2,11 +2,11 @@ import type { MJMLParsingOptions } from 'mjml-core';
 import { TemplateRendererProvider } from '../template-renderer.provider';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
+export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
     preprocessorOptions?: any;
 };
-export declare type MjmlRendererString = 'mjml' | `mjml-${string}`;
-export declare type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions>;
+export type MjmlRendererString = 'mjml' | `mjml-${string}`;
+export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions>;
 export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
     private readonly rendererProvider;
     constructor(rendererProvider: TemplateRendererProvider);

package/templates/renderers/string.template-renderer.d.ts

@@ -1,6 +1,6 @@
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type StringTemplateRenderObject = TemplateRenderObject<'string', undefined>;
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined>;
 export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
     constructor();
     canHandleType(type: string): boolean;

package/templates/resolvers/file.template-resolver.d.ts

@@ -4,10 +4,10 @@ import { TypedOmit } from "../../types";
 import { TemplateField } from '../template.model';
 import { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer';
 import { TemplateResolver } from '../template.resolver';
-export declare type FileTemplateProviderConfig = {
+export type FileTemplateProviderConfig = {
     basePath?: string;
 };
-export declare type FileTemplateProviderArgument = string;
+export type FileTemplateProviderArgument = string;
 export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
 export declare class FileTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'file', Renderer, Options> {
     templateFile: string;

package/templates/template.model.d.ts

@@ -4,7 +4,7 @@ export declare class TemplateField<Resolver extends string = string, Renderer ex
     renderer: Renderer;
     options?: Options;
 }
-export declare type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
     [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options>;
 } & {
     [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;

package/templates/template.renderer.d.ts

@@ -1,11 +1,11 @@
-export declare type TemplateRenderResult = string;
-export declare type TemplateRenderObject<Renderer extends string = string, Options = any> = {
+export type TemplateRenderResult = string;
+export type TemplateRenderObject<Renderer extends string = string, Options = any> = {
     renderer: Renderer;
     template: string;
     options?: Options;
 };
-export declare type TemplateRendererString = typeof templateRendererString;
-export declare type TemplateRendererOptions = typeof templateRendererOptions;
+export type TemplateRendererString = typeof templateRendererString;
+export type TemplateRendererOptions = typeof templateRendererOptions;
 export declare const templateRendererString: unique symbol;
 export declare const templateRendererOptions: unique symbol;
 export declare abstract class TemplateRenderer<Renderer extends string = string, Options = any> {

package/templates/template.service.d.ts

@@ -3,7 +3,7 @@ import { TemplateRendererProvider } from './template-renderer.provider';
 import { TemplateResolverProvider } from './template-resolver.provider';
 import type { Template } from './template.model';
 import { TemplateProvider } from './template.provider';
-export declare type TemplateServiceRenderResult<T extends Template = Template> = {
+export type TemplateServiceRenderResult<T extends Template = Template> = {
     fields: Record<keyof T['fields'], string>;
     options: T['options'];
 };

package/text/dynamic-text.model.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
 import type { LocalizableText } from './localizable-text.model';
 import { LocalizationService } from './localization.service';
-export declare type DynamicText = LocalizableText | Observable<LocalizableText>;
+export type DynamicText = LocalizableText | Observable<LocalizableText>;
 export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;

package/text/localizable-text.model.d.ts

@@ -1,2 +1,2 @@
 import type { LocalizationData } from './localization.service';
-export declare type LocalizableText = string | LocalizationData;
+export type LocalizableText = string | LocalizationData;

package/text/localization.service.d.ts

@@ -1,20 +1,20 @@
 import type { Enumeration, EnumerationValue } from "../types";
 import type { PropertyName } from "../utils/object/property-name";
 import type { Observable } from 'rxjs';
-export declare type Language = {
+export type Language = {
     code: string;
     name: string;
 };
-export declare type LocalizeFunction<Parameters = void> = (parameters: Parameters) => string;
-export declare type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
-declare type LocalizationTemplate = {
+export type LocalizeFunction<Parameters = void> = (parameters: Parameters) => string;
+export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
+type LocalizationTemplate = {
     [key: string]: LocalizeItem<any> | LocalizationTemplate;
 };
-export declare type EnumerationLocalization<T extends Enumeration = Enumeration> = {
+export type EnumerationLocalization<T extends Enumeration = Enumeration> = {
     [P in EnumerationValue<T>]: LocalizeItem<any>;
 };
-export declare type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [T, EnumerationLocalization<T>];
-export declare type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = []> = {
+export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [T, EnumerationLocalization<T>];
+export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = []> = {
     language: Language;
     keys: T;
     enums: {
@@ -22,18 +22,18 @@ export declare type Localization<T extends LocalizationTemplate = LocalizationTe
     };
 };
 declare const parametersSymbol: unique symbol;
-export declare type LocalizationKey<Parameters = void> = PropertyName & {
+export type LocalizationKey<Parameters = void> = PropertyName & {
     [parametersSymbol]: Parameters;
 };
-export declare type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
+export type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
     key: LocalizationKey;
     parameters?: void;
 };
-export declare type LocalizationDataObject<Parameters> = {
+export type LocalizationDataObject<Parameters> = {
     key: LocalizationKey<Parameters>;
     parameters: Parameters;
 };
-export declare type LocalizationKeys<T extends LocalizationTemplate> = {
+export type LocalizationKeys<T extends LocalizationTemplate> = {
     [P in keyof T]: T[P] extends LocalizationTemplate ? LocalizationKeys<T[P]> : T[P] extends LocalizeItem<infer R> ? LocalizationKey<R> : LocalizationKey;
 };
 export declare function isLocalizationKey(value: any): value is LocalizationKey;

package/theme/theme-service.d.ts

@@ -1,30 +1,30 @@
 import type { UnionToTuple } from "../types";
 import type { Observable } from 'rxjs';
-export declare type CalculatedPalette<Colors extends string = string> = {
+export type CalculatedPalette<Colors extends string = string> = {
     [Color in Colors]: {
         main: ColorTones;
         text: ColorTones;
         border?: ColorTones;
     };
 };
-export declare type CalculatedTheme<Colors extends string = string> = {
+export type CalculatedTheme<Colors extends string = string> = {
     name: string;
     palette: CalculatedPalette<Colors>;
 };
-export declare type PaletteColor = string | {
+export type PaletteColor = string | {
     main: string;
     text?: string;
     border?: string;
 };
-export declare type Theme<Colors extends string = string> = {
+export type Theme<Colors extends string = string> = {
     name: string;
     textColors?: string[];
     palette: Palette<Colors>;
 };
-export declare type Palette<Colors extends string = string> = {
+export type Palette<Colors extends string = string> = {
     [Color in Colors]: PaletteColor;
 };
-export declare type ColorTones = {
+export type ColorTones = {
     base: string;
     50: string;
     100: string;

package/threading/thread-pool.d.ts

@@ -4,7 +4,7 @@ import { disposeAsync } from "../disposable";
 import type { Logger } from "../logger";
 import type * as NodeWorkerThreads from 'worker_threads';
 import type { ThreadWorker } from './thread-worker';
-export declare type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
+export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
     threadCount?: number;
 };
 export declare class ThreadPool implements AsyncDisposable {

package/threading/thread-worker.d.ts

@@ -1,3 +1,3 @@
 import type { RpcEndpointSource } from "../rpc";
-export declare type ThreadWorker = (...args: any[]) => any | Promise<any>;
+export type ThreadWorker = (...args: any[]) => any | Promise<any>;
 export declare function exposeThreadWorker<T extends ThreadWorker>(worker: T, endpointOrSource: RpcEndpointSource, name?: string): void;

package/types/geo-json.d.ts

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

package/types.d.ts

@@ -1,6 +1,6 @@
 import type { UnionToIntersection } from 'type-fest';
-export declare type ObjectLiteral = {};
-export declare type PrimitiveTypeMap = {
+export type ObjectLiteral = {};
+export type PrimitiveTypeMap = {
     'string': string;
     'number': number;
     'boolean': boolean;
@@ -10,162 +10,162 @@ export declare type PrimitiveTypeMap = {
     'function': Function;
     'undefined': undefined;
 };
-export declare type PrimitiveTypeString<T extends PrimitiveTypeMap[keyof PrimitiveTypeMap] = PrimitiveTypeMap[keyof PrimitiveTypeMap]> = Simplify<keyof PickBy<PrimitiveTypeMap, T>>;
-export declare type PrimitiveType<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> = Simplify<PrimitiveTypeMap[T]>;
-export declare type Nested<T> = T | NestedObject<T> | NestedArray<T>;
-export declare type NestedObject<T> = {
+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 declare type NestedArray<T> = T[];
-export declare type FilledArray<T> = [T, ...(T)[]];
-export declare type FilledReadonlyArray<T> = readonly [T, ...(T)[]];
-export declare type Primitive = string | number | boolean | bigint | null | undefined | symbol;
-export declare type PrimitiveValue = Primitive | PrimitiveObject | PrimitiveArray;
-export declare type PrimitiveObject = {
+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 | null | undefined | symbol;
+export type PrimitiveValue = Primitive | PrimitiveObject | PrimitiveArray;
+export type PrimitiveObject = {
     [key: string]: PrimitiveValue;
 };
-export declare type PrimitiveArray = PrimitiveValue[];
-export declare type BuiltIn = Primitive | RegExp | Date | Function;
-export declare type Json = JsonPrimitive | JsonObject | JsonArray;
-export declare type JsonPrimitive = string | number | boolean | null;
-export declare type JsonObject = {
+export type PrimitiveArray = PrimitiveValue[];
+export type BuiltIn = Primitive | RegExp | Date | Function;
+export type Json = JsonPrimitive | JsonObject | JsonArray;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonObject = {
     [key: string]: Json;
 };
-export declare type JsonArray = Json[];
-export declare type UndefinableJson = JsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
-export declare type UndefinableJsonInnerNode = UndefinableJsonPrimitive | UndefinableJsonObject | UndefinableJsonArray;
-export declare type UndefinableJsonPrimitive = JsonPrimitive | undefined;
-export declare type UndefinableJsonObject = {
+export type JsonArray = 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 declare type UndefinableJsonArray = UndefinableJsonInnerNode[];
-export declare type ArrayItem<T extends readonly any[]> = T extends readonly (infer U)[] ? U : never;
-export declare type Enumeration = EnumerationArray | EnumerationObject;
-export declare type EnumerationArray = readonly [string | number, ...(string | number)[]];
-export declare type EnumerationObject = Record<string, string | number>;
-export declare type EnumerationKey<T extends EnumerationObject = EnumerationObject> = Extract<keyof T, string>;
-export declare type EnumerationMap<T extends EnumerationObject = EnumerationObject> = SimplifyObject<{
+export type UndefinableJsonArray = 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 = Record<string, string | number>;
+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 declare type EnumerationValue<T extends Enumeration = Enumeration> = T extends EnumerationObject ? Simplify<EnumerationMap<T>[keyof EnumerationMap<T>]> : T extends EnumerationArray ? T[number] : never;
-export declare type EnumerationEntry<T extends EnumerationObject = EnumerationObject> = {
+export type EnumerationValue<T extends Enumeration = Enumeration> = T extends EnumerationObject ? Simplify<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>];
-declare type EnumerationEntriesHelper<T extends EnumerationObject = EnumerationObject, Tuple = UnionToTuple<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 declare type EnumerationEntries<T extends EnumerationObject = EnumerationObject> = EnumerationEntriesHelper<T> extends (infer U)[] ? U[] : never;
-export declare type Type<T = any, Arguments extends any[] = any> = Constructor<T, Arguments> & {
+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 declare type Constructor<T = any, Arguments extends any[] = any> = new (...args: Arguments) => T;
-export declare type AbstractType<T = any, Arguments extends any[] = any> = AbstractConstructor<T, Arguments> & {
+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 declare type AbstractConstructor<T = any, Arguments extends any[] = any> = abstract new (...args: Arguments) => T;
-export declare type ReturnTypeOrT<T> = T extends (...args: any) => infer R ? R : T;
-export declare type Record<K extends PropertyKey = PropertyKey, V = any> = {
+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 Record<K extends PropertyKey = PropertyKey, V = any> = {
     [P in K]: V;
 };
-export declare type DeepRecord<K extends PropertyKey = PropertyKey, V = any> = {
+export type DeepRecord<K extends PropertyKey = PropertyKey, V = any> = {
     [P in K]: V | DeepRecord<K, V>;
 };
-export declare type StringMap<T = any> = Record<string, T>;
-export declare type NumberMap<T = any> = Record<number, T>;
-export declare type StringNumberMap<T = any> = {
+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 declare type OneOrMany<T> = T | readonly T[];
-export declare type WritableOneOrMany<T> = T | T[];
-export declare type Writable<T> = {
+export type OneOrMany<T> = T | readonly T[];
+export type WritableOneOrMany<T> = T | T[];
+export type Writable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-export declare type RequiredKeys<T> = {
+export type RequiredKeys<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
 }[keyof T];
-export declare type OptionalKeys<T> = {
+export type OptionalKeys<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
 }[keyof T];
-export declare type TypedOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-export declare type TypedExtract<T, U extends T> = T extends U ? T : never;
-export declare type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
-export declare type OmitNever<T extends Record> = {
+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 declare 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>>>;
+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 declare type OmitBy<T, V> = Omit<T, {
+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 declare type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
-export declare type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
+export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
+export type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
 /**
  * remove nested type information
  */
-export declare type Simplify<T> = T extends (Primitive | Function | Date | RegExp) ? T : T extends (infer AT)[] ? Simplify<AT>[] : T extends readonly (infer AT)[] ? readonly Simplify<AT>[] : T extends Record ? SimplifyObject<T> : T;
+export type Simplify<T> = T extends (Primitive | Function | Date | RegExp) ? T : T extends (infer AT)[] ? Simplify<AT>[] : T extends readonly (infer AT)[] ? readonly Simplify<AT>[] : T extends Record ? SimplifyObject<T> : T;
 /**
  * remove type information on object
  */
-export declare type SimplifyObject<T extends Record> = {
+export type SimplifyObject<T extends Record> = {
     [K in keyof T]: T[K];
 } & {};
-export declare type UnionToTuple<T, Tuple extends any[] = []> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? UnionToTuple<Exclude<T, R>, [R, ...Tuple]> : Tuple;
-export declare type UndefinableObject<T extends Record> = {
+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 declare type PickBy<T, V> = Pick<T, {
+export type PickBy<T, V> = Pick<T, {
     [K in keyof T]: V extends Extract<T[K], V> ? K : never;
 }[keyof T]>;
-export declare type NonNullable<T> = T extends null ? never : T;
-export declare type NonUndefinable<T> = T extends undefined ? never : T;
-export declare type NonNullOrUndefinable<T> = T extends null | undefined ? never : 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 declare type DeepNonNullable<T> = T extends Record ? {
+export type DeepNonNullable<T> = T extends Record ? {
     [P in keyof T]-?: DeepNonNullable<T[P]>;
 } : NonNullable<T>;
-export declare type IfAny<T, Then, Else = never> = true extends (false & T) ? Then : Else;
-export declare type IfUnknown<T, Then, Else = never> = unknown extends T ? Then : Else;
-export declare type IsAny<T> = IfAny<T, true, false>;
-export declare type IsUnknown<T> = IfUnknown<T, true, false>;
-export declare type If<B extends Boolean, Then, Else> = B extends true ? Then : Else;
-export declare type PartialProperty<T, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
-export declare type TypeOf<T extends object, P extends keyof T> = T[P];
-export declare type PropertyOf<T extends object, P extends keyof T> = Property<Of<T>, P>;
-export declare type Property<T extends object, P extends keyof 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 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 declare type Of<T> = T;
-export declare type PropertiesOfType<T, U> = keyof PickBy<T, U>;
-export declare type Flatten<T> = T extends readonly (infer R)[] ? R : T;
-export declare type DeepFlatten<T> = T extends readonly (infer R)[] ? DeepFlatten<R> : T extends Record ? {
+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 declare type DeepArray<T> = (T | DeepArray<T>)[];
-export declare type DeepReadonly<T> = T extends BuiltIn ? T : T extends (any[] | readonly any[]) ? DeepReadonlyArray<T[number]> : DeepReadonlyObject<T>;
-export declare type DeepReadonlyObject<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 declare type DeepReadonlyArray<T> = readonly DeepReadonly<T>[];
-export declare type DeepPartial<T> = T extends BuiltIn ? T : T extends any[] ? DeepPartialArray<T[number]> : T extends readonly any[] ? Readonly<DeepPartialArray<T[number]>> : DeepPartialObject<T>;
-export declare type DeepPartialObject<T> = {
+export type DeepReadonlyArray<T> = readonly DeepReadonly<T>[];
+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 declare type DeepPartialArray<T> = DeepPartial<T>[];
-export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export declare type BinaryData = ArrayBuffer | ArrayBufferView;
-declare type JoinPaths<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
-declare type Prev = [
+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;
+type JoinPaths<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
+type Prev = [
     never,
     0,
     1,
@@ -190,10 +190,10 @@ declare type Prev = [
     20,
     ...0[]
 ];
-export declare type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ? {
+export type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ? {
     [K in keyof T]-?: K extends string | number ? `${K}` | (Paths<T[K], Prev[D]> extends infer R ? JoinPaths<K, R> : never) : never;
 }[keyof T] : '';
-export declare type LeavePaths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ? {
+export type LeavePaths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ? {
     [K in keyof T]-?: JoinPaths<K, LeavePaths<T[K], Prev[D]>>;
 }[keyof T] : '';
 export {};

package/utils/any-iterable-iterator.d.ts

@@ -1,4 +1,4 @@
-export declare type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;
-export declare type AnyIterator<T> = Iterator<T> | AsyncIterator<T>;
-export declare type AnyIterableIterator<T> = IterableIterator<T> | AsyncIterableIterator<T>;
+export type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;
+export type AnyIterator<T> = Iterator<T> | AsyncIterator<T>;
+export type AnyIterableIterator<T> = IterableIterator<T> | AsyncIterableIterator<T>;
 export declare function isAnyIterable<T = any>(obj: any): obj is AnyIterable<T>;

package/utils/async-iterable-helpers/parallel/types.d.ts

@@ -1,2 +1,2 @@
-export declare type FeedFunction<T> = (item: T, index: number) => void;
-export declare type ParallelFeedIteratorFunction<TIn, TOut> = (item: TIn, index: number, feed: FeedFunction<TOut>) => Promise<void>;
+export type FeedFunction<T> = (item: T, index: number) => void;
+export type ParallelFeedIteratorFunction<TIn, TOut> = (item: TIn, index: number, feed: FeedFunction<TOut>) => Promise<void>;