@cuxt/sandboxjs 0.1.1 → 0.1.3

package/dist/cjs/executor/ops/misc.js

@@ -0,0 +1,25 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/misc.ts
+require_opsRegistry.addOps(require_types.LispType.Internal, ({ done, a, b, scope, bobj, internal }) => {
+	if (!internal) throw new require_errors.SandboxCapabilityError("Internal variables are not accessible");
+	done(void 0, scope.declare(a, require_types.VarType.internal, b, bobj?.isGlobal || false, internal));
+});
+require_opsRegistry.addOps(require_types.LispType.LoopAction, ({ done, a, b, context, statementLabels }) => {
+	const label = require_executorUtils.normalizeStatementLabel(b);
+	const target = require_executorUtils.findControlFlowTarget(statementLabels, a, label);
+	if (target === null) throw new TypeError("Illegal continue statement");
+	if (!target) throw new TypeError(label ? `Undefined label '${label}'` : "Illegal " + a + " statement");
+	done(void 0, new require_executorUtils.ExecReturn(context.ctx.auditReport, void 0, false, {
+		type: a,
+		label
+	}));
+});
+require_opsRegistry.addOps(require_types.LispType.Throw, ({ done, b }) => {
+	done(b);
+});
+require_opsRegistry.addOps(require_types.LispType.None, ({ done }) => done());
+//#endregion

package/dist/cjs/executor/ops/object.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/object.js

