@cuxt/sandboxjs 0.1.1 → 0.1.4

package/dist/esm/parser/lispTypes/operators.js

@@ -0,0 +1,254 @@
+import { CodeString } from "../../utils/CodeString.js";
+import { LispType } from "../../utils/types.js";
+import { isLisp } from "../../utils/ExecContext.js";
+import "../../utils/index.js";
+//#region src/parser/lispTypes/operators.ts
+function registerOperatorLispTypes({ createLisp, expandDestructure, expectTypes, getDestructurePatternSource, lispifyBlock, restOfExp, lispify, lispifyExpr, setLispType }) {
+	const inlineIfElse = /^:/;
+	const modifierTypes = {
+		inverse: LispType.Inverse,
+		not: LispType.Not,
+		positive: LispType.Positive,
+		negative: LispType.Negative,
+		typeof: LispType.Typeof,
+		delete: LispType.Delete
+	};
+	setLispType([
+		"inverse",
+		"not",
+		"negative",
+		"positive",
+		"typeof",
+		"delete"
+	], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
+		if (part.substring(extract.length + res[0].length).trim().toString().startsWith("**")) throw new SyntaxError("Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence");
+		ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, createLisp({
+			op: modifierTypes[type],
+			a: ctx.lispTree,
+			b: lispify(constants, extract, expectTypes[expect].next)
+		}), false, ctx);
+	});
+	setLispType(["taggedTemplate"], (ctx) => {
+		const { constants, part, res, expect } = ctx;
+		const literalIndex = res[1];
+		const [, templateStr, jsExprs] = constants.literals[parseInt(literalIndex)];
+		const stringParts = [];
+		const expressions = [];
+		let currentStr = "";
+		let i = 0;
+		while (i < templateStr.length) if (templateStr.substring(i, i + 2) === "${") {
+			let j = i + 2;
+			let exprIndex = "";
+			let isValidPlaceholder = false;
+			while (j < templateStr.length && templateStr[j] !== "}") {
+				exprIndex += templateStr[j];
+				j++;
+			}
+			if (j < templateStr.length && templateStr[j] === "}" && /^\d+$/.test(exprIndex)) isValidPlaceholder = true;
+			if (isValidPlaceholder) {
+				stringParts.push(currentStr);
+				currentStr = "";
+				expressions.push(jsExprs[parseInt(exprIndex)]);
+				i = j + 1;
+			} else {
+				currentStr += templateStr[i];
+				i++;
+			}
+		} else {
+			currentStr += templateStr[i];
+			i++;
+		}
+		stringParts.push(currentStr);
+		const stringsArray = stringParts.map((str) => createLisp({
+			op: LispType.StringIndex,
+			a: LispType.None,
+			b: String(constants.strings.push(str) - 1)
+		}));
+		const stringsArrayLisp = createLisp({
+			op: LispType.CreateArray,
+			a: createLisp({
+				op: LispType.None,
+				a: LispType.None,
+				b: LispType.None
+			}),
+			b: stringsArray
+		});
+		ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: LispType.Call,
+			a: ctx.lispTree,
+			b: [stringsArrayLisp, ...expressions]
+		}), false, ctx);
+	});
+	const incrementTypes = {
+		"++$": LispType.IncrementBefore,
+		"--$": LispType.DecrementBefore,
+		"$++": LispType.IncrementAfter,
+		"$--": LispType.DecrementAfter
+	};
+	setLispType(["incrementerBefore"], (ctx) => {
+		const { constants, part, res } = ctx;
+		const extract = restOfExp(constants, part.substring(2), [/^[^\s.\w$]/]);
+		ctx.lispTree = lispify(constants, part.substring(extract.length + 2), restOfExp.next, createLisp({
+			op: incrementTypes[res[0] + "$"],
+			a: lispify(constants, extract, expectTypes.incrementerBefore.next),
+			b: LispType.None
+		}), false, ctx);
+	});
+	setLispType(["incrementerAfter"], (ctx) => {
+		const { constants, part, res, expect } = ctx;
+		if (ctx.lispTree[0] === LispType.Number || ctx.lispTree[0] === LispType.BigInt || ctx.lispTree[0] === LispType.GlobalSymbol || ctx.lispTree[0] === LispType.StringIndex || ctx.lispTree[0] === LispType.LiteralIndex || ctx.lispTree[0] === LispType.RegexIndex) throw new SyntaxError("Invalid left-hand side expression in postfix operation");
+		ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: incrementTypes["$" + res[0]],
+			a: ctx.lispTree,
+			b: LispType.None
+		}), false, ctx);
+	});
+	const adderTypes = {
+		"&&": LispType.And,
+		"||": LispType.Or,
+		"??": LispType.NullishCoalescing,
+		instanceof: LispType.Instanceof,
+		in: LispType.In,
+		"=": LispType.Assign,
+		"-=": LispType.SubractEquals,
+		"+=": LispType.AddEquals,
+		"/=": LispType.DivideEquals,
+		"**=": LispType.PowerEquals,
+		"*=": LispType.MultiplyEquals,
+		"%=": LispType.ModulusEquals,
+		"^=": LispType.BitNegateEquals,
+		"&=": LispType.BitAndEquals,
+		"|=": LispType.BitOrEquals,
+		">>>=": LispType.UnsignedShiftRightEquals,
+		"<<=": LispType.ShiftLeftEquals,
+		">>=": LispType.ShiftRightEquals,
+		"&&=": LispType.AndEquals,
+		"||=": LispType.OrEquals,
+		"??=": LispType.NullishCoalescingEquals
+	};
+	setLispType([
+		"assign",
+		"assignModify",
+		"nullishCoalescing"
+	], (ctx) => {
+		const { constants, type, part, res } = ctx;
+		if (type !== "nullishCoalescing" && isLisp(ctx.lispTree) && (ctx.lispTree[0] === LispType.PropOptional || ctx.lispTree[0] === LispType.CallOptional)) throw new SyntaxError("Invalid left-hand side in assignment");
+		if (res[0] === "=") {
+			const patternStr = getDestructurePatternSource(ctx.lispTree);
+			if (patternStr) {
+				const rhsStr = part.substring(res[0].length).toString();
+				const tempName = `$$_da${Math.random().toString(36).slice(2)}`;
+				const expandedCode = `internal ${tempName} = (${rhsStr}); ${expandDestructure("", patternStr, tempName)}; ${tempName}`;
+				ctx.lispTree = createLisp({
+					op: LispType.InternalBlock,
+					a: lispifyBlock(new CodeString(expandedCode), constants, false, ctx),
+					b: LispType.None
+				});
+				return;
+			}
+		}
+		ctx.lispTree = createLisp({
+			op: adderTypes[res[0]],
+			a: ctx.lispTree,
+			b: lispify(constants, part.substring(res[0].length), expectTypes.assignment.next, void 0, false, {
+				...ctx,
+				lispDepth: ctx.lispDepth + 1
+			})
+		});
+	});
+	const opTypes = {
+		"&": LispType.BitAnd,
+		"|": LispType.BitOr,
+		"^": LispType.BitNegate,
+		"<<": LispType.BitShiftLeft,
+		">>": LispType.BitShiftRight,
+		">>>": LispType.BitUnsignedShiftRight,
+		"<=": LispType.SmallerEqualThan,
+		">=": LispType.LargerEqualThan,
+		"<": LispType.SmallerThan,
+		">": LispType.LargerThan,
+		"!==": LispType.StrictNotEqual,
+		"!=": LispType.NotEqual,
+		"===": LispType.StrictEqual,
+		"==": LispType.Equal,
+		"+": LispType.Plus,
+		"-": LispType.Minus,
+		"/": LispType.Divide,
+		"**": LispType.Power,
+		"*": LispType.Multiply,
+		"%": LispType.Modulus,
+		"&&": LispType.And,
+		"||": LispType.Or,
+		instanceof: LispType.Instanceof,
+		in: LispType.In
+	};
+	setLispType([
+		"power",
+		"opHigh",
+		"op",
+		"comparitor",
+		"bitwiseShift",
+		"bitwiseAnd",
+		"bitwiseXor",
+		"bitwiseOr",
+		"boolOpAnd",
+		"boolOpOr"
+	], (ctx) => {
+		const { constants, type, part, res } = ctx;
+		const next = [expectTypes.inlineIf.types.inlineIf, inlineIfElse];
+		switch (type) {
+			case "power": break;
+			case "opHigh": next.push(expectTypes.splitter.types.opHigh);
+			case "op": next.push(expectTypes.splitter.types.op);
+			case "comparitor": next.push(expectTypes.splitter.types.comparitor);
+			case "bitwiseShift": next.push(expectTypes.splitter.types.bitwiseShift);
+			case "bitwiseAnd": next.push(expectTypes.splitter.types.bitwiseAnd);
+			case "bitwiseXor": next.push(expectTypes.splitter.types.bitwiseXor);
+			case "bitwiseOr": next.push(expectTypes.splitter.types.bitwiseOr);
+			case "boolOpAnd": next.push(expectTypes.splitter.types.boolOpAnd);
+			case "boolOpOr": next.push(expectTypes.splitter.types.boolOpOr);
+		}
+		const extract = restOfExp(constants, part.substring(res[0].length), next);
+		ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, createLisp({
+			op: opTypes[res[0]],
+			a: ctx.lispTree,
+			b: lispify(constants, extract, expectTypes.splitter.next)
+		}), false, ctx);
+	});
+	setLispType(["inlineIf"], (ctx) => {
+		const { constants, part, res } = ctx;
+		let found = false;
+		const extract = part.substring(0, 0);
+		let quoteCount = 1;
+		while (!found && extract.length < part.length) {
+			extract.end = restOfExp(constants, part.substring(extract.length + 1), [expectTypes.inlineIf.types.inlineIf, inlineIfElse]).end;
+			if (part.char(extract.length) === "?") quoteCount++;
+			else quoteCount--;
+			if (!quoteCount) found = true;
+		}
+		extract.start = part.start + 1;
+		const falseExpr = part.substring(res[0].length + extract.length + 1);
+		if (!falseExpr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+		ctx.lispTree = createLisp({
+			op: LispType.InlineIf,
+			a: ctx.lispTree,
+			b: createLisp({
+				op: LispType.InlineIfCase,
+				a: lispifyExpr(constants, extract, void 0, {
+					...ctx,
+					lispDepth: ctx.lispDepth + 1
+				}),
+				b: lispifyExpr(constants, falseExpr, void 0, {
+					...ctx,
+					lispDepth: ctx.lispDepth + 1
+				})
+			})
+		});
+	});
+}
+//#endregion
+export { registerOperatorLispTypes };
+
+//# sourceMappingURL=operators.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","names":[],"sources":["../../../../src/parser/lispTypes/operators.ts"],"sourcesContent":["import { CodeString, isLisp, LispType } from '../../utils';\nimport type {\n  AddEquals,\n  And,\n  AndEquals,\n  Assigns,\n  BigInt as BigIntLisp,\n  BitAnd,\n  BitAndEquals,\n  BitNegate,\n  BitNegateEquals,\n  BitOr,\n  BitOrEquals,\n  BitShiftLeft,\n  BitShiftRight,\n  BitUnsignedShiftRight,\n  Call,\n  CreateArray,\n  DecrementAfter,\n  DecrementBefore,\n  Delete,\n  Divide,\n  DivideEquals,\n  Equal,\n  GlobalSymbol,\n  In,\n  IncrementAfter,\n  IncrementBefore,\n  InlineIf,\n  InlineIfCase,\n  Instanceof,\n  InternalCode,\n  Inverse,\n  LargerEqualThan,\n  LargerThan,\n  Lisp,\n  Minus,\n  Modulus,\n  ModulusEquals,\n  Multiply,\n  MultiplyEquals,\n  Negative,\n  Not,\n  NotEqual,\n  NullishCoalescing,\n  NullishCoalescingEquals,\n  Number as NumberLisp,\n  Or,\n  OrEquals,\n  Plus,\n  Positive,\n  Power,\n  PowerEquals,\n  ShiftLeftEquals,\n  ShiftRightEquals,\n  SmallerEqualThan,\n  SmallerThan,\n  StrictEqual,\n  StrictNotEqual,\n  StringIndex,\n  SubractEquals,\n  Typeof,\n  UnsignedShiftRightEquals,\n} from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerOperatorLispTypes({\n  createLisp,\n  expandDestructure,\n  expectTypes,\n  getDestructurePatternSource,\n  lispifyBlock,\n  restOfExp,\n  lispify,\n  lispifyExpr,\n  setLispType,\n}: RegisterLispTypesDeps) {\n  const inlineIfElse = /^:/;\n\n  const modifierTypes = {\n    inverse: LispType.Inverse,\n    not: LispType.Not,\n    positive: LispType.Positive,\n    negative: LispType.Negative,\n    typeof: LispType.Typeof,\n    delete: LispType.Delete,\n  } as const;\n\n  setLispType(['inverse', 'not', 'negative', 'positive', 'typeof', 'delete'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\\s.?\\w$]|\\?[^.])/]);\n    const remainingAfterOperand = part.substring(extract.length + res[0].length);\n    const remainingStr = remainingAfterOperand.trim().toString();\n    if (remainingStr.startsWith('**')) {\n      throw new SyntaxError(\n        'Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence',\n      );\n    }\n\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(extract.length + res[0].length),\n      restOfExp.next,\n      createLisp<Inverse | Not | Negative | Positive | Typeof | Delete>({\n        op: modifierTypes[type],\n        a: ctx.lispTree,\n        b: lispify(constants, extract, expectTypes[expect].next),\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['taggedTemplate'] as const, (ctx) => {\n    const { constants, part, res, expect } = ctx;\n    const literalIndex = res[1];\n    const literal = constants.literals[parseInt(literalIndex)];\n    const [, templateStr, jsExprs] = literal;\n    const stringParts: string[] = [];\n    const expressions: Lisp[] = [];\n    let currentStr = '';\n    let i = 0;\n\n    while (i < templateStr.length) {\n      if (templateStr.substring(i, i + 2) === '${') {\n        let j = i + 2;\n        let exprIndex = '';\n        let isValidPlaceholder = false;\n        while (j < templateStr.length && templateStr[j] !== '}') {\n          exprIndex += templateStr[j];\n          j++;\n        }\n        if (j < templateStr.length && templateStr[j] === '}' && /^\\d+$/.test(exprIndex)) {\n          isValidPlaceholder = true;\n        }\n\n        if (isValidPlaceholder) {\n          stringParts.push(currentStr);\n          currentStr = '';\n          expressions.push(jsExprs[parseInt(exprIndex)]);\n          i = j + 1;\n        } else {\n          currentStr += templateStr[i];\n          i++;\n        }\n      } else {\n        currentStr += templateStr[i];\n        i++;\n      }\n    }\n    stringParts.push(currentStr);\n\n    const stringsArray = stringParts.map((str) =>\n      createLisp<StringIndex>({\n        op: LispType.StringIndex,\n        a: LispType.None,\n        b: String(constants.strings.push(str) - 1),\n      }),\n    );\n\n    const stringsArrayLisp = createLisp<CreateArray>({\n      op: LispType.CreateArray,\n      a: createLisp({\n        op: LispType.None,\n        a: LispType.None,\n        b: LispType.None,\n      }),\n      b: stringsArray,\n    });\n\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length),\n      expectTypes[expect].next,\n      createLisp<Call>({\n        op: LispType.Call,\n        a: ctx.lispTree,\n        b: [stringsArrayLisp, ...expressions],\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  const incrementTypes = {\n    '++$': LispType.IncrementBefore,\n    '--$': LispType.DecrementBefore,\n    '$++': LispType.IncrementAfter,\n    '$--': LispType.DecrementAfter,\n  } as any;\n\n  setLispType(['incrementerBefore'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const extract = restOfExp(constants, part.substring(2), [/^[^\\s.\\w$]/]);\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(extract.length + 2),\n      restOfExp.next,\n      createLisp<IncrementBefore | DecrementBefore>({\n        op: incrementTypes[res[0] + '$'],\n        a: lispify(constants, extract, expectTypes.incrementerBefore.next),\n        b: LispType.None,\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['incrementerAfter'] as const, (ctx) => {\n    const { constants, part, res, expect } = ctx;\n    if (\n      ctx.lispTree[0] === LispType.Number ||\n      ctx.lispTree[0] === LispType.BigInt ||\n      ctx.lispTree[0] === LispType.GlobalSymbol ||\n      ctx.lispTree[0] === LispType.StringIndex ||\n      ctx.lispTree[0] === LispType.LiteralIndex ||\n      ctx.lispTree[0] === LispType.RegexIndex\n    ) {\n      throw new SyntaxError('Invalid left-hand side expression in postfix operation');\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length),\n      expectTypes[expect].next,\n      createLisp<IncrementAfter | DecrementAfter>({\n        op: incrementTypes['$' + res[0]],\n        a: ctx.lispTree,\n        b: LispType.None,\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  const adderTypes = {\n    '&&': LispType.And,\n    '||': LispType.Or,\n    '??': LispType.NullishCoalescing,\n    instanceof: LispType.Instanceof,\n    in: LispType.In,\n    '=': LispType.Assign,\n    '-=': LispType.SubractEquals,\n    '+=': LispType.AddEquals,\n    '/=': LispType.DivideEquals,\n    '**=': LispType.PowerEquals,\n    '*=': LispType.MultiplyEquals,\n    '%=': LispType.ModulusEquals,\n    '^=': LispType.BitNegateEquals,\n    '&=': LispType.BitAndEquals,\n    '|=': LispType.BitOrEquals,\n    '>>>=': LispType.UnsignedShiftRightEquals,\n    '<<=': LispType.ShiftLeftEquals,\n    '>>=': LispType.ShiftRightEquals,\n    '&&=': LispType.AndEquals,\n    '||=': LispType.OrEquals,\n    '??=': LispType.NullishCoalescingEquals,\n  } as any;\n\n  setLispType(['assign', 'assignModify', 'nullishCoalescing'] as const, (ctx) => {\n    const { constants, type, part, res } = ctx;\n    if (\n      type !== 'nullishCoalescing' &&\n      isLisp(ctx.lispTree) &&\n      (ctx.lispTree[0] === LispType.PropOptional || ctx.lispTree[0] === LispType.CallOptional)\n    ) {\n      throw new SyntaxError('Invalid left-hand side in assignment');\n    }\n    if (res[0] === '=') {\n      const patternStr = getDestructurePatternSource(ctx.lispTree);\n      if (patternStr) {\n        const rhsStr = part.substring(res[0].length).toString();\n        const tempName = `$$_da${Math.random().toString(36).slice(2)}`;\n        const expandedCode = `internal ${tempName} = (${rhsStr}); ${expandDestructure('', patternStr, tempName)}; ${tempName}`;\n        ctx.lispTree = createLisp<InternalCode>({\n          op: LispType.InternalBlock,\n          a: lispifyBlock(new CodeString(expandedCode), constants, false, ctx),\n          b: LispType.None,\n        });\n        return;\n      }\n    }\n    ctx.lispTree = createLisp<\n      | NullishCoalescing\n      | Assigns\n      | SubractEquals\n      | AddEquals\n      | DivideEquals\n      | PowerEquals\n      | MultiplyEquals\n      | ModulusEquals\n      | BitNegateEquals\n      | BitAndEquals\n      | BitOrEquals\n      | UnsignedShiftRightEquals\n      | ShiftLeftEquals\n      | ShiftRightEquals\n      | AndEquals\n      | OrEquals\n      | NullishCoalescingEquals\n    >({\n      op: adderTypes[res[0]],\n      a: ctx.lispTree,\n      b: lispify(\n        constants,\n        part.substring(res[0].length),\n        expectTypes.assignment.next,\n        undefined,\n        false,\n        { ...ctx, lispDepth: ctx.lispDepth + 1 },\n      ),\n    });\n  });\n\n  const opTypes = {\n    '&': LispType.BitAnd,\n    '|': LispType.BitOr,\n    '^': LispType.BitNegate,\n    '<<': LispType.BitShiftLeft,\n    '>>': LispType.BitShiftRight,\n    '>>>': LispType.BitUnsignedShiftRight,\n    '<=': LispType.SmallerEqualThan,\n    '>=': LispType.LargerEqualThan,\n    '<': LispType.SmallerThan,\n    '>': LispType.LargerThan,\n    '!==': LispType.StrictNotEqual,\n    '!=': LispType.NotEqual,\n    '===': LispType.StrictEqual,\n    '==': LispType.Equal,\n    '+': LispType.Plus,\n    '-': LispType.Minus,\n    '/': LispType.Divide,\n    '**': LispType.Power,\n    '*': LispType.Multiply,\n    '%': LispType.Modulus,\n    '&&': LispType.And,\n    '||': LispType.Or,\n    instanceof: LispType.Instanceof,\n    in: LispType.In,\n  } as any;\n\n  setLispType(\n    [\n      'power',\n      'opHigh',\n      'op',\n      'comparitor',\n      'bitwiseShift',\n      'bitwiseAnd',\n      'bitwiseXor',\n      'bitwiseOr',\n      'boolOpAnd',\n      'boolOpOr',\n    ] as const,\n    (ctx) => {\n      const { constants, type, part, res } = ctx;\n      const next = [expectTypes.inlineIf.types.inlineIf, inlineIfElse];\n      switch (type) {\n        case 'power':\n          break;\n        case 'opHigh':\n          next.push(expectTypes.splitter.types.opHigh);\n        case 'op':\n          next.push(expectTypes.splitter.types.op);\n        case 'comparitor':\n          next.push(expectTypes.splitter.types.comparitor);\n        case 'bitwiseShift':\n          next.push(expectTypes.splitter.types.bitwiseShift);\n        case 'bitwiseAnd':\n          next.push(expectTypes.splitter.types.bitwiseAnd);\n        case 'bitwiseXor':\n          next.push(expectTypes.splitter.types.bitwiseXor);\n        case 'bitwiseOr':\n          next.push(expectTypes.splitter.types.bitwiseOr);\n        case 'boolOpAnd':\n          next.push(expectTypes.splitter.types.boolOpAnd);\n        case 'boolOpOr':\n          next.push(expectTypes.splitter.types.boolOpOr);\n      }\n      const extract = restOfExp(constants, part.substring(res[0].length), next);\n      ctx.lispTree = lispify(\n        constants,\n        part.substring(extract.length + res[0].length),\n        restOfExp.next,\n        createLisp<\n          | BitAnd\n          | BitOr\n          | BitNegate\n          | BitShiftLeft\n          | BitShiftRight\n          | BitUnsignedShiftRight\n          | SmallerEqualThan\n          | LargerEqualThan\n          | SmallerThan\n          | LargerThan\n          | StrictNotEqual\n          | NotEqual\n          | StrictEqual\n          | Equal\n          | Plus\n          | Minus\n          | Divide\n          | Power\n          | Multiply\n          | Modulus\n          | And\n          | Or\n          | Instanceof\n          | In\n        >({\n          op: opTypes[res[0]],\n          a: ctx.lispTree,\n          b: lispify(constants, extract, expectTypes.splitter.next),\n        }),\n        false,\n        ctx,\n      );\n    },\n  );\n\n  setLispType(['inlineIf'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    let found = false;\n    const extract = part.substring(0, 0);\n    let quoteCount = 1;\n    while (!found && extract.length < part.length) {\n      extract.end = restOfExp(constants, part.substring(extract.length + 1), [\n        expectTypes.inlineIf.types.inlineIf,\n        inlineIfElse,\n      ]).end;\n      if (part.char(extract.length) === '?') {\n        quoteCount++;\n      } else {\n        quoteCount--;\n      }\n      if (!quoteCount) {\n        found = true;\n      }\n    }\n    extract.start = part.start + 1;\n    const falseExpr = part.substring(res[0].length + extract.length + 1);\n    if (!falseExpr.trimStart().length) {\n      throw new SyntaxError('Unexpected end of expression');\n    }\n    ctx.lispTree = createLisp<InlineIf>({\n      op: LispType.InlineIf,\n      a: ctx.lispTree,\n      b: createLisp<InlineIfCase>({\n        op: LispType.InlineIfCase,\n        a: lispifyExpr(constants, extract, undefined, { ...ctx, lispDepth: ctx.lispDepth + 1 }),\n        b: lispifyExpr(constants, falseExpr, undefined, { ...ctx, lispDepth: ctx.lispDepth + 1 }),\n      }),\n    });\n  });\n}\n"],"mappings":"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"}

