@mionjs/core 0.8.0-alpha.0

package/.dist/cjs/src/types/formats/formatsParams.types.d.ts

@@ -0,0 +1,234 @@
+import { FormatParam } from './formats.types.ts';
+export type Samples = string | readonly string[];
+export type StringValidators = {
+    maxLength?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    minLength?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    length?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    disallowedChars?: {
+        val: string;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: string;
+    };
+    disallowedValues?: {
+        val: readonly string[];
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: Samples;
+    };
+    pattern?: {
+        val: RegExp;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples: Samples;
+    };
+    allowedChars?: {
+        val: string;
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples?: Samples;
+    };
+    allowedValues?: {
+        val: readonly string[];
+        errorMessage: string;
+        desc?: string;
+        ignoreCase?: boolean;
+        mockSamples?: Samples;
+    };
+};
+export type StringTransformers = {
+    lowercase?: boolean;
+    uppercase?: boolean;
+    capitalize?: boolean;
+    trim?: boolean;
+    replace?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+    replaceAll?: {
+        searchValue: string;
+        replaceValue: string;
+    };
+};
+export type StringParams = StringValidators & StringTransformers;
+export type DateFmt = 'ISO' | 'YYYY-MM-DD' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'MM-DD' | 'DD-MM' | 'YYYY-MM';
+export type FormatParams_Date = {
+    format: FormatParam<DateFmt>;
+};
+export type TimeFmt = 'ISO' | 'HH:mm:ss[.mmm]TZ' | 'HH:mm:ss[.mmm]' | 'HH:mm:ss' | 'HH:mm' | 'mm:ss' | 'HH' | 'mm' | 'ss';
+export type FormatParams_Time = {
+    format: FormatParam<TimeFmt>;
+};
+export type FormatParams_DateTime = {
+    date: FormatParams_Date;
+    time: FormatParams_Time;
+    splitChar: FormatParam<string>;
+};
+export type FormatParams_EmailPattern = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars' | 'allowedValues'>;
+export type FormatParams_Email = FormatParams_EmailPattern & {
+    localPart?: StringValidators;
+    domain?: FormatParams_Domain;
+};
+export type FormatParams_UrlPattern = Omit<StringParams, 'allowedChars' | 'disallowedChars' | 'allowedValues' | 'disallowedValues'>;
+export type FormatParams_Url = FormatParams_UrlPattern & {
+    ip?: FormatParams_IP;
+    domain?: FormatParams_Domain;
+};
+export type FormatParams_DomainName = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars'>;
+export type FormatParams_Tld = Omit<StringValidators, 'length' | 'allowedChars' | 'disallowedChars'>;
+export type FormatParam_Pattern = StringValidators['pattern'];
+export type FormatParams_DomainCore = {
+    names?: never;
+    tld?: never;
+    pattern: FormatParam_Pattern;
+} | {
+    names: FormatParams_DomainName;
+    tld: FormatParams_Tld;
+    pattern?: never;
+};
+export type FormatParams_Domain = {
+    maxLength?: FormatParam<number>;
+    minLength?: FormatParam<number>;
+    maxParts?: FormatParam<number>;
+    minParts?: FormatParam<number>;
+} & FormatParams_DomainCore;
+export type FormatParams_IP = {
+    version: FormatParam<4 | 6 | 'any'>;
+    allowLocalHost?: FormatParam<boolean>;
+    allowPort?: FormatParam<boolean>;
+};
+export type FormatParams_UUID = {
+    version: FormatParam<'4' | '7'>;
+};
+type NumberMax = {
+    max?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    gt?: never;
+} | {
+    max?: never;
+    gt?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type NumberMin = {
+    min?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+    lt?: never;
+} | {
+    min?: never;
+    lt?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type NumberType = {
+    integer?: boolean | {
+        val: boolean;
+        errorMessage: string;
+        desc?: string;
+    };
+    float?: never;
+} | {
+    integer?: never;
+    float?: boolean | {
+        val: boolean;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type FormatParams_Number = NumberMax & NumberMin & NumberType & {
+    multipleOf?: number | {
+        val: number;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type BigIntMax = {
+    max?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+    gt?: never;
+} | {
+    max?: never;
+    gt?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+type BigIntMin = {
+    min?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+    lt?: never;
+} | {
+    min?: never;
+    lt?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type FormatParams_BigInt = BigIntMax & BigIntMin & {
+    multipleOf?: bigint | {
+        val: bigint;
+        errorMessage: string;
+        desc?: string;
+    };
+};
+export type AnyStringFormatParam = StringParams | FormatParams_Email | FormatParams_Url | FormatParams_Domain | FormatParams_IP | FormatParams_UUID | FormatParams_DateTime | FormatParams_Date | FormatParams_Time;
+export type AnyFormatParams = AnyStringFormatParam | FormatParams_Number | FormatParams_BigInt;
+export {};
+export declare type __ΩSamples = any[];
+export declare type __ΩStringValidators = any[];
+export declare type __ΩStringTransformers = any[];
+export declare type __ΩStringParams = any[];
+export declare type __ΩDateFmt = any[];
+export declare type __ΩFormatParams_Date = any[];
+export declare type __ΩTimeFmt = any[];
+export declare type __ΩFormatParams_Time = any[];
+export declare type __ΩFormatParams_DateTime = any[];
+export declare type __ΩFormatParams_EmailPattern = any[];
+export declare type __ΩFormatParams_Email = any[];
+export declare type __ΩFormatParams_UrlPattern = any[];
+export declare type __ΩFormatParams_Url = any[];
+export declare type __ΩFormatParams_DomainName = any[];
+export declare type __ΩFormatParams_Tld = any[];
+export declare type __ΩFormatParam_Pattern = any[];
+export declare type __ΩFormatParams_DomainCore = any[];
+export declare type __ΩFormatParams_Domain = any[];
+export declare type __ΩFormatParams_IP = any[];
+export declare type __ΩFormatParams_UUID = any[];
+export declare type __ΩFormatParams_Number = any[];
+export declare type __ΩFormatParams_BigInt = any[];
+export declare type __ΩAnyStringFormatParam = any[];
+export declare type __ΩAnyFormatParams = any[];

package/.dist/cjs/src/types/formats/friendlyErrors.types.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_general_types = require("../general.types.cjs");
+const src_types_formats_formatsParams_types = require("./formatsParams.types.cjs");
+const src_types_formats_formats_types = require("./formats.types.cjs");
+const src_types_formats_formatBrands_types = require("./formatBrands.types.cjs");
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩTypeErrorParam = [() => src_types_general_types.__ΩRunTypeError, "rtError", () => src_types_general_types.__ΩRunTypeError, "rtErrors", "propName", "index", "TypeErrorParam", `Pn!4"n#F4$P&'J4%'4&8Mw'y`];
+const __ΩUnionKeys = ["T", "UnionKeys", 'l5e$!gR!RPe#!#qk#(QRb!Pde"!p*w"y'];
+const __ΩFriendlyErrorParams = ["T", () => __ΩUnionKeys, () => src_types_formats_formats_types.__ΩTypeFormatError, () => __ΩTypeErrorParam, "FriendlyErrorParams", 'l&n#Rb!PPde#!o""N#"n$Kw%y'];
+const __ΩStringErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩStringParams, "StringErrorParams", 'n"o!"w#y'];
+const __ΩEmailErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Email, "EmailErrorParams", 'n"o!"w#y'];
+const __ΩUrlErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Url, "UrlErrorParams", 'n"o!"w#y'];
+const __ΩDomainErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Domain, "DomainErrorParams", 'n"o!"w#y'];
+const __ΩIPErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_IP, "IPErrorParams", 'n"o!"w#y'];
+const __ΩUUIDErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_UUID, "UUIDErrorParams", 'n"o!"w#y'];
+const __ΩDateTimeErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_DateTime, "DateTimeErrorParams", 'n"o!"w#y'];
+const __ΩDateErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Date, "DateErrorParams", 'n"o!"w#y'];
+const __ΩTimeErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Time, "TimeErrorParams", 'n"o!"w#y'];
+const __ΩNumberErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Number, "NumberErrorParams", 'n"o!"w#y'];
+const __ΩBigIntErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_BigInt, "BigIntErrorParams", 'n"o!"w#y'];
+const __ΩAnyFriendlyErrorParams = [() => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩAnyStringFormatParam, () => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_Number, () => __ΩFriendlyErrorParams, () => src_types_formats_formatsParams_types.__ΩFormatParams_BigInt, "AnyFriendlyErrorParams", `Pn"o!"n$o#"n&o%"Jw'y`];
+const __ΩExtractErrorParams = ["T", () => src_types_formats_formats_types.__ΩExtractFormatParams, () => __ΩTypeErrorParam, () => src_types_formats_formatBrands_types.__ΩBrandEmail, () => __ΩEmailErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandUUID, () => __ΩUUIDErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandUrl, () => __ΩUrlErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandDomain, () => __ΩDomainErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandIP, () => __ΩIPErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandDateTime, () => __ΩDateTimeErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandDate, () => __ΩDateErrorParams, () => src_types_formats_formatBrands_types.__ΩBrandTime, () => __ΩTimeErrorParams, () => __ΩStringErrorParams, () => __ΩNumberErrorParams, () => __ΩBigIntErrorParams, () => __ΩTypeErrorParam, "ExtractErrorParams", `lĮn#Rn%Rn'Rn)Rn+Rn-Rn/Rn1Rn3Rn4Rn5Rn6Rn7RPe#!*qkDGQRPde%!pJRPe#!'qkAUQRPde%!p]RPe#!&qk>hQRPde%!ppRPe#!n2qk;{QRPde%!pƒRPe#!n0qk8QRPde%!p—RPe#!n.qk5£QRPde%!p«RPe#!n,qk2·QRPde%!p¿RPe#!n*qk/ËQRPde%!pÓRPe#!n(qk,ßQRPde%!pçRPe#!n&qk)óQRPde%!pûRPe#!n$qk&ćQRPde&!pďRPe#!-qk#ěQRb!Pde"!o""pģw8y`];
+const __ΩFriendlyErrorHandler = ["T", () => __ΩExtractErrorParams, "params", "", "FriendlyErrorHandler", 'b!Pe"!o""2#&/$w%y'];
+const __ΩMapErrorHandlers = ["K", "V", () => __ΩFriendlyErrorHandler, "$key", () => __ΩFriendlyErrors, () => __ΩFriendlyErrorHandler, "$value", "MapErrorHandlers", `b!b"Pe"!o#"4$8Pe#"o%"e#"o&"J4'8Mw(y`];
+const __ΩSetErrorHandlers = ["T", () => __ΩFriendlyErrors, () => __ΩFriendlyErrorHandler, "$item", "SetErrorHandlers", 'b!PPe#!o""e#!o#"J4$8Mw%y'];
+const __ΩFriendlyErrors = ["T", 0, () => __ΩFriendlyErrorHandler, () => __ΩFriendlyErrorHandler, () => __ΩMapErrorHandlers, () => __ΩFriendlyErrorHandler, () => __ΩSetErrorHandlers, () => __ΩFriendlyErrorHandler, 0, () => __ΩFriendlyErrorHandler, () => __ΩFriendlyErrorHandler, () => __ΩMapErrorHandlers, () => __ΩFriendlyErrorHandler, () => __ΩSetErrorHandlers, () => __ΩFriendlyErrorHandler, 0, () => __ΩFriendlyErrorHandler, () => __ΩFriendlyErrorHandler, "FriendlyErrors", `lūPe%!o""e%!o#"JRe$!o$"RPe#!%qk#2QRPde#!p9RPe#!e#"o%#e#"o&"JRPe+!o'"e+!o("JRPe%!o)"e%!o*"JRe$!o+"RPe#!%qkm|QRPde/!pƒRPe-!e-"o,#e-"o-"JRPe3!o."e3!o/"JRPe/!e+!fo0"e/!e+!fo1"JRe.!e*!fo2"RPe-!e)!f%qk·ÎQRPe+!e'!fh1!Dqk¨ÙQRPe)!e%!fh+!h+"Eqk–èQRPe'!e#!fh-!FqkŽúQRPde%!gNď"RPe#!h)!Dqk^ġQRPde%!pīRPdde#!h!!h!"EqkLĹQRPde%!pŁRPde#!h!!FqkDŔQRb!Pde"!pŜw3y`];
+const __ΩMapErrorsResult = ["_K", "V", () => __ΩRecord, () => src_types_general_types.__ΩStrNumber, "$keys", () => __ΩRecord, () => src_types_general_types.__ΩStrNumber, () => __ΩFriendlyErrorsResult, "$values", "MapErrorsResult", `l7e$!o("R&RPe#!%qk#*QRb!b"Pn$&o##4%8n'Pde#"p,o&#4)8Mw*y`];
+const __ΩSetErrorsResult = ["T", () => __ΩRecord, () => src_types_general_types.__ΩStrNumber, () => __ΩFriendlyErrorsResult, "SetErrorsResult", 'l7e$!o$"R&RPe#!%qk#*QRb!n#Pde"!p,o"#w%y'];
+const __ΩFriendlyErrorsResult = ["T", () => __ΩRecord, () => src_types_general_types.__ΩStrNumber, 0, () => __ΩMapErrorsResult, () => __ΩSetErrorsResult, () => __ΩRecord, () => src_types_general_types.__ΩStrNumber, 0, () => __ΩMapErrorsResult, () => __ΩSetErrorsResult, 0, "$root", "FriendlyErrorsResult", `lŃe$!o$"R&RPe#!%qk#*QRn#Pde#!p,o"#Re"!e""o%#Re*!o&"Re$!o)"R&RPe#!%qkU\\QRn(Pde4!p^o'#Re1!e1"o*#Re7!o+"Re/!e*!fo,"R&RPe.!e)!f%qk‡’QRPe,!e'!fh6!Dqk€”QRPe*!e%!fh0!h0"Eqkv£QRPe(!e#!fh2!FqkiµQRPPde&!gNÊ"P&4-8MKR&RPe#!%qkÜîQRPde%!pðRPe#!h)!DqkNûQRPde%!păRPdde#!h!!h!"EqkDđQRPde%!pęRPde#!h!!Fqk7ĬQRb!Pde"!pĴw.y`];
+exports.__ΩAnyFriendlyErrorParams = __ΩAnyFriendlyErrorParams;
+exports.__ΩBigIntErrorParams = __ΩBigIntErrorParams;
+exports.__ΩDateErrorParams = __ΩDateErrorParams;
+exports.__ΩDateTimeErrorParams = __ΩDateTimeErrorParams;
+exports.__ΩDomainErrorParams = __ΩDomainErrorParams;
+exports.__ΩEmailErrorParams = __ΩEmailErrorParams;
+exports.__ΩExtractErrorParams = __ΩExtractErrorParams;
+exports.__ΩFriendlyErrorHandler = __ΩFriendlyErrorHandler;
+exports.__ΩFriendlyErrorParams = __ΩFriendlyErrorParams;
+exports.__ΩFriendlyErrors = __ΩFriendlyErrors;
+exports.__ΩFriendlyErrorsResult = __ΩFriendlyErrorsResult;
+exports.__ΩIPErrorParams = __ΩIPErrorParams;
+exports.__ΩMapErrorHandlers = __ΩMapErrorHandlers;
+exports.__ΩMapErrorsResult = __ΩMapErrorsResult;
+exports.__ΩNumberErrorParams = __ΩNumberErrorParams;
+exports.__ΩSetErrorHandlers = __ΩSetErrorHandlers;
+exports.__ΩSetErrorsResult = __ΩSetErrorsResult;
+exports.__ΩStringErrorParams = __ΩStringErrorParams;
+exports.__ΩTimeErrorParams = __ΩTimeErrorParams;
+exports.__ΩTypeErrorParam = __ΩTypeErrorParam;
+exports.__ΩUUIDErrorParams = __ΩUUIDErrorParams;
+exports.__ΩUrlErrorParams = __ΩUrlErrorParams;
+//# sourceMappingURL=friendlyErrors.types.cjs.map

