@mionjs/core 0.8.0-alpha.0

package/.dist/esm/src/types/formats/formatsParams.types.js

@@ -0,0 +1,60 @@
+import { __ΩFormatParam as ___FormatParam } from "./formats.types.js";
+const __ΩOmit = ["T", "K", () => __ΩPick, () => __ΩExclude, "Omit", 'b!b"e!!e!!ge!"o$#o##w%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 __ΩSamples = ["Samples", "P&&F9Jw!y"];
+const __ΩStringValidators = ["val", "errorMessage", "desc", "maxLength", "minLength", "length", "ignoreCase", "mockSamples", "disallowedChars", () => __ΩSamples, "disallowedValues", () => __ΩSamples, "pattern", () => __ΩSamples, "allowedChars", () => __ΩSamples, "allowedValues", "StringValidators", `PP'P'4!&4"&4#8MJ4$8P'P'4!&4"&4#8MJ4%8P'P'4!&4"&4#8MJ4&8P&4!&4"&4#8)4'8&4(M4)8P&F94!&4"&4#8)4'8n*4(M4+8PA4!&4"&4#8)4'8n,4(M4-8P&4!&4"&4#8)4'8n.4(8M4/8P&F94!&4"&4#8)4'8n04(8M418Mw2y`];
+const __ΩStringTransformers = ["lowercase", "uppercase", "capitalize", "trim", "searchValue", "replaceValue", "replace", "replaceAll", "StringTransformers", `P)4!8)4"8)4#8)4$8P&4%&4&M4'8P&4%&4&M4(8Mw)y`];
+const __ΩStringParams = [() => __ΩStringValidators, () => __ΩStringTransformers, "StringParams", 'Pn!n"Kw#y'];
+const __ΩDateFmt = ["ISO", "YYYY-MM-DD", "DD-MM-YYYY", "MM-DD-YYYY", "MM-DD", "DD-MM", "YYYY-MM", "DateFmt", `P.!.".#.$.%.&.'Jw(y`];
+const __ΩFormatParams_Date = [() => ___FormatParam, () => __ΩDateFmt, "format", "FormatParams_Date", 'Pn"o!"4#Mw$y'];
+const __ΩTimeFmt = ["ISO", "HH:mm:ss[.mmm]TZ", "HH:mm:ss[.mmm]", "HH:mm:ss", "HH:mm", "mm:ss", "HH", "mm", "ss", "TimeFmt", `P.!.".#.$.%.&.'.(.)Jw*y`];
+const __ΩFormatParams_Time = [() => ___FormatParam, () => __ΩTimeFmt, "format", "FormatParams_Time", 'Pn"o!"4#Mw$y'];
+const __ΩFormatParams_DateTime = [() => __ΩFormatParams_Date, "date", () => __ΩFormatParams_Time, "time", () => ___FormatParam, "splitChar", "FormatParams_DateTime", `Pn!4"n#4$&o%"4&Mw'y`];
+const __ΩFormatParams_EmailPattern = [() => __ΩOmit, () => __ΩStringValidators, "length", "allowedChars", "disallowedChars", "allowedValues", "FormatParams_EmailPattern", `n"P.#.$.%.&Jo!#w'y`];
+const __ΩFormatParams_Email = [() => __ΩFormatParams_EmailPattern, () => __ΩStringValidators, "localPart", () => __ΩFormatParams_Domain, "domain", "FormatParams_Email", 'Pn!Pn"4#8n$4%8MKw&y'];
+const __ΩFormatParams_UrlPattern = [() => __ΩOmit, () => __ΩStringParams, "allowedChars", "disallowedChars", "allowedValues", "disallowedValues", "FormatParams_UrlPattern", `n"P.#.$.%.&Jo!#w'y`];
+const __ΩFormatParams_Url = [() => __ΩFormatParams_UrlPattern, () => __ΩFormatParams_IP, "ip", () => __ΩFormatParams_Domain, "domain", "FormatParams_Url", 'Pn!Pn"4#8n$4%8MKw&y'];
+const __ΩFormatParams_DomainName = [() => __ΩOmit, () => __ΩStringValidators, "length", "allowedChars", "disallowedChars", "FormatParams_DomainName", 'n"P.#.$.%Jo!#w&y'];
+const __ΩFormatParams_Tld = [() => __ΩOmit, () => __ΩStringValidators, "length", "allowedChars", "disallowedChars", "FormatParams_Tld", 'n"P.#.$.%Jo!#w&y'];
+const __ΩFormatParam_Pattern = [() => __ΩStringValidators, "pattern", "FormatParam_Pattern", 'n!."fw#y'];
+const __ΩFormatParams_DomainCore = ["names", "tld", () => __ΩFormatParam_Pattern, "pattern", () => __ΩFormatParams_DomainName, () => __ΩFormatParams_Tld, "FormatParams_DomainCore", `PP!4!8!4"8n#4$MPn%4!n&4"!4$8MJw'y`];
+const __ΩFormatParams_Domain = [() => ___FormatParam, "maxLength", () => ___FormatParam, "minLength", () => ___FormatParam, "maxParts", () => ___FormatParam, "minParts", () => __ΩFormatParams_DomainCore, "FormatParams_Domain", `PP'o!"4"8'o#"4$8'o%"4&8'o'"4(8Mn)Kw*y`];
+const __ΩFormatParams_IP = [() => ___FormatParam, 4, 6, "any", "version", () => ___FormatParam, "allowLocalHost", () => ___FormatParam, "allowPort", "FormatParams_IP", `PP.".#.$Jo!"4%)o&"4'8)o("4)8Mw*y`];
+const __ΩFormatParams_UUID = [() => ___FormatParam, "4", "7", "version", "FormatParams_UUID", 'PP.".#Jo!"4$Mw%y'];
+const __ΩNumberMax = ["val", "errorMessage", "desc", "max", "gt", "NumberMax", `PPP'P'4!&4"&4#8MJ4$8!4%8MP!4$8P'P'4!&4"&4#8MJ4%8MJw&y`];
+const __ΩNumberMin = ["val", "errorMessage", "desc", "min", "lt", "NumberMin", `PPP'P'4!&4"&4#8MJ4$8!4%8MP!4$8P'P'4!&4"&4#8MJ4%8MJw&y`];
+const __ΩNumberType = ["val", "errorMessage", "desc", "integer", "float", "NumberType", 'PPP)P)4!&4"&4#8MJ4$8!4%8MP!4$8P)P)4!&4"&4#8MJ4%8MJw&y'];
+const __ΩFormatParams_Number = [() => __ΩNumberMax, () => __ΩNumberMin, () => __ΩNumberType, "val", "errorMessage", "desc", "multipleOf", "FormatParams_Number", `Pn!n"n#PP'P'4$&4%&4&8MJ4'8MKw(y`];
+const __ΩBigIntMax = ["val", "errorMessage", "desc", "max", "gt", "BigIntMax", 'PPP*P*4!&4"&4#8MJ4$8!4%8MP!4$8P*P*4!&4"&4#8MJ4%8MJw&y'];
+const __ΩBigIntMin = ["val", "errorMessage", "desc", "min", "lt", "BigIntMin", 'PPP*P*4!&4"&4#8MJ4$8!4%8MP!4$8P*P*4!&4"&4#8MJ4%8MJw&y'];
+const __ΩFormatParams_BigInt = [() => __ΩBigIntMax, () => __ΩBigIntMin, "val", "errorMessage", "desc", "multipleOf", "FormatParams_BigInt", `Pn!n"PP*P*4#&4$&4%8MJ4&8MKw'y`];
+const __ΩAnyStringFormatParam = [() => __ΩStringParams, () => __ΩFormatParams_Email, () => __ΩFormatParams_Url, () => __ΩFormatParams_Domain, () => __ΩFormatParams_IP, () => __ΩFormatParams_UUID, () => __ΩFormatParams_DateTime, () => __ΩFormatParams_Date, () => __ΩFormatParams_Time, "AnyStringFormatParam", `Pn!n"n#n$n%n&n'n(n)Jw*y`];
+const __ΩAnyFormatParams = [() => __ΩAnyStringFormatParam, () => __ΩFormatParams_Number, () => __ΩFormatParams_BigInt, "AnyFormatParams", 'Pn!n"n#Jw$y'];
+export {
+  __ΩAnyFormatParams,
+  __ΩAnyStringFormatParam,
+  __ΩDateFmt,
+  __ΩFormatParam_Pattern,
+  __ΩFormatParams_BigInt,
+  __ΩFormatParams_Date,
+  __ΩFormatParams_DateTime,
+  __ΩFormatParams_Domain,
+  __ΩFormatParams_DomainCore,
+  __ΩFormatParams_DomainName,
+  __ΩFormatParams_Email,
+  __ΩFormatParams_EmailPattern,
+  __ΩFormatParams_IP,
+  __ΩFormatParams_Number,
+  __ΩFormatParams_Time,
+  __ΩFormatParams_Tld,
+  __ΩFormatParams_UUID,
+  __ΩFormatParams_Url,
+  __ΩFormatParams_UrlPattern,
+  __ΩSamples,
+  __ΩStringParams,
+  __ΩStringTransformers,
+  __ΩStringValidators,
+  __ΩTimeFmt
+};
+//# sourceMappingURL=formatsParams.types.js.map

package/.dist/esm/src/types/formats/formatsParams.types.js.map

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

package/.dist/esm/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/esm/src/types/formats/friendlyErrors.types.js

@@ -0,0 +1,53 @@
+import { __ΩRunTypeError as ___RunTypeError, __ΩStrNumber as ___StrNumber } from "../general.types.js";
+import { __ΩAnyStringFormatParam as ___AnyStringFormatParam, __ΩFormatParams_Number as ___FormatParams_Number, __ΩFormatParams_BigInt as ___FormatParams_BigInt, __ΩFormatParams_Date as ___FormatParams_Date, __ΩFormatParams_DateTime as ___FormatParams_DateTime, __ΩFormatParams_Domain as ___FormatParams_Domain, __ΩFormatParams_Email as ___FormatParams_Email, __ΩFormatParams_UUID as ___FormatParams_UUID, __ΩFormatParams_Url as ___FormatParams_Url, __ΩFormatParams_IP as ___FormatParams_IP, __ΩFormatParams_Time as ___FormatParams_Time, __ΩStringParams as ___StringParams } from "./formatsParams.types.js";
+import { __ΩTypeFormatError as ___TypeFormatError, __ΩExtractFormatParams as ___ExtractFormatParams } from "./formats.types.js";
+import { __ΩBrandEmail as ___BrandEmail, __ΩBrandUUID as ___BrandUUID, __ΩBrandUrl as ___BrandUrl, __ΩBrandDomain as ___BrandDomain, __ΩBrandIP as ___BrandIP, __ΩBrandDateTime as ___BrandDateTime, __ΩBrandDate as ___BrandDate, __ΩBrandTime as ___BrandTime } from "./formatBrands.types.js";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩTypeErrorParam = [() => ___RunTypeError, "rtError", () => ___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, () => ___TypeFormatError, () => __ΩTypeErrorParam, "FriendlyErrorParams", 'l&n#Rb!PPde#!o""N#"n$Kw%y'];
+const __ΩStringErrorParams = [() => __ΩFriendlyErrorParams, () => ___StringParams, "StringErrorParams", 'n"o!"w#y'];
+const __ΩEmailErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Email, "EmailErrorParams", 'n"o!"w#y'];
+const __ΩUrlErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Url, "UrlErrorParams", 'n"o!"w#y'];
+const __ΩDomainErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Domain, "DomainErrorParams", 'n"o!"w#y'];
+const __ΩIPErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_IP, "IPErrorParams", 'n"o!"w#y'];
+const __ΩUUIDErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_UUID, "UUIDErrorParams", 'n"o!"w#y'];
+const __ΩDateTimeErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_DateTime, "DateTimeErrorParams", 'n"o!"w#y'];
+const __ΩDateErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Date, "DateErrorParams", 'n"o!"w#y'];
+const __ΩTimeErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Time, "TimeErrorParams", 'n"o!"w#y'];
+const __ΩNumberErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_Number, "NumberErrorParams", 'n"o!"w#y'];
+const __ΩBigIntErrorParams = [() => __ΩFriendlyErrorParams, () => ___FormatParams_BigInt, "BigIntErrorParams", 'n"o!"w#y'];
+const __ΩAnyFriendlyErrorParams = [() => __ΩFriendlyErrorParams, () => ___AnyStringFormatParam, () => __ΩFriendlyErrorParams, () => ___FormatParams_Number, () => __ΩFriendlyErrorParams, () => ___FormatParams_BigInt, "AnyFriendlyErrorParams", `Pn"o!"n$o#"n&o%"Jw'y`];
+const __ΩExtractErrorParams = ["T", () => ___ExtractFormatParams, () => __ΩTypeErrorParam, () => ___BrandEmail, () => __ΩEmailErrorParams, () => ___BrandUUID, () => __ΩUUIDErrorParams, () => ___BrandUrl, () => __ΩUrlErrorParams, () => ___BrandDomain, () => __ΩDomainErrorParams, () => ___BrandIP, () => __ΩIPErrorParams, () => ___BrandDateTime, () => __ΩDateTimeErrorParams, () => ___BrandDate, () => __ΩDateErrorParams, () => ___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, () => ___StrNumber, "$keys", () => __ΩRecord, () => ___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, () => ___StrNumber, () => __ΩFriendlyErrorsResult, "SetErrorsResult", 'l7e$!o$"R&RPe#!%qk#*QRb!n#Pde"!p,o"#w%y'];
+const __ΩFriendlyErrorsResult = ["T", () => __ΩRecord, () => ___StrNumber, 0, () => __ΩMapErrorsResult, () => __ΩSetErrorsResult, () => __ΩRecord, () => ___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`];
+export {
+  __ΩAnyFriendlyErrorParams,
+  __ΩBigIntErrorParams,
+  __ΩDateErrorParams,
+  __ΩDateTimeErrorParams,
+  __ΩDomainErrorParams,
+  __ΩEmailErrorParams,
+  __ΩExtractErrorParams,
+  __ΩFriendlyErrorHandler,
+  __ΩFriendlyErrorParams,
+  __ΩFriendlyErrors,
+  __ΩFriendlyErrorsResult,
+  __ΩIPErrorParams,
+  __ΩMapErrorHandlers,
+  __ΩMapErrorsResult,
+  __ΩNumberErrorParams,
+  __ΩSetErrorHandlers,
+  __ΩSetErrorsResult,
+  __ΩStringErrorParams,
+  __ΩTimeErrorParams,
+  __ΩTypeErrorParam,
+  __ΩUUIDErrorParams,
+  __ΩUrlErrorParams
+};
+//# sourceMappingURL=friendlyErrors.types.js.map

package/.dist/esm/src/types/formats/friendlyErrors.types.js.map

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

package/.dist/esm/src/types/general.types.d.ts

@@ -0,0 +1,246 @@
+import { MIME_TYPES } from '../constants.ts';
+import { TypeFormatError } from './formats/formats.types.ts';
+import { JITUtils } from '../jit/jitUtils.ts';
+import { CompiledPureFunction, PersistedPureFunction, PureFunctionData } from './pureFunctions.types.ts';
+export declare const SerializerModes: {
+    readonly json: 1;
+    readonly binary: 2;
+    readonly stringifyJson: 3;
+};
+export type SerializerMode = keyof typeof SerializerModes;
+export type SerializerCode = (typeof SerializerModes)[SerializerMode];
+export type CoreRouterOptions = {
+    autoGenerateErrorId: boolean;
+    basePath: string;
+    suffix: string;
+};
+export interface TypedErrorParams<ErrType extends StrNumber> {
+    type: ErrType;
+    message?: string;
+    originalError?: Error;
+}
+export interface RpcErrorParams<ErrType extends StrNumber, ErrData = any> {
+    type: ErrType;
+    id?: number | string;
+    publicMessage?: string;
+    message?: string;
+    errorData?: ErrData;
+    originalError?: Error;
+    statusCode?: number;
+}
+export interface RpcErrorWithPublic<ErrType extends StrNumber, ErrData = any> extends RpcErrorParams<ErrType, ErrData> {
+    publicMessage: string;
+}
+export interface RpcErrorWithPrivate<ErrType extends StrNumber, ErrData = any> extends RpcErrorParams<ErrType, ErrData> {
+    message: string;
+}
+export interface PublicRpcError<ErrType extends StrNumber, ErrData = any> extends Omit<RpcErrorParams<ErrType, ErrData>, 'message' | 'originalError'> {
+    readonly 'mion@isΣrrθr': true;
+    type: ErrType;
+    errorData?: ErrData;
+    publicMessage: string;
+}
+export type AnyErrorParams<ErrType extends StrNumber, ErrData = any> = RpcErrorWithPublic<ErrType, ErrData> | RpcErrorWithPrivate<ErrType, ErrData>;
+export type MapKeyPathSegment = {
+    key: unknown;
+    index: number;
+    failed: 'mapKey';
+};
+export type MapValuePathSegment = {
+    key: unknown;
+    index: number;
+    failed: 'mapVal';
+};
+export type SetItemPathSegment = {
+    key: unknown;
+    index: number;
+};
+export type PathSegment = StrNumber | MapKeyPathSegment | MapValuePathSegment | SetItemPathSegment;
+export interface RunTypeError {
+    path: PathSegment[];
+    expected: string;
+    format?: TypeFormatError;
+}
+export type JitFnArgs = {
+    vλl: string;
+    [key: string]: string;
+};
+export interface JitCompiledFnData {
+    readonly typeName: string;
+    readonly fnID: string;
+    readonly jitFnHash: string;
+    readonly args: JitFnArgs;
+    readonly defaultParamValues: JitFnArgs;
+    readonly isNoop?: boolean;
+    readonly code: string;
+    readonly jitDependencies: Array<string>;
+    readonly pureFnDependencies: Array<string>;
+    paramNames?: string[];
+}
+export interface JitCompiledFn<Fn extends AnyFn = AnyFn> extends JitCompiledFnData {
+    readonly createJitFn: (utl: JITUtils) => Fn;
+    readonly fn: Fn;
+}
+export interface PersistedJitFn extends Omit<JitCompiledFn, 'fn'> {
+    readonly fn: undefined;
+}
+export interface JitCompiledFunctions {
+    isType: JitCompiledFn<IsTypeFn>;
+    typeErrors: JitCompiledFn<TypeErrorsFn>;
+    prepareForJson: JitCompiledFn<PrepareForJsonFn>;
+    restoreFromJson: JitCompiledFn<RestoreFromJsonFn>;
+    stringifyJson: JitCompiledFn<JsonStringifyFn>;
+    toBinary: JitCompiledFn<ToBinaryFn>;
+    fromBinary: JitCompiledFn<FromBinaryFn>;
+}
+export interface SerializableJITFunctions {
+    isType: JitCompiledFnData;
+    typeErrors: JitCompiledFnData;
+    prepareForJson: JitCompiledFnData;
+    restoreFromJson: JitCompiledFnData;
+    stringifyJson: JitCompiledFnData;
+    toBinary: JitCompiledFnData;
+    fromBinary: JitCompiledFnData;
+}
+export interface JitFunctionsHashes {
+    isType: string;
+    typeErrors: string;
+    prepareForJson: string;
+    restoreFromJson: string;
+    stringifyJson: string;
+    toBinary: string;
+    fromBinary: string;
+}
+export type JsonStringifyFn = (value: any) => JSONString;
+export type RestoreFromJsonFn = (value: JSONValue) => any;
+export type PrepareForJsonFn = (value: any) => JSONValue;
+export type TypeErrorsFn = (value: any) => RunTypeError[];
+export type IsTypeFn = (value: any) => boolean;
+export type ToCodeFn = (value: any) => string;
+export type ToBinaryFn = (value: any, serializer: DataViewSerializer) => void;
+export type FromBinaryFn = (value: undefined, deserializer: DataViewDeserializer) => any;
+export type JitFunctionsCache = Record<string, JitCompiledFn>;
+export type PureFunctionsCache = Record<string, Record<string, CompiledPureFunction>>;
+export type PersistedJitFunctionsCache = Record<string, PersistedJitFn>;
+export type PersistedPureFunctionsCache = Record<string, Record<string, PersistedPureFunction>>;
+export type FnsDataCache = Record<string, JitCompiledFnData>;
+export type PureFnsDataCache = Record<string, Record<string, PureFunctionData>>;
+export interface SrcCodeJitCompiledFn extends JitCompiledFnData {
+    readonly createJitFn: (utl: JITUtils) => AnyFn;
+    readonly fn: undefined;
+}
+export interface SrcCodeCompiledPureFunction extends PureFunctionData {
+    readonly createPureFn: (utl: JITUtils) => AnyFn;
+    readonly fn: undefined;
+}
+export type SrcCodeJITCompiledFnsCache = Record<string, SrcCodeJitCompiledFn>;
+export type SrcCodePureFunctionsCache = Record<string, Record<string, SrcCodeCompiledPureFunction>>;
+export type StrNumber = string | number;
+export type AnyFn = (...args: any[]) => any;
+export type AnyObject = Record<string, unknown>;
+export interface AnyClass<T = any> {
+    new (...args: any[]): T;
+}
+export interface SerializableClass<T = any> {
+    new (): T;
+}
+export type DeserializeClassFn<C extends InstanceType<AnyClass>> = (deserialized: DataOnly<C>) => C;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+export type JSONValue = StrNumber | boolean | null | {
+    [key: string]: JSONValue;
+} | Array<JSONValue>;
+export type JSONString = string;
+type Native = Date | RegExp | URL | URLSearchParams | Blob | File | FileList | FormData | ArrayBuffer | SharedArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type DataOnly<T> = T extends object ? T extends Native ? T : T extends Function ? never : T extends new (...args: any[]) => any ? never : T extends Array<infer U> ? Array<DataOnly<U>> : T extends Map<infer K, infer V> ? Map<DataOnly<K>, DataOnly<V>> : T extends Set<infer U> ? Set<DataOnly<U>> : {
+    [K in keyof T as T[K] extends Function ? never : K]: DataOnly<T[K]>;
+} : T;
+export type StrictArrayBuffer = ArrayBuffer & {
+    buffer?: undefined;
+};
+export type BinaryInput = ArrayBuffer | ArrayBufferView;
+export interface DataViewSerializer {
+    index: number;
+    view: DataView;
+    reset: () => void;
+    getBuffer: () => StrictArrayBuffer;
+    getBufferView: () => Uint8Array;
+    markAsEnded: () => void;
+    getLength(): number;
+    serString(str: string): void;
+    serFloat64(n: number): void;
+    serEnum(n: number | string): void;
+    setBitMask(bitMaskIndex: number, bitIndex: number): void;
+}
+export interface DataViewDeserializer {
+    index: number;
+    view: DataView;
+    reset: () => void;
+    setBuffer: (buffer: StrictArrayBuffer, byteOffset?: number, byteLength?: number) => void;
+    markAsEnded: () => void;
+    getLength(): number;
+    desString(): string;
+    desFloat64(): number;
+    desEnum(): number | string;
+}
+export type MimeTypes = (typeof MIME_TYPES)[keyof typeof MIME_TYPES];
+export {};
+export declare type __ΩSerializerMode = any[];
+export declare type __ΩSerializerCode = any[];
+export declare type __ΩCoreRouterOptions = any[];
+export declare type __ΩTypedErrorParams = any[];
+export declare type __ΩRpcErrorParams = any[];
+export declare type __ΩRpcErrorWithPublic = any[];
+export declare type __ΩRpcErrorWithPrivate = any[];
+export declare type __ΩPublicRpcError = any[];
+export declare type __ΩAnyErrorParams = any[];
+export declare type __ΩMapKeyPathSegment = any[];
+export declare type __ΩMapValuePathSegment = any[];
+export declare type __ΩSetItemPathSegment = any[];
+export declare type __ΩPathSegment = any[];
+export declare type __ΩRunTypeError = any[];
+export declare type __ΩJitFnArgs = any[];
+export declare type __ΩJitCompiledFnData = any[];
+export declare type __ΩJitCompiledFn = any[];
+export declare type __ΩPersistedJitFn = any[];
+export declare type __ΩJitCompiledFunctions = any[];
+export declare type __ΩSerializableJITFunctions = any[];
+export declare type __ΩJitFunctionsHashes = any[];
+export declare type __ΩJsonStringifyFn = any[];
+export declare type __ΩRestoreFromJsonFn = any[];
+export declare type __ΩPrepareForJsonFn = any[];
+export declare type __ΩTypeErrorsFn = any[];
+export declare type __ΩIsTypeFn = any[];
+export declare type __ΩToCodeFn = any[];
+export declare type __ΩToBinaryFn = any[];
+export declare type __ΩFromBinaryFn = any[];
+export declare type __ΩJitFunctionsCache = any[];
+export declare type __ΩPureFunctionsCache = any[];
+export declare type __ΩPersistedJitFunctionsCache = any[];
+export declare type __ΩPersistedPureFunctionsCache = any[];
+export declare type __ΩFnsDataCache = any[];
+export declare type __ΩPureFnsDataCache = any[];
+export declare type __ΩSrcCodeJitCompiledFn = any[];
+export declare type __ΩSrcCodeCompiledPureFunction = any[];
+export declare type __ΩSrcCodeJITCompiledFnsCache = any[];
+export declare type __ΩSrcCodePureFunctionsCache = any[];
+export declare type __ΩStrNumber = any[];
+export declare type __ΩAnyFn = any[];
+export declare type __ΩAnyObject = any[];
+export declare type __ΩAnyClass = any[];
+export declare type __ΩSerializableClass = any[];
+export declare type __ΩDeserializeClassFn = any[];
+export declare type __ΩMutable = any[];
+export declare type __ΩPrettify = any[];
+export declare type __ΩJSONValue = any[];
+export declare type __ΩJSONString = any[];
+export declare type __ΩDataOnly = any[];
+export declare type __ΩStrictArrayBuffer = any[];
+export declare type __ΩBinaryInput = any[];
+export declare type __ΩDataViewSerializer = any[];
+export declare type __ΩDataViewDeserializer = any[];
+export declare type __ΩMimeTypes = any[];

package/.dist/esm/src/types/general.types.js

@@ -0,0 +1,145 @@
+import { MIME_TYPES } from "../constants.js";
+import { __ΩTypeFormatError as ___TypeFormatError } from "./formats/formats.types.js";
+import { __ΩPersistedPureFunction as ___PersistedPureFunction, __ΩPureFunctionData as ___PureFunctionData, __ΩCompiledPureFunction as ___CompiledPureFunction } from "./pureFunctions.types.js";
+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", () => ___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, () => ___CompiledPureFunction, "PureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩPersistedJitFunctionsCache = [() => __ΩRecord, () => __ΩPersistedJitFn, "PersistedJitFunctionsCache", '&n"o!#w#y'];
+const __ΩPersistedPureFunctionsCache = [() => __ΩRecord, () => __ΩRecord, () => ___PersistedPureFunction, "PersistedPureFunctionsCache", '&&n#o"#o!#w$y'];
+const __ΩFnsDataCache = [() => __ΩRecord, () => __ΩJitCompiledFnData, "FnsDataCache", '&n"o!#w#y'];
+const __ΩPureFnsDataCache = [() => __ΩRecord, () => __ΩRecord, () => ___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 = [() => ___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 = [() => MIME_TYPES, () => MIME_TYPES, "MimeTypes", 'i!i"gfw#y'];
+export {
+  SerializerModes,
+  __ΩAnyClass,
+  __ΩAnyErrorParams,
+  __ΩAnyFn,
+  __ΩAnyObject,
+  __ΩBinaryInput,
+  __ΩCoreRouterOptions,
+  __ΩDataOnly,
+  __ΩDataViewDeserializer,
+  __ΩDataViewSerializer,
+  __ΩDeserializeClassFn,
+  __ΩFnsDataCache,
+  __ΩFromBinaryFn,
+  __ΩIsTypeFn,
+  __ΩJSONString,
+  __ΩJSONValue,
+  __ΩJitCompiledFn,
+  __ΩJitCompiledFnData,
+  __ΩJitCompiledFunctions,
+  __ΩJitFnArgs,
+  __ΩJitFunctionsCache,
+  __ΩJitFunctionsHashes,
+  __ΩJsonStringifyFn,
+  __ΩMapKeyPathSegment,
+  __ΩMapValuePathSegment,
+  __ΩMimeTypes,
+  __ΩMutable,
+  __ΩPathSegment,
+  __ΩPersistedJitFn,
+  __ΩPersistedJitFunctionsCache,
+  __ΩPersistedPureFunctionsCache,
+  __ΩPrepareForJsonFn,
+  __ΩPrettify,
+  __ΩPublicRpcError,
+  __ΩPureFnsDataCache,
+  __ΩPureFunctionsCache,
+  __ΩRestoreFromJsonFn,
+  __ΩRpcErrorParams,
+  __ΩRpcErrorWithPrivate,
+  __ΩRpcErrorWithPublic,
+  __ΩRunTypeError,
+  __ΩSerializableClass,
+  __ΩSerializableJITFunctions,
+  __ΩSerializerCode,
+  __ΩSerializerMode,
+  __ΩSetItemPathSegment,
+  __ΩSrcCodeCompiledPureFunction,
+  __ΩSrcCodeJITCompiledFnsCache,
+  __ΩSrcCodeJitCompiledFn,
+  __ΩSrcCodePureFunctionsCache,
+  __ΩStrNumber,
+  __ΩStrictArrayBuffer,
+  __ΩToBinaryFn,
+  __ΩToCodeFn,
+  __ΩTypeErrorsFn,
+  __ΩTypedErrorParams
+};
+//# sourceMappingURL=general.types.js.map

package/.dist/esm/src/types/general.types.js.map

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