package/dist/esm/parser/lispTypes/shared.d.ts

@@ -0,0 +1,38 @@
+import { CodeString } from '../../utils';
+import { ExtractLispA, ExtractLispB, ExtractLispOp, IConstants, Lisp, LispCallback, LispDepthCtx, LispItem, None, Return } from '../lisp';
+export interface RegisterLispTypesDeps {
+    NullLisp: None;
+    ParseError: new (message: string, code: string) => Error;
+    createLisp: <L extends Lisp>(obj: {
+        op: ExtractLispOp<L>;
+        a: ExtractLispA<L>;
+        b: ExtractLispB<L>;
+    }) => L;
+    emptyString: CodeString;
+    expectTypes: Record<string, {
+        types: Record<string, RegExp>;
+        next: string[];
+    }>;
+    expandDestructure: (keyword: string, patternStr: string, rhsStr: string) => string;
+    expandFunctionParamDestructure: (args: string[], funcBody: string) => {
+        args: string[];
+        body: string;
+    };
+    extractStatementLabels: (prefix?: string) => string[];
+    findPatternEndIdx: (s: string) => number;
+    getDestructurePatternSource: (tree: LispItem) => string | null;
+    insertSemicolons: (constants: IConstants, str: CodeString) => CodeString;
+    lispify: (constants: IConstants, part: CodeString, expected?: readonly string[], lispTree?: Lisp, topLevel?: boolean, depthCtx?: LispDepthCtx) => Lisp;
+    lispifyBlock: (str: CodeString, constants: IConstants, expression?: boolean, depthCtx?: LispDepthCtx) => Lisp[];
+    lispifyExpr: (constants: IConstants, str: CodeString, expected?: readonly string[], depthCtx?: LispDepthCtx) => Lisp;
+    lispifyFunction: (str: CodeString, constants: IConstants, expression?: boolean, depthCtx?: LispDepthCtx) => Lisp[];
+    lispifyReturnExpr: (constants: IConstants, str: CodeString) => Return;
+    restOfExp: ((constants: IConstants, part: CodeString, tests?: RegExp[], quote?: string, firstOpening?: string, closingsTests?: RegExp[], details?: any, depth?: number) => CodeString) & {
+        next: string[];
+    };
+    semiColon: RegExp;
+    setLispType: <T extends readonly string[]>(types: T, fn: LispCallback<T[number]>) => void;
+    splitByCommasDestructure: (s: string) => string[];
+    startingExecpted: readonly string[];
+    wrapLabeledStatement: <T extends Lisp>(labels: string[], statement: T) => Lisp;
+}