package/.dist/cjs/src/types/formats/friendlyErrors.types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"friendlyErrors.types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/src/types/formats/friendlyErrors.types.d.ts

@@ -0,0 +1,71 @@
+import { RunTypeError, StrNumber } from '../general.types.ts';
+import { AnyFormatParams, AnyStringFormatParam, FormatParams_BigInt, FormatParams_Number, StringParams, FormatParams_Email, FormatParams_Url, FormatParams_Domain, FormatParams_IP, FormatParams_UUID, FormatParams_DateTime, FormatParams_Date, FormatParams_Time } from './formatsParams.types.ts';
+import { ExtractFormatParams, TypeFormatError } from './formats.types.ts';
+import { BrandEmail, BrandUUID, BrandUrl, BrandDomain, BrandIP, BrandDate, BrandTime, BrandDateTime } from './formatBrands.types.ts';
+export type TypeErrorParam = {
+    rtError: RunTypeError;
+    rtErrors: RunTypeError[];
+    propName: string | number;
+    index?: number;
+};
+type UnionKeys<T> = T extends unknown ? keyof T : never;
+export type FriendlyErrorParams<T extends AnyFormatParams> = {
+    [K in UnionKeys<T>]?: TypeFormatError;
+} & TypeErrorParam;
+export type StringErrorParams = FriendlyErrorParams<StringParams>;
+export type EmailErrorParams = FriendlyErrorParams<FormatParams_Email>;
+export type UrlErrorParams = FriendlyErrorParams<FormatParams_Url>;
+export type DomainErrorParams = FriendlyErrorParams<FormatParams_Domain>;
+export type IPErrorParams = FriendlyErrorParams<FormatParams_IP>;
+export type UUIDErrorParams = FriendlyErrorParams<FormatParams_UUID>;
+export type DateTimeErrorParams = FriendlyErrorParams<FormatParams_DateTime>;
+export type DateErrorParams = FriendlyErrorParams<FormatParams_Date>;
+export type TimeErrorParams = FriendlyErrorParams<FormatParams_Time>;
+export type NumberErrorParams = FriendlyErrorParams<FormatParams_Number>;
+export type BigIntErrorParams = FriendlyErrorParams<FormatParams_BigInt>;
+export type AnyFriendlyErrorParams = FriendlyErrorParams<AnyStringFormatParam> | FriendlyErrorParams<FormatParams_Number> | FriendlyErrorParams<FormatParams_BigInt>;
+export type ExtractErrorParams<T> = ExtractFormatParams<T> extends undefined ? TypeErrorParam : T extends BrandEmail ? EmailErrorParams : T extends BrandUUID ? UUIDErrorParams : T extends BrandUrl ? UrlErrorParams : T extends BrandDomain ? DomainErrorParams : T extends BrandIP ? IPErrorParams : T extends BrandDateTime ? DateTimeErrorParams : T extends BrandDate ? DateErrorParams : T extends BrandTime ? TimeErrorParams : T extends string ? StringErrorParams : T extends number ? NumberErrorParams : T extends bigint ? BigIntErrorParams : TypeErrorParam;
+export type FriendlyErrorHandler<T> = (params: ExtractErrorParams<T>) => string;
+export type MapErrorHandlers<K, V> = {
+    $key?: FriendlyErrorHandler<K>;
+    $value?: FriendlyErrors<V> | FriendlyErrorHandler<V>;
+};
+export type SetErrorHandlers<T> = {
+    $item?: FriendlyErrors<T> | FriendlyErrorHandler<T>;
+};
+export type FriendlyErrors<T> = T extends (infer U)[] ? U extends object ? FriendlyErrors<U> | FriendlyErrorHandler<U> : FriendlyErrorHandler<U> : T extends Map<infer K, infer V> ? MapErrorHandlers<K, V> | FriendlyErrorHandler<V> : T extends Set<infer U> ? SetErrorHandlers<U> | FriendlyErrorHandler<U> : {
+    [P in keyof T]?: T[P] extends (infer U)[] ? U extends object ? FriendlyErrors<U> | FriendlyErrorHandler<U> : FriendlyErrorHandler<U> : T[P] extends Map<infer K, infer V> ? MapErrorHandlers<K, V> | FriendlyErrorHandler<V> : T[P] extends Set<infer U> ? SetErrorHandlers<U> | FriendlyErrorHandler<U> : T[P] extends object ? FriendlyErrors<T[P]> | FriendlyErrorHandler<T[P]> : FriendlyErrorHandler<T[P]>;
+};
+export type MapErrorsResult<_K, V> = {
+    $keys?: Record<StrNumber, string>;
+    $values?: Record<StrNumber, V extends object ? FriendlyErrorsResult<V> : string>;
+};
+export type SetErrorsResult<T> = Record<StrNumber, T extends object ? FriendlyErrorsResult<T> : string>;
+export type FriendlyErrorsResult<T> = T extends (infer U)[] ? Record<StrNumber, U extends object ? FriendlyErrorsResult<U> : string> : T extends Map<infer K, infer V> ? MapErrorsResult<K, V> : T extends Set<infer U> ? SetErrorsResult<U> : T extends object ? {
+    [P in keyof T]?: T[P] extends (infer U)[] ? Record<StrNumber, U extends object ? FriendlyErrorsResult<U> : string> : T[P] extends Map<infer K, infer V> ? MapErrorsResult<K, V> : T[P] extends Set<infer U> ? SetErrorsResult<U> : T[P] extends object ? FriendlyErrorsResult<T[P]> : string;
+} & {
+    $root?: string;
+} : string;
+export {};
+export declare type __ΩTypeErrorParam = any[];
+export declare type __ΩFriendlyErrorParams = any[];
+export declare type __ΩStringErrorParams = any[];
+export declare type __ΩEmailErrorParams = any[];
+export declare type __ΩUrlErrorParams = any[];
+export declare type __ΩDomainErrorParams = any[];
+export declare type __ΩIPErrorParams = any[];
+export declare type __ΩUUIDErrorParams = any[];
+export declare type __ΩDateTimeErrorParams = any[];
+export declare type __ΩDateErrorParams = any[];
+export declare type __ΩTimeErrorParams = any[];
+export declare type __ΩNumberErrorParams = any[];
+export declare type __ΩBigIntErrorParams = any[];
+export declare type __ΩAnyFriendlyErrorParams = any[];
+export declare type __ΩExtractErrorParams = any[];
+export declare type __ΩFriendlyErrorHandler = any[];
+export declare type __ΩMapErrorHandlers = any[];
+export declare type __ΩSetErrorHandlers = any[];
+export declare type __ΩFriendlyErrors = any[];
+export declare type __ΩMapErrorsResult = any[];
+export declare type __ΩSetErrorsResult = any[];
+export declare type __ΩFriendlyErrorsResult = any[];

