@cuxt/sandboxjs 0.1.1 → 0.1.4

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

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

package/dist/esm/executor/ops/unary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unary.js","names":[],"sources":["../../../../src/executor/ops/unary.ts"],"sourcesContent":["import { addOps, assignCheck } from '../executorUtils';\nimport type { LispItem } from '../../parser';\nimport { LispType, Prop, sanitizeProp } from '../../utils';\n\naddOps<unknown, unknown>(LispType.Not, ({ done, b }) => done(undefined, !b));\n\naddOps<unknown, number>(LispType.Inverse, ({ done, b }) => done(undefined, ~b));\n\naddOps<unknown, unknown, Prop<any>>(LispType.IncrementBefore, ({ done, obj, context }) => {\n  assignCheck(obj, context);\n  done(undefined, ++obj.context[obj.prop]);\n});\n\naddOps<unknown, unknown, Prop<any>>(LispType.IncrementAfter, ({ done, obj, context }) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop]++);\n});\n\naddOps<unknown, unknown, Prop<any>>(LispType.DecrementBefore, ({ done, obj, context }) => {\n  assignCheck(obj, context);\n  done(undefined, --obj.context[obj.prop]);\n});\n\naddOps<unknown, unknown, Prop<any>>(LispType.DecrementAfter, ({ done, obj, context }) => {\n  assignCheck(obj, context);\n  done(undefined, obj.context[obj.prop]--);\n});\n\naddOps<number, number>(LispType.Positive, ({ done, b }) => done(undefined, +b));\n\naddOps<number, number>(LispType.Negative, ({ done, b }) => done(undefined, -b));\n\naddOps<unknown, LispItem>(\n  LispType.Typeof,\n  ({ exec, done, ticks, b, context, scope, internal, generatorYield }) => {\n    exec(\n      ticks,\n      b,\n      scope,\n      context,\n      (e, prop) => {\n        done(undefined, typeof sanitizeProp(prop, context));\n      },\n      undefined,\n      internal,\n      generatorYield,\n    );\n  },\n);\n\naddOps<unknown, unknown>(LispType.Delete, ({ done, context, bobj }) => {\n  if (!(bobj instanceof Prop)) {\n    done(undefined, true);\n    return;\n  }\n  assignCheck(bobj, context, 'delete');\n  if (bobj.isVariable) {\n    done(undefined, false);\n    return;\n  }\n  done(undefined, delete (bobj.context as any)?.[bobj.prop]);\n});\n\naddOps(LispType.Void, ({ done }) => {\n  done();\n});\n"],"mappings":";;;;;;;AAIA,OAAyB,SAAS,MAAM,EAAE,MAAM,QAAQ,KAAK,KAAA,GAAW,CAAC,EAAE,CAAC;AAE5E,OAAwB,SAAS,UAAU,EAAE,MAAM,QAAQ,KAAK,KAAA,GAAW,CAAC,EAAE,CAAC;AAE/E,OAAoC,SAAS,kBAAkB,EAAE,MAAM,KAAK,cAAc;AACxF,aAAY,KAAK,QAAQ;AACzB,MAAK,KAAA,GAAW,EAAE,IAAI,QAAQ,IAAI,MAAM;EACxC;AAEF,OAAoC,SAAS,iBAAiB,EAAE,MAAM,KAAK,cAAc;AACvF,aAAY,KAAK,QAAQ;AACzB,MAAK,KAAA,GAAW,IAAI,QAAQ,IAAI,QAAQ;EACxC;AAEF,OAAoC,SAAS,kBAAkB,EAAE,MAAM,KAAK,cAAc;AACxF,aAAY,KAAK,QAAQ;AACzB,MAAK,KAAA,GAAW,EAAE,IAAI,QAAQ,IAAI,MAAM;EACxC;AAEF,OAAoC,SAAS,iBAAiB,EAAE,MAAM,KAAK,cAAc;AACvF,aAAY,KAAK,QAAQ;AACzB,MAAK,KAAA,GAAW,IAAI,QAAQ,IAAI,QAAQ;EACxC;AAEF,OAAuB,SAAS,WAAW,EAAE,MAAM,QAAQ,KAAK,KAAA,GAAW,CAAC,EAAE,CAAC;AAE/E,OAAuB,SAAS,WAAW,EAAE,MAAM,QAAQ,KAAK,KAAA,GAAW,CAAC,EAAE,CAAC;AAE/E,OACE,SAAS,SACR,EAAE,MAAM,MAAM,OAAO,GAAG,SAAS,OAAO,UAAU,qBAAqB;AACtE,MACE,OACA,GACA,OACA,UACC,GAAG,SAAS;AACX,OAAK,KAAA,GAAW,OAAO,aAAa,MAAM,QAAQ,CAAC;IAErD,KAAA,GACA,UACA,eACD;EAEJ;AAED,OAAyB,SAAS,SAAS,EAAE,MAAM,SAAS,WAAW;AACrE,KAAI,EAAE,gBAAgB,OAAO;AAC3B,OAAK,KAAA,GAAW,KAAK;AACrB;;AAEF,aAAY,MAAM,SAAS,SAAS;AACpC,KAAI,KAAK,YAAY;AACnB,OAAK,KAAA,GAAW,MAAM;AACtB;;AAEF,MAAK,KAAA,GAAW,OAAQ,KAAK,UAAkB,KAAK,MAAM;EAC1D;AAEF,OAAO,SAAS,OAAO,EAAE,WAAW;AAClC,OAAM;EACN"}

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

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

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

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

