@mionjs/core 0.8.0-alpha.0

package/.dist/cjs/src/pureFns/restoreJitFns.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreJitFns.cjs","sources":["../../../../src/pureFns/restoreJitFns.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {\n    Mutable,\n    JitCompiledFn,\n    PersistedJitFunctionsCache,\n    PersistedPureFunctionsCache,\n    FnsDataCache,\n    PureFnsDataCache,\n    PureFunctionsCache,\n    JitCompiledFnData,\n    PersistedJitFn,\n} from '../types/general.types.ts';\nimport {JITUtils} from '../jit/jitUtils.ts';\nimport type {PersistedPureFunction} from '../types/pureFunctions.types.ts';\nimport type {CompiledPureFunction} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionData} from '../types/pureFunctions.types.ts';\nimport type {PureFunctionFactory} from '../types/pureFunctions.types.ts';\nimport {TypedError} from '../errors.ts';\n\n/**\n * Restores the full state of a persisted/serialized jit functions.\n * This functions mutates the input caches!!!\n * Persisted functions are jit functions written to code that contains the createJitFn closure but not the fn.\n * Serialized functions are jit functions sent over the network that contains the code to recreate the createJitFn closure and fn.\n * The JIT fn itself can't be compiled to code as it contains references to context code and jitUtils.\n * So we need to restore it manually by invoking the closure function.\n * */\nexport function restoreCompiledJitFns(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    jUtil: JITUtils\n): void {\n    // Use visited sets to prevent infinite recursion on circular dependencies\n    // This is needed because during restoration, the `fn` property is not set until after\n    // all dependencies are restored, so checking `fn` alone can't prevent circular calls\n    const visitedPure = new Set<string>();\n    const visitedJit = new Set<string>();\n\n    // Iterate over all namespaces and restore pure functions\n    for (const namespace in pureCache) {\n        const nsCache = pureCache[namespace];\n        const keysPureFns = Object.keys(nsCache);\n        keysPureFns.forEach((key) => restoreCompiledPureFn(pureCache, namespace, key, jUtil, visitedPure));\n    }\n    const keysJitFns = Object.keys(jitCache);\n    keysJitFns.forEach((key) => restoreCompiledJitFn(jitCache, pureCache, key, jUtil, visitedPure, visitedJit));\n}\n\nfunction restoreCompiledPureFn(\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    namespace: string,\n    fnName: string,\n    jUtil: JITUtils,\n    visited: Set<string>\n) {\n    // Use namespace:fnName as the visited key to handle same function names in different namespaces\n    const visitedKey = `${namespace}:${fnName}`;\n    // Skip if already visited (handles circular dependencies)\n    if (visited.has(visitedKey)) return;\n    visited.add(visitedKey);\n\n    const nsCache = pureCache[namespace];\n    if (!nsCache) throw new Error(`Pure function namespace ${namespace} not found`);\n    const pureCompiled = nsCache[fnName];\n    if (!pureCompiled) throw new Error(`Pure function ${fnName} not found in namespace ${namespace}`);\n    if ((pureCompiled as CompiledPureFunction).fn) return;\n    const dependencies = pureCompiled.pureFnDependencies;\n    // Dependencies are in the same namespace\n    dependencies.forEach((depName) => restoreCompiledPureFn(pureCache, namespace, depName, jUtil, visited));\n    // persisted pure functions (AOT code caches) have the createJitFn but not the fn\n    if ((pureCompiled as PersistedPureFunction).createPureFn) {\n        (pureCompiled as any as Mutable<CompiledPureFunction>).fn = (pureCompiled as PersistedPureFunction).createPureFn(jUtil);\n        return;\n    }\n    // serialized pure functions (network sent) do not contains neither createJitFn nor fn\n    restorePureFunction(pureCompiled, jUtil);\n}\n\nfunction restoreCompiledJitFn(\n    jitCache: PersistedJitFunctionsCache | FnsDataCache,\n    pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache,\n    fnHash: string,\n    jUtil: JITUtils,\n    visitedPure: Set<string>,\n    visitedJit: Set<string>\n) {\n    // Skip if already visited (handles circular dependencies)\n    if (visitedJit.has(fnHash)) return;\n    visitedJit.add(fnHash);\n\n    const jitCompiled = jitCache[fnHash];\n    if (!jitCompiled) throw new Error(`Jit function ${fnHash} not found`);\n    if ((jitCompiled as JitCompiledFn).fn) return;\n    const pureDependencies = jitCompiled.pureFnDependencies;\n    // Pure function dependencies are stored as \"namespace::fnHash\"\n    pureDependencies.forEach((dep) => {\n        const parts = dep.split('::');\n        if (parts.length !== 2) throw new Error(`Invalid pure function dependency format: ${dep}, expected \"namespace::fnHash\"`);\n        const [namespace, fnHash] = parts;\n        restoreCompiledPureFn(pureCache, namespace, fnHash, jUtil, visitedPure);\n    });\n    const dependencies = jitCompiled.jitDependencies;\n    dependencies.forEach((dep) => restoreCompiledJitFn(jitCache, pureCache, dep, jUtil, visitedPure, visitedJit));\n    if ((jitCompiled as PersistedJitFn).createJitFn) {\n        (jitCompiled as any as Mutable<JitCompiledFn>).fn = (jitCompiled as PersistedJitFn).createJitFn(jUtil);\n        return;\n    }\n    restoreCreateJitFn(jitCompiled, jUtil);\n}\n\n/**\n * Restores a JIT function from serialized function data.\n * This functionsMutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final JIT function.\n * @param fnData - The serialized function data containing code, args, and metadata\n * @returns A JitCompiledFn with both the createJitFn closure and the executed fn\n */\nfunction restoreCreateJitFn(fnData: JitCompiledFnData, jUtil: JITUtils): JitCompiledFn {\n    const fnName = fnData.jitFnHash;\n    // fnData.code already contains the complete function with context (e.g., \"const x = ...; return function fnName(args){...}\")\n    const fnWithContext = `'use strict'; ${fnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual jit function\n        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const jitFn = fnData as Mutable<JitCompiledFn>;\n        jitFn.createJitFn = wrapperWithContext;\n        jitFn.fn = fn;\n        return jitFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'jit-fn-restore-error',\n            message: `Failed to restore JIT function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n\n/**\n * Restores a pure function from serialized function data.\n * This function mutates the input data!!!\n * Creates a dynamic function using the serialized code (which already contains the complete function with context),\n * then executes it with jitUtils to produce the final pure function.\n * @param pureFnData - The serialized pure function data containing code and metadata\n * @returns A CompiledPureFunction with both the createJitFn closure and the executed fn\n */\nfunction restorePureFunction(pureFnData: PureFunctionData, jUtil: JITUtils): CompiledPureFunction {\n    const fnName = pureFnData.fnName;\n    // pureFnData.code already contains the complete function with context\n    const fnWithContext = `'use strict'; ${pureFnData.code}`;\n    try {\n        // Create wrapper function that works as a factory and returns the actual pure function\n        const wrapperWithContext = new Function('utl', fnWithContext) as PureFunctionFactory;\n        // Execute the wrapper with jitUtils to get the final function\n        const fn = wrapperWithContext(jUtil);\n        const pureFn = pureFnData as Mutable<CompiledPureFunction>;\n        pureFn.createPureFn = wrapperWithContext;\n        pureFn.fn = fn;\n        return pureFn;\n    } catch (e: any) {\n        throw new TypedError({\n            type: 'pure-fn-restore-error',\n            message: `Failed to restore pure function ${fnName}: ${e?.message}`,\n        });\n    }\n}\n"],"names":["fnHash","TypedError"],"mappings":"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"}

package/.dist/cjs/src/pureFns/restoreJitFns.d.ts

@@ -0,0 +1,3 @@
+import { PersistedJitFunctionsCache, PersistedPureFunctionsCache, FnsDataCache, PureFnsDataCache, PureFunctionsCache } from '../types/general.types.ts';
+import { JITUtils } from '../jit/jitUtils.ts';
+export declare function restoreCompiledJitFns(jitCache: PersistedJitFunctionsCache | FnsDataCache, pureCache: PureFunctionsCache | PersistedPureFunctionsCache | PureFnsDataCache, jUtil: JITUtils): void;

package/.dist/cjs/src/routerUtils.cjs

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_constants = require("./constants.cjs");
+const src_jit_jitUtils = require("./jit/jitUtils.cjs");
+const methodsCache = {};
+const methodsOptionsCache = {};
+const jitFunctionsCache = /* @__PURE__ */ new Map();
+const headerJitFunctionsCache = /* @__PURE__ */ new Map();
+const routesCache = {
+  /**
+   * Get method metadata from the router cache by id.
+   * @param id - The method id
+   * @returns The method metadata or undefined if not found
+   */
+  getMetadata(id) {
+    return methodsCache[id];
+  },
+  /**
+   * Set method metadata in the router cache
+   * @param id - The method id
+   * @param methodData - The method metadata
+   */
+  setMetadata(id, methodData) {
+    methodsCache[id] = methodData;
+  },
+  /**
+   * Check if the router cache contains a method by id.
+   * @param id - The method id
+   * @returns True if the method exists in the cache
+   */
+  hasMetadata(id) {
+    return id in methodsCache;
+  },
+  /**
+   * Get the raw router cache object.
+   * Use with caution - prefer using get/set/has methods.
+   * @returns The router cache object
+   */
+  getCache() {
+    return methodsCache;
+  },
+  /**
+   * Get method metadata with JIT functions restored from the router cache by id.
+   * This augments the MethodWithOptions with paramsJitFns and returnJitFns.
+   * JIT functions are cached in the entry after first access for performance.
+   * @param id - The method id
+   * @returns The method metadata with JIT functions or undefined if not found
+   */
+  getMethodJitFns(id) {
+    if (id in methodsCache) {
+      const cached = methodsCache[id];
+      if (cached.paramsJitFns && cached.returnJitFns) {
+        return cached;
+      }
+    }
+    const metadata = this.getMetadata(id);
+    if (!metadata) return void 0;
+    const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);
+    const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);
+    const headersParam = metadata.headersParam ? { ...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash) } : void 0;
+    const headersReturn = metadata.headersReturn ? { ...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash) } : void 0;
+    const result = {
+      ...metadata,
+      paramsJitFns,
+      returnJitFns,
+      headersParam,
+      headersReturn
+    };
+    methodsCache[id] = result;
+    return result;
+  },
+  /**
+   * Get method metadata with JIT functions restored from the router cache by id.
+   * @param id
+   * @returns
+   */
+  useMethodJitFns(id) {
+    const MethodWithOptsAndJitFns = this.getMethodJitFns(id);
+    if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);
+    return MethodWithOptsAndJitFns;
+  },
+  /**
+   * Set method metadata with JIT functions in the router cache.
+   * This stores the complete MethodWithOptsAndJitFns object directly.
+   * @param id - The method id
+   * @param MethodWithOptsAndJitFns - The method metadata with JIT functions
+   */
+  setMethodJitFns(id, MethodWithOptsAndJitFns) {
+    methodsCache[id] = MethodWithOptsAndJitFns;
+  }
+};
+const methodOptsCache = {
+  getMethodOptions(id) {
+    return methodsOptionsCache[id];
+  },
+  setMethodOptions(id, options) {
+    methodsOptionsCache[id] = options;
+  }
+};
+function addRoutesToCache(newCache) {
+  for (const key in newCache) {
+    if (!(key in methodsCache)) {
+      methodsCache[key] = { ...newCache[key] };
+    }
+  }
+}
+function getJitFnHashes(jitHash) {
+  return {
+    isType: `${src_constants.JIT_FUNCTION_IDS.isType}_${jitHash}`,
+    typeErrors: `${src_constants.JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,
+    prepareForJson: `${src_constants.JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,
+    restoreFromJson: `${src_constants.JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,
+    stringifyJson: `${src_constants.JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,
+    toBinary: `${src_constants.JIT_FUNCTION_IDS.toBinary}_${jitHash}`,
+    fromBinary: `${src_constants.JIT_FUNCTION_IDS.fromBinary}_${jitHash}`
+  };
+}
+function getJitFunctionsFromHash(jitHash) {
+  if (jitHash === src_constants.EMPTY_HASH) return noopJitFns;
+  const cached = jitFunctionsCache.get(jitHash);
+  if (cached) return cached;
+  const hashes = getJitFnHashes(jitHash);
+  const jUtils = src_jit_jitUtils.getJitUtils();
+  const jitFns = {
+    isType: jUtils.getJIT(hashes.isType),
+    typeErrors: jUtils.getJIT(hashes.typeErrors),
+    prepareForJson: jUtils.getJIT(hashes.prepareForJson),
+    restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),
+    stringifyJson: jUtils.getJIT(hashes.stringifyJson),
+    toBinary: jUtils.getJIT(hashes.toBinary),
+    fromBinary: jUtils.getJIT(hashes.fromBinary)
+  };
+  for (const key in jitFns) {
+    if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);
+  }
+  jitFunctionsCache.set(jitHash, jitFns);
+  return jitFns;
+}
+function getHeaderJitFunctionsFromHash(jitHash) {
+  const cached = headerJitFunctionsCache.get(jitHash);
+  if (cached) return cached;
+  const hashes = getJitFnHashes(jitHash);
+  const jUtils = src_jit_jitUtils.getJitUtils();
+  const jitFns = {
+    isType: jUtils.getJIT(hashes.isType),
+    typeErrors: jUtils.getJIT(hashes.typeErrors)
+  };
+  headerJitFunctionsCache.set(jitHash, jitFns);
+  return jitFns;
+}
+function getRouterItemId(itemPointer) {
+  return itemPointer.join(src_constants.ROUTER_ITEM_SEPARATOR_CHAR);
+}
+function getRoutePath(pathPointer, routerOptions) {
+  const pathId = getRouterItemId(pathPointer);
+  const basePath = routerOptions.basePath.startsWith(src_constants.ROUTE_PATH_ROOT) ? routerOptions.basePath : `${src_constants.ROUTE_PATH_ROOT}${routerOptions.basePath}`;
+  const routePath = basePath.endsWith(src_constants.PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${src_constants.PATH_SEPARATOR}${pathId}`;
+  return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;
+}
+function resetRoutesCache() {
+  for (const k in methodsCache) delete methodsCache[k];
+}
+function resetJitFunctionsCache() {
+  jitFunctionsCache.clear();
+  headerJitFunctionsCache.clear();
+}
+const noopJitFns = {
+  isType: fakeJitFn(src_constants.JIT_FUNCTION_IDS.isType),
+  typeErrors: fakeJitFn(src_constants.JIT_FUNCTION_IDS.typeErrors),
+  prepareForJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.prepareForJson),
+  restoreFromJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.restoreFromJson),
+  stringifyJson: fakeJitFn(src_constants.JIT_FUNCTION_IDS.stringifyJson),
+  toBinary: fakeJitFn(src_constants.JIT_FUNCTION_IDS.toBinary),
+  fromBinary: fakeJitFn(src_constants.JIT_FUNCTION_IDS.fromBinary)
+};
+function fakeJitFn(fnID) {
+  return {
+    typeName: "mionNoopJit",
+    fnID,
+    jitFnHash: src_constants.EMPTY_HASH,
+    args: { vλl: "v" },
+    defaultParamValues: { vλl: "v" },
+    isNoop: true,
+    code: "",
+    jitDependencies: [],
+    pureFnDependencies: [],
+    createJitFn: () => {
+      throw new Error("isNoop JIT functions should not be called, this is a function when jit is never used");
+    },
+    fn: () => {
+      throw new Error("isNoop JIT functions should not be called, this is a function when jit is never used");
+    }
+  };
+}
+function getNoopJitFns() {
+  return noopJitFns;
+}
+exports.addRoutesToCache = addRoutesToCache;
+exports.getHeaderJitFunctionsFromHash = getHeaderJitFunctionsFromHash;
+exports.getJitFnHashes = getJitFnHashes;
+exports.getJitFunctionsFromHash = getJitFunctionsFromHash;
+exports.getNoopJitFns = getNoopJitFns;
+exports.getRoutePath = getRoutePath;
+exports.getRouterItemId = getRouterItemId;
+exports.methodOptsCache = methodOptsCache;
+exports.resetJitFunctionsCache = resetJitFunctionsCache;
+exports.resetRoutesCache = resetRoutesCache;
+exports.routesCache = routesCache;
+//# sourceMappingURL=routerUtils.cjs.map

package/.dist/cjs/src/routerUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routerUtils.cjs","sources":["../../../src/routerUtils.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JIT_FUNCTION_IDS, PATH_SEPARATOR, ROUTER_ITEM_SEPARATOR_CHAR, ROUTE_PATH_ROOT, EMPTY_HASH} from './constants.ts';\nimport type {RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns} from './types/method.types.ts';\nimport type {CoreRouterOptions, JitCompiledFn, JitCompiledFunctions, JitFunctionsHashes} from './types/general.types.ts';\nimport {getJitUtils} from './jit/jitUtils.ts';\n\nconst methodsCache: MethodsCache = {};\nconst methodsOptionsCache: Record<string, RemoteMethodOpts> = {};\n\n// Cache for JitCompiledFunctions objects keyed by jitHash\nconst jitFunctionsCache = new Map<string, JitCompiledFunctions>();\nconst headerJitFunctionsCache = new Map<string, Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>>();\n\n/**\n * Utilities for accessing and modifying the router cache.\n * The router cache stores method metadata for routes registered via addRoutesToCache() or virtual modules.\n */\nexport const routesCache = {\n    /**\n     * Get method metadata from the router cache by id.\n     * @param id - The method id\n     * @returns The method metadata or undefined if not found\n     */\n    getMetadata(id: string): MethodWithOptions | undefined {\n        return methodsCache[id] as MethodWithOptions | undefined;\n    },\n\n    /**\n     * Set method metadata in the router cache\n     * @param id - The method id\n     * @param methodData - The method metadata\n     */\n    setMetadata(id: string, methodData: MethodWithOptions): void {\n        methodsCache[id] = methodData as any;\n    },\n\n    /**\n     * Check if the router cache contains a method by id.\n     * @param id - The method id\n     * @returns True if the method exists in the cache\n     */\n    hasMetadata(id: string): boolean {\n        return id in methodsCache;\n    },\n\n    /**\n     * Get the raw router cache object.\n     * Use with caution - prefer using get/set/has methods.\n     * @returns The router cache object\n     */\n    getCache(): MethodsCache {\n        return methodsCache;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * This augments the MethodWithOptions with paramsJitFns and returnJitFns.\n     * JIT functions are cached in the entry after first access for performance.\n     * @param id - The method id\n     * @returns The method metadata with JIT functions or undefined if not found\n     */\n    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined {\n        if (id in methodsCache) {\n            const cached = methodsCache[id] as any;\n            if (cached.paramsJitFns && cached.returnJitFns) {\n                return cached as MethodWithOptsAndJitFns;\n            }\n        }\n\n        const metadata = this.getMetadata(id);\n        if (!metadata) return undefined;\n\n        const paramsJitFns = getJitFunctionsFromHash(metadata.paramsJitHash);\n        const returnJitFns = getJitFunctionsFromHash(metadata.returnJitHash);\n        const headersParam = metadata.headersParam\n            ? {...metadata.headersParam, jitFns: getHeaderJitFunctionsFromHash(metadata.headersParam.jitHash)}\n            : undefined;\n        const headersReturn = metadata.headersReturn\n            ? {...metadata.headersReturn, jitFns: getHeaderJitFunctionsFromHash(metadata.headersReturn.jitHash)}\n            : undefined;\n\n        const result: MethodWithOptsAndJitFns = {\n            ...metadata,\n            paramsJitFns,\n            returnJitFns,\n            headersParam,\n            headersReturn,\n        };\n\n        methodsCache[id] = result;\n        return result as MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Get method metadata with JIT functions restored from the router cache by id.\n     * @param id\n     * @returns\n     */\n    useMethodJitFns(id: string): MethodWithOptsAndJitFns {\n        const MethodWithOptsAndJitFns = this.getMethodJitFns(id);\n        if (!MethodWithOptsAndJitFns) throw new Error(`Metadata for remote method ${id} not found`);\n        return MethodWithOptsAndJitFns;\n    },\n\n    /**\n     * Set method metadata with JIT functions in the router cache.\n     * This stores the complete MethodWithOptsAndJitFns object directly.\n     * @param id - The method id\n     * @param MethodWithOptsAndJitFns - The method metadata with JIT functions\n     */\n    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void {\n        methodsCache[id] = MethodWithOptsAndJitFns as any;\n    },\n};\n\nexport const methodOptsCache = {\n    getMethodOptions(id: string): RemoteMethodOpts | undefined {\n        return methodsOptionsCache[id];\n    },\n    setMethodOptions(id: string, options: RemoteMethodOpts): void {\n        methodsOptionsCache[id] = options;\n    },\n};\n\n/**\n * Adds new routes to the router cache.\n * This is the public API for registering routes - called by virtual modules or directly.\n * @param newCache\n */\nexport function addRoutesToCache(newCache: MethodsCache) {\n    for (const key in newCache) {\n        if (!(key in methodsCache)) {\n            // Clone the cache entry to avoid mutating the original\n            methodsCache[key] = {...newCache[key]} as MethodWithOptions;\n        }\n    }\n}\n\nexport function getJitFnHashes(jitHash: string): JitFunctionsHashes {\n    return {\n        isType: `${JIT_FUNCTION_IDS.isType}_${jitHash}`,\n        typeErrors: `${JIT_FUNCTION_IDS.typeErrors}_${jitHash}`,\n        prepareForJson: `${JIT_FUNCTION_IDS.prepareForJson}_${jitHash}`,\n        restoreFromJson: `${JIT_FUNCTION_IDS.restoreFromJson}_${jitHash}`,\n        stringifyJson: `${JIT_FUNCTION_IDS.stringifyJson}_${jitHash}`,\n        toBinary: `${JIT_FUNCTION_IDS.toBinary}_${jitHash}`,\n        fromBinary: `${JIT_FUNCTION_IDS.fromBinary}_${jitHash}`,\n    };\n}\n\n/**\n * Helper function to get JIT functions from a JIT hash\n * Returns nullJitFns for empty hash (handlers with no params or void return)\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions {\n    // Empty hash means no JIT functions were generated (optimization for no params or void return)\n    if (jitHash === EMPTY_HASH) return noopJitFns;\n\n    // Check cache first\n    const cached = jitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n        prepareForJson: jUtils.getJIT(hashes.prepareForJson),\n        restoreFromJson: jUtils.getJIT(hashes.restoreFromJson),\n        stringifyJson: jUtils.getJIT(hashes.stringifyJson),\n        toBinary: jUtils.getJIT(hashes.toBinary),\n        fromBinary: jUtils.getJIT(hashes.fromBinary),\n    } as JitCompiledFunctions;\n    for (const key in jitFns) {\n        if (!jitFns[key]) throw new Error(`Jit function ${key} not found for jitHash ${jitHash}`);\n    }\n\n    // Cache for future calls\n    jitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Helper function to get header JIT functions from a JIT hash\n * Results are cached to avoid creating duplicate objects.\n */\nexport function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'> {\n    // Check cache first\n    const cached = headerJitFunctionsCache.get(jitHash);\n    if (cached) return cached;\n\n    const hashes = getJitFnHashes(jitHash);\n    const jUtils = getJitUtils();\n    const jitFns = {\n        isType: jUtils.getJIT(hashes.isType),\n        typeErrors: jUtils.getJIT(hashes.typeErrors),\n    } as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;\n\n    // Cache for future calls\n    headerJitFunctionsCache.set(jitHash, jitFns);\n    return jitFns;\n}\n\n/**\n * Get the router id for Routes or MiddleFns\n * @param itemPointer - The pointer to the item within the Routes object\n * i.e:\n * const routes = {\n *   auth: () => {},\n *   users: {\n *    getUser: () => {}\n *   }\n *   login: () => {}\n * }\n *\n * then the pointer for getUser is => ['users', 'getUser']\n */\nexport function getRouterItemId(itemPointer: string[]) {\n    return itemPointer.join(ROUTER_ITEM_SEPARATOR_CHAR);\n}\n\n/** Gets a route path from a route pointer */\nexport function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions) {\n    const pathId = getRouterItemId(pathPointer);\n    const basePath = routerOptions.basePath.startsWith(ROUTE_PATH_ROOT)\n        ? routerOptions.basePath\n        : `${ROUTE_PATH_ROOT}${routerOptions.basePath}`;\n    const routePath = basePath.endsWith(PATH_SEPARATOR) ? `${basePath}${pathId}` : `${basePath}${PATH_SEPARATOR}${pathId}`;\n    return routerOptions.suffix ? routePath + routerOptions.suffix : routePath;\n}\n\nexport function resetRoutesCache() {\n    for (const k in methodsCache) delete methodsCache[k];\n}\n\n/** Resets the JIT functions cache. Useful for testing purposes only. */\nexport function resetJitFunctionsCache(): void {\n    jitFunctionsCache.clear();\n    headerJitFunctionsCache.clear();\n}\n\n// Noop JIT functions used for handlers with no params or void return\n// prettier-ignore\nconst noopJitFns: JitCompiledFunctions = {\n    isType: fakeJitFn(JIT_FUNCTION_IDS.isType),\n    typeErrors: fakeJitFn(JIT_FUNCTION_IDS.typeErrors),\n    prepareForJson: fakeJitFn(JIT_FUNCTION_IDS.prepareForJson),\n    restoreFromJson: fakeJitFn(JIT_FUNCTION_IDS.restoreFromJson),\n    stringifyJson: fakeJitFn(JIT_FUNCTION_IDS.stringifyJson),\n    toBinary: fakeJitFn(JIT_FUNCTION_IDS.toBinary),\n    fromBinary: fakeJitFn(JIT_FUNCTION_IDS.fromBinary),\n} as any;\n\n/** Creates a fake JIT function with isNoop=true for handlers with no params or void return */\nfunction fakeJitFn(fnID: string): JitCompiledFn<any> {\n    return {\n        typeName: 'mionNoopJit',\n        fnID,\n        jitFnHash: EMPTY_HASH,\n        args: {vλl: 'v'},\n        defaultParamValues: {vλl: 'v'},\n        isNoop: true,\n        code: '',\n        jitDependencies: [],\n        pureFnDependencies: [],\n        createJitFn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n        fn: () => {\n            throw new Error('isNoop JIT functions should not be called, this is a function when jit is never used');\n        },\n    };\n}\n\nexport function getNoopJitFns(): JitCompiledFunctions {\n    return noopJitFns;\n}\n"],"names":["JIT_FUNCTION_IDS","EMPTY_HASH","getJitUtils","ROUTER_ITEM_SEPARATOR_CHAR","ROUTE_PATH_ROOT","PATH_SEPARATOR"],"mappings":"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"}

package/.dist/cjs/src/routerUtils.d.ts

@@ -0,0 +1,24 @@
+import { RemoteMethodOpts, MethodWithOptions, MethodsCache, MethodWithOptsAndJitFns } from './types/method.types.ts';
+import { CoreRouterOptions, JitCompiledFunctions, JitFunctionsHashes } from './types/general.types.ts';
+export declare const routesCache: {
+    getMetadata(id: string): MethodWithOptions | undefined;
+    setMetadata(id: string, methodData: MethodWithOptions): void;
+    hasMetadata(id: string): boolean;
+    getCache(): MethodsCache;
+    getMethodJitFns(id: string): MethodWithOptsAndJitFns | undefined;
+    useMethodJitFns(id: string): MethodWithOptsAndJitFns;
+    setMethodJitFns(id: string, MethodWithOptsAndJitFns: MethodWithOptsAndJitFns): void;
+};
+export declare const methodOptsCache: {
+    getMethodOptions(id: string): RemoteMethodOpts | undefined;
+    setMethodOptions(id: string, options: RemoteMethodOpts): void;
+};
+export declare function addRoutesToCache(newCache: MethodsCache): void;
+export declare function getJitFnHashes(jitHash: string): JitFunctionsHashes;
+export declare function getJitFunctionsFromHash(jitHash: string): JitCompiledFunctions;
+export declare function getHeaderJitFunctionsFromHash(jitHash: string): Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>;
+export declare function getRouterItemId(itemPointer: string[]): string;
+export declare function getRoutePath(pathPointer: string[], routerOptions: CoreRouterOptions): string;
+export declare function resetRoutesCache(): void;
+export declare function resetJitFunctionsCache(): void;
+export declare function getNoopJitFns(): JitCompiledFunctions;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩBrand = ["BaseType", "Name", "brand", "Brand", 'b!b"Pe"!Pe#"4#MKw$y'];
+const __ΩBrandEmail = [() => __ΩBrand, "email", "BrandEmail", '&."o!#w#y'];
+const __ΩBrandUUID = [() => __ΩBrand, "uuid", "BrandUUID", '&."o!#w#y'];
+const __ΩBrandUrl = [() => __ΩBrand, "url", "BrandUrl", '&."o!#w#y'];
+const __ΩBrandDomain = [() => __ΩBrand, "domain", "BrandDomain", '&."o!#w#y'];
+const __ΩBrandIP = [() => __ΩBrand, "ip", "BrandIP", '&."o!#w#y'];
+const __ΩBrandDate = [() => __ΩBrand, "date", "BrandDate", '&."o!#w#y'];
+const __ΩBrandTime = [() => __ΩBrand, "time", "BrandTime", '&."o!#w#y'];
+const __ΩBrandDateTime = [() => __ΩBrand, "dateTime", "BrandDateTime", '&."o!#w#y'];
+const __ΩBrandInteger = [() => __ΩBrand, "integer", "BrandInteger", `'."o!#w#y`];
+const __ΩBrandFloat = [() => __ΩBrand, "float", "BrandFloat", `'."o!#w#y`];
+const __ΩBrandPositive = [() => __ΩBrand, "positive", "BrandPositive", `'."o!#w#y`];
+const __ΩBrandNegative = [() => __ΩBrand, "negative", "BrandNegative", `'."o!#w#y`];
+const __ΩBrandPositiveInt = [() => __ΩBrand, "positiveInt", "BrandPositiveInt", `'."o!#w#y`];
+const __ΩBrandNegativeInt = [() => __ΩBrand, "negativeInt", "BrandNegativeInt", `'."o!#w#y`];
+const __ΩBrandInt8 = [() => __ΩBrand, "int8", "BrandInt8", `'."o!#w#y`];
+const __ΩBrandInt16 = [() => __ΩBrand, "int16", "BrandInt16", `'."o!#w#y`];
+const __ΩBrandInt32 = [() => __ΩBrand, "int32", "BrandInt32", `'."o!#w#y`];
+const __ΩBrandUInt8 = [() => __ΩBrand, "uint8", "BrandUInt8", `'."o!#w#y`];
+const __ΩBrandUInt16 = [() => __ΩBrand, "uint16", "BrandUInt16", `'."o!#w#y`];
+const __ΩBrandUInt32 = [() => __ΩBrand, "uint32", "BrandUInt32", `'."o!#w#y`];
+exports.__ΩBrand = __ΩBrand;
+exports.__ΩBrandDate = __ΩBrandDate;
+exports.__ΩBrandDateTime = __ΩBrandDateTime;
+exports.__ΩBrandDomain = __ΩBrandDomain;
+exports.__ΩBrandEmail = __ΩBrandEmail;
+exports.__ΩBrandFloat = __ΩBrandFloat;
+exports.__ΩBrandIP = __ΩBrandIP;
+exports.__ΩBrandInt16 = __ΩBrandInt16;
+exports.__ΩBrandInt32 = __ΩBrandInt32;
+exports.__ΩBrandInt8 = __ΩBrandInt8;
+exports.__ΩBrandInteger = __ΩBrandInteger;
+exports.__ΩBrandNegative = __ΩBrandNegative;
+exports.__ΩBrandNegativeInt = __ΩBrandNegativeInt;
+exports.__ΩBrandPositive = __ΩBrandPositive;
+exports.__ΩBrandPositiveInt = __ΩBrandPositiveInt;
+exports.__ΩBrandTime = __ΩBrandTime;
+exports.__ΩBrandUInt16 = __ΩBrandUInt16;
+exports.__ΩBrandUInt32 = __ΩBrandUInt32;
+exports.__ΩBrandUInt8 = __ΩBrandUInt8;
+exports.__ΩBrandUUID = __ΩBrandUUID;
+exports.__ΩBrandUrl = __ΩBrandUrl;
+//# sourceMappingURL=formatBrands.types.cjs.map

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

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

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

@@ -0,0 +1,45 @@
+import { TypeFormatPrimitives } from './formats.types.ts';
+export type Brand<BaseType extends TypeFormatPrimitives, Name extends string> = BaseType & {
+    brand: Name;
+};
+export type BrandEmail = Brand<string, 'email'>;
+export type BrandUUID = Brand<string, 'uuid'>;
+export type BrandUrl = Brand<string, 'url'>;
+export type BrandDomain = Brand<string, 'domain'>;
+export type BrandIP = Brand<string, 'ip'>;
+export type BrandDate = Brand<string, 'date'>;
+export type BrandTime = Brand<string, 'time'>;
+export type BrandDateTime = Brand<string, 'dateTime'>;
+export type BrandInteger = Brand<number, 'integer'>;
+export type BrandFloat = Brand<number, 'float'>;
+export type BrandPositive = Brand<number, 'positive'>;
+export type BrandNegative = Brand<number, 'negative'>;
+export type BrandPositiveInt = Brand<number, 'positiveInt'>;
+export type BrandNegativeInt = Brand<number, 'negativeInt'>;
+export type BrandInt8 = Brand<number, 'int8'>;
+export type BrandInt16 = Brand<number, 'int16'>;
+export type BrandInt32 = Brand<number, 'int32'>;
+export type BrandUInt8 = Brand<number, 'uint8'>;
+export type BrandUInt16 = Brand<number, 'uint16'>;
+export type BrandUInt32 = Brand<number, 'uint32'>;
+export declare type __ΩBrand = any[];
+export declare type __ΩBrandEmail = any[];
+export declare type __ΩBrandUUID = any[];
+export declare type __ΩBrandUrl = any[];
+export declare type __ΩBrandDomain = any[];
+export declare type __ΩBrandIP = any[];
+export declare type __ΩBrandDate = any[];
+export declare type __ΩBrandTime = any[];
+export declare type __ΩBrandDateTime = any[];
+export declare type __ΩBrandInteger = any[];
+export declare type __ΩBrandFloat = any[];
+export declare type __ΩBrandPositive = any[];
+export declare type __ΩBrandNegative = any[];
+export declare type __ΩBrandPositiveInt = any[];
+export declare type __ΩBrandNegativeInt = any[];
+export declare type __ΩBrandInt8 = any[];
+export declare type __ΩBrandInt16 = any[];
+export declare type __ΩBrandInt32 = any[];
+export declare type __ΩBrandUInt8 = any[];
+export declare type __ΩBrandUInt16 = any[];
+export declare type __ΩBrandUInt32 = any[];

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+const __ΩStrNumber = ["StrNumber", "P&'Jw!y"];
+const __ΩTypeFormatPrimitives = ["TypeFormatPrimitives", "P&'*TJw!y"];
+const __ΩFormatParamLiteral = ["FormatParamLiteral", "P&')A*Jw!y"];
+const __ΩTypeFormatValue = [() => __ΩFormatParamLiteral, 0, 0, "TypeFormatValue", 'Pn!n"F9P&Pn#-!JLMJw$y'];
+const __ΩFormatParamMeta = [() => __ΩTypeFormatValue, "L", "val", "errorMessage", "desc", "FormatParamMeta", 'n!c"Pe"!4#&4$&4%8Mw&y'];
+const __ΩFormatParam = ["L", () => __ΩFormatParamMeta, "FormatParam", 'b!Pe"!e"!o""Jw#y'];
+const __ΩTypeFormatParams = [() => __ΩRecord, () => __ΩTypeFormatValue, "TypeFormatParams", '&Pn"-!Jo!#w#y'];
+const __ΩTypeFormatParsedParams = ["__jitId", () => __ΩTypeFormatValue, "TypeFormatParsedParams", 'P&4!&n"LMw#y'];
+const __ΩAliasTypeAnnotation = ["Name", "Options", "AliasTypeAnnotation", 'b!!c"#w#y'];
+const __ΩAliasTypeFormat = ["BaseType", "Name", "P", () => __ΩAliasTypeAnnotation, "AliasTypeFormat", 'b!b"b#Pe"!e""e"#o$#Kw%y'];
+const __ΩExtractFormatParams = ["T", () => __ΩAliasTypeFormat, "ExtractFormatParams", `lBe"#R-RPddde#!h!!h!"h!#o"$qk#'QRb!Pde"!p)w#y`];
+const __ΩTypeFormatError = ["name", () => __ΩStrNumber, () => __ΩStrNumber, "val", () => __ΩStrNumber, "formatPath", "TypeFormatError", `P&4!Pn")*Pn#)*JFJ4$n%F4&Mw'y`];
+exports.__ΩAliasTypeAnnotation = __ΩAliasTypeAnnotation;
+exports.__ΩAliasTypeFormat = __ΩAliasTypeFormat;
+exports.__ΩExtractFormatParams = __ΩExtractFormatParams;
+exports.__ΩFormatParam = __ΩFormatParam;
+exports.__ΩFormatParamLiteral = __ΩFormatParamLiteral;
+exports.__ΩFormatParamMeta = __ΩFormatParamMeta;
+exports.__ΩTypeFormatError = __ΩTypeFormatError;
+exports.__ΩTypeFormatParams = __ΩTypeFormatParams;
+exports.__ΩTypeFormatParsedParams = __ΩTypeFormatParsedParams;
+exports.__ΩTypeFormatPrimitives = __ΩTypeFormatPrimitives;
+exports.__ΩTypeFormatValue = __ΩTypeFormatValue;
+//# sourceMappingURL=formats.types.cjs.map

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

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

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

@@ -0,0 +1,37 @@
+type StrNumber = string | number;
+export type TypeFormatPrimitives = string | number | bigint | Date;
+export type FormatParamLiteral = string | number | boolean | RegExp | bigint;
+export type TypeFormatValue = FormatParamLiteral | readonly TypeFormatValue[] | {
+    [key: string]: TypeFormatValue | undefined | never;
+};
+export type FormatParamMeta<L extends TypeFormatValue = TypeFormatValue> = {
+    val: L;
+    errorMessage: string;
+    desc?: string;
+};
+export type FormatParam<L extends TypeFormatValue> = L | FormatParamMeta<L>;
+export type TypeFormatParams = Record<string, TypeFormatValue | undefined | never>;
+export type TypeFormatParsedParams = {
+    __jitId: string;
+    [key: string]: TypeFormatValue;
+};
+export type AliasTypeAnnotation<Name extends string, Options = never> = unknown;
+export type AliasTypeFormat<BaseType extends string | number | bigint, Name extends string, P extends TypeFormatParams> = BaseType & AliasTypeAnnotation<Name, P>;
+export type ExtractFormatParams<T> = T extends AliasTypeFormat<infer Base, infer Name, infer P> ? P : undefined;
+export type TypeFormatError = {
+    name: string;
+    val: StrNumber | boolean | bigint | (StrNumber | boolean | bigint)[];
+    formatPath: StrNumber[];
+};
+export {};
+export declare type __ΩTypeFormatPrimitives = any[];
+export declare type __ΩFormatParamLiteral = any[];
+export declare type __ΩTypeFormatValue = any[];
+export declare type __ΩFormatParamMeta = any[];
+export declare type __ΩFormatParam = any[];
+export declare type __ΩTypeFormatParams = any[];
+export declare type __ΩTypeFormatParsedParams = any[];
+export declare type __ΩAliasTypeAnnotation = any[];
+export declare type __ΩAliasTypeFormat = any[];
+export declare type __ΩExtractFormatParams = any[];
+export declare type __ΩTypeFormatError = any[];

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_formats_formats_types = require("./formats.types.cjs");
+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 = [() => src_types_formats_formats_types.__Ω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 = [() => src_types_formats_formats_types.__ΩFormatParam, () => __ΩTimeFmt, "format", "FormatParams_Time", 'Pn"o!"4#Mw$y'];
+const __ΩFormatParams_DateTime = [() => __ΩFormatParams_Date, "date", () => __ΩFormatParams_Time, "time", () => src_types_formats_formats_types.__Ω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 = [() => src_types_formats_formats_types.__ΩFormatParam, "maxLength", () => src_types_formats_formats_types.__ΩFormatParam, "minLength", () => src_types_formats_formats_types.__ΩFormatParam, "maxParts", () => src_types_formats_formats_types.__ΩFormatParam, "minParts", () => __ΩFormatParams_DomainCore, "FormatParams_Domain", `PP'o!"4"8'o#"4$8'o%"4&8'o'"4(8Mn)Kw*y`];
+const __ΩFormatParams_IP = [() => src_types_formats_formats_types.__ΩFormatParam, 4, 6, "any", "version", () => src_types_formats_formats_types.__ΩFormatParam, "allowLocalHost", () => src_types_formats_formats_types.__ΩFormatParam, "allowPort", "FormatParams_IP", `PP.".#.$Jo!"4%)o&"4'8)o("4)8Mw*y`];
+const __ΩFormatParams_UUID = [() => src_types_formats_formats_types.__Ω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'];
+exports.__ΩAnyFormatParams = __ΩAnyFormatParams;
+exports.__ΩAnyStringFormatParam = __ΩAnyStringFormatParam;
+exports.__ΩDateFmt = __ΩDateFmt;
+exports.__ΩFormatParam_Pattern = __ΩFormatParam_Pattern;
+exports.__ΩFormatParams_BigInt = __ΩFormatParams_BigInt;
+exports.__ΩFormatParams_Date = __ΩFormatParams_Date;
+exports.__ΩFormatParams_DateTime = __ΩFormatParams_DateTime;
+exports.__ΩFormatParams_Domain = __ΩFormatParams_Domain;
+exports.__ΩFormatParams_DomainCore = __ΩFormatParams_DomainCore;
+exports.__ΩFormatParams_DomainName = __ΩFormatParams_DomainName;
+exports.__ΩFormatParams_Email = __ΩFormatParams_Email;
+exports.__ΩFormatParams_EmailPattern = __ΩFormatParams_EmailPattern;
+exports.__ΩFormatParams_IP = __ΩFormatParams_IP;
+exports.__ΩFormatParams_Number = __ΩFormatParams_Number;
+exports.__ΩFormatParams_Time = __ΩFormatParams_Time;
+exports.__ΩFormatParams_Tld = __ΩFormatParams_Tld;
+exports.__ΩFormatParams_UUID = __ΩFormatParams_UUID;
+exports.__ΩFormatParams_Url = __ΩFormatParams_Url;
+exports.__ΩFormatParams_UrlPattern = __ΩFormatParams_UrlPattern;
+exports.__ΩSamples = __ΩSamples;
+exports.__ΩStringParams = __ΩStringParams;
+exports.__ΩStringTransformers = __ΩStringTransformers;
+exports.__ΩStringValidators = __ΩStringValidators;
+exports.__ΩTimeFmt = __ΩTimeFmt;
+//# sourceMappingURL=formatsParams.types.cjs.map

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

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