@mionjs/run-types 0.8.10 → 0.13.2

package/src/nodes/collection/interface.ts

@@ -1,300 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import {TypeObjectLiteral, TypeClass, TypeIntersection, ReflectionKind} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {arrayToLiteral, getJitFnArgCallVarName, memorize, sortDiscriminatorsFirst} from '../../lib/utils.ts';
-import {PropertyRunType} from '../member/property.ts';
-import {BaseRunType, CollectionRunType, MemberRunType} from '../../lib/baseRunTypes.ts';
-import {MethodSignatureRunType} from '../member/methodSignature.ts';
-import {IndexSignatureRunType} from '../member/indexProperty.ts';
-import {MethodRunType} from '../member/method.ts';
-import {CallSignatureRunType} from '../member/callSignature.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-import {isIndexSignatureRunType} from '../../lib/guards.ts';
-import {cpf_getUnknownKeysFromArray, cpf_hasUnknownKeysFromArray} from '../../run-types-pure-fns.ts';
-
-export type InterfaceMember =
-    | PropertyRunType
-    | MethodSignatureRunType
-    | IndexSignatureRunType
-    | MethodRunType
-    | CallSignatureRunType;
-
-export class InterfaceRunType<
-    T extends TypeObjectLiteral | TypeClass | TypeIntersection = TypeObjectLiteral,
-> extends CollectionRunType<T> {
-    getNamedChildren(comp: JitFnCompiler): InterfaceMember[] {
-        return this.getJitChildren(comp).filter((prop) => !!(prop.src as any).name) as InterfaceMember[];
-    }
-
-    isCallable(): boolean {
-        return this.getCallSignature() !== undefined;
-    }
-
-    getCallSignature = memorize((): CallSignatureRunType | undefined => {
-        return this.getChildRunTypes().find((prop) => prop.src.kind === ReflectionKind.callSignature) as CallSignatureRunType;
-    });
-
-    getJitChildren(comp: JitFnCompiler): InterfaceMember[] {
-        const children = super.getJitChildren(comp) as InterfaceMember[];
-        return children.toSorted((a, b) => sortDiscriminatorsFirst(a, b)) as InterfaceMember[];
-    }
-    /** Split children in two groups: required and optional */
-    splitJitSplitChildren(comp: JitFnCompiler): {
-        /** all required properties */
-        required: PropertyRunType[];
-        /** all optional properties */
-        optional: PropertyRunType[];
-        /** all index signatures */
-        indexSignatures: IndexSignatureRunType[];
-    } {
-        const children = super.getJitChildren(comp) as InterfaceMember[];
-        const required = children.filter((prop) => !prop.isOptional()) as PropertyRunType[];
-        const optional = children.filter((prop) => prop.isOptional() && !isIndexSignatureRunType(prop)) as PropertyRunType[];
-        const indexSignatures = children.filter((prop) => isIndexSignatureRunType(prop)) as IndexSignatureRunType[];
-        return {required, optional, indexSignatures};
-    }
-    isPartOfUnion(): boolean {
-        return this.getParent()?.src.kind === ReflectionKind.union;
-    }
-    hasIndexSignature(comp: JitFnCompiler): boolean {
-        return this.getJitChildren(comp).some((prop) => isIndexSignatureRunType(prop));
-    }
-
-    // #### collection's jit code ####
-
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const varName = comp.vλl;
-        const children = this.getJitChildren(comp);
-        const childrenCode = children
-            .map((prop) => comp.compileIsType(prop, 'E').code)
-            .filter(Boolean)
-            .join(' && ');
-        if (this.isCallable())
-            return {
-                code: [this.getCallSignature()!.emitIsType(comp).code, childrenCode].filter(Boolean).join(' && '),
-                type: 'E',
-            };
-        let propsCode = '';
-        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
-            const unknownCheck = callCheckUnknownProperties(this, comp, children, false, false);
-            if (unknownCheck) propsCode = `!${unknownCheck}`;
-        }
-        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
-        const itemsCode = [objectCheck, this.allOptionalCode(comp), childrenCode, propsCode].filter(Boolean).join(' && ');
-        return {code: `(${itemsCode})`, type: 'E'};
-    }
-
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const varName = comp.vλl;
-        const children = this.getJitChildren(comp);
-        const childrenCode = children
-            .map((prop) => comp.compileTypeErrors(prop, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        if (this.isCallable()) {
-            return {code: `${this.getCallSignature()!.emitTypeErrors(comp).code} else {${childrenCode}}`, type: 'S'};
-        }
-        let propsCode = '';
-        if (comp.opts.strictTypes && !this.hasIndexSignature(comp)) {
-            const unknownVar = comp.getLocalVarName('unk', this);
-            const keyVar = comp.getLocalVarName('ky', this);
-            const unknownValue = callCheckUnknownProperties(this, comp, children, true, false);
-            if (unknownValue) {
-                propsCode = `
-                    const ${unknownVar} = ${unknownValue};
-                    if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
-                `;
-            }
-        }
-        const objectCheck = this.isPartOfUnion() ? '' : `typeof ${varName} === 'object' && ${varName} !== null`;
-        const isObjectCode = [objectCheck, this.allOptionalCode(comp)].filter(Boolean).join(' && ');
-        return {
-            code: `
-            if (!(${isObjectCode})) {
-                ${comp.callJitErr(this)};
-            } else {
-                ${childrenCode}
-                ${propsCode}
-            }
-        `,
-            type: 'S',
-        };
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        if (this.isCallable()) return this.getCallSignature()!.emitPrepareForJson();
-        const children = this.getJitChildren(comp);
-        const childrenCode = children
-            .map((prop) => comp.compilePrepareForJson(prop, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        return {code: childrenCode, type: 'S'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        if (this.isCallable()) return this.getCallSignature()!.emitRestoreFromJson();
-        const children = this.getJitChildren(comp);
-        const childrenCode = children
-            .map((prop) => comp.compileRestoreFromJson(prop, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        return {code: childrenCode, type: 'S'};
-    }
-    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {
-        const children = this.getJitChildren(comp);
-        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
-        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
-        const parentCode = hasIndexProp
-            ? ''
-            : callCheckUnknownProperties(this, comp, children, false, !this.isPartOfUnion(), allChildren);
-        const childrenCode = super.emitHasUnknownKeys(comp).code;
-        return {code: [parentCode, childrenCode].filter(Boolean).join(' || '), type: 'E'};
-    }
-    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {
-        const children = this.getJitChildren(comp);
-        const allChildren = this.getChildRunTypes().filter((prop) => !isIndexSignatureRunType(prop));
-        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
-        const unknownVar = comp.getLocalVarName('unk', this);
-        const keyVar = comp.getLocalVarName('ky', this);
-        const unknownValue = hasIndexProp
-            ? undefined
-            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion(), allChildren);
-        const parentCode = `
-            const ${unknownVar} = ${unknownValue};
-            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}) {${comp.callJitErrWithPath('never', keyVar)}}}
-        `;
-        const childrenCode = super.emitUnknownKeyErrors(comp).code;
-        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
-    }
-    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {
-        const children = this.getJitChildren(comp);
-        const unknownVar = comp.getLocalVarName('unk', this);
-        const keyVar = comp.getLocalVarName('ky', this);
-        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
-        const unknownValue = hasIndexProp
-            ? undefined
-            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
-        const parentCode = `
-            const ${unknownVar} = ${unknownValue};
-            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){delete ${comp.vλl}[${keyVar}]}}
-        `;
-        const childrenCode = super.emitStripUnknownKeys(comp).code;
-        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
-    }
-    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {
-        const children = this.getJitChildren(comp);
-        const unknownVar = comp.getLocalVarName('unk', this);
-        const keyVar = comp.getLocalVarName('ky', this);
-        const hasIndexProp = children.some((prop) => isIndexSignatureRunType(prop));
-        const unknownValue = hasIndexProp
-            ? undefined
-            : callCheckUnknownProperties(this, comp, children, true, !this.isPartOfUnion());
-        const parentCode = `
-            const ${unknownVar} = ${unknownValue};
-            if (${unknownVar}) {for (const ${keyVar} of ${unknownVar}){${comp.vλl}[${keyVar}] = undefined}}
-        `;
-        const childrenCode = super.emitUnknownKeysToUndefined(comp).code;
-        return {code: [unknownValue ? parentCode : '', childrenCode].filter(Boolean).join('\n'), type: 'S'};
-    }
-
-    // In order to json stringify to work properly optional properties must come first
-    getJsonStringifySortedChildren(comp: JitFnCompiler): MemberRunType<any>[] {
-        return this.getJitChildren(comp).toSorted((a, b) => {
-            const aOptional = a instanceof MemberRunType && a.isOptional();
-            const bOptional = b instanceof MemberRunType && b.isOptional();
-            if (aOptional && !bOptional) return -1;
-            if (!aOptional && bOptional) return 1;
-            return 0;
-        }) as MemberRunType<any>[];
-    }
-
-    // extra check to prevent empty array passing as object where all properties are optional
-    // when this check is disabled empty array will pass as object but fail when checking for properties
-    allOptionalCode(comp: JitFnCompiler): string {
-        const children = this.getJitChildren(comp);
-        if (children.length !== 0 && !this.areAllChildrenOptional(children)) return '';
-        const isNotArray = `!Array.isArray(${comp.vλl})`;
-        const ifNoNative = `Object.prototype.toString.call(${comp.vλl}) === '[object Object]'`;
-        return `(${isNotArray} && ${ifNoNative})`;
-    }
-
-    addObjectPropsToContext(comp: JitFnCompiler, jitChildrenRunTypes?: BaseRunType[], allChildrenRuntypes?: BaseRunType[]) {
-        const children = jitChildrenRunTypes || this.getJitChildren(comp);
-        const allChildren = allChildrenRuntypes || this.getChildRunTypes();
-        return addObjectPropsToContext(this, comp, children, allChildren);
-    }
-}
-
-export interface ObjectPropsContextResult {
-    keysName: string;
-    allKeysName: string;
-    hasNonJitChildren: boolean;
-    jitChildrenNames: string[];
-    allChildrenNames: string[];
-}
-
-/**
- * Extracts object property names and adds them to the JIT compiler context.
- */
-function addObjectPropsToContext(
-    rt: InterfaceRunType<any>,
-    comp: JitFnCompiler,
-    jitChildrenRunTypes: BaseRunType[],
-    allChildrenRuntypes?: BaseRunType[]
-): ObjectPropsContextResult {
-    const jitArrNames = jitChildrenRunTypes.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
-    const AllArrNames = allChildrenRuntypes?.filter((prop) => !!(prop.src as any).name).map((prop) => (prop.src as any).name);
-    const jitChildrenNames = Array.from(new Set(jitArrNames));
-    const allChildrenNames = Array.from(new Set(AllArrNames));
-    const isSameLength = jitChildrenNames.length === allChildrenNames.length;
-    const isSameSet = isSameLength && jitChildrenNames.every((v) => allChildrenNames.includes(v));
-    const hasNonJitChildren = !(isSameLength && isSameSet);
-    const keysName = `k_${rt.getJitHash(comp.opts)}`;
-    const allKeysName = `kA_${rt.getJitHash(comp.opts)}`;
-
-    comp.setContextItem(keysName, `const ${keysName} = ${arrayToLiteral(jitChildrenNames)}`);
-    if (hasNonJitChildren) comp.setContextItem(allKeysName, `const ${allKeysName} = ${arrayToLiteral(allChildrenNames)}`);
-
-    return {
-        keysName,
-        allKeysName,
-        hasNonJitChildren,
-        jitChildrenNames,
-        allChildrenNames,
-    };
-}
-
-// TODO: look like some of this logic should be moved to index prop ? Also the runtime
-function callCheckUnknownProperties(
-    rt: InterfaceRunType<any>,
-    comp: JitFnCompiler,
-    jitChildrenRunTypes: BaseRunType[],
-    returnKeys: boolean,
-    checkObject = true,
-    allChildrenRuntypes?: BaseRunType[]
-): string {
-    const result = addObjectPropsToContext(rt, comp, jitChildrenRunTypes, allChildrenRuntypes);
-
-    if (result.jitChildrenNames.length === 0 && result.allChildrenNames.length === 0) return '';
-
-    const objectCheckCode = checkObject ? [`typeof ${comp.vλl} === 'object'`, `${comp.vλl} !== null`] : [];
-    const checkPropName = JitFunctions.hasUnknownKeys.runTimeOptions.checkNonJitProps.keyName;
-    const optsVarName = getJitFnArgCallVarName(comp, rt, JitFunctions.hasUnknownKeys.id, 'θpts');
-    const conditional =
-        allChildrenRuntypes?.length && result.hasNonJitChildren
-            ? `${optsVarName}.${checkPropName} ? ${result.allKeysName} : ${result.keysName}`
-            : result.keysName;
-    if (returnKeys) {
-        const getUnknownKeysFn = comp.addPureFunction(cpf_getUnknownKeysFromArray);
-        return `${getUnknownKeysFn}(${comp.vλl}, ${conditional})`;
-    }
-    const hasUnknownKeysFn = comp.addPureFunction(cpf_hasUnknownKeysFromArray);
-    objectCheckCode.push(`${hasUnknownKeysFn}(${comp.vλl}, ${conditional})`);
-    const filtered = objectCheckCode.filter(Boolean);
-    if (filtered.length > 1) return `(${filtered.join(' && ')})`;
-    return filtered[0];
-}

package/src/nodes/collection/intersection.ts

@@ -1,30 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {TypeIntersection} from '@deepkit/type';
-import {InterfaceRunType} from './interface.ts';
-import {type JitCode} from '../../types.ts';
-
-/** IMPORTANT:
- * Intersection are already resolved by deepkit so seems like this runType wont ever be called
- * ie: type A = {a: string} & {b: number} will be resolved to ObjectLiteral {a: string, b: number}
- * ie: type NeVer = string & number will be resolved to never
- * */
-export class IntersectionRunType extends InterfaceRunType<TypeIntersection> {
-    compileIsType(): JitCode {
-        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
-    }
-    compileTypeErrors(): JitCode {
-        throw new Error('Intersection validation not supported, should be resolve to other RunTypes');
-    }
-    compilePrepareForJson(): JitCode {
-        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
-    }
-    compileRestoreFromJson(): JitCode {
-        throw new Error('Intersection serialization not supported, should be resolve to other RunTypes');
-    }
-}

package/src/nodes/collection/templateLiteral.ts

@@ -1,87 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind, type TypeTemplateLiteral, type TypeLiteral} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {JitCode} from '../../types.ts';
-import {CollectionRunType} from '../../lib/baseRunTypes.ts';
-
-/**
- * RunType for TypeScript template literal types, ie: `type T = \`api/user/${number}\``.
- * The runtime value is a string. Validation is done by compiling the template literal type
- * to a single anchored regex at JIT-build time and then calling `regex.test(v)` at runtime.
- * Mocking walks the children directly (literal => verbatim, string/any => mockString, number => mockNumber)
- * and concatenates the spans, which guarantees the result satisfies the validation regex.
- */
-export class TemplateLiteralRunType extends CollectionRunType<TypeTemplateLiteral> {
-    private _regexSource: string | undefined;
-
-    /** Builds the anchored regex source from src.types. Memoized. */
-    getRegexSource(): string {
-        if (this._regexSource !== undefined) return this._regexSource;
-        this._regexSource = buildAnchoredTemplateRegexSource(this.src.types || []);
-        return this._regexSource;
-    }
-
-    /** Returns a context-bound variable name holding the RegExp; emits the const into the compiler context. */
-    private getRegexVar(comp: JitFnCompiler): string {
-        const varName = comp.getLocalVarName('reTL', this);
-        if (!comp.hasContextItem(varName)) {
-            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(this.getRegexSource())})`);
-        }
-        return varName;
-    }
-
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const re = this.getRegexVar(comp);
-        return {code: `(typeof ${comp.vλl} === 'string' && ${re}.test(${comp.vλl}))`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const re = this.getRegexVar(comp);
-        return {
-            code: `if (typeof ${comp.vλl} !== 'string' || !${re}.test(${comp.vλl})) ${comp.callJitErr(this)}`,
-            type: 'S',
-        };
-    }
-    /** value is already a JSON-safe string, no transform required */
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    /** value is already a JSON-safe string, no transform required */
-    emitRestoreFromJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-}
-
-/** Build the full ^...$ regex source for a template literal type's spans */
-export function buildAnchoredTemplateRegexSource(types: TypeTemplateLiteral['types']): string {
-    return `^${types.map((t) => spanToRegex(t)).join('')}$`;
-}
-
-/** Translate a single template-literal span (TypeString | TypeAny | TypeNumber | TypeLiteral | TypeInfer) into regex source */
-export function spanToRegex(t: TypeTemplateLiteral['types'][number]): string {
-    switch (t.kind) {
-        case ReflectionKind.literal:
-            return escapeForRegex(String((t as TypeLiteral).literal));
-        case ReflectionKind.number:
-            // matches signed integers and floats (including leading dot like '.5'), mirroring TS's `${number}` semantics
-            return '-?(?:\\d+\\.?\\d*|\\.\\d+)';
-        case ReflectionKind.string:
-        case ReflectionKind.any:
-        case ReflectionKind.infer:
-            // `${string}` accepts the empty string, so use * not +
-            return '[\\s\\S]*';
-        default:
-            // unreachable per deepkit's TypeTemplateLiteral.types definition
-            throw new Error(`Unsupported template literal span kind: ${(t as {kind: number}).kind}`);
-    }
-}
-
-/** Escape regex metacharacters so a literal substring is matched verbatim */
-function escapeForRegex(s: string): string {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/src/nodes/collection/tuple.ts

@@ -1,80 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeFunction, TypeTuple} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {AnyParameterListRunType, SrcType, JitCode} from '../../types.ts';
-import {ParameterRunType} from '../member/param.ts';
-import {CollectionRunType} from '../../lib/baseRunTypes.ts';
-import {TupleMemberRunType} from '../member/tupleMember.ts';
-
-type AnyParamRunType = ParameterRunType | TupleMemberRunType;
-
-export class TupleRunType<
-    ParamList extends AnyParameterListRunType = TypeTuple,
-    ParamType extends AnyParamRunType = TupleMemberRunType,
-> extends CollectionRunType<ParamList> {
-    getChildRunTypes = (): ParamType[] => {
-        const childTypes = ((this.src as TypeFunction).parameters || (this.src as TypeTuple).types || []) as SrcType[];
-        return childTypes.map((t) => t._rt as ParamType);
-    };
-    getParamRunTypes(comp: JitFnCompiler): ParamType[] {
-        const start = comp.opts?.paramsSlice?.start;
-        const end = comp.opts?.paramsSlice?.end;
-        const children = this.getChildRunTypes();
-        if (!start && !end) return children;
-        // Get all child run types first without using comp to avoid recursion
-        return children.slice(start, end);
-    }
-    hasRestParameter(comp: JitFnCompiler): boolean {
-        return (
-            !!this.getParamRunTypes(comp).length && this.getParamRunTypes(comp)[this.getParamRunTypes(comp).length - 1].isRest()
-        );
-    }
-    totalRequiredParams(comp: JitFnCompiler): number {
-        return this.getParamRunTypes(comp).filter((p) => !p.isOptional() && !p.isRest()).length;
-    }
-    // ####### params #######
-
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'E'};
-        if (children.length === 0) return {code: `Array.isArray(${comp.vλl}) && ${comp.vλl}.length === 0`, type: 'E'};
-        const lengthCode = this.hasRestParameter(comp) ? '' : `&& ${comp.vλl}.length <= ${this.getParamRunTypes(comp).length}`;
-        const paramsCode = children.map((p) => `(${comp.compileIsType(p, 'E').code})`).join(' && ');
-        const checkIsArrayCode = comp.opts.noIsArrayCheck ? '' : `Array.isArray(${comp.vλl})${lengthCode} && `;
-        return {code: `(${checkIsArrayCode} ${paramsCode})`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (children.length === 0 && comp.opts.noIsArrayCheck) return {code: undefined, type: 'S'};
-        if (children.length === 0)
-            return {code: `if (!Array.isArray(${comp.vλl}) || && ${comp.vλl}.length === 0) ${comp.callJitErr(this)}`, type: 'S'};
-        const lengthCode = this.hasRestParameter(comp) ? '' : `|| ${comp.vλl}.length > ${this.getParamRunTypes(comp).length}`;
-        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).join(';');
-        if (comp.opts.noIsArrayCheck) return {code: paramsCode, type: 'S'};
-        return {code: `if (!Array.isArray(${comp.vλl})${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode}}`, type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (!children.length) return {code: undefined, type: 'S'};
-        const code = children
-            .map((p) => comp.compilePrepareForJson(p, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        return {code: code, type: 'S'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (!children.length) return {code: undefined, type: 'S'};
-        const code = children
-            .map((p) => comp.compileRestoreFromJson(p, 'S').code)
-            .filter(Boolean)
-            .join(';');
-        return {code: code, type: 'S'};
-    }
-}