package/dist/esm/parser/lispTypes/structures.d.ts

@@ -0,0 +1,2 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerStructureLispTypes({ NullLisp, createLisp, emptyString, expectTypes, expandDestructure, findPatternEndIdx, lispify, lispifyBlock, lispifyExpr, restOfExp, setLispType, }: RegisterLispTypesDeps): void;

package/dist/esm/parser/lispTypes/structures.js

@@ -0,0 +1,190 @@
+import { CodeString } from "../../utils/CodeString.js";
+import { LispType, reservedWords } from "../../utils/types.js";
+import { isLisp } from "../../utils/ExecContext.js";
+import "../../utils/index.js";
+//#region src/parser/lispTypes/structures.ts
+function registerStructureLispTypes({ NullLisp, createLisp, emptyString, expectTypes, expandDestructure, findPatternEndIdx, lispify, lispifyBlock, lispifyExpr, restOfExp, setLispType }) {
+	const closingsCreate = {
+		createArray: /^\]/,
+		createObject: /^\}/,
+		group: /^\)/,
+		arrayProp: /^\]/,
+		call: /^\)/
+	};
+	const typesCreate = {
+		createArray: LispType.CreateArray,
+		createObject: LispType.CreateObject,
+		group: LispType.Group,
+		arrayProp: LispType.ArrayProp,
+		call: LispType.Call,
+		prop: LispType.Prop,
+		"?prop": LispType.PropOptional,
+		"?call": LispType.CallOptional
+	};
+	setLispType([
+		"createArray",
+		"createObject",
+		"group",
+		"arrayProp",
+		"call"
+	], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		let extract = emptyString;
+		const arg = [];
+		const argIsHole = [];
+		let end = false;
+		let i = res[0].length;
+		const start = i;
+		while (i < part.length && !end) {
+			extract = restOfExp(constants, part.substring(i), [closingsCreate[type], /^,/]);
+			i += extract.length;
+			if (extract.trim().length) {
+				arg.push(extract);
+				argIsHole.push(false);
+			} else if (type === "createArray" && part.char(i) === ",") {
+				arg.push(extract);
+				argIsHole.push(true);
+			}
+			if (part.char(i) !== ",") end = true;
+			else {
+				if (!extract.trim().length && type === "call") throw new SyntaxError("Unexpected end of expression");
+				if (!extract.trim().length && type === "createObject") throw new SyntaxError("Unexpected token ,");
+				i++;
+			}
+		}
+		const next = type === "createArray" || type === "createObject" || type === "group" ? [
+			"value",
+			"modifier",
+			"prop",
+			"incrementerBefore",
+			"assignment",
+			"expEnd"
+		] : [
+			"value",
+			"modifier",
+			"prop",
+			"incrementerBefore",
+			"expEnd"
+		];
+		let l;
+		let funcFound;
+		switch (type) {
+			case "group": {
+				const groupContentStr = part.substring(start, i).trim().toString();
+				if (groupContentStr.startsWith("{") || groupContentStr.startsWith("[")) {
+					const patternEnd = findPatternEndIdx(groupContentStr);
+					const patternStr = groupContentStr.slice(0, patternEnd).trim();
+					const afterPattern = groupContentStr.slice(patternEnd).trimStart();
+					if (afterPattern.startsWith("=")) {
+						const rhsStr = afterPattern.slice(1).trim();
+						const tempName = `$$_da${Math.random().toString(36).slice(2)}`;
+						const expandedCode = `internal ${tempName} = (${rhsStr}); ${expandDestructure("", patternStr, tempName)}; ${tempName}`;
+						l = createLisp({
+							op: LispType.InternalBlock,
+							a: lispifyBlock(new CodeString(expandedCode), constants, false, ctx),
+							b: LispType.None
+						});
+						break;
+					}
+				}
+			}
+			case "arrayProp": {
+				const arrayPropExpr = part.substring(start, i);
+				if (!arrayPropExpr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+				l = lispifyExpr(constants, arrayPropExpr, void 0, {
+					...ctx,
+					lispDepth: ctx.lispDepth + 1
+				});
+				break;
+			}
+			case "call":
+				l = arg.map((e) => lispify(constants, e, [...next, "spreadArray"], void 0, false, ctx));
+				break;
+			case "createArray":
+				l = arg.map((e, idx) => argIsHole[idx] ? createLisp({
+					op: LispType.Hole,
+					a: LispType.None,
+					b: LispType.None
+				}) : lispify(constants, e, [...next, "spreadArray"], void 0, false, ctx));
+				break;
+			case "createObject":
+				l = arg.map((str) => {
+					str = str.trimStart();
+					let value;
+					let key = "";
+					if (str.char(0) === "[") {
+						const innerExpr = restOfExp(constants, str.substring(1), [], "[");
+						const afterBracket = str.substring(1 + innerExpr.length + 1).trimStart();
+						key = lispify(constants, innerExpr, next);
+						if (afterBracket.length > 0 && afterBracket.char(0) === ":") value = lispify(constants, afterBracket.substring(1));
+						else if (afterBracket.length > 0 && afterBracket.char(0) === "(") value = lispify(constants, new CodeString("function" + afterBracket.toString()));
+						else throw new SyntaxError("Unexpected token in computed property");
+						return createLisp({
+							op: LispType.KeyVal,
+							a: key,
+							b: value
+						});
+					}
+					funcFound = expectTypes.expFunction.types.function.exec("function " + str);
+					if (funcFound) {
+						key = funcFound[3].trimStart();
+						value = lispify(constants, new CodeString("function " + str.toString().replace(key, "")));
+					} else {
+						const extract = restOfExp(constants, str, [/^:/]);
+						key = lispify(constants, extract, [...next, "spreadObject"]);
+						if (isLisp(key) && key[0] === LispType.SpreadObject) value = NullLisp;
+						else {
+							if (key[0] === LispType.Prop) key = key[2];
+							if (str.length > extract.length && str.char(extract.length) === ":") value = lispify(constants, str.substring(extract.length + 1));
+							else value = lispify(constants, extract, next);
+						}
+					}
+					return createLisp({
+						op: LispType.KeyVal,
+						a: key,
+						b: value
+					});
+				});
+				break;
+		}
+		const lisptype = type === "arrayProp" ? res[1] ? LispType.PropOptional : LispType.Prop : type === "call" ? res[1] ? LispType.CallOptional : LispType.Call : typesCreate[type];
+		const currentTree = createLisp({
+			op: lisptype,
+			a: ctx.lispTree,
+			b: l
+		});
+		if (lisptype === LispType.Group || lisptype === LispType.CreateArray || lisptype === LispType.CreateObject) currentTree.source = part.substring(start, i).toString();
+		ctx.lispTree = lispify(constants, part.substring(i + 1), expectTypes[expect].next, currentTree, false, ctx);
+	});
+	setLispType(["dot", "prop"], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		let prop = res[0];
+		let index = res[0].length;
+		let op = "prop";
+		if (type === "dot") {
+			if (res[1]) op = "?prop";
+			const matches = part.substring(res[0].length).toString().match(expectTypes.prop.types.prop);
+			if (matches && matches.length) {
+				prop = matches[0];
+				index = prop.length + res[0].length;
+			} else throw new SyntaxError("Hanging dot");
+		} else if (reservedWords.has(prop) && prop !== "this") throw new SyntaxError(`Unexpected token '${prop}'`);
+		ctx.lispTree = lispify(constants, part.substring(index), expectTypes[expect].next, createLisp({
+			op: typesCreate[op],
+			a: ctx.lispTree,
+			b: prop
+		}), false, ctx);
+	});
+	setLispType(["spreadArray", "spreadObject"], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		ctx.lispTree = createLisp({
+			op: type === "spreadArray" ? LispType.SpreadArray : LispType.SpreadObject,
+			a: LispType.None,
+			b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)
+		});
+	});
+}
+//#endregion
+export { registerStructureLispTypes };
+
+//# sourceMappingURL=structures.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structures.js","names":[],"sources":["../../../../src/parser/lispTypes/structures.ts"],"sourcesContent":["import { CodeString, isLisp, LispType, reservedWords } from '../../utils';\nimport type {\n  ArrayProp,\n  Call,\n  CallOptional,\n  CreateArray,\n  CreateObject,\n  Group,\n  InternalCode,\n  KeyValLisp,\n  Lisp,\n  PropLisp,\n  PropOptional,\n  SpreadArrayLisp,\n  SpreadObjectLisp,\n} from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerStructureLispTypes({\n  NullLisp,\n  createLisp,\n  emptyString,\n  expectTypes,\n  expandDestructure,\n  findPatternEndIdx,\n  lispify,\n  lispifyBlock,\n  lispifyExpr,\n  restOfExp,\n  setLispType,\n}: RegisterLispTypesDeps) {\n  type LispWithSource = Lisp & { source?: string };\n\n  const closingsCreate: { [type: string]: RegExp } = {\n    createArray: /^\\]/,\n    createObject: /^\\}/,\n    group: /^\\)/,\n    arrayProp: /^\\]/,\n    call: /^\\)/,\n  };\n\n  const typesCreate = {\n    createArray: LispType.CreateArray,\n    createObject: LispType.CreateObject,\n    group: LispType.Group,\n    arrayProp: LispType.ArrayProp,\n    call: LispType.Call,\n    prop: LispType.Prop,\n    '?prop': LispType.PropOptional,\n    '?call': LispType.CallOptional,\n  } as any;\n\n  setLispType(['createArray', 'createObject', 'group', 'arrayProp', 'call'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    let extract = emptyString;\n    const arg: CodeString[] = [];\n    const argIsHole: boolean[] = [];\n    let end = false;\n    let i = res[0].length;\n    const start = i;\n    while (i < part.length && !end) {\n      extract = restOfExp(constants, part.substring(i), [closingsCreate[type], /^,/]);\n      i += extract.length;\n      if (extract.trim().length) {\n        arg.push(extract);\n        argIsHole.push(false);\n      } else if (type === 'createArray' && part.char(i) === ',') {\n        arg.push(extract);\n        argIsHole.push(true);\n      }\n      if (part.char(i) !== ',') {\n        end = true;\n      } else {\n        if (!extract.trim().length && type === 'call') {\n          throw new SyntaxError('Unexpected end of expression');\n        }\n        if (!extract.trim().length && type === 'createObject') {\n          throw new SyntaxError('Unexpected token ,');\n        }\n        i++;\n      }\n    }\n    const next =\n      type === 'createArray' || type === 'createObject' || type === 'group'\n        ? ['value', 'modifier', 'prop', 'incrementerBefore', 'assignment', 'expEnd']\n        : ['value', 'modifier', 'prop', 'incrementerBefore', 'expEnd'];\n    let l: Lisp | Lisp[];\n\n    let funcFound: RegExpExecArray | null;\n    switch (type) {\n      case 'group': {\n        const groupContent = part.substring(start, i).trim();\n        const groupContentStr = groupContent.toString();\n        if (groupContentStr.startsWith('{') || groupContentStr.startsWith('[')) {\n          const patternEnd = findPatternEndIdx(groupContentStr);\n          const patternStr = groupContentStr.slice(0, patternEnd).trim();\n          const afterPattern = groupContentStr.slice(patternEnd).trimStart();\n          if (afterPattern.startsWith('=')) {\n            const rhsStr = afterPattern.slice(1).trim();\n            const tempName = `$$_da${Math.random().toString(36).slice(2)}`;\n            const expandedCode = `internal ${tempName} = (${rhsStr}); ${expandDestructure('', patternStr, tempName)}; ${tempName}`;\n            l = createLisp<InternalCode>({\n              op: LispType.InternalBlock,\n              a: lispifyBlock(new CodeString(expandedCode), constants, false, ctx),\n              b: LispType.None,\n            });\n            break;\n          }\n        }\n      }\n      case 'arrayProp': {\n        const arrayPropExpr = part.substring(start, i);\n        if (!arrayPropExpr.trimStart().length) {\n          throw new SyntaxError('Unexpected end of expression');\n        }\n        l = lispifyExpr(constants, arrayPropExpr, undefined, {\n          ...ctx,\n          lispDepth: ctx.lispDepth + 1,\n        });\n        break;\n      }\n      case 'call':\n        l = arg.map((e) => lispify(constants, e, [...next, 'spreadArray'], undefined, false, ctx));\n        break;\n      case 'createArray':\n        l = arg.map((e, idx) =>\n          argIsHole[idx]\n            ? createLisp({ op: LispType.Hole, a: LispType.None, b: LispType.None })\n            : lispify(constants, e, [...next, 'spreadArray'], undefined, false, ctx),\n        );\n        break;\n      case 'createObject':\n        l = arg.map((str) => {\n          str = str.trimStart();\n          let value: Lisp;\n          let key: string | Lisp = '';\n          if (str.char(0) === '[') {\n            const innerExpr = restOfExp(constants, str.substring(1), [], '[');\n            const afterBracket = str.substring(1 + innerExpr.length + 1).trimStart();\n            key = lispify(constants, innerExpr, next);\n            if (afterBracket.length > 0 && afterBracket.char(0) === ':') {\n              value = lispify(constants, afterBracket.substring(1));\n            } else if (afterBracket.length > 0 && afterBracket.char(0) === '(') {\n              value = lispify(constants, new CodeString('function' + afterBracket.toString()));\n            } else {\n              throw new SyntaxError('Unexpected token in computed property');\n            }\n            return createLisp<KeyValLisp>({\n              op: LispType.KeyVal,\n              a: key,\n              b: value,\n            });\n          }\n          funcFound = expectTypes.expFunction.types.function.exec('function ' + str);\n          if (funcFound) {\n            key = funcFound[3].trimStart();\n            value = lispify(\n              constants,\n              new CodeString('function ' + str.toString().replace(key, '')),\n            );\n          } else {\n            const extract = restOfExp(constants, str, [/^:/]);\n            key = lispify(constants, extract, [...next, 'spreadObject']) as PropLisp;\n\n            if (isLisp(key) && key[0] === LispType.SpreadObject) {\n              value = NullLisp;\n            } else {\n              if (key[0] === LispType.Prop) {\n                key = (key as PropLisp)[2];\n              }\n\n              if (str.length > extract.length && str.char(extract.length) === ':') {\n                value = lispify(constants, str.substring(extract.length + 1));\n              } else {\n                value = lispify(constants, extract, next);\n              }\n            }\n          }\n          return createLisp<KeyValLisp>({\n            op: LispType.KeyVal,\n            a: key,\n            b: value,\n          });\n        });\n        break;\n    }\n    const lisptype = (\n      type === 'arrayProp'\n        ? res[1]\n          ? LispType.PropOptional\n          : LispType.Prop\n        : type === 'call'\n          ? res[1]\n            ? LispType.CallOptional\n            : LispType.Call\n          : typesCreate[type]\n    ) as (typeof typesCreate)[keyof typeof typesCreate];\n    const currentTree = createLisp<\n      ArrayProp | PropLisp | Call | CreateObject | CreateArray | Group | PropOptional | CallOptional\n    >({\n      op: lisptype,\n      a: ctx.lispTree,\n      b: l,\n    }) as LispWithSource;\n    if (\n      lisptype === LispType.Group ||\n      lisptype === LispType.CreateArray ||\n      lisptype === LispType.CreateObject\n    ) {\n      currentTree.source = part.substring(start, i).toString();\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(i + 1),\n      expectTypes[expect].next,\n      currentTree,\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['dot', 'prop'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    let prop = res[0];\n    let index = res[0].length;\n    let op = 'prop';\n    if (type === 'dot') {\n      if (res[1]) {\n        op = '?prop';\n      }\n      const matches = part.substring(res[0].length).toString().match(expectTypes.prop.types.prop);\n      if (matches && matches.length) {\n        prop = matches[0];\n        index = prop.length + res[0].length;\n      } else {\n        throw new SyntaxError('Hanging dot');\n      }\n    } else if (reservedWords.has(prop) && prop !== 'this') {\n      throw new SyntaxError(`Unexpected token '${prop}'`);\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(index),\n      expectTypes[expect].next,\n      createLisp<PropLisp | PropOptional>({\n        op: typesCreate[op],\n        a: ctx.lispTree,\n        b: prop,\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['spreadArray', 'spreadObject'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    ctx.lispTree = createLisp<SpreadArrayLisp | SpreadObjectLisp>({\n      op: type === 'spreadArray' ? LispType.SpreadArray : LispType.SpreadObject,\n      a: LispType.None,\n      b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next),\n    });\n  });\n}\n"],"mappings":"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"}