@@ -0,0 +1,51 @@
+const require_types = require("../../utils/types.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/object.ts
+require_opsRegistry.addOps(require_types.LispType.CreateObject, (params) => {
+	const { done, b } = params;
+	let res = {};
+	for (const item of b) if (item.key instanceof require_executorUtils.SpreadObject) {
+		const keys = Object.keys(item.key.item);
+		if (require_executorUtils.checkHaltExpectedTicks(params, BigInt(keys.length))) return;
+		res = {
+			...res,
+			...item.key.item
+		};
+	} else res[item.key] = item.val;
+	done(void 0, res);
+});
+require_opsRegistry.addOps(require_types.LispType.KeyVal, ({ done, a, b }) => done(void 0, new require_executorUtils.KeyVal(a, b)));
+require_opsRegistry.addOps(require_types.LispType.CreateArray, (params) => {
+	const { done, b, context } = params;
+	const items = [];
+	for (const item of b) if (item instanceof require_executorUtils.SpreadArray) {
+		const expanded = Array.isArray(item.item) ? item.item : [...item.item];
+		if (require_executorUtils.checkHaltExpectedTicks(params, BigInt(expanded.length))) return;
+		for (const v of expanded) items.push(require_Scope.sanitizeProp(v, context));
+	} else if (item instanceof require_executorUtils.ArrayHole) items.length++;
+	else items.push(require_Scope.sanitizeProp(item, context));
+	done(void 0, items);
+});
+require_opsRegistry.addOps(require_types.LispType.Hole, ({ done }) => done(void 0, new require_executorUtils.ArrayHole()));
+require_opsRegistry.addOps(require_types.LispType.Group, ({ done, b }) => done(void 0, b));
+require_opsRegistry.addOps(require_types.LispType.GlobalSymbol, ({ done, b }) => {
+	switch (b) {
+		case "true": return done(void 0, true);
+		case "false": return done(void 0, false);
+		case "null": return done(void 0, null);
+		case "undefined": return done(void 0, void 0);
+		case "NaN": return done(void 0, NaN);
+		case "Infinity": return done(void 0, Infinity);
+	}
+	done(/* @__PURE__ */ new Error("Unknown symbol: " + b));
+});
+require_opsRegistry.addOps(require_types.LispType.SpreadArray, ({ done, b }) => {
+	done(void 0, new require_executorUtils.SpreadArray(b));
+});
+require_opsRegistry.addOps(require_types.LispType.SpreadObject, ({ done, b }) => {
+	done(void 0, new require_executorUtils.SpreadObject(b));
+});
+//#endregion

package/dist/cjs/executor/ops/prop.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/prop.js

@@ -0,0 +1,70 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+const require_Prop = require("../../utils/Prop.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/prop.ts
+require_opsRegistry.addOps(require_types.LispType.Prop, ({ done, a, b, obj, context, scope, internal }) => {
+	if (a === null) throw new TypeError(`Cannot read properties of null (reading '${b?.toString()}')`);
+	if (!require_executorUtils.isPropertyKey(b)) b = `${b}`;
+	if (a === void 0 && obj === void 0 && typeof b === "string") {
+		const prop = scope.get(b, internal);
+		if (prop.context === void 0) throw new ReferenceError(`${b} is not defined`);
+		if (prop.context === context.ctx.sandboxGlobal) {
+			if (context.ctx.options.audit) context.ctx.auditReport?.globalsAccess.add(b);
+		}
+		const val = prop.context[prop.prop];
+		done(void 0, require_Prop.resolveSandboxProp(val, context, prop) || prop);
+		return;
+	} else if (a === void 0) throw new TypeError(`Cannot read properties of undefined (reading '${b.toString()}')`);
+	if (!require_executorUtils.hasPossibleProperties(a)) {
+		done(void 0, new require_Prop.Prop(void 0, b));
+		return;
+	}
+	const prototypeAccess = typeof a === "function" || !require_Prop.hasOwnProperty(a, b);
+	if (context.ctx.options.audit && prototypeAccess) {
+		let prot = Object.getPrototypeOf(a);
+		do
+			if (require_Prop.hasOwnProperty(prot, b)) {
+				if (context.ctx.auditReport && !context.ctx.auditReport.prototypeAccess[prot.constructor.name]) context.ctx.auditReport.prototypeAccess[prot.constructor.name] = /* @__PURE__ */ new Set();
+				context.ctx.auditReport?.prototypeAccess[prot.constructor.name].add(b);
+			}
+		while (prot = Object.getPrototypeOf(prot));
+	}
+	if (prototypeAccess) {
+		if (typeof a === "function") {
+			if (require_Prop.hasOwnProperty(a, b)) {
+				const whitelist = context.ctx.prototypeWhitelist.get(a.prototype);
+				if (!(whitelist && (!whitelist.size || whitelist.has(b))) && !context.ctx.sandboxedFunctions.has(a)) throw new require_errors.SandboxAccessError(`Static method or property access not permitted: ${a.name}.${b.toString()}`);
+			}
+		}
+		let prot = a;
+		while (prot = Object.getPrototypeOf(prot)) if (require_Prop.hasOwnProperty(prot, b) || b === "__proto__") {
+			const whitelist = context.ctx.prototypeWhitelist.get(prot);
+			if (whitelist && (!whitelist.size || whitelist.has(b)) || context.ctx.sandboxedFunctions.has(prot.constructor)) break;
+			if (b === "__proto__") throw new require_errors.SandboxAccessError(`Access to prototype of global object is not permitted`);
+			throw new require_errors.SandboxAccessError(`Method or property access not permitted: ${prot.constructor.name}.${b.toString()}`);
+		}
+	}
+	if (typeof a === "function") {
+		if (b === "prototype" && !context.ctx.sandboxedFunctions.has(a)) throw new require_errors.SandboxAccessError(`Access to prototype of global object is not permitted`);
+		if ([
+			"caller",
+			"callee",
+			"arguments"
+		].includes(b)) throw new require_errors.SandboxAccessError(`Access to '${b}' property is not permitted`);
+	}
+	const val = a[b];
+	if (b === "__proto__" && !context.ctx.sandboxedFunctions.has(val?.constructor)) throw new require_errors.SandboxAccessError(`Access to prototype of global object is not permitted`);
+	const p = require_Prop.resolveSandboxProp(val, context, new require_Prop.Prop(a, b, false, false));
+	if (p) {
+		done(void 0, p);
+		return;
+	}
+	const isSandboxGlobal = a === context.ctx.sandboxGlobal;
+	const g = !isSandboxGlobal && obj instanceof require_Prop.Prop && obj.isGlobal || typeof a === "function" && !context.ctx.sandboxedFunctions.has(a) || context.ctx.globalsWhitelist.has(a) || isSandboxGlobal && typeof b === "string" && require_Prop.hasOwnProperty(context.ctx.globalScope.globals, b);
+	done(void 0, new require_Prop.Prop(a, b, false, g, false));
+});
+require_opsRegistry.addOps(require_types.LispType.StringIndex, ({ done, b, context }) => done(void 0, context.constants.strings[parseInt(b)]));
+//#endregion

package/dist/cjs/executor/ops/unary.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/unary.js

@@ -0,0 +1,48 @@
+const require_types = require("../../utils/types.js");
+const require_Prop = require("../../utils/Prop.js");
+const require_Scope = require("../../utils/Scope.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+const require_executorUtils = require("../executorUtils.js");
+//#region src/executor/ops/unary.ts
+require_opsRegistry.addOps(require_types.LispType.Not, ({ done, b }) => done(void 0, !b));
+require_opsRegistry.addOps(require_types.LispType.Inverse, ({ done, b }) => done(void 0, ~b));
+require_opsRegistry.addOps(require_types.LispType.IncrementBefore, ({ done, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, ++obj.context[obj.prop]);
+});
+require_opsRegistry.addOps(require_types.LispType.IncrementAfter, ({ done, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop]++);
+});
+require_opsRegistry.addOps(require_types.LispType.DecrementBefore, ({ done, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, --obj.context[obj.prop]);
+});
+require_opsRegistry.addOps(require_types.LispType.DecrementAfter, ({ done, obj, context }) => {
+	require_executorUtils.assignCheck(obj, context);
+	done(void 0, obj.context[obj.prop]--);
+});
+require_opsRegistry.addOps(require_types.LispType.Positive, ({ done, b }) => done(void 0, +b));
+require_opsRegistry.addOps(require_types.LispType.Negative, ({ done, b }) => done(void 0, -b));
+require_opsRegistry.addOps(require_types.LispType.Typeof, ({ exec, done, ticks, b, context, scope, internal, generatorYield }) => {
+	exec(ticks, b, scope, context, (e, prop) => {
+		done(void 0, typeof require_Scope.sanitizeProp(prop, context));
+	}, void 0, internal, generatorYield);
+});
+require_opsRegistry.addOps(require_types.LispType.Delete, ({ done, context, bobj }) => {
+	if (!(bobj instanceof require_Prop.Prop)) {
+		done(void 0, true);
+		return;
+	}
+	require_executorUtils.assignCheck(bobj, context, "delete");
+	if (bobj.isVariable) {
+		done(void 0, false);
+		return;
+	}
+	done(void 0, delete bobj.context?.[bobj.prop]);
+});
+require_opsRegistry.addOps(require_types.LispType.Void, ({ done }) => {
+	done();
+});
+//#endregion

package/dist/cjs/executor/ops/variables.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/executor/ops/variables.js

@@ -0,0 +1,16 @@
+const require_types = require("../../utils/types.js");
+require("../../utils/index.js");
+const require_opsRegistry = require("../opsRegistry.js");
+require("../executorUtils.js");
+//#region src/executor/ops/variables.ts
+require_opsRegistry.addOps(require_types.LispType.Return, ({ done, b }) => done(void 0, b));
+require_opsRegistry.addOps(require_types.LispType.Var, ({ done, a, b, scope, bobj, internal }) => {
+	done(void 0, scope.declare(a, require_types.VarType.var, b, bobj?.isGlobal || false, internal));
+});
+require_opsRegistry.addOps(require_types.LispType.Let, ({ done, a, b, scope, bobj, internal }) => {
+	done(void 0, scope.declare(a, require_types.VarType.let, b, bobj?.isGlobal || false, internal));
+});
+require_opsRegistry.addOps(require_types.LispType.Const, ({ done, a, b, scope, bobj, internal }) => {
+	done(void 0, scope.declare(a, require_types.VarType.const, b, bobj?.isGlobal || false, internal));
+});
+//#endregion

package/dist/cjs/executor/opsRegistry.d.ts

@@ -0,0 +1,33 @@
+import { LispType, IExecContext, Ticks, Scope } from '../utils';
+import { LispItem } from '../parser';
+import { YieldValue, Done } from './executorUtils';
+export type ControlFlowAction = 'break' | 'continue';
+export interface ControlFlowTarget {
+    label?: string;
+    acceptsBreak: boolean;
+    acceptsContinue: boolean;
+    acceptsUnlabeledBreak: boolean;
+    acceptsUnlabeledContinue: boolean;
+}
+export type ControlFlowTargets = readonly ControlFlowTarget[] | undefined;
+export type Execution = <T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, statementLabels: ControlFlowTargets, internal: boolean, generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined) => void;
+export type OpsCallbackParams<a, b, obj, bobj> = {
+    op: LispType;
+    exec: Execution;
+    a: a;
+    b: b;
+    obj: obj;
+    bobj: bobj;
+    ticks: Ticks;
+    tree: LispItem;
+    scope: Scope;
+    context: IExecContext;
+    done: Done;
+    statementLabels: ControlFlowTargets;
+    internal: boolean;
+    generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined;
+};
+type OpCallback<a, b, obj, bobj> = (params: OpsCallbackParams<a, b, obj, bobj>) => void;
+export declare const ops: Map<LispType, OpCallback<any, any, any, any>>;
+export declare function addOps<a = unknown, b = unknown, obj = unknown, bobj = unknown>(type: LispType, cb: OpCallback<a, b, obj, bobj>): void;
+export {};

package/dist/cjs/executor/opsRegistry.js

@@ -0,0 +1,8 @@
+//#region src/executor/opsRegistry.ts
+var ops = /* @__PURE__ */ new Map();
+function addOps(type, cb) {
+	ops.set(type, cb);
+}
+//#endregion
+exports.addOps = addOps;
+exports.ops = ops;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/parser/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lisp';
+export * from './parserUtils';
+export { default } from './parserUtils';

package/dist/cjs/parser/index.js

@@ -0,0 +1 @@
+require("./parserUtils.js");

package/dist/{parser.d.ts → cjs/parser/lisp.d.ts}

@@ -1,4 +1,4 @@
-import { CodeString, LispType } from './utils.js';
+import { CodeString, LispType } from '../utils';
 export type DefineLisp<op extends LispType, a extends LispItem | LispItem, b extends LispItem | LispItem> = [op, a, b];
 export type ExtractLispOp<L> = L extends DefineLisp<infer i, any, any> ? i : never;
 export type ExtractLispA<L> = L extends DefineLisp<any, infer i, any> ? i : never;
@@ -9,15 +9,17 @@ export type Lisp = [LispType, LispItem, LispItem];
 export type Literal = DefineLisp<LispType.Literal, string, Lisp[]> & {
     tempJsStrings?: string[];
 };
-export type If = DefineLisp<LispType.If, Lisp, IfCase>;
+export type IfLisp = DefineLisp<LispType.If, Lisp, IfCase>;
 export type InlineIf = DefineLisp<LispType.InlineIf, Lisp, InlineIfCase>;
+export type StatementLabel = string | LispType.None;
 export type IfCase = DefineLisp<LispType.IfCase, Lisp[], Lisp[]>;
 export type InlineIfCase = DefineLisp<LispType.InlineIfCase, Lisp, Lisp>;
-export type KeyVal = DefineLisp<LispType.KeyVal, string | Lisp, Lisp>;
-export type SpreadObject = DefineLisp<LispType.SpreadObject, LispType.None, Lisp>;
-export type SpreadArray = DefineLisp<LispType.SpreadArray, LispType.None, Lisp>;
+export type Labeled = DefineLisp<LispType.Labeled, StatementLabel, Lisp>;
+export type KeyValLisp = DefineLisp<LispType.KeyVal, string | Lisp, Lisp>;
+export type SpreadObjectLisp = DefineLisp<LispType.SpreadObject, LispType.None, Lisp>;
+export type SpreadArrayLisp = DefineLisp<LispType.SpreadArray, LispType.None, Lisp>;
 export type ArrayProp = DefineLisp<LispType.ArrayProp, Lisp, Lisp>;
-export type Prop = DefineLisp<LispType.Prop, Lisp, string | Lisp>;
+export type PropLisp = DefineLisp<LispType.Prop, Lisp, string | Lisp>;
 export type PropOptional = DefineLisp<LispType.PropOptional, Lisp, Lisp[]>;
 export type Call = DefineLisp<LispType.Call, Lisp, Lisp[]>;
 export type CallOptional = DefineLisp<LispType.CallOptional, Lisp, Lisp[]>;
@@ -75,6 +77,7 @@ export type Divide = DefineLisp<LispType.Divide, Lisp, Lisp>;
 export type Power = DefineLisp<LispType.Power, Lisp, Lisp>;
 export type Multiply = DefineLisp<LispType.Multiply, Lisp, Lisp>;
 export type Modulus = DefineLisp<LispType.Modulus, Lisp, Lisp>;
+export type InternalCode = DefineLisp<LispType.InternalBlock, Lisp[], LispType.None>;
 export type Block = DefineLisp<LispType.Block, Lisp[], LispType.None>;
 export type Expression = DefineLisp<LispType.Expression, Lisp[], LispType.None>;
 export type Return = DefineLisp<LispType.Return, LispType.None, Lisp>;
@@ -84,6 +87,7 @@ export type SwitchCase = DefineLisp<LispType.SwitchCase, LispType.None | Lisp, L
 export type Var = DefineLisp<LispType.Var, string, Lisp | LispType.None>;
 export type Let = DefineLisp<LispType.Let, string, Lisp | LispType.None>;
 export type Const = DefineLisp<LispType.Const, string, Lisp | LispType.None>;
+export type Internal = DefineLisp<LispType.Internal, string, Lisp | LispType.None>;
 export type Number = DefineLisp<LispType.Number, LispType.None, string>;
 export type BigInt = DefineLisp<LispType.BigInt, LispType.None, string>;
 export type GlobalSymbol = DefineLisp<LispType.GlobalSymbol, LispType.None, string>;
@@ -94,13 +98,15 @@ export type Function = DefineLisp<LispType.Function, (string | LispType.None | L
 export type InlineFunction = DefineLisp<LispType.InlineFunction, string[], string | Lisp[]>;
 export type ArrowFunction = DefineLisp<LispType.ArrowFunction, string[], string | Lisp[]>;
 export type Loop = DefineLisp<LispType.Loop, LispItem, Lisp[]>;
-export type LoopAction = DefineLisp<LispType.LoopAction, string, LispType.None>;
+export type LoopAction = DefineLisp<LispType.LoopAction, string, StatementLabel>;
 export type Try = DefineLisp<LispType.Try, Lisp[], LispItem>;
 export type Void = DefineLisp<LispType.Void, Lisp, LispType.None>;
 export type Await = DefineLisp<LispType.Await, Lisp, LispType.None>;
+export type Yield = DefineLisp<LispType.Yield, Lisp, LispType.None>;
+export type YieldDelegate = DefineLisp<LispType.YieldDelegate, Lisp, LispType.None>;
 export type New = DefineLisp<LispType.New, Lisp, Lisp[]>;
 export type None = DefineLisp<LispType.None, LispType.None, LispType.None>;
-export type LispFamily = Literal | If | InlineIf | IfCase | InlineIfCase | KeyVal | SpreadObject | SpreadArray | ArrayProp | Prop | PropOptional | Call | CallOptional | CreateArray | CreateObject | Group | Inverse | Not | Negative | Positive | Typeof | Delete | IncrementBefore | IncrementAfter | DecrementBefore | DecrementAfter | And | Or | NullishCoalescing | Instanceof | In | Assigns | SubractEquals | AddEquals | DivideEquals | PowerEquals | MultiplyEquals | ModulusEquals | BitNegateEquals | BitAndEquals | BitOrEquals | UnsignedShiftRightEquals | ShiftLeftEquals | ShiftRightEquals | AndEquals | OrEquals | NullishCoalescingEquals | BitAnd | BitOr | BitNegate | BitShiftLeft | BitShiftRight | BitUnsignedShiftRight | SmallerEqualThan | LargerEqualThan | SmallerThan | LargerThan | StrictNotEqual | NotEqual | StrictEqual | Equal | Plus | Minus | Divide | Power | Multiply | Modulus | Block | Expression | Return | Throw | Switch | SwitchCase | Var | Let | Const | Number | BigInt | GlobalSymbol | LiteralIndex | StringIndex | RegexIndex | Function | InlineFunction | ArrowFunction | Loop | LoopAction | Try | Void | Await | New | None;
+export type LispFamily = Literal | IfLisp | InlineIf | IfCase | InlineIfCase | Labeled | KeyValLisp | SpreadObjectLisp | SpreadArrayLisp | ArrayProp | PropLisp | PropOptional | Call | CallOptional | CreateArray | CreateObject | Group | Inverse | Not | Negative | Positive | Typeof | Delete | IncrementBefore | IncrementAfter | DecrementBefore | DecrementAfter | And | Or | NullishCoalescing | Instanceof | In | Assigns | SubractEquals | AddEquals | DivideEquals | PowerEquals | MultiplyEquals | ModulusEquals | BitNegateEquals | BitAndEquals | BitOrEquals | UnsignedShiftRightEquals | ShiftLeftEquals | ShiftRightEquals | AndEquals | OrEquals | NullishCoalescingEquals | BitAnd | BitOr | BitNegate | BitShiftLeft | BitShiftRight | BitUnsignedShiftRight | SmallerEqualThan | LargerEqualThan | SmallerThan | LargerThan | StrictNotEqual | NotEqual | StrictEqual | Equal | Plus | Minus | Divide | Power | Multiply | Modulus | InternalCode | Expression | Return | Throw | Switch | SwitchCase | Var | Let | Const | Number | BigInt | GlobalSymbol | LiteralIndex | StringIndex | RegexIndex | Function | InlineFunction | ArrowFunction | Loop | LoopAction | Try | Void | Await | Yield | YieldDelegate | New | Block | Internal | None;
 export interface IRegEx {
     regex: string;
     flags: string;
@@ -111,44 +117,25 @@ export interface IConstants {
     literals: Literal[];
     regexes: IRegEx[];
     eager: boolean;
+    maxDepth: number;
 }
 export interface IExecutionTree {
     tree: Lisp[];
     constants: IConstants;
 }
-type LispCallback<T> = (strings: IConstants, type: T, part: CodeString, res: string[], expect: string, ctx: {
-    lispTree: Lisp;
-}) => any;
-export declare class ParseError extends Error {
-    code: string;
-    constructor(message: string, code: string);
+export interface LispDepthCtx {
+    generatorDepth: number;
+    asyncDepth: number;
+    lispDepth: number;
 }
-export declare const expectTypes: Record<string, {
-    types: Record<string, RegExp>;
-    next: string[];
-}>;
-export declare function testMultiple(str: string, tests: RegExp[]): RegExpExecArray | null;
-export interface restDetails {
-    oneliner?: boolean;
-    words?: string[];
-    lastWord?: string;
-    lastAnyWord?: string;
-    regRes?: RegExpExecArray;
-    bodyContentAfterKeyword?: boolean;
-}
-export declare function restOfExp(constants: IConstants, part: CodeString, tests?: RegExp[], quote?: string, firstOpening?: string, closingsTests?: RegExp[], details?: restDetails): CodeString;
-export declare namespace restOfExp {
-    var next: string[];
+export interface LispCallbackCtx extends LispDepthCtx {
+    constants: IConstants;
+    type: string;
+    part: CodeString;
+    res: string[];
+    expect: string;
+    lispTree: Lisp;
 }
-export declare const setLispType: <T extends readonly string[]>(types: T, fn: LispCallback<T[number]>) => void;
-export declare function lispifyReturnExpr(constants: IConstants, str: CodeString): Return;
-export declare function lispifyBlock(str: CodeString, constants: IConstants, expression?: boolean): Lisp[];
-export declare function lispifyFunction(str: CodeString, constants: IConstants, expression?: boolean): Lisp[];
-export declare function insertSemicolons(constants: IConstants, str: CodeString): CodeString;
-export declare function checkRegex(str: string): IRegEx | null;
-export declare function extractConstants(constants: IConstants, str: string, currentEnclosure?: string): {
-    str: string;
-    length: number;
-};
-export default function parse(code: string, eager?: boolean, expression?: boolean): IExecutionTree;
-export {};
+export type LispCallback<T> = (ctx: LispCallbackCtx & {
+    type: T;
+}) => any;

package/dist/cjs/parser/lispTypes/conditionals.d.ts

@@ -0,0 +1,2 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerConditionalLispTypes({ createLisp, emptyString, extractStatementLabels, insertSemicolons, lispifyBlock, lispifyExpr, restOfExp, semiColon, setLispType, wrapLabeledStatement, }: RegisterLispTypesDeps): void;

package/dist/cjs/parser/lispTypes/conditionals.js

@@ -0,0 +1,135 @@
+const require_errors = require("../../utils/errors.js");
+const require_types = require("../../utils/types.js");
+require("../../utils/index.js");
+//#region src/parser/lispTypes/conditionals.ts
+function registerConditionalLispTypes({ createLisp, emptyString, extractStatementLabels, insertSemicolons, lispifyBlock, lispifyExpr, restOfExp, semiColon, setLispType, wrapLabeledStatement }) {
+	const elseIf = /^else(?![\w$])/;
+	const ifElse = /^if(?![\w$])/;
+	function extractIfElse(constants, part, depth = 0) {
+		if (depth > constants.maxDepth) throw new require_errors.SandboxCapabilityError("Maximum expression depth exceeded");
+		let count = 0;
+		let found = part.substring(0, 0);
+		let foundElse = emptyString;
+		let foundTrue;
+		let first = true;
+		let elseReg;
+		let details = {};
+		while ((found = restOfExp(constants, part.substring(found.end - part.start), [
+			elseIf,
+			ifElse,
+			semiColon
+		], void 0, void 0, void 0, details)).length || first) {
+			first = false;
+			const f = part.substring(found.end - part.start).toString();
+			if (f.startsWith("if")) {
+				found.end++;
+				count++;
+			} else if (f.startsWith("else")) {
+				foundTrue = part.substring(0, found.end - part.start);
+				found.end++;
+				count--;
+				if (!count) found.end--;
+			} else if (elseReg = /^;?\s*else(?![\w$])/.exec(f)) {
+				foundTrue = part.substring(0, found.end - part.start);
+				found.end += elseReg[0].length - 1;
+				count--;
+				if (!count) found.end -= elseReg[0].length - 1;
+			} else {
+				foundTrue = foundElse.length ? foundTrue : part.substring(0, found.end - part.start);
+				break;
+			}
+			if (!count) {
+				foundElse = extractIfElse(constants, part.substring(found.end - part.start + (/^;?\s*else(?![\w$])/.exec(f)?.[0].length || 0)), depth + 1).all;
+				break;
+			}
+			details = {};
+		}
+		foundTrue = foundTrue || part.substring(0, found.end - part.start);
+		return {
+			all: part.substring(0, Math.max(foundTrue.end, foundElse.end) - part.start),
+			true: foundTrue,
+			false: foundElse
+		};
+	}
+	setLispType(["if"], (ctx) => {
+		const { constants, part, res } = ctx;
+		const labels = extractStatementLabels(res[1]);
+		let condition = restOfExp(constants, part.substring(res[0].length), [], "(");
+		const ie = extractIfElse(constants, part.substring(res[1].length));
+		const startTrue = res[0].length - res[1].length + condition.length + 1;
+		let trueBlock = ie.true.substring(startTrue);
+		let elseBlock = ie.false;
+		condition = condition.trim();
+		trueBlock = trueBlock.trim();
+		elseBlock = elseBlock.trim();
+		if (!trueBlock.length || /^else(?![\w$])/.test(trueBlock.toString())) throw new SyntaxError("Unexpected token");
+		if (trueBlock.char(0) === "{") trueBlock = trueBlock.slice(1, -1);
+		if (elseBlock.char(0) === "{") elseBlock = elseBlock.slice(1, -1);
+		ctx.lispTree = wrapLabeledStatement(labels, createLisp({
+			op: require_types.LispType.If,
+			a: lispifyExpr(constants, condition, void 0, ctx),
+			b: createLisp({
+				op: require_types.LispType.IfCase,
+				a: lispifyBlock(trueBlock, constants, false, ctx),
+				b: lispifyBlock(elseBlock, constants, false, ctx)
+			})
+		}));
+	});
+	setLispType(["switch"], (ctx) => {
+		const { constants, part, res } = ctx;
+		const labels = extractStatementLabels(res[1]);
+		const test = restOfExp(constants, part.substring(res[0].length), [], "(");
+		let start = part.toString().indexOf("{", res[0].length + test.length + 1);
+		if (start === -1) throw new SyntaxError("Invalid switch");
+		let statement = insertSemicolons(constants, restOfExp(constants, part.substring(start + 1), [], "{"));
+		let caseFound;
+		const caseTest = /^\s*(case\s|default)\s*/;
+		const caseNoTestReg = /^\s*case\s*:/;
+		const cases = [];
+		let defaultFound = false;
+		while ((caseFound = caseTest.exec(statement.toString())) || caseNoTestReg.test(statement.toString())) {
+			if (!caseFound) throw new SyntaxError("Unexpected end of expression");
+			if (caseFound[1] === "default") {
+				if (defaultFound) throw new SyntaxError("Only one default switch case allowed");
+				defaultFound = true;
+			}
+			const cond = restOfExp(constants, statement.substring(caseFound[0].length), [/^:/]);
+			if (caseFound[1] !== "default" && !cond.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+			let found = emptyString;
+			let i = start = caseFound[0].length + cond.length + 1;
+			const bracketFound = /^\s*\{/.exec(statement.substring(i).toString());
+			let exprs = [];
+			if (bracketFound) {
+				i += bracketFound[0].length;
+				found = restOfExp(constants, statement.substring(i), [], "{");
+				i += found.length + 1;
+				exprs = lispifyBlock(found, constants, false, ctx);
+			} else {
+				const notEmpty = restOfExp(constants, statement.substring(i), [caseTest]);
+				if (!notEmpty.trim().length) {
+					exprs = [];
+					i += notEmpty.length;
+				} else {
+					while ((found = restOfExp(constants, statement.substring(i), [semiColon])).length) {
+						i += found.length + (statement.char(i + found.length) === ";" ? 1 : 0);
+						if (caseTest.test(statement.substring(i).toString())) break;
+					}
+					exprs = lispifyBlock(statement.substring(start, found.end - statement.start), constants, false, ctx);
+				}
+			}
+			statement = statement.substring(i);
+			cases.push(createLisp({
+				op: require_types.LispType.SwitchCase,
+				a: caseFound[1] === "default" ? require_types.LispType.None : lispifyExpr(constants, cond, void 0, ctx),
+				b: exprs
+			}));
+		}
+		ctx.lispTree = wrapLabeledStatement(labels, createLisp({
+			op: require_types.LispType.Switch,
+			a: lispifyExpr(constants, test, void 0, ctx),
+			b: cases
+		}));
+	});
+}
+//#endregion
+exports.registerConditionalLispTypes = registerConditionalLispTypes;

package/dist/cjs/parser/lispTypes/control.d.ts

@@ -0,0 +1,2 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerControlLispTypes({ ParseError, createLisp, emptyString, expandDestructure, extractStatementLabels, insertSemicolons, lispify, lispifyBlock, lispifyExpr, lispifyReturnExpr, restOfExp, semiColon, setLispType, startingExecpted, wrapLabeledStatement, }: RegisterLispTypesDeps): void;