@mionjs/run-types 0.8.10 → 0.13.2

package/src/nodes/member/tupleMember.ts

@@ -1,93 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind, TypeTupleMember, type TypeParameter} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {MemberRunType} from '../../lib/baseRunTypes.ts';
-import {JitCode} from '../../types.ts';
-import {childIsExpression, getParamIndex} from '../../lib/utils.ts';
-
-type TupleMemberT = TypeParameter | TypeTupleMember;
-export class TupleMemberRunType<T extends TupleMemberT = TypeTupleMember> extends MemberRunType<T> {
-    isOptional(): boolean {
-        return !!this.src.optional || this.isRest() || this.hasDefaultValue();
-    }
-    getChildIndex(comp: JitFnCompiler): number {
-        const start = comp?.opts?.paramsSlice?.start;
-        if (start) return getParamIndex(this.src as TypeParameter) - start;
-        return getParamIndex(this.src as TypeParameter);
-    }
-    getChildVarName(comp: JitFnCompiler): number {
-        // For tuple members, use the index in the parent tuple
-        const src = this.src as any;
-        if (src.parent?.types) {
-            return src.parent.types.indexOf(this.src);
-        }
-        // Fallback to parameter index for non-tuple members
-        return this.getChildIndex(comp);
-    }
-    getChildLiteral(comp: JitFnCompiler): number {
-        return this.getChildVarName(comp);
-    }
-    useArrayAccessor(): true {
-        return true;
-    }
-    isRest(): boolean {
-        return this.getMemberType().src.kind === ReflectionKind.rest;
-    }
-    skipSettingAccessor() {
-        return this.isRest();
-    }
-    hasDefaultValue(): boolean {
-        return !!(this.src as TypeParameter).default;
-    }
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const child = this.getJitChild(comp);
-        const skipChild = child?.skipJit(comp);
-        const childJit = comp.compileIsType(child, 'E');
-        const isNonSerializable = skipChild || (!childJit?.code && !child);
-        if (isNonSerializable) return {code: `${comp.getChildVλl()} === undefined`, type: 'E'}; // non serializable types must be undefined
-        if (!childJit?.code) return {code: undefined, type: 'E'};
-        if (this.isRest()) return childJit;
-        return this.isOptional() ? {code: `(${comp.getChildVλl()} === undefined || (${childJit.code}))`, type: 'E'} : childJit;
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const child = this.getJitChild(comp);
-        const skipChild = child?.skipJit(comp);
-        const childJit = comp.compileTypeErrors(child, 'S');
-        const isNonSerializable = skipChild || (!childJit?.code && !child);
-        if (isNonSerializable)
-            return {
-                code: `if (${comp.getChildVλl()} !== undefined) ${comp.callJitErrWithPath('undefined', this.getChildIndex(comp))}`,
-                type: 'S',
-            }; // non serializable types must be undefined
-        if (!childJit?.code) return {code: undefined, type: 'S'};
-        if (this.isRest()) return childJit;
-        return this.isOptional() ? {code: `if (${comp.getChildVλl()} !== undefined) {${childJit.code}}`, type: 'S'} : childJit;
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        const child = this.getJitChild(comp);
-        const childJit = comp.compilePrepareForJson(child, 'S');
-        const optionalCode = `if (${comp.getChildVλl()} === undefined ) {if (${comp.vλl}.length > ${this.getChildIndex(comp)}) ${comp.getChildVλl()} = null}`;
-        if (!child || !childJit?.code) return this.isOptional() ? {code: optionalCode, type: 'S'} : {code: undefined, type: 'S'};
-        const isExpression = childIsExpression(childJit, child);
-        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
-        return this.isOptional() ? {code: `${optionalCode} else {${code}}`, type: 'S'} : {code, type: 'S'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        if (!this.getJitChild(comp)) return {code: `${comp.getChildVλl()} = undefined;`, type: 'S'}; // non serializable are restored to undefined
-        const child = this.getJitChild(comp);
-        const childJit = comp.compileRestoreFromJson(child, 'S');
-        const optionalCOde = `if (${comp.getChildVλl()} === null ) {${comp.getChildVλl()} = undefined}`;
-        if (!child || !childJit?.code) return this.isOptional() ? {code: optionalCOde, type: 'S'} : {code: undefined, type: 'S'};
-        const isExpression = childIsExpression(childJit, child);
-        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';
-        return this.isOptional()
-            ? {code: `${optionalCOde} else if (${comp.getChildVλl()} !== undefined) {${code}}`, type: 'S'}
-            : {code, type: 'S'};
-    }
-}

