@mionjs/run-types 0.8.10 → 0.13.2

package/src/nodes/atomic/date.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type TypeClass} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class DateRunType extends AtomicRunType<TypeClass> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (!(${comp.vλl} instanceof Date && !isNaN(${comp.vλl}.getTime()))) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {code: `new Date(${comp.vλl})`, type: 'E'};
-    }
-}

package/src/nodes/atomic/enum.ts

@@ -1,23 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {TypeEnum} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {toLiteral} from '../../lib/utils.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class EnumRunType extends AtomicRunType<TypeEnum> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);
-        return {code: `(${items.join(' || ')})`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const items = this.src.values.map((v) => `${comp.vλl} === ${toLiteral(v)}`);
-        return {code: `if (!(${items.join(' || ')})) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-}

package/src/nodes/atomic/enumMember.ts

@@ -1,29 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {type TypeEnum} from '@deepkit/type';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import {JitCode} from '../../types.ts';
-
-// TODO: not sure when run type will be generated but doesn't seem to be used when using reflection on enums
-export class EnumMemberRunType extends AtomicRunType<TypeEnum> {
-    skipJit() {
-        return true;
-    }
-    emitIsType(): JitCode {
-        throw new Error('Enum member operations are not supported');
-    }
-    emitTypeErrors(): JitCode {
-        throw new Error('Enum member operations are not supported');
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error('Enum member operations are not supported');
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error('Enum member operations are not supported');
-    }
-}

package/src/nodes/atomic/literal.ts

@@ -1,125 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind, type TypeLiteral} from '@deepkit/type';
-import type {JitCode, RunType} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {Mutable} from '@mionjs/core';
-import {toLiteral} from '../../lib/utils.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import {BigIntRunType} from './bigInt.ts';
-import {RegexpRunType} from './regexp.ts';
-import {SymbolRunType} from './symbol.ts';
-import {AnyKindName} from '../../constants.kind.ts';
-import {StringRunType} from './string.ts';
-import {NumberRunType} from './number.ts';
-import {BooleanRunType} from './boolean.ts';
-
-const stringRt = new StringRunType();
-const numberRt = new NumberRunType();
-const booleanRt = new BooleanRunType();
-const symbolRt = new SymbolRunType();
-const regexpRt = new RegexpRunType();
-const bigIntRt = new BigIntRunType();
-
-type AnyLiteralRunType = StringRunType | NumberRunType | BooleanRunType | SymbolRunType | RegexpRunType | BigIntRunType;
-
-export class LiteralRunType extends AtomicRunType<TypeLiteral> {
-    getRunTypeForLiteral(comp: JitFnCompiler): AnyLiteralRunType {
-        const noLiterals = comp.opts.noLiterals;
-        const lit = this.src.literal;
-        let rt: AnyLiteralRunType;
-        if (lit instanceof RegExp) {
-            rt = regexpRt;
-            (rt as Mutable<RunType>).src = this.src;
-            if (noLiterals) (this.src as any).kind = ReflectionKind.regexp;
-            return rt;
-        }
-        switch (typeof lit) {
-            case 'string':
-                rt = stringRt;
-                if (noLiterals) (this.src as any).kind = ReflectionKind.string;
-                break;
-            case 'number':
-                rt = numberRt;
-                if (noLiterals) (this.src as any).kind = ReflectionKind.number;
-                break;
-            case 'boolean':
-                rt = booleanRt;
-                if (noLiterals) (this.src as any).kind = ReflectionKind.boolean;
-                break;
-            case 'bigint':
-                rt = bigIntRt;
-                if (noLiterals) (this.src as any).kind = ReflectionKind.bigint;
-                break;
-            case 'symbol':
-                rt = symbolRt;
-                if (noLiterals) (this.src as any).kind = ReflectionKind.symbol;
-                break;
-            default:
-                throw new Error(`Unsupported literal type ${typeof lit}`);
-        }
-        (rt as Mutable<RunType>).src = this.src;
-        return rt;
-    }
-    emitIsType(comp: JitFnCompiler): JitCode {
-        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitIsType(comp);
-        return {code: compileIsLiteral(comp, this.src.literal), type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        if (comp.opts.noLiterals) return this.getRunTypeForLiteral(comp).emitTypeErrors(comp);
-        return {code: compileTypeErrorsLiteral(comp, this.src.literal, this.getKindName()), type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        return this.getRunTypeForLiteral(comp).emitPrepareForJson(comp);
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return this.getRunTypeForLiteral(comp).emitRestoreFromJson(comp);
-    }
-    getLiteralValue() {
-        return this.src.literal;
-    }
-}
-
-function compileIsLiteral(comp: JitFnCompiler, lit: TypeLiteral['literal']): string {
-    const literalType = typeof lit;
-    if (lit instanceof RegExp) return `${comp.vλl} instanceof RegExp && String(${comp.vλl}) === String(${lit})`;
-    switch (literalType) {
-        case 'string':
-            return `${comp.vλl} === ${toLiteral(lit)}`;
-        case 'number':
-            return `${comp.vλl} === ${toLiteral(lit)}`;
-        case 'boolean':
-            return `${comp.vλl} === ${toLiteral(lit)}`;
-        case 'bigint':
-            return `${comp.vλl} === ${toLiteral(lit)}`;
-        case 'symbol':
-            return `typeof ${comp.vλl} === 'symbol' && ${comp.vλl}.description === ${toLiteral((lit as symbol).description)}`;
-        default:
-            throw new Error(`Unsupported literal type ${literalType}`);
-    }
-}
-
-function compileTypeErrorsLiteral(comp: JitErrorsFnCompiler, lit: TypeLiteral['literal'], name: AnyKindName): string {
-    const literalType = typeof lit;
-    if (lit instanceof RegExp)
-        return `if (!(${comp.vλl} instanceof RegExp) || String(${comp.vλl}) !== String(${lit})) ${comp.callJitErr(name)}`;
-    switch (literalType) {
-        case 'string':
-            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
-        case 'number':
-            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
-        case 'boolean':
-            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
-        case 'bigint':
-            return `if (${comp.vλl} !== ${toLiteral(lit)}) ${comp.callJitErr(name)}`;
-        case 'symbol':
-            return `if (typeof ${comp.vλl} !== 'symbol' || ${comp.vλl}.description !== ${toLiteral((lit as symbol).description)}) {${comp.callJitErr(name)}}`;
-        default:
-            throw new Error(`Unsupported literal type ${literalType}`);
-    }
-}

package/src/nodes/atomic/never.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeNever} from '@deepkit/type';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import {JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {JitCode} from '../../types.ts';
-
-export class NeverRunType extends AtomicRunType<TypeNever> {
-    emitIsType(): JitCode {
-        return {code: 'false', type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        throw new Error('Never type cannot be encoded to JSON.');
-    }
-    emitRestoreFromJson(): JitCode {
-        throw new Error('Never type cannot be decoded from JSON.');
-    }
-}

package/src/nodes/atomic/null.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeNull} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class NullRunType extends AtomicRunType<TypeNull> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl} === null`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (${comp.vλl} !== null) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    emitRestoreFromJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-}

package/src/nodes/atomic/number.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeNumber} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class NumberRunType extends AtomicRunType<TypeNumber> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `Number.isFinite(${comp.vλl})`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if(!(Number.isFinite(${comp.vλl}))) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-    emitRestoreFromJson(): JitCode {
-        return {code: undefined, type: 'S'};
-    }
-}