package/.dist/cjs/src/types/general.types.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_constants = require("../constants.cjs");
+const src_types_formats_formats_types = require("./formats/formats.types.cjs");
+const src_types_pureFunctions_types = require("./pureFunctions.types.cjs");
+const __ΩError = ["name", "message", "stack", "Error", 'P&4!&4"&4#8Mw$y'];
+const __ΩOmit = ["T", "K", () => __ΩPick, () => __ΩExclude, "Omit", 'b!b"e!!e!!ge!"o$#o##w%y'];
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩSharedArrayBuffer = ["byteLength", "begin", "end", 0, "slice", "SharedArrayBuffer", () => Symbol.toStringTag, "SharedArrayBuffer", `P'4!9P'2"8'2#8n$1%.&4'9Mw(y`];
+const __ΩDataView = [() => __ΩArrayBufferLike, "TArrayBuffer", "buffer", "byteLength", "byteOffset", "littleEndian", "getFloat32", "getFloat64", "getInt8", "getInt16", "getInt32", "getUint8", "getUint16", "getUint32", "value", "setFloat32", "setFloat64", "setInt8", "setInt16", "setInt32", "setUint8", "setUint16", "setUint32", "DataView", `n!c"Pe"!4#9'4$9'4%9P'2%)2&8'1'P'2%)2&8'1(P'2%'1)P'2%)2&8'1*P'2%)2&8'1+P'2%'1,P'2%)2&8'1-P'2%)2&8'1.P'2%'2/)2&8$10P'2%'2/)2&8$11P'2%'2/$12P'2%'2/)2&8$13P'2%'2/)2&8$14P'2%'2/$15P'2%'2/)2&8$16P'2%'2/)2&8$17Mw8y`];
+const __ΩBigUint64Array = [() => __ΩArrayBufferLike, "TArrayBuffer", "BYTES_PER_ELEMENT", "buffer", "byteLength", "byteOffset", "target", "start", "end", "copyWithin", () => __ΩArrayIterator, "entries", "value", "index", 0, "array", "", "predicate", "thisArg", "every", "fill", 0, 0, "filter", 0, "find", 0, "findIndex", 0, "callbackfn", "forEach", "searchElement", "fromIndex", "includes", "indexOf", "separator", "join", () => __ΩArrayIterator, "keys", "lastIndexOf", "length", 0, 0, "map", "previousValue", "currentValue", "currentIndex", 0, "reduce", 0, "initialValue", 0, "reduceRight", 0, "reverse", () => __ΩArrayLike, "offset", "set", 0, "slice", 0, "some", "a", "b", "compareFn", "sort", "begin", 0, "subarray", "locales", "options", "toLocaleString", "toString", 0, "valueOf", () => __ΩArrayIterator, "values", () => __ΩArrayIterator, () => Symbol.iterator, "BigUint64Array", () => Symbol.toStringTag, "BigUint64Array", `n!c"P'4#9e"!4$9'4%9'4&9P'2''2('2)8!1*PP'*Go+"1,PP*2-'2.e$!o/"20)/122"238)14P*2-'2(8'2)8!15PP*2-'2.e$!o6"20"/122"238_o7"18PP*2-'2.e$!o9"20)/122"238P*-J1:PP*2-'2.e$!o;"20)/122"238'1<PP*2-'2.e$!o="20$/12>"238$1?P*2@'2A8)1BP*2@'2A8'1CP&2D8&1EP'oF"1GP*2@'2A8'1H'4I9PP*2-'2.e$!oJ"20*/12>"238_oK"1LPP*2M*2N'2Oe$!oP"20*/12>*1QPP"2M*2N'2Oe$!oR"20"/12>"2S"1QPP*2M*2N'2Oe$!oT"20*/12>*1UPP"2M*2N'2Oe$!oV"20"/12>"2S"1UP!1WP*oX"20'2Y8$1ZP'2(8'2)8_o["1\\PP*2-'2.e$!o]"20)/122"238)1^PP*2_*2\`P'*J/12a8!1bP'2c8'2)8e#!od"1ePP&&FJ2f8!2g8&1hP&1iPe#!oj"1kP*ol"1mP*on"1o.p4q9'*LMwry`];
+const __ΩArrayBufferView = [() => __ΩArrayBufferLike, "TArrayBuffer", "buffer", "byteLength", "byteOffset", "ArrayBufferView", `n!c"Pe"!4#9'4$9'4%9Mw&y`];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩExclude = ["T", "U", "Exclude", 'l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y'];
+const __ΩArrayBufferLike = [() => __ΩArrayBufferTypes, () => __ΩArrayBufferTypes, "ArrayBufferLike", 'n!n"gfw#y'];
+const __ΩArrayIterator = ["T", () => __ΩIteratorObject, () => __ΩBuiltinIteratorReturn, 0, () => Symbol.iterator, "ArrayIterator", 'b!Pe"!n##o"$Pe#!o$"1%Mw&y'];
+const __ΩArrayLike = ["T", "length", "ArrayLike", `b!P'4"9'e"!LMw#y`];
+const __ΩArrayBufferTypes = ["ArrayBuffer", "ArrayBufferTypes", 'P_4!Mw"y'];
+const __ΩIteratorObject = ["T", "TReturn", "TNext", () => __ΩIterator, 0, () => Symbol.iterator, "IteratorObject", `b!#c"#c#Pe"!e""e"#o$$Pe#!e#"e##o%$1&Mw'y`];
+const __ΩBuiltinIteratorReturn = ["BuiltinIteratorReturn", "!w!y"];
+const __ΩIterator = ["T", "TReturn", "TNext", "param0", () => __ΩIteratorResult, "next", "value", () => __ΩIteratorResult, "return", "e", () => __ΩIteratorResult, "throw", "Iterator", `b!"c""c#PPPPGPe%#GJ@2$e#!e#"o%#1&Pe#"2'8e#!e#"o(#1)8P"2*8e#!e#"o+#1,8Mw-y`];
+const __ΩIteratorResult = ["T", "TReturn", () => __ΩIteratorYieldResult, () => __ΩIteratorReturnResult, "IteratorResult", 'b!"c"Pe"!o#"e""o$"Jw%y'];
+const __ΩIteratorYieldResult = ["TYield", false, "done", "value", "IteratorYieldResult", 'b!P."4#8e"!4$Mw%y'];
+const __ΩIteratorReturnResult = ["TReturn", true, "done", "value", "IteratorReturnResult", 'b!P."4#e"!4$Mw%y'];
+const SerializerModes = {
+  /** Use prepareForJson (mutates original objects), and leaves JSON.stringify to the platform adapter */
+  json: 1,
+  /** Use toBinary JIT function for binary serialization */
+  binary: 2,
+  /** Use stringifyJson JIT function that do not mutates objects. */
+  stringifyJson: 3
+};
+const __ΩSerializerMode = [() => SerializerModes, "SerializerMode", 'i!gw"y'];
+const __ΩSerializerCode = [() => SerializerModes, () => __ΩSerializerMode, "SerializerCode", 'i!n"fw#y'];
+const __ΩCoreRouterOptions = ["autoGenerateErrorId", "basePath", "suffix", "CoreRouterOptions", 'P)4!&4"&4#Mw$y'];
+const __ΩTypedErrorParams = ["ErrType", "type", "message", () => __ΩError, "originalError", "TypedErrorParams", 'b!Pe"!4"&4#8n$4%8Mw&y'];
+const __ΩRpcErrorParams = ["ErrType", "ErrData", "type", "id", "publicMessage", "message", "errorData", () => __ΩError, "originalError", "statusCode", "RpcErrorParams", `b!"c"Pe"!4#P'&J4$8&4%8&4&8e""4'8n(4)8'4*8Mw+y`];
+const __ΩRpcErrorWithPublic = ["ErrType", "ErrData", () => __ΩRpcErrorParams, "publicMessage", "RpcErrorWithPublic", 'b!"c"Pe"!e""o##&4$Mw%y'];
+const __ΩRpcErrorWithPrivate = ["ErrType", "ErrData", () => __ΩRpcErrorParams, "message", "RpcErrorWithPrivate", 'b!"c"Pe"!e""o##&4$Mw%y'];
+const __ΩPublicRpcError = ["ErrType", "ErrData", () => __ΩOmit, () => __ΩRpcErrorParams, "message", "originalError", true, "mion@isΣrrθr", "type", "errorData", "publicMessage", "PublicRpcError", `b!"c"Pe"!e""o$#P.%.&Jo##.'4(9e"!4)e""4*8&4+Mw,y`];
+const __ΩAnyErrorParams = ["ErrType", "ErrData", () => __ΩRpcErrorWithPublic, () => __ΩRpcErrorWithPrivate, "AnyErrorParams", 'b!"c"Pe"!e""o##e"!e""o$#Jw%y'];
+const __ΩMapKeyPathSegment = ["key", "index", "mapKey", "failed", "MapKeyPathSegment", `P#4!'4".#4$Mw%y`];
+const __ΩMapValuePathSegment = ["key", "index", "mapVal", "failed", "MapValuePathSegment", `P#4!'4".#4$Mw%y`];
+const __ΩSetItemPathSegment = ["key", "index", "SetItemPathSegment", `P#4!'4"Mw#y`];
+const __ΩPathSegment = [() => __ΩStrNumber, () => __ΩMapKeyPathSegment, () => __ΩMapValuePathSegment, () => __ΩSetItemPathSegment, "PathSegment", 'Pn!n"n#n$Jw%y'];
+const __ΩRunTypeError = [() => __ΩPathSegment, "path", "expected", () => src_types_formats_formats_types.__ΩTypeFormatError, "format", "RunTypeError", 'Pn!F4"&4#n$4%8Mw&y'];
+const __ΩJitFnArgs = ["vλl", "JitFnArgs", 'P&4!&&LMw"y'];
+const __ΩJitCompiledFnData = ["typeName", "fnID", "jitFnHash", () => __ΩJitFnArgs, "args", () => __ΩJitFnArgs, "defaultParamValues", "isNoop", "code", "jitDependencies", "pureFnDependencies", "paramNames", "JitCompiledFnData", `P&4!9&4"9&4#9n$4%9n&4'9)4(89&4)9&F4*9&F4+9&F4,8Mw-y`];
+const __ΩJitCompiledFn = [() => __ΩAnyFn, "Fn", () => __ΩJitCompiledFnData, "JITUtils", "utl", "", "createJitFn", "fn", "JitCompiledFn", `n!c"Pn#P"w$2%e#!/&4'9e"!4(9Mw)y`];
+const __ΩPersistedJitFn = [() => __ΩOmit, () => __ΩJitCompiledFn, "fn", "fn", "PersistedJitFn", 'Pn".#o!#-4$9Mw%y'];
+const __ΩJitCompiledFunctions = [() => __ΩJitCompiledFn, () => __ΩIsTypeFn, "isType", () => __ΩJitCompiledFn, () => __ΩTypeErrorsFn, "typeErrors", () => __ΩJitCompiledFn, () => __ΩPrepareForJsonFn, "prepareForJson", () => __ΩJitCompiledFn, () => __ΩRestoreFromJsonFn, "restoreFromJson", () => __ΩJitCompiledFn, () => __ΩJsonStringifyFn, "stringifyJson", () => __ΩJitCompiledFn, () => __ΩToBinaryFn, "toBinary", () => __ΩJitCompiledFn, () => __ΩFromBinaryFn, "fromBinary", "JitCompiledFunctions", `Pn"o!"4#n%o$"4&n(o'"4)n+o*"4,n.o-"4/n1o0"42n4o3"45Mw6y`];
+const __ΩSerializableJITFunctions = [() => __ΩJitCompiledFnData, "isType", () => __ΩJitCompiledFnData, "typeErrors", () => __ΩJitCompiledFnData, "prepareForJson", () => __ΩJitCompiledFnData, "restoreFromJson", () => __ΩJitCompiledFnData, "stringifyJson", () => __ΩJitCompiledFnData, "toBinary", () => __ΩJitCompiledFnData, "fromBinary", "SerializableJITFunctions", `Pn!4"n#4$n%4&n'4(n)4*n+4,n-4.Mw/y`];
+const __ΩJitFunctionsHashes = ["isType", "typeErrors", "prepareForJson", "restoreFromJson", "stringifyJson", "toBinary", "fromBinary", "JitFunctionsHashes", `P&4!&4"&4#&4$&4%&4&&4'Mw(y`];
+const __ΩJsonStringifyFn = ["value", () => __ΩJSONString, "", "JsonStringifyFn", 'P"2!n"/#w$y'];
+const __ΩRestoreFromJsonFn = [() => __ΩJSONValue, "value", "", "RestoreFromJsonFn", 'Pn!2""/#w$y'];
+const __ΩPrepareForJsonFn = ["value", () => __ΩJSONValue, "", "PrepareForJsonFn", 'P"2!n"/#w$y'];
+const __ΩTypeErrorsFn = ["value", () => __ΩRunTypeError, "", "TypeErrorsFn", 'P"2!n"F/#w$y'];
+const __ΩIsTypeFn = ["value", "", "IsTypeFn", 'P"2!)/"w#y'];
+const __ΩToCodeFn = ["value", "", "ToCodeFn", 'P"2!&/"w#y'];
+const __ΩToBinaryFn = ["value", () => __ΩDataViewSerializer, "serializer", "", "ToBinaryFn", 'P"2!n"2#$/$w%y'];
+const __ΩFromBinaryFn = ["value", () => __ΩDataViewDeserializer, "deserializer", "", "FromBinaryFn", 'P-2!n"2#"/$w%y'];
+const __ΩJitFunctionsCache = [() => __ΩRecord, () => __ΩJitCompiledFn, "JitFunctionsCache", '&n"o!#w#y'];
+const __ΩPureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => src_types_pureFunctions_types.__ΩCompiledPureFunction, "PureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩPersistedJitFunctionsCache = [() => __ΩRecord, () => __ΩPersistedJitFn, "PersistedJitFunctionsCache", '&n"o!#w#y'];
+const __ΩPersistedPureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => src_types_pureFunctions_types.__ΩPersistedPureFunction, "PersistedPureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩFnsDataCache = [() => __ΩRecord, () => __ΩJitCompiledFnData, "FnsDataCache", '&n"o!#w#y'];
+const __ΩPureFnsDataCache = [() => __ΩRecord, () => __ΩRecord, () => src_types_pureFunctions_types.__ΩPureFunctionData, "PureFnsDataCache", '&&n#o"#o!#w$y'];
+const __ΩSrcCodeJitCompiledFn = [() => __ΩJitCompiledFnData, "JITUtils", "utl", () => __ΩAnyFn, "", "createJitFn", "fn", "SrcCodeJitCompiledFn", `Pn!P"w"2#n$/%4&9-4'9Mw(y`];
+const __ΩSrcCodeCompiledPureFunction = [() => src_types_pureFunctions_types.__ΩPureFunctionData, "JITUtils", "utl", () => __ΩAnyFn, "", "createPureFn", "fn", "SrcCodeCompiledPureFunction", `Pn!P"w"2#n$/%4&9-4'9Mw(y`];
+const __ΩSrcCodeJITCompiledFnsCache = [() => __ΩRecord, () => __ΩSrcCodeJitCompiledFn, "SrcCodeJITCompiledFnsCache", '&n"o!#w#y'];
+const __ΩSrcCodePureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => __ΩSrcCodeCompiledPureFunction, "SrcCodePureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
+const __ΩAnyFn = ["args", "", "AnyFn", 'P"@2!"/"w#y'];
+const __ΩAnyObject = [() => __ΩRecord, "AnyObject", '&#o!#w"y'];
+const __ΩAnyClass = ["T", "args", "new", "AnyClass", '"c!PP"@2"e#!1#Mw$y'];
+const __ΩSerializableClass = ["T", "new", "SerializableClass", '"c!PPe#!1"Mw#y'];
+const __ΩDeserializeClassFn = ["C", () => __ΩDataOnly, "deserialized", "", "DeserializeClassFn", 'b!Pe"!o""2#e"!/$w%y'];
+const __ΩMutable = ["T", "Mutable", 'l+e#!e"!fRb!Pde"!gN#)w"y'];
+const __ΩPrettify = ["T", "Prettify", 'l+e$!e"!fRb!PPde#!gN#!PMKw"y'];
+const __ΩJSONValue = [() => __ΩStrNumber, 0, 0, "JSONValue", 'Pn!),P&n"LMn#FJw$y'];
+const __ΩJSONString = ["JSONString", "&w!y"];
+const __ΩNative = [() => __ΩSharedArrayBuffer, () => __ΩDataView, () => __ΩBigUint64Array, "Native", 'PTA!!!!!!_n!n"UWVXYZ[\\]^n#Jw$y'];
+const __ΩDataOnly = ["T", () => __ΩNative, () => Function, "args", "new", 0, 0, 0, 0, 0, () => Function, "DataOnly", `lĐe$!R!R!Re"!o&"FRe"!o'"e""o("ERe*!o)"DR!Re%!RPe'!e#!fo*"Pe(!e$!fPu+qkIKQGRPde%!gtO!RPe#!h)!DqkAlQRPde%!pvRPdde#!h!!h!"Eqk3„QRPde%!pŒRPde#!h!!Fqk+ŸQRPde%!p§RPe#!P"@2$"/%qk)¶QRPde%!p¾RPe#!Pu#qk'ÐQRPde%!pØRPe#!n"qk#åQRPde%!píRe$!RPe#!%qkùāQRb!Pde"!pąw,y`];
+const __ΩStrictArrayBuffer = ["buffer", "StrictArrayBuffer", 'P_P-4!8MKw"y'];
+const __ΩBinaryInput = [() => __ΩArrayBufferView, "BinaryInput", 'P_n!Jw"y'];
+const __ΩDataViewSerializer = ["index", () => __ΩDataView, "view", "", "reset", () => __ΩStrictArrayBuffer, "getBuffer", "getBufferView", "markAsEnded", "getLength", "str", "serString", "n", "serFloat64", "serEnum", "bitMaskIndex", "bitIndex", "setBitMask", "DataViewSerializer", `P'4!n"4#P$/$4%Pn&/$4'PW/$4(P$/$4)P'1*P&2+$1,P'2-$1.PP'&J2-$1/P'20'21$12Mw3y`];
+const __ΩDataViewDeserializer = ["index", () => __ΩDataView, "view", "", "reset", () => __ΩStrictArrayBuffer, "buffer", "byteOffset", "byteLength", "setBuffer", "markAsEnded", "getLength", "desString", "desFloat64", "desEnum", "DataViewDeserializer", `P'4!n"4#P$/$4%Pn&2''2(8'2)8$/$4*P$/$4+P'1,P&1-P'1.PP'&J1/Mw0y`];
+const __ΩMimeTypes = [() => src_constants.MIME_TYPES, () => src_constants.MIME_TYPES, "MimeTypes", 'i!i"gfw#y'];
+exports.SerializerModes = SerializerModes;
+exports.__ΩAnyClass = __ΩAnyClass;
+exports.__ΩAnyErrorParams = __ΩAnyErrorParams;
+exports.__ΩAnyFn = __ΩAnyFn;
+exports.__ΩAnyObject = __ΩAnyObject;
+exports.__ΩBinaryInput = __ΩBinaryInput;
+exports.__ΩCoreRouterOptions = __ΩCoreRouterOptions;
+exports.__ΩDataOnly = __ΩDataOnly;
+exports.__ΩDataViewDeserializer = __ΩDataViewDeserializer;
+exports.__ΩDataViewSerializer = __ΩDataViewSerializer;
+exports.__ΩDeserializeClassFn = __ΩDeserializeClassFn;
+exports.__ΩFnsDataCache = __ΩFnsDataCache;
+exports.__ΩFromBinaryFn = __ΩFromBinaryFn;
+exports.__ΩIsTypeFn = __ΩIsTypeFn;
+exports.__ΩJSONString = __ΩJSONString;
+exports.__ΩJSONValue = __ΩJSONValue;
+exports.__ΩJitCompiledFn = __ΩJitCompiledFn;
+exports.__ΩJitCompiledFnData = __ΩJitCompiledFnData;
+exports.__ΩJitCompiledFunctions = __ΩJitCompiledFunctions;
+exports.__ΩJitFnArgs = __ΩJitFnArgs;
+exports.__ΩJitFunctionsCache = __ΩJitFunctionsCache;
+exports.__ΩJitFunctionsHashes = __ΩJitFunctionsHashes;
+exports.__ΩJsonStringifyFn = __ΩJsonStringifyFn;
+exports.__ΩMapKeyPathSegment = __ΩMapKeyPathSegment;
+exports.__ΩMapValuePathSegment = __ΩMapValuePathSegment;
+exports.__ΩMimeTypes = __ΩMimeTypes;
+exports.__ΩMutable = __ΩMutable;
+exports.__ΩPathSegment = __ΩPathSegment;
+exports.__ΩPersistedJitFn = __ΩPersistedJitFn;
+exports.__ΩPersistedJitFunctionsCache = __ΩPersistedJitFunctionsCache;
+exports.__ΩPersistedPureFunctionsCache = __ΩPersistedPureFunctionsCache;
+exports.__ΩPrepareForJsonFn = __ΩPrepareForJsonFn;
+exports.__ΩPrettify = __ΩPrettify;
+exports.__ΩPublicRpcError = __ΩPublicRpcError;
+exports.__ΩPureFnsDataCache = __ΩPureFnsDataCache;
+exports.__ΩPureFunctionsCache = __ΩPureFunctionsCache;
+exports.__ΩRestoreFromJsonFn = __ΩRestoreFromJsonFn;
+exports.__ΩRpcErrorParams = __ΩRpcErrorParams;
+exports.__ΩRpcErrorWithPrivate = __ΩRpcErrorWithPrivate;
+exports.__ΩRpcErrorWithPublic = __ΩRpcErrorWithPublic;
+exports.__ΩRunTypeError = __ΩRunTypeError;
+exports.__ΩSerializableClass = __ΩSerializableClass;
+exports.__ΩSerializableJITFunctions = __ΩSerializableJITFunctions;
+exports.__ΩSerializerCode = __ΩSerializerCode;
+exports.__ΩSerializerMode = __ΩSerializerMode;
+exports.__ΩSetItemPathSegment = __ΩSetItemPathSegment;
+exports.__ΩSrcCodeCompiledPureFunction = __ΩSrcCodeCompiledPureFunction;
+exports.__ΩSrcCodeJITCompiledFnsCache = __ΩSrcCodeJITCompiledFnsCache;
+exports.__ΩSrcCodeJitCompiledFn = __ΩSrcCodeJitCompiledFn;
+exports.__ΩSrcCodePureFunctionsCache = __ΩSrcCodePureFunctionsCache;
+exports.__ΩStrNumber = __ΩStrNumber;
+exports.__ΩStrictArrayBuffer = __ΩStrictArrayBuffer;
+exports.__ΩToBinaryFn = __ΩToBinaryFn;
+exports.__ΩToCodeFn = __ΩToCodeFn;
+exports.__ΩTypeErrorsFn = __ΩTypeErrorsFn;
+exports.__ΩTypedErrorParams = __ΩTypedErrorParams;
+//# sourceMappingURL=general.types.cjs.map

package/.dist/cjs/src/types/general.types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}