package/src/nodes/native/Iterable.ts

@@ -1,153 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {JitCode} from '../../types.ts';
-import {ClassRunType} from '../collection/class.ts';
-import {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {BaseRunType} from '../../lib/baseRunTypes.ts';
-
-// This is the base class for all iterable run types, like SetRunType and MapRunType
-export abstract class IterableRunType extends ClassRunType {
-    abstract children: BaseRunType[];
-    abstract constructorName: string;
-    getIndexVarName(comp: JitFnCompiler): string {
-        return comp.getLocalVarName('e', this);
-    }
-    getChildRunTypes = (): BaseRunType[] => {
-        return this.children;
-    };
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        const childrenCode = this.getJitChildren(comp)
-            .map((c) => `if (!(${comp.compileIsType(c, 'E').code})) return false`)
-            .join(';');
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
-            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return true;
-        `,
-            type: 'RB',
-        };
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        const childrenCode = this.getJitChildren(comp)
-            .map((c) => comp.compileTypeErrors(c, 'S').code)
-            .join(';');
-        const index = this.getIndexVarName(comp);
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})){${comp.callJitErr(this)}}
-            else {let ${index} = 0;for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}}
-        `,
-            type: 'S',
-        };
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        const resName = comp.getLocalVarName('ml', this);
-        const childrenCode = this.getJitChildren(comp)
-            .map((c) => comp.compilePrepareForJson(c, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (!childrenCode) return {code: `${comp.vλl} = Array.from(${comp.vλl})`, type: 'S'};
-        return {
-            code: `
-            const ${resName} = [];
-            for (let ${entry} of ${comp.vλl}) {${childrenCode} ${resName}.push(${entry})}
-            ${comp.vλl} = ${resName};
-        `,
-            type: 'S',
-        };
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        const children = this.getJitChildren(comp);
-        if (!children.length) return {code: `${comp.vλl} = new Map(${comp.vλl})`, type: 'S'};
-        const index = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        const childrenCode = children
-            .map((c) => comp.compileRestoreFromJson(c, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (!childrenCode) return {code: `${comp.vλl} = new ${this.constructorName}(${comp.vλl})`, type: 'S'};
-        return {
-            code: `
-            for (let ${index} = 0; ${index} < ${comp.vλl}.length; ${index}++) {${childrenCode}}
-            ${comp.vλl} = new ${this.constructorName}(${comp.vλl})
-        `,
-            type: 'S',
-        };
-    }
-
-    // TODO: Implement the following methods, should just call same compile method for children, look into to array run type
-
-    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
-        const childrenCode = this.getJitChildren(comp)
-            .map((child) => {
-                const itemJit = comp.compileHasUnknownKeys(child, 'E');
-                return itemJit?.code ? `if (${itemJit.code}) return true;` : '';
-            })
-            .filter(Boolean)
-            .join('');
-        if (!childrenCode) return {code: 'return false', type: 'RB'};
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})) return false;
-            for (const ${entry} of ${comp.vλl}) {${childrenCode}} return false;
-        `,
-            type: 'RB',
-        };
-    }
-
-    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
-        const childrenCode = this.getJitChildren(comp)
-            .map((child) => comp.compileUnknownKeyErrors(child, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (!childrenCode) return {code: undefined, type: 'S'};
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        const index = this.getIndexVarName(comp);
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
-            let ${index} = 0; for (const ${entry} of ${comp.vλl}) {${childrenCode}; ${index}++}
-        `,
-            type: 'S',
-        };
-    }
-
-    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
-        const childrenCode = this.getJitChildren(comp)
-            .map((child) => comp.compileStripUnknownKeys(child, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (!childrenCode) return {code: undefined, type: 'S'};
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
-            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
-        `,
-            type: 'S',
-        };
-    }
-
-    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
-        const childrenCode = this.getJitChildren(comp)
-            .map((child) => comp.compileUnknownKeysToUndefined(child, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (!childrenCode) return {code: undefined, type: 'S'};
-        const entry = this.getCustomVλl(comp)?.vλl || comp.vλl;
-        return {
-            code: `
-            if (!(${comp.vλl} instanceof ${this.constructorName})) return;
-            for (const ${entry} of ${comp.vλl}) {${childrenCode}}
-        `,
-            type: 'S',
-        };
-    }
-}

package/src/nodes/native/map.ts

@@ -1,91 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {SrcType} from '../../types.ts';
-import {GenericMemberRunType} from '../member/genericMember.ts';
-import {ReflectionSubKind} from '../../constants.kind.ts';
-import {ReflectionKind, TypeClass} from '@deepkit/type';
-import {IterableRunType} from './Iterable.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {cpf_safeIterableKey} from '../../run-types-pure-fns.ts';
-
-export class MapRunType extends IterableRunType {
-    keyRT = new MapKeyRunType();
-    valueRT = new MapValueRunType();
-    children = [this.keyRT, this.valueRT];
-    constructorName = 'Map';
-    onCreated(src: SrcType<TypeClass>): void {
-        const types = src.arguments;
-        if (!types || types.length !== 2) throw new Error(`Map expects 2 type arguments: ie: Map<string, number>`);
-        super.onCreated(src);
-        this.keyRT.onCreated({
-            kind: ReflectionKind.parameter,
-            parent: src,
-            type: types[0],
-            subKind: ReflectionSubKind.mapKey,
-        });
-        this.valueRT.onCreated({
-            kind: ReflectionKind.parameter,
-            parent: src,
-            type: types[1],
-            subKind: ReflectionSubKind.mapValue,
-        });
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        // restoreFromJson is decoding a regular array so no need to use an special case for vλl as other operations
-        if (comp.fnID === JitFunctions.restoreFromJson.id)
-            return {vλl: comp.getLocalVarName('it', this), isStandalone: false, useArrayAccessor: true};
-        // other operations use an special case for vλl where all parents are skipped
-        return {vλl: comp.getLocalVarName('it', this), isStandalone: true};
-    }
-    getMapKeyVλl(comp: JitFnCompiler) {
-        return comp.getLocalVarName('mpk', this);
-    }
-    getMapValueVλl(comp: JitFnCompiler) {
-        return comp.getLocalVarName('mpV', this);
-    }
-}
-
-class MapKeyRunType extends GenericMemberRunType<any> {
-    index = 0;
-    getStaticPathLiteral(comp: JitFnCompiler): string | number {
-        const parent = this.getParent()! as MapRunType;
-        const custom = parent.getCustomVλl(comp)!;
-        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
-        return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapKey'}`;
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        // temp variable to assign mapKey
-        if (comp.fnID === JitFunctions.fromBinary.id)
-            return {
-                vλl: (this.getParent()! as MapRunType).getMapKeyVλl(comp),
-                isStandalone: true,
-                useArrayAccessor: false,
-            };
-        return undefined;
-    }
-}
-
-class MapValueRunType extends GenericMemberRunType<any> {
-    index = 1;
-    getStaticPathLiteral(comp: JitFnCompiler): string | number {
-        const parent = this.getParent()! as MapRunType;
-        const custom = parent.getCustomVλl(comp)!;
-        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
-        return `{key:${safeKeyFn}(${custom.vλl}[0]),index:${parent.getIndexVarName(comp)},failed:'mapVal'}`;
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        // temp variable to assign mapKey
-        if (comp.fnID === JitFunctions.fromBinary.id)
-            return {
-                vλl: (this.getParent()! as MapRunType).getMapValueVλl(comp),
-                isStandalone: true,
-                useArrayAccessor: false,
-            };
-        return undefined;
-    }
-}