package/dist/esm/executor/ops/variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.js","names":[],"sources":["../../../../src/executor/ops/variables.ts"],"sourcesContent":["import { addOps } from '../executorUtils';\nimport { LispType, Prop, VarType } from '../../utils';\n\naddOps(LispType.Return, ({ done, b }) => done(undefined, b));\n\naddOps<string, unknown, unknown, Prop>(LispType.Var, ({ done, a, b, scope, bobj, internal }) => {\n  done(undefined, scope.declare(a, VarType.var, b, bobj?.isGlobal || false, internal));\n});\n\naddOps<string, unknown, unknown, Prop>(LispType.Let, ({ done, a, b, scope, bobj, internal }) => {\n  done(undefined, scope.declare(a, VarType.let, b, bobj?.isGlobal || false, internal));\n});\n\naddOps<string, unknown, unknown, Prop>(LispType.Const, ({ done, a, b, scope, bobj, internal }) => {\n  done(undefined, scope.declare(a, VarType.const, b, bobj?.isGlobal || false, internal));\n});\n"],"mappings":";;;;;AAGA,OAAO,SAAS,SAAS,EAAE,MAAM,QAAQ,KAAK,KAAA,GAAW,EAAE,CAAC;AAE5D,OAAuC,SAAS,MAAM,EAAE,MAAM,GAAG,GAAG,OAAO,MAAM,eAAe;AAC9F,MAAK,KAAA,GAAW,MAAM,QAAQ,GAAG,QAAQ,KAAK,GAAG,MAAM,YAAY,OAAO,SAAS,CAAC;EACpF;AAEF,OAAuC,SAAS,MAAM,EAAE,MAAM,GAAG,GAAG,OAAO,MAAM,eAAe;AAC9F,MAAK,KAAA,GAAW,MAAM,QAAQ,GAAG,QAAQ,KAAK,GAAG,MAAM,YAAY,OAAO,SAAS,CAAC;EACpF;AAEF,OAAuC,SAAS,QAAQ,EAAE,MAAM,GAAG,GAAG,OAAO,MAAM,eAAe;AAChG,MAAK,KAAA,GAAW,MAAM,QAAQ,GAAG,QAAQ,OAAO,GAAG,MAAM,YAAY,OAAO,SAAS,CAAC;EACtF"}

package/dist/esm/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/esm/executor/opsRegistry.js

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

package/dist/esm/executor/opsRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opsRegistry.js","names":[],"sources":["../../../src/executor/opsRegistry.ts"],"sourcesContent":["/**\n * Ops registry — kept separate from executorUtils.ts so that ops/*.ts files\n * can import addOps without creating a circular initialization problem.\n *\n * executorUtils.ts imports from here; ops/*.ts imports from here too.\n * No imports from executorUtils.ts allowed in this file.\n */\nimport { LispType } from '../utils';\nimport type { LispItem } from '../parser';\nimport type { IExecContext, Ticks } from '../utils';\nimport type { Scope } from '../utils';\nimport type { YieldValue, Done } from './executorUtils';\n\nexport type ControlFlowAction = 'break' | 'continue';\n\nexport interface ControlFlowTarget {\n  label?: string;\n  acceptsBreak: boolean;\n  acceptsContinue: boolean;\n  acceptsUnlabeledBreak: boolean;\n  acceptsUnlabeledContinue: boolean;\n}\n\nexport type ControlFlowTargets = readonly ControlFlowTarget[] | undefined;\n\nexport type Execution = <T = any>(\n  ticks: Ticks,\n  tree: LispItem,\n  scope: Scope,\n  context: IExecContext,\n  done: Done<T>,\n  statementLabels: ControlFlowTargets,\n  internal: boolean,\n  generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined,\n) => void;\n\nexport type OpsCallbackParams<a, b, obj, bobj> = {\n  op: LispType;\n  exec: Execution;\n  a: a;\n  b: b;\n  obj: obj;\n  bobj: bobj;\n  ticks: Ticks;\n  tree: LispItem;\n  scope: Scope;\n  context: IExecContext;\n  done: Done;\n  statementLabels: ControlFlowTargets;\n  internal: boolean;\n  generatorYield: ((yv: YieldValue, done?: Done) => void) | undefined;\n};\n\ntype OpCallback<a, b, obj, bobj> = (params: OpsCallbackParams<a, b, obj, bobj>) => void;\n\nexport const ops = new Map<LispType, OpCallback<any, any, any, any>>();\n\nexport function addOps<a = unknown, b = unknown, obj = unknown, bobj = unknown>(\n  type: LispType,\n  cb: OpCallback<a, b, obj, bobj>,\n) {\n  ops.set(type, cb);\n}\n"],"mappings":";AAuDA,IAAa,sBAAM,IAAI,KAA+C;AAEtE,SAAgB,OACd,MACA,IACA;AACA,KAAI,IAAI,MAAM,GAAG"}