package/dist/esm/parser/lispTypes/values.d.ts

@@ -0,0 +1,2 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerValueLispTypes({ createLisp, expectTypes, lispify, lispifyExpr, restOfExp, semiColon, setLispType, }: RegisterLispTypesDeps): void;

package/dist/esm/parser/lispTypes/values.js

@@ -0,0 +1,91 @@
+import { LispType } from "../../utils/types.js";
+import "../../utils/index.js";
+//#region src/parser/lispTypes/values.ts
+function registerValueLispTypes({ createLisp, expectTypes, lispify, lispifyExpr, restOfExp, semiColon, setLispType }) {
+	setLispType(["return", "throw"], (ctx) => {
+		const { constants, type, part, res } = ctx;
+		const expr = part.substring(res[0].length);
+		if (type === "throw" && !expr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+		ctx.lispTree = createLisp({
+			op: type === "return" ? LispType.Return : LispType.Throw,
+			a: LispType.None,
+			b: lispifyExpr(constants, expr, void 0, ctx)
+		});
+	});
+	setLispType([
+		"number",
+		"boolean",
+		"null",
+		"und",
+		"NaN",
+		"Infinity"
+	], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: type === "number" ? res[12] ? LispType.BigInt : LispType.Number : LispType.GlobalSymbol,
+			a: LispType.None,
+			b: res[12] ? res[1] : res[0]
+		}), false, ctx);
+	});
+	setLispType([
+		"string",
+		"literal",
+		"regex"
+	], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: type === "string" ? LispType.StringIndex : type === "literal" ? LispType.LiteralIndex : LispType.RegexIndex,
+			a: LispType.None,
+			b: res[1]
+		}), false, ctx);
+	});
+	setLispType(["void", "await"], (ctx) => {
+		const { constants, type, part, res, expect } = ctx;
+		const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
+		if (!extract.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+		ctx.lispTree = lispify(constants, part.substring(res[0].length + extract.length), expectTypes[expect].next, createLisp({
+			op: type === "void" ? LispType.Void : LispType.Await,
+			a: lispify(constants, extract),
+			b: LispType.None
+		}), false, ctx);
+	});
+	setLispType(["yield"], (ctx) => {
+		const { constants, part, res, expect, generatorDepth } = ctx;
+		if (generatorDepth === 0) throw new SyntaxError("Unexpected token");
+		const isDelegate = res[0].trimEnd().endsWith("*");
+		const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
+		if (isDelegate && !extract.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+		ctx.lispTree = lispify(constants, part.substring(res[0].length + extract.length), expectTypes[expect].next, createLisp({
+			op: isDelegate ? LispType.YieldDelegate : LispType.Yield,
+			a: lispify(constants, extract),
+			b: LispType.None
+		}), false, ctx);
+	});
+	setLispType(["new"], (ctx) => {
+		const { constants, part, res } = ctx;
+		let i = res[0].length;
+		const obj = restOfExp(constants, part.substring(i), [], void 0, "(");
+		if (!obj.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+		i += obj.length + 1;
+		const args = [];
+		if (part.char(i - 1) === "(") {
+			const argsString = restOfExp(constants, part.substring(i), [], "(");
+			i += argsString.length + 1;
+			let found;
+			let j = 0;
+			while ((found = restOfExp(constants, argsString.substring(j), [/^,/])).length) {
+				j += found.length + 1;
+				args.push(found.trim());
+			}
+		}
+		ctx.lispTree = lispify(constants, part.substring(i), expectTypes.expEdge.next, createLisp({
+			op: LispType.New,
+			a: lispify(constants, obj, expectTypes.initialize.next),
+			b: args.map((arg) => lispify(constants, arg, expectTypes.initialize.next))
+		}), false, ctx);
+	});
+}
+//#endregion
+export { registerValueLispTypes };
+
+//# sourceMappingURL=values.js.map