package/src/nodes/native/nonSerializable.ts

@@ -1,42 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeClass, TypeObjectLiteral} from '@deepkit/type';
-import {JitCode} from '../../types.ts';
-import {InterfaceRunType} from '../collection/interface.ts';
-
-// Non serializable types might not be Atomic but will be skipped so it doesn't matter
-export class NonSerializableRunType extends InterfaceRunType<TypeObjectLiteral | TypeClass> {
-    skipJit() {
-        // skip return false so we ensure the compile functions will throw when a NonSerializable type is used
-        return false;
-    }
-    emitIsType(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitTypeErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitHasUnknownKeys(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitUnknownKeyErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitStripUnknownKeys(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitUnknownKeysToUndefined(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-}

package/src/nodes/native/promise.ts

@@ -1,43 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import {type TypePromise} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {MemberRunType} from '../../lib/baseRunTypes.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class PromiseRunType extends MemberRunType<TypePromise> {
-    skipJit(comp: JitFnCompiler): boolean {
-        return comp?.fnID !== JitFunctions.toJSCode.id;
-    }
-    emitIsType(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitTypeErrors(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error(`Jit compilation disabled for Non Serializable types.`);
-    }
-    isOptional(): boolean {
-        return false;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getChildVarName(comp: JitFnCompiler): string | number {
-        return comp.getLocalVarName('p', this);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getChildLiteral(comp: JitFnCompiler): string | number {
-        return this.getChildVarName(comp);
-    }
-    useArrayAccessor(): boolean {
-        return false;
-    }
-}

package/src/nodes/native/set.ts

@@ -1,56 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {SrcType} from '../../types.ts';
-import {ReflectionSubKind} from '../../constants.kind.ts';
-import {ReflectionKind, type TypeClass} from '@deepkit/type';
-import {GenericMemberRunType} from '../member/genericMember.ts';
-import {IterableRunType} from './Iterable.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import type {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {cpf_safeIterableKey} from '../../run-types-pure-fns.ts';
-export class SetRunType extends IterableRunType {
-    keyRT = new SetKeyRunType();
-    children = [this.keyRT];
-    constructorName = 'Set';
-    onCreated(src: SrcType<TypeClass>): void {
-        const types = src.arguments;
-        if (!types || types.length !== 1) throw new Error(`Set expects 1 type argument: ie: Set<number>`);
-        super.onCreated(src);
-        this.keyRT.onCreated({
-            kind: ReflectionKind.parameter,
-            parent: src,
-            type: types[0],
-            subKind: ReflectionSubKind.setItem,
-        });
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        // restoreFromJson is decoding a regular array so no need to use an special case for vλl as other operations
-        if (comp.fnID === JitFunctions.restoreFromJson.id)
-            return {vλl: comp.getLocalVarName('it', this), isStandalone: false, useArrayAccessor: true};
-        // other operations use an special case for vλl where all parents are skipped
-        return {vλl: comp.getLocalVarName('it', this), isStandalone: true};
-    }
-}
-
-export class SetKeyRunType extends GenericMemberRunType<any> {
-    index = 0;
-    skipSettingAccessor() {
-        return true;
-    }
-    getStaticPathLiteral(comp: JitFnCompiler): string {
-        const parent = this.getParent()! as SetRunType;
-        const custom = parent.getCustomVλl(comp)!;
-        const safeKeyFn = comp.addPureFunction(cpf_safeIterableKey);
-        return `{key:${safeKeyFn}(${custom.vλl}),index:${parent.getIndexVarName(comp)}}`;
-    }
-    getCustomVλl(comp: JitFnCompiler) {
-        if (comp.fnID === JitFunctions.fromBinary.id)
-            return {vλl: comp.getLocalVarName('sK', this), isStandalone: true, useArrayAccessor: false};
-        // other operations use an special case for vλl where all parents are skipped
-        return undefined;
-    }
-}

package/src/run-types-pure-fns.ts

@@ -1,116 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import type {TypeFormatError, StrNumber, RunTypeError} from '@mionjs/core';
-import {registerPureFnFactory} from '@mionjs/core';
-
-export const cpf_asJSONString = registerPureFnFactory('mion', 'asJSONString', function () {
-    // @ts-expect-error 2867
-    if (typeof Bun !== 'undefined') return JSON.stringify; // bun has a faster JSON.stringify
-    // eslint-disable-next-line no-control-regex
-    const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
-    const MAX_SCAPE_TEST_LENGTH = 1000;
-    return function _asJSONStringRegexOnly(str) {
-        // Always use regex test for strings >= 42 chars (n o for loop)
-        if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
-            return '"' + str + '"';
-        } else {
-            return JSON.stringify(str);
-        }
-    };
-});
-
-export const cpf_getUnknownKeysFromArray = registerPureFnFactory('mion', 'getUnknownKeysFromArray', function () {
-    const MAX_UNKNOWN_KEYS = 10;
-    return function _getUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): StrNumber[] {
-        const unknownKeys: StrNumber[] = [];
-        for (const prop in obj) {
-            let found = false;
-            for (let j = 0; j < keys.length; j++) {
-                if (keys[j] === prop) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                unknownKeys.push(prop as string);
-                if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error('Too many unknown keys');
-            }
-        }
-        return unknownKeys;
-    };
-});
-
-export const cpf_hasUnknownKeysFromArray = registerPureFnFactory('mion', 'hasUnknownKeysFromArray', function () {
-    return function _hasUnknownKeysFromArray(obj: Record<StrNumber, any>, keys: StrNumber[]): boolean {
-        for (const prop in obj) {
-            // iterates over the object keys and if not found prop adds to unknownKeys
-            let found = false;
-            for (let j = 0; j < keys.length; j++) {
-                if (keys[j] === prop) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) return true;
-        }
-        return false;
-    };
-});
-
-export const cpf_newRunTypeErr = registerPureFnFactory('mion', 'newRunTypeErr', function () {
-    return function _err(
-        pλth: readonly StrNumber[],
-        εrr: RunTypeError[],
-        expected: string,
-        accessPath?: readonly StrNumber[]
-    ): void {
-        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-        const runTypeErr: RunTypeError = {expected, path};
-        εrr.push(runTypeErr);
-    };
-});
-
-export const cpf_formatErr = registerPureFnFactory('mion', 'formatErr', function () {
-    return function _formatErr(
-        pλth: StrNumber[],
-        εrr: RunTypeError[],
-        expected: string,
-        fmtName: string,
-        paramName: string,
-        paramVal: string | number | boolean | bigint,
-        fmtPath: StrNumber[],
-        accessPath?: StrNumber[],
-        fmtAccessPath?: StrNumber[]
-    ): void {
-        const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];
-        const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
-        const format: TypeFormatError = {name: fmtName, formatPath: formatPath, val: paramVal};
-        const runTypeErr: Required<RunTypeError> = {expected, path, format};
-        εrr.push(runTypeErr);
-    };
-});
-
-export const cpf_safeIterableKey = registerPureFnFactory('mion', 'safeIterableKey', function () {
-    return function _safeKey(value: any): any {
-        if (value === undefined) return null;
-        if (value === null) return null;
-        const type = typeof value;
-        if (type === 'number' || type === 'string' || type === 'boolean') return value;
-        return null;
-    };
-});
-
-/** @reflection never */
-export const cpf_sanitizeCompiledFn = registerPureFnFactory('mion', 'sanitizeCompiledFn', function () {
-    const anonymousRegex = /^\s*function\s+anonymous\s*\(/;
-    return function sanitizeCompiled(fnCode: string): string {
-        if (anonymousRegex.test(fnCode)) {
-            return fnCode.replace(anonymousRegex, 'function (');
-        }
-        return fnCode;
-    };
-});