package/dist/esm/package.json

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

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

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

package/dist/esm/parser/index.js

@@ -0,0 +1 @@
+import "./parserUtils.js";

package/{build/parser.d.ts → dist/esm/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/esm/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/esm/parser/lispTypes/conditionals.js

@@ -0,0 +1,137 @@
+import { SandboxCapabilityError } from "../../utils/errors.js";
+import { LispType } from "../../utils/types.js";
+import "../../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 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: LispType.If,
+			a: lispifyExpr(constants, condition, void 0, ctx),
+			b: createLisp({
+				op: 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: LispType.SwitchCase,
+				a: caseFound[1] === "default" ? LispType.None : lispifyExpr(constants, cond, void 0, ctx),
+				b: exprs
+			}));
+		}
+		ctx.lispTree = wrapLabeledStatement(labels, createLisp({
+			op: LispType.Switch,
+			a: lispifyExpr(constants, test, void 0, ctx),
+			b: cases
+		}));
+	});
+}
+//#endregion
+export { registerConditionalLispTypes };
+
+//# sourceMappingURL=conditionals.js.map

package/dist/esm/parser/lispTypes/conditionals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.js","names":[],"sources":["../../../../src/parser/lispTypes/conditionals.ts"],"sourcesContent":["import { CodeString, LispType, SandboxCapabilityError } from '../../utils';\nimport type { IConstants, IfLisp, IfCase, Lisp, Switch, SwitchCase } from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerConditionalLispTypes({\n  createLisp,\n  emptyString,\n  extractStatementLabels,\n  insertSemicolons,\n  lispifyBlock,\n  lispifyExpr,\n  restOfExp,\n  semiColon,\n  setLispType,\n  wrapLabeledStatement,\n}: RegisterLispTypesDeps) {\n  const inlineIfElse = /^:/;\n  const elseIf = /^else(?![\\w$])/;\n  const ifElse = /^if(?![\\w$])/;\n\n  function extractIfElse(constants: IConstants, part: CodeString, depth = 0) {\n    if (depth > constants.maxDepth) {\n      throw new SandboxCapabilityError('Maximum expression depth exceeded');\n    }\n    let count = 0;\n    let found = part.substring(0, 0);\n    let foundElse = emptyString;\n    let foundTrue: CodeString | undefined;\n    let first = true;\n    let elseReg: RegExpExecArray | null;\n    let details: any = {};\n    while (\n      (found = restOfExp(\n        constants,\n        part.substring(found.end - part.start),\n        [elseIf, ifElse, semiColon],\n        undefined,\n        undefined,\n        undefined,\n        details,\n      )).length ||\n      first\n    ) {\n      first = false;\n      const f = part.substring(found.end - part.start).toString();\n\n      if (f.startsWith('if')) {\n        found.end++;\n        count++;\n      } else if (f.startsWith('else')) {\n        foundTrue = part.substring(0, found.end - part.start);\n        found.end++;\n        count--;\n        if (!count) {\n          found.end--;\n        }\n      } else if ((elseReg = /^;?\\s*else(?![\\w$])/.exec(f))) {\n        foundTrue = part.substring(0, found.end - part.start);\n        found.end += elseReg[0].length - 1;\n        count--;\n        if (!count) {\n          found.end -= elseReg[0].length - 1;\n        }\n      } else {\n        foundTrue = foundElse.length ? foundTrue : part.substring(0, found.end - part.start);\n        break;\n      }\n      if (!count) {\n        const ie = extractIfElse(\n          constants,\n          part.substring(found.end - part.start + (/^;?\\s*else(?![\\w$])/.exec(f)?.[0].length || 0)),\n          depth + 1,\n        );\n        foundElse = ie.all;\n        break;\n      }\n      details = {};\n    }\n    foundTrue = foundTrue || part.substring(0, found.end - part.start);\n    return {\n      all: part.substring(0, Math.max(foundTrue.end, foundElse.end) - part.start),\n      true: foundTrue,\n      false: foundElse,\n    };\n  }\n\n  setLispType(['if'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const labels = extractStatementLabels(res[1]);\n    let condition = restOfExp(constants, part.substring(res[0].length), [], '(');\n    const ie = extractIfElse(constants, part.substring(res[1].length));\n    const startTrue = res[0].length - res[1].length + condition.length + 1;\n\n    let trueBlock = ie.true.substring(startTrue);\n    let elseBlock = ie.false;\n\n    condition = condition.trim();\n    trueBlock = trueBlock.trim();\n    elseBlock = elseBlock.trim();\n\n    if (!trueBlock.length || /^else(?![\\w$])/.test(trueBlock.toString())) {\n      throw new SyntaxError('Unexpected token');\n    }\n    if (trueBlock.char(0) === '{') trueBlock = trueBlock.slice(1, -1);\n    if (elseBlock.char(0) === '{') elseBlock = elseBlock.slice(1, -1);\n    ctx.lispTree = wrapLabeledStatement(\n      labels,\n      createLisp<IfLisp>({\n        op: LispType.If,\n        a: lispifyExpr(constants, condition, undefined, ctx),\n        b: createLisp<IfCase>({\n          op: LispType.IfCase,\n          a: lispifyBlock(trueBlock, constants, false, ctx),\n          b: lispifyBlock(elseBlock, constants, false, ctx),\n        }),\n      }),\n    ) as Lisp;\n  });\n\n  setLispType(['switch'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const labels = extractStatementLabels(res[1]);\n    const test = restOfExp(constants, part.substring(res[0].length), [], '(');\n    let start = part.toString().indexOf('{', res[0].length + test.length + 1);\n    if (start === -1) throw new SyntaxError('Invalid switch');\n    let statement = insertSemicolons(\n      constants,\n      restOfExp(constants, part.substring(start + 1), [], '{'),\n    );\n    let caseFound: RegExpExecArray | null;\n    const caseTest = /^\\s*(case\\s|default)\\s*/;\n    const caseNoTestReg = /^\\s*case\\s*:/;\n    const cases: SwitchCase[] = [];\n    let defaultFound = false;\n    while (\n      (caseFound = caseTest.exec(statement.toString())) ||\n      caseNoTestReg.test(statement.toString())\n    ) {\n      if (!caseFound) {\n        throw new SyntaxError('Unexpected end of expression');\n      }\n      if (caseFound[1] === 'default') {\n        if (defaultFound) throw new SyntaxError('Only one default switch case allowed');\n        defaultFound = true;\n      }\n      const cond = restOfExp(constants, statement.substring(caseFound[0].length), [/^:/]);\n      if (caseFound[1] !== 'default' && !cond.trimStart().length) {\n        throw new SyntaxError('Unexpected end of expression');\n      }\n      let found = emptyString;\n      let i = (start = caseFound[0].length + cond.length + 1);\n      const bracketFound = /^\\s*\\{/.exec(statement.substring(i).toString());\n      let exprs: Lisp[] = [];\n      if (bracketFound) {\n        i += bracketFound[0].length;\n        found = restOfExp(constants, statement.substring(i), [], '{');\n        i += found.length + 1;\n        exprs = lispifyBlock(found, constants, false, ctx);\n      } else {\n        const notEmpty = restOfExp(constants, statement.substring(i), [caseTest]);\n        if (!notEmpty.trim().length) {\n          exprs = [];\n          i += notEmpty.length;\n        } else {\n          while ((found = restOfExp(constants, statement.substring(i), [semiColon])).length) {\n            i += found.length + (statement.char(i + found.length) === ';' ? 1 : 0);\n            if (caseTest.test(statement.substring(i).toString())) {\n              break;\n            }\n          }\n          exprs = lispifyBlock(\n            statement.substring(start, found.end - statement.start),\n            constants,\n            false,\n            ctx,\n          );\n        }\n      }\n      statement = statement.substring(i);\n      cases.push(\n        createLisp<SwitchCase>({\n          op: LispType.SwitchCase,\n          a:\n            caseFound[1] === 'default'\n              ? LispType.None\n              : lispifyExpr(constants, cond, undefined, ctx),\n          b: exprs,\n        }),\n      );\n    }\n    ctx.lispTree = wrapLabeledStatement(\n      labels,\n      createLisp<Switch>({\n        op: LispType.Switch,\n        a: lispifyExpr(constants, test, undefined, ctx),\n        b: cases,\n      }),\n    ) as Lisp;\n  });\n\n  void inlineIfElse;\n}\n"],"mappings":"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"}

package/dist/esm/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;