package/src/nodes/atomic/object.ts

@@ -1,20 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeAny, TypeUnknown} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class ObjectRunType extends AtomicRunType<TypeAny | TypeUnknown> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (!(typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null)) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-}

package/src/nodes/atomic/regexp.ts

@@ -1,29 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeRegexp} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class RegexpRunType extends AtomicRunType<TypeRegexp> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `(${comp.vλl} instanceof RegExp)`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (!(${comp.vλl} instanceof RegExp)) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl}.toString()`, type: 'E'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {
-            code: `(function(){const parts = ${comp.vλl}.match(/\\/(.*)\\/(.*)?/) ;return new RegExp(parts[1], parts[2] || '')})()`,
-            type: 'E',
-        };
-    }
-}

package/src/nodes/atomic/string.ts

@@ -1,20 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeString} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class StringRunType extends AtomicRunType<TypeString> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `typeof ${comp.vλl} === 'string'`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (typeof ${comp.vλl} !== 'string') ${comp.callJitErr(this)}`, type: 'S'};
-    }
-}

package/src/nodes/atomic/symbol.ts

@@ -1,31 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeSymbol} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import {JitFunctions} from '../../constants.functions.ts';
-
-export class SymbolRunType extends AtomicRunType<TypeSymbol> {
-    skipJit(comp: JitFnCompiler): boolean {
-        if (!comp) return true;
-        return comp.fnID !== JitFunctions.toJSCode.id;
-    }
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `typeof ${comp.vλl} === 'symbol'`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (typeof ${comp.vλl} !== 'symbol') ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        return {code: `'Symbol:' + (${comp.vλl}.description || '')`, type: 'E'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {code: `Symbol(${comp.vλl}.substring(7))`, type: 'E'};
-    }
-}

package/src/nodes/atomic/undefined.ts

@@ -1,23 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeUndefined} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-
-export class UndefinedRunType extends AtomicRunType<TypeUndefined> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `typeof ${comp.vλl} === 'undefined'`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (typeof ${comp.vλl} !== 'undefined') ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitRestoreFromJson(): JitCode {
-        return {code: `undefined`, type: 'E'};
-    }
-}

package/src/nodes/atomic/unknown.ts

@@ -1,10 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {AnyRunType} from './any.ts';
-
-export class UnknownRunType extends AnyRunType {}

package/src/nodes/atomic/void.ts

@@ -1,26 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {TypeVoid} from '@deepkit/type';
-import type {JitCode} from '../../types.ts';
-import {AtomicRunType} from '../../lib/baseRunTypes.ts';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-
-export class VoidRunType extends AtomicRunType<TypeVoid> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl} === undefined`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        return {code: `if (${comp.vλl} !== undefined) ${comp.callJitErr(this)}`, type: 'S'};
-    }
-    emitPrepareForJson(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl} = undefined`, type: 'E'};
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        return {code: `${comp.vλl} = undefined`, type: 'E'};
-    }
-}

package/src/nodes/collection/class.ts

@@ -1,36 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-import {TypeClass} from '@deepkit/type';
-import {InterfaceMember, InterfaceRunType} from './interface.ts';
-import {JitFnCompiler} from '../../lib/jitFnCompiler.ts';
-import {getJitUtils} from '@mionjs/core';
-import {toLiteral} from '../../lib/utils.ts';
-import {isConstructor} from '../../lib/guards.ts';
-import {JitCode} from '../../types.ts';
-
-export class ClassRunType extends InterfaceRunType<TypeClass> {
-    getClassName(): string {
-        return this.src.classType.name;
-    }
-    isClassWithEmptyConstructor(): boolean {
-        const children = this.getChildRunTypes() as InterfaceMember[];
-        const isEmpty = children.every((prop) => !isConstructor(prop) || prop.getParameters().getChildRunTypes().length === 0);
-        return isEmpty;
-    }
-    emitRestoreFromJson(comp: JitFnCompiler): JitCode {
-        const objJit = super.emitRestoreFromJson(comp);
-        const desFnVarName = comp.getLocalVarName('desFn', this);
-        const classLiteral = toLiteral(this.getClassName());
-        const code = `
-            ${objJit.code};
-            let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${classLiteral});
-            if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}
-            else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${classLiteral})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}
-        `;
-        return {code, type: 'S'};
-    }
-}

package/src/nodes/collection/functionParams.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 {TypeFunction} from '@deepkit/type';
-import type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {AnyParameterListRunType, JitCode} from '../../types.ts';
-import {TupleRunType} from './tuple.ts';
-import {ParameterRunType} from '../member/param.ts';
-
-export class FunctionParamsRunType<ParamList extends AnyParameterListRunType = TypeFunction> extends TupleRunType<
-    ParamList,
-    ParameterRunType
-> {
-    emitIsType(comp: JitFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (children.length === 0) return {code: `${comp.vλl}.length === 0`, type: 'E'};
-        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length <= ${children.length}`;
-        // Only include parameters that require validation
-        const paramsCode = children.map((p) => comp.compileIsType(p, 'E').code).filter(Boolean);
-        if (paramsCode.length === 0) return lengthCode ? {code: `(${lengthCode})`, type: 'E'} : {code: undefined, type: 'E'};
-        return lengthCode
-            ? {code: `(${lengthCode} && ${paramsCode.join(' && ')})`, type: 'E'}
-            : {code: `(${paramsCode.join(' && ')})`, type: 'E'};
-    }
-    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {
-        const children = this.getParamRunTypes(comp);
-        if (children.length === 0) return {code: `if (${comp.vλl}.length !== 0) ${comp.callJitErr(this)}`, type: 'S'};
-        const lengthCode = this.hasRestParameter(comp) ? '' : `${comp.vλl}.length > ${children.length}`;
-
-        // Only include parameters that require validation
-        const paramsCode = children.map((p) => comp.compileTypeErrors(p, 'S').code).filter(Boolean);
-        if (paramsCode.length === 0)
-            return lengthCode ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}`, type: 'S'} : {code: undefined, type: 'S'};
-        return lengthCode
-            ? {code: `if (${lengthCode}) ${comp.callJitErr(this)}; else {${paramsCode.join(';')}}`, type: 'S'}
-            : {code: paramsCode.join(';'), type: 'S'};
-    }
-}