@cuxt/sandboxjs 0.1.1 → 0.1.3

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

@@ -0,0 +1,206 @@
+import { CodeString } from "../../utils/CodeString.js";
+import { LispType } from "../../utils/types.js";
+import "../../utils/index.js";
+//#region src/parser/lispTypes/control.ts
+function registerControlLispTypes({ ParseError, createLisp, emptyString, expandDestructure, extractStatementLabels, insertSemicolons, lispify, lispifyBlock, lispifyExpr, lispifyReturnExpr, restOfExp, semiColon, setLispType, startingExecpted, wrapLabeledStatement }) {
+	const iteratorRegex = /^((let|var|const|internal)\s+)?\s*([a-zA-Z$_][a-zA-Z\d$_]*)\s+(in|of)(?![\w$])/;
+	const iteratorDestructureRegex = /^((let|var|const|internal)\s+)\s*([[{])/;
+	const ofStart2 = lispify({ maxDepth: 10 }, new CodeString("let $$iterator = $$obj[Symbol.iterator]()"), ["initialize"]);
+	const ofStart3 = lispify({ maxDepth: 10 }, new CodeString("let $$next = $$iterator.next()"), ["initialize"]);
+	const ofCondition = lispify({ maxDepth: 10 }, new CodeString("return !$$next.done"), ["initialize"]);
+	const ofStep = lispify({ maxDepth: 10 }, new CodeString("$$next = $$iterator.next()"));
+	const asyncOfStart2 = lispify({ maxDepth: 10 }, new CodeString("let $$iterator = $$obj"), ["initialize"]);
+	const asyncOfStart3 = lispify({ maxDepth: 10 }, new CodeString("let $$next = $$iterator.next()"), ["initialize"]);
+	const asyncOfStep = lispify({ maxDepth: 10 }, new CodeString("$$next = $$iterator.next()"));
+	const inStart2 = lispify({ maxDepth: 10 }, new CodeString("let $$keys = Object.keys($$obj)"), ["initialize"]);
+	const inStart3 = lispify({ maxDepth: 10 }, new CodeString("let $$keyIndex = 0"), ["initialize"]);
+	const inStep = lispify({ maxDepth: 10 }, new CodeString("$$keyIndex++"));
+	const inCondition = lispify({ maxDepth: 10 }, new CodeString("return $$keyIndex < $$keys.length"), ["initialize"]);
+	setLispType([
+		"for",
+		"do",
+		"while"
+	], (ctx) => {
+		const { constants, type, part, res } = ctx;
+		const labels = extractStatementLabels(res[1]);
+		let i = 0;
+		let startStep = LispType.True;
+		let startInternal = [];
+		let getIterator = LispType.None;
+		let beforeStep = LispType.None;
+		let checkFirst = LispType.True;
+		let condition;
+		let step = LispType.True;
+		let body;
+		const isForAwait = type === "for" && res[2] ? LispType.True : LispType.None;
+		switch (type) {
+			case "while": {
+				i = part.toString().indexOf("(") + 1;
+				const extract = restOfExp(constants, part.substring(i), [], "(");
+				if (!extract.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+				condition = lispifyReturnExpr(constants, extract);
+				body = restOfExp(constants, part.substring(i + extract.length + 1)).trim();
+				if (body.char(0) === "{") body = body.slice(1, -1);
+				break;
+			}
+			case "for": {
+				i = part.toString().indexOf("(") + 1;
+				const args = [];
+				let extract2 = emptyString;
+				for (let k = 0; k < 3; k++) {
+					extract2 = restOfExp(constants, part.substring(i), [/^[;)]/]);
+					args.push(extract2.trim());
+					i += extract2.length + 1;
+					if (part.char(i - 1) === ")") break;
+				}
+				let iterator;
+				let iteratorDestructure;
+				if (args.length === 1 && (iterator = iteratorRegex.exec(args[0].toString()))) {
+					const iterableExpr = args[0].substring(iterator[0].length);
+					if (!iterableExpr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+					if (iterator[4] === "of") {
+						getIterator = lispifyReturnExpr(constants, iterableExpr);
+						startInternal = isForAwait ? [asyncOfStart2, asyncOfStart3] : [ofStart2, ofStart3];
+						condition = ofCondition;
+						step = isForAwait ? asyncOfStep : ofStep;
+						beforeStep = lispify(constants, new CodeString((iterator[1] || "let ") + iterator[3] + " = $$next.value"), ["initialize"]);
+					} else {
+						if (isForAwait) throw new SyntaxError("Unexpected token 'in'");
+						getIterator = lispifyReturnExpr(constants, iterableExpr);
+						startInternal = [inStart2, inStart3];
+						step = inStep;
+						condition = inCondition;
+						beforeStep = lispify(constants, new CodeString((iterator[1] || "let ") + iterator[3] + " = $$keys[$$keyIndex]"), ["initialize"]);
+					}
+				} else if (args.length === 1 && (iteratorDestructure = iteratorDestructureRegex.exec(args[0].toString()))) {
+					const keyword = iteratorDestructure[1].trim();
+					const openBracket = iteratorDestructure[3];
+					const closeBracket = openBracket === "[" ? "]" : "}";
+					const keywordPrefixLen = iteratorDestructure[0].length - 1;
+					const patternContent = restOfExp(constants, args[0].substring(keywordPrefixLen + 1), [], openBracket);
+					const patternStr = openBracket + patternContent.toString() + closeBracket;
+					const afterClose = args[0].substring(keywordPrefixLen + 1 + patternContent.length + 1).trimStart();
+					const inOfMatch = /^(in|of)(?![\w$])\s*/.exec(afterClose.toString());
+					if (!inOfMatch) throw new SyntaxError("Invalid for loop definition");
+					const inOf = inOfMatch[1];
+					const iterExpr = afterClose.substring(inOfMatch[0].length);
+					if (!iterExpr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+					const tempVarName = "$$_fv";
+					if (inOf === "of") {
+						getIterator = lispifyReturnExpr(constants, iterExpr);
+						startInternal = isForAwait ? [asyncOfStart2, asyncOfStart3] : [ofStart2, ofStart3];
+						condition = ofCondition;
+						step = isForAwait ? asyncOfStep : ofStep;
+						const stmts = lispifyBlock(new CodeString(expandDestructure(keyword, patternStr, tempVarName)), constants, false, ctx);
+						beforeStep = createLisp({
+							op: LispType.InternalBlock,
+							a: [lispify(constants, new CodeString(`${keyword} ${tempVarName} = $$next.value`), ["initialize"]), ...stmts],
+							b: LispType.None
+						});
+					} else {
+						getIterator = lispifyReturnExpr(constants, iterExpr);
+						startInternal = [inStart2, inStart3];
+						step = inStep;
+						condition = inCondition;
+						const stmts = lispifyBlock(new CodeString(expandDestructure(keyword, patternStr, tempVarName)), constants, false, ctx);
+						beforeStep = createLisp({
+							op: LispType.InternalBlock,
+							a: [lispify(constants, new CodeString(`${keyword} ${tempVarName} = $$keys[$$keyIndex]`), ["initialize"]), ...stmts],
+							b: LispType.None
+						});
+					}
+				} else if (args.length === 3) {
+					const [startArg, conditionArg, stepArg] = args;
+					if (startArg.length) startStep = lispifyExpr(constants, startArg, startingExecpted, ctx);
+					condition = conditionArg.length ? lispifyReturnExpr(constants, conditionArg) : LispType.True;
+					if (stepArg.length) step = lispifyExpr(constants, stepArg, void 0, ctx);
+				} else throw new SyntaxError("Invalid for loop definition");
+				body = restOfExp(constants, part.substring(i)).trim();
+				if (body.char(0) === "{") body = body.slice(1, -1);
+				break;
+			}
+			case "do": {
+				checkFirst = LispType.None;
+				const isBlock = !!res[2];
+				body = restOfExp(constants, part.substring(res[0].length), isBlock ? [/^\}/] : [semiColon]);
+				condition = lispifyReturnExpr(constants, restOfExp(constants, part.substring(part.toString().indexOf("(", res[0].length + body.length) + 1), [], "("));
+				break;
+			}
+		}
+		const a = [
+			checkFirst,
+			startInternal,
+			getIterator,
+			startStep,
+			step,
+			condition,
+			beforeStep,
+			isForAwait,
+			labels
+		];
+		ctx.lispTree = createLisp({
+			op: LispType.Loop,
+			a,
+			b: lispifyBlock(body, constants, false, ctx)
+		});
+	});
+	setLispType(["block"], (ctx) => {
+		const { constants, part, res } = ctx;
+		ctx.lispTree = wrapLabeledStatement(extractStatementLabels(res[1]), createLisp({
+			op: LispType.Block,
+			a: lispifyBlock(restOfExp(constants, part.substring(res[0].length), [], "{"), constants, false, ctx),
+			b: LispType.None
+		}));
+	});
+	setLispType(["loopAction"], (ctx) => {
+		const { part, res } = ctx;
+		const remaining = part.substring(res[0].length).trimStart();
+		if (remaining.length && !res[2]) throw new SyntaxError(`Unexpected token '${remaining.char(0)}'`);
+		ctx.lispTree = createLisp({
+			op: LispType.LoopAction,
+			a: res[1],
+			b: res[2] || LispType.None
+		});
+	});
+	const catchReg = /^\s*(catch\s*(\(\s*([a-zA-Z$_][a-zA-Z\d$_]*)\s*\))?|finally)\s*\{/;
+	const catchEmptyBindingReg = /^\s*catch\s*\(\s*\)/;
+	const catchReservedBindingReg = /^\s*catch\s*\(\s*(break|case|catch|continue|debugger|default|delete|do|else|finally|for|function|if|in|instanceof|new|return|switch|this|throw|try|typeof|var|void|while|with|class|const|enum|export|extends|implements|import|interface|let|package|private|protected|public|static|super|yield|await)\s*\)/;
+	const finallyKeywordReg = /^\s*finally\b/;
+	setLispType(["try"], (ctx) => {
+		const { constants, part, res } = ctx;
+		const body = restOfExp(constants, part.substring(res[0].length), [], "{");
+		const afterBody = part.substring(res[0].length + body.length + 1).toString();
+		if (catchEmptyBindingReg.test(afterBody)) throw new ParseError("Unexpected token ')'", part.toString());
+		const reservedMatch = catchReservedBindingReg.exec(afterBody);
+		if (reservedMatch) throw new ParseError(`Unexpected token '${reservedMatch[1]}'`, part.toString());
+		const finallyMatch = finallyKeywordReg.exec(afterBody);
+		if (finallyMatch && !/^\s*\{/.test(afterBody.substring(finallyMatch[0].length))) throw new ParseError("Unexpected token", part.toString());
+		let catchRes = catchReg.exec(afterBody);
+		let finallyBody;
+		let exception = "";
+		let catchBody;
+		let offset = 0;
+		if (!catchRes) throw new ParseError("Missing catch or finally after try", part.toString());
+		if (catchRes[1].startsWith("catch")) {
+			catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());
+			exception = catchRes[3] || "";
+			catchBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], "{");
+			offset = res[0].length + body.length + 1 + catchRes[0].length + catchBody.length + 1;
+			if ((catchRes = catchReg.exec(part.substring(offset).toString())) && catchRes[1].startsWith("finally")) finallyBody = restOfExp(constants, part.substring(offset + catchRes[0].length), [], "{");
+		} else finallyBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], "{");
+		const b = [
+			exception,
+			lispifyBlock(insertSemicolons(constants, catchBody || emptyString), constants, false, ctx),
+			lispifyBlock(insertSemicolons(constants, finallyBody || emptyString), constants, false, ctx)
+		];
+		ctx.lispTree = wrapLabeledStatement(extractStatementLabels(res[1]), createLisp({
+			op: LispType.Try,
+			a: lispifyBlock(insertSemicolons(constants, body), constants, false, ctx),
+			b
+		}));
+	});
+}
+//#endregion
+export { registerControlLispTypes };
+
+//# sourceMappingURL=control.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control.js","names":[],"sources":["../../../../src/parser/lispTypes/control.ts"],"sourcesContent":["import { CodeString, LispType } from '../../utils';\nimport type {\n  Block,\n  InternalCode,\n  Lisp,\n  LispItem,\n  Loop,\n  LoopAction,\n  StatementLabel,\n  Try,\n} from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerControlLispTypes({\n  ParseError,\n  createLisp,\n  emptyString,\n  expandDestructure,\n  extractStatementLabels,\n  insertSemicolons,\n  lispify,\n  lispifyBlock,\n  lispifyExpr,\n  lispifyReturnExpr,\n  restOfExp,\n  semiColon,\n  setLispType,\n  startingExecpted,\n  wrapLabeledStatement,\n}: RegisterLispTypesDeps) {\n  const iteratorRegex =\n    /^((let|var|const|internal)\\s+)?\\s*([a-zA-Z$_][a-zA-Z\\d$_]*)\\s+(in|of)(?![\\w$])/;\n  const iteratorDestructureRegex = /^((let|var|const|internal)\\s+)\\s*([[{])/;\n\n  const ofStart2 = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('let $$iterator = $$obj[Symbol.iterator]()'),\n    ['initialize'],\n  );\n  const ofStart3 = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('let $$next = $$iterator.next()'),\n    ['initialize'],\n  );\n  const ofCondition = lispify({ maxDepth: 10 } as any, new CodeString('return !$$next.done'), [\n    'initialize',\n  ]);\n  const ofStep = lispify({ maxDepth: 10 } as any, new CodeString('$$next = $$iterator.next()'));\n  const asyncOfStart2 = lispify({ maxDepth: 10 } as any, new CodeString('let $$iterator = $$obj'), [\n    'initialize',\n  ]);\n  const asyncOfStart3 = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('let $$next = $$iterator.next()'),\n    ['initialize'],\n  );\n  const asyncOfStep = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('$$next = $$iterator.next()'),\n  );\n  const inStart2 = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('let $$keys = Object.keys($$obj)'),\n    ['initialize'],\n  );\n  const inStart3 = lispify({ maxDepth: 10 } as any, new CodeString('let $$keyIndex = 0'), [\n    'initialize',\n  ]);\n  const inStep = lispify({ maxDepth: 10 } as any, new CodeString('$$keyIndex++'));\n  const inCondition = lispify(\n    { maxDepth: 10 } as any,\n    new CodeString('return $$keyIndex < $$keys.length'),\n    ['initialize'],\n  );\n\n  setLispType(['for', 'do', 'while'] as const, (ctx) => {\n    const { constants, type, part, res } = ctx;\n    const labels = extractStatementLabels(res[1]);\n    let i = 0;\n    let startStep: LispItem = LispType.True;\n    let startInternal: Lisp[] = [];\n    let getIterator: Lisp | LispType.None = LispType.None;\n    let beforeStep: LispItem = LispType.None;\n    let checkFirst = LispType.True;\n    let condition: LispItem;\n    let step: LispItem = LispType.True;\n    let body: CodeString;\n    const isForAwait: LispItem = type === 'for' && res[2] ? LispType.True : LispType.None;\n    switch (type) {\n      case 'while': {\n        i = part.toString().indexOf('(') + 1;\n        const extract = restOfExp(constants, part.substring(i), [], '(');\n        if (!extract.trimStart().length) {\n          throw new SyntaxError('Unexpected end of expression');\n        }\n        condition = lispifyReturnExpr(constants, extract);\n        body = restOfExp(constants, part.substring(i + extract.length + 1)).trim();\n        if (body.char(0) === '{') body = body.slice(1, -1);\n        break;\n      }\n      case 'for': {\n        i = part.toString().indexOf('(') + 1;\n        const args: CodeString[] = [];\n        let extract2 = emptyString;\n        for (let k = 0; k < 3; k++) {\n          extract2 = restOfExp(constants, part.substring(i), [/^[;)]/]);\n          args.push(extract2.trim());\n          i += extract2.length + 1;\n          if (part.char(i - 1) === ')') break;\n        }\n        let iterator: RegExpExecArray | null;\n        let iteratorDestructure: RegExpExecArray | null;\n        if (args.length === 1 && (iterator = iteratorRegex.exec(args[0].toString()))) {\n          const iterableExpr = args[0].substring(iterator[0].length);\n          if (!iterableExpr.trimStart().length) {\n            throw new SyntaxError('Unexpected end of expression');\n          }\n          if (iterator[4] === 'of') {\n            getIterator = lispifyReturnExpr(constants, iterableExpr);\n            startInternal = isForAwait ? [asyncOfStart2, asyncOfStart3] : [ofStart2, ofStart3];\n            condition = ofCondition;\n            step = isForAwait ? asyncOfStep : ofStep;\n            beforeStep = lispify(\n              constants,\n              new CodeString((iterator[1] || 'let ') + iterator[3] + ' = $$next.value'),\n              ['initialize'],\n            );\n          } else {\n            if (isForAwait) {\n              throw new SyntaxError(\"Unexpected token 'in'\");\n            }\n            getIterator = lispifyReturnExpr(constants, iterableExpr);\n            startInternal = [inStart2, inStart3];\n            step = inStep;\n            condition = inCondition;\n            beforeStep = lispify(\n              constants,\n              new CodeString((iterator[1] || 'let ') + iterator[3] + ' = $$keys[$$keyIndex]'),\n              ['initialize'],\n            );\n          }\n        } else if (\n          args.length === 1 &&\n          (iteratorDestructure = iteratorDestructureRegex.exec(args[0].toString()))\n        ) {\n          const keyword = iteratorDestructure[1].trim();\n          const openBracket = iteratorDestructure[3];\n          const closeBracket = openBracket === '[' ? ']' : '}';\n          const keywordPrefixLen = iteratorDestructure[0].length - 1;\n          const patternContent = restOfExp(\n            constants,\n            args[0].substring(keywordPrefixLen + 1),\n            [],\n            openBracket,\n          );\n          const patternStr = openBracket + patternContent.toString() + closeBracket;\n          const afterClose = args[0]\n            .substring(keywordPrefixLen + 1 + patternContent.length + 1)\n            .trimStart();\n          const inOfMatch = /^(in|of)(?![\\w$])\\s*/.exec(afterClose.toString());\n          if (!inOfMatch) throw new SyntaxError('Invalid for loop definition');\n          const inOf = inOfMatch[1];\n          const iterExpr = afterClose.substring(inOfMatch[0].length);\n          if (!iterExpr.trimStart().length) {\n            throw new SyntaxError('Unexpected end of expression');\n          }\n          const tempVarName = '$$_fv';\n          if (inOf === 'of') {\n            getIterator = lispifyReturnExpr(constants, iterExpr);\n            startInternal = isForAwait ? [asyncOfStart2, asyncOfStart3] : [ofStart2, ofStart3];\n            condition = ofCondition;\n            step = isForAwait ? asyncOfStep : ofStep;\n            const expandedCode = expandDestructure(keyword, patternStr, tempVarName);\n            const stmts = lispifyBlock(new CodeString(expandedCode), constants, false, ctx);\n            beforeStep = createLisp<InternalCode>({\n              op: LispType.InternalBlock,\n              a: [\n                lispify(constants, new CodeString(`${keyword} ${tempVarName} = $$next.value`), [\n                  'initialize',\n                ]),\n                ...stmts,\n              ],\n              b: LispType.None,\n            });\n          } else {\n            getIterator = lispifyReturnExpr(constants, iterExpr);\n            startInternal = [inStart2, inStart3];\n            step = inStep;\n            condition = inCondition;\n            const expandedCode = expandDestructure(keyword, patternStr, tempVarName);\n            const stmts = lispifyBlock(new CodeString(expandedCode), constants, false, ctx);\n            beforeStep = createLisp<InternalCode>({\n              op: LispType.InternalBlock,\n              a: [\n                lispify(\n                  constants,\n                  new CodeString(`${keyword} ${tempVarName} = $$keys[$$keyIndex]`),\n                  ['initialize'],\n                ),\n                ...stmts,\n              ],\n              b: LispType.None,\n            });\n          }\n        } else if (args.length === 3) {\n          const [startArg, conditionArg, stepArg] = args;\n          if (startArg.length) {\n            startStep = lispifyExpr(constants, startArg, startingExecpted, ctx);\n          }\n          condition = conditionArg.length\n            ? lispifyReturnExpr(constants, conditionArg)\n            : LispType.True;\n          if (stepArg.length) {\n            step = lispifyExpr(constants, stepArg, undefined, ctx);\n          }\n        } else {\n          throw new SyntaxError('Invalid for loop definition');\n        }\n        body = restOfExp(constants, part.substring(i)).trim();\n        if (body.char(0) === '{') body = body.slice(1, -1);\n        break;\n      }\n      case 'do': {\n        checkFirst = LispType.None;\n        const isBlock = !!res[2];\n        body = restOfExp(constants, part.substring(res[0].length), isBlock ? [/^\\}/] : [semiColon]);\n        condition = lispifyReturnExpr(\n          constants,\n          restOfExp(\n            constants,\n            part.substring(part.toString().indexOf('(', res[0].length + body.length) + 1),\n            [],\n            '(',\n          ),\n        );\n        break;\n      }\n    }\n    const a = [\n      checkFirst,\n      startInternal,\n      getIterator,\n      startStep,\n      step,\n      condition,\n      beforeStep,\n      isForAwait,\n      labels,\n    ] as LispItem;\n    ctx.lispTree = createLisp<Loop>({\n      op: LispType.Loop,\n      a,\n      b: lispifyBlock(body, constants, false, ctx),\n    });\n  });\n\n  setLispType(['block'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const labels = extractStatementLabels(res[1]);\n    ctx.lispTree = wrapLabeledStatement(\n      labels,\n      createLisp<Block>({\n        op: LispType.Block,\n        a: lispifyBlock(\n          restOfExp(constants, part.substring(res[0].length), [], '{'),\n          constants,\n          false,\n          ctx,\n        ),\n        b: LispType.None,\n      }),\n    ) as Lisp;\n  });\n\n  setLispType(['loopAction'] as const, (ctx) => {\n    const { part, res } = ctx;\n    const remaining = part.substring(res[0].length).trimStart();\n    if (remaining.length && !res[2]) {\n      throw new SyntaxError(`Unexpected token '${remaining.char(0)}'`);\n    }\n    ctx.lispTree = createLisp<LoopAction>({\n      op: LispType.LoopAction,\n      a: res[1],\n      b: (res[2] || LispType.None) as StatementLabel,\n    });\n  });\n\n  const catchReg = /^\\s*(catch\\s*(\\(\\s*([a-zA-Z$_][a-zA-Z\\d$_]*)\\s*\\))?|finally)\\s*\\{/;\n  const catchEmptyBindingReg = /^\\s*catch\\s*\\(\\s*\\)/;\n  const catchReservedBindingReg =\n    /^\\s*catch\\s*\\(\\s*(break|case|catch|continue|debugger|default|delete|do|else|finally|for|function|if|in|instanceof|new|return|switch|this|throw|try|typeof|var|void|while|with|class|const|enum|export|extends|implements|import|interface|let|package|private|protected|public|static|super|yield|await)\\s*\\)/;\n  const finallyKeywordReg = /^\\s*finally\\b/;\n\n  setLispType(['try'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const body = restOfExp(constants, part.substring(res[0].length), [], '{');\n    const afterBody = part.substring(res[0].length + body.length + 1).toString();\n\n    if (catchEmptyBindingReg.test(afterBody)) {\n      throw new ParseError(\"Unexpected token ')'\", part.toString());\n    }\n\n    const reservedMatch = catchReservedBindingReg.exec(afterBody);\n    if (reservedMatch) {\n      throw new ParseError(`Unexpected token '${reservedMatch[1]}'`, part.toString());\n    }\n\n    const finallyMatch = finallyKeywordReg.exec(afterBody);\n    if (finallyMatch && !/^\\s*\\{/.test(afterBody.substring(finallyMatch[0].length))) {\n      throw new ParseError('Unexpected token', part.toString());\n    }\n\n    let catchRes = catchReg.exec(afterBody);\n    let finallyBody;\n    let exception = '';\n    let catchBody;\n    let offset = 0;\n\n    if (!catchRes) {\n      throw new ParseError('Missing catch or finally after try', part.toString());\n    }\n\n    if (catchRes[1].startsWith('catch')) {\n      catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());\n      exception = catchRes![3] || '';\n      catchBody = restOfExp(\n        constants,\n        part.substring(res[0].length + body.length + 1 + catchRes![0].length),\n        [],\n        '{',\n      );\n      offset = res[0].length + body.length + 1 + catchRes![0].length + catchBody.length + 1;\n      if (\n        (catchRes = catchReg.exec(part.substring(offset).toString())) &&\n        catchRes[1].startsWith('finally')\n      ) {\n        finallyBody = restOfExp(constants, part.substring(offset + catchRes[0].length), [], '{');\n      }\n    } else {\n      finallyBody = restOfExp(\n        constants,\n        part.substring(res[0].length + body.length + 1 + catchRes![0].length),\n        [],\n        '{',\n      );\n    }\n    const b = [\n      exception,\n      lispifyBlock(insertSemicolons(constants, catchBody || emptyString), constants, false, ctx),\n      lispifyBlock(insertSemicolons(constants, finallyBody || emptyString), constants, false, ctx),\n    ] as LispItem;\n    ctx.lispTree = wrapLabeledStatement(\n      extractStatementLabels(res[1]),\n      createLisp<Try>({\n        op: LispType.Try,\n        a: lispifyBlock(insertSemicolons(constants, body), constants, false, ctx),\n        b,\n      }),\n    ) as Lisp;\n  });\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerDeclarationLispTypes({ createLisp, expectTypes, expandDestructure, expandFunctionParamDestructure, lispify, lispifyBlock, lispifyFunction, restOfExp, semiColon, setLispType, splitByCommasDestructure, }: RegisterLispTypesDeps): void;

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

@@ -0,0 +1,101 @@
+import { CodeString } from "../../utils/CodeString.js";
+import { LispType, reservedWords } from "../../utils/types.js";
+import "../../utils/index.js";
+//#region src/parser/lispTypes/declarations.ts
+function registerDeclarationLispTypes({ createLisp, expectTypes, expandDestructure, expandFunctionParamDestructure, lispify, lispifyBlock, lispifyFunction, restOfExp, semiColon, setLispType, splitByCommasDestructure }) {
+	setLispType(["initializeDestructure"], (ctx) => {
+		const { constants, part, res } = ctx;
+		const keyword = res[1];
+		const openBracket = res[2];
+		const closeBracket = openBracket === "[" ? "]" : "}";
+		const patternContent = restOfExp(constants, part.substring(res[0].length), [], openBracket);
+		const patternStr = openBracket + patternContent.toString() + closeBracket;
+		const afterClose = part.substring(res[0].length + patternContent.length + 1).trimStart();
+		if (!afterClose.length || afterClose.char(0) !== "=") throw new SyntaxError("Destructuring declaration requires an initializer");
+		const stmts = lispifyBlock(new CodeString(expandDestructure(keyword, patternStr, restOfExp(constants, afterClose.substring(1).trimStart(), [semiColon]).toString())), constants, false, ctx);
+		ctx.lispTree = createLisp({
+			op: LispType.InternalBlock,
+			a: stmts,
+			b: LispType.None
+		});
+	});
+	setLispType(["initialize"], (ctx) => {
+		const { constants, part, res, expect } = ctx;
+		const lt = res[1] === "var" ? LispType.Var : res[1] === "let" ? LispType.Let : res[1] === "const" ? LispType.Const : LispType.Internal;
+		if (!res[3]) ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: lt,
+			a: res[2],
+			b: LispType.None
+		}), false, ctx);
+		else {
+			const initExpr = part.substring(res[0].length);
+			if (!initExpr.trimStart().length) throw new SyntaxError("Unexpected end of expression");
+			ctx.lispTree = createLisp({
+				op: lt,
+				a: res[2],
+				b: lispify(constants, initExpr, expectTypes[expect].next, void 0, false, ctx)
+			});
+		}
+	});
+	setLispType([
+		"function",
+		"inlineFunction",
+		"arrowFunction",
+		"arrowFunctionSingle"
+	], (ctx) => {
+		const { constants, type, part, res, expect, generatorDepth, asyncDepth } = ctx;
+		const isArrow = type !== "function" && type !== "inlineFunction";
+		const isReturn = isArrow && !res[res.length - 1];
+		const isGenerator = !isArrow && res[2] && res[2].trimStart().startsWith("*") ? LispType.True : LispType.None;
+		const isAsync = res[1] ? LispType.True : LispType.None;
+		let rawArgStr;
+		let bodyOffset;
+		if (type === "function" || type === "inlineFunction") {
+			const argsCode = restOfExp(constants, part.substring(res[0].length), [], "(");
+			rawArgStr = argsCode.toString().trim();
+			bodyOffset = res[0].length + argsCode.length + 1;
+			const afterParen = part.substring(bodyOffset).trimStart();
+			bodyOffset = part.length - afterParen.length + 1;
+		} else {
+			rawArgStr = res[2] ?? "";
+			bodyOffset = 0;
+		}
+		const args = [...rawArgStr ? splitByCommasDestructure(rawArgStr).map((a) => a.trim()).filter(Boolean) : []];
+		if (!isArrow) args.unshift((res[3] || "").trimStart());
+		let ended = false;
+		args.forEach((arg) => {
+			if (ended) throw new SyntaxError("Rest parameter must be last formal parameter");
+			if (arg.startsWith("...")) ended = true;
+		});
+		const f = restOfExp(constants, isArrow ? part.substring(res[0].length) : part.substring(bodyOffset), !isReturn ? [/^}/] : [/^[,)}\]]/, semiColon]);
+		let funcBody = isReturn ? "return " + f : f.toString();
+		const expanded = expandFunctionParamDestructure(isArrow ? args : args.slice(1), funcBody);
+		const finalArgs = isArrow ? expanded.args : [args[0], ...expanded.args];
+		funcBody = expanded.body;
+		finalArgs.forEach((arg) => {
+			if (reservedWords.has(arg.replace(/^\.\.\./, ""))) throw new SyntaxError(`Unexpected token '${arg}'`);
+		});
+		const afterFunc = isArrow ? res[0].length + f.length + 1 : bodyOffset + f.length + 1;
+		ctx.lispTree = lispify(constants, part.substring(afterFunc), expectTypes[expect].next, createLisp({
+			op: isArrow ? LispType.ArrowFunction : type === "function" ? LispType.Function : LispType.InlineFunction,
+			a: isArrow ? [isAsync, ...finalArgs] : [
+				isAsync,
+				isGenerator,
+				...finalArgs
+			],
+			b: constants.eager ? lispifyFunction(new CodeString(funcBody), constants, false, isArrow ? {
+				generatorDepth: 0,
+				asyncDepth: 0,
+				lispDepth: 0
+			} : {
+				generatorDepth: isGenerator === LispType.True ? generatorDepth + 1 : 0,
+				asyncDepth: isAsync === LispType.True ? asyncDepth + 1 : 0,
+				lispDepth: 0
+			}) : funcBody
+		}), false, ctx);
+	});
+}
+//#endregion
+export { registerDeclarationLispTypes };
+
+//# sourceMappingURL=declarations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.js","names":[],"sources":["../../../../src/parser/lispTypes/declarations.ts"],"sourcesContent":["import { CodeString, LispType, reservedWords } from '../../utils';\nimport type {\n  ArrowFunction,\n  Const,\n  Function as FunctionLisp,\n  InlineFunction,\n  Internal,\n  InternalCode,\n  Let,\n  Var,\n} from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerDeclarationLispTypes({\n  createLisp,\n  expectTypes,\n  expandDestructure,\n  expandFunctionParamDestructure,\n  lispify,\n  lispifyBlock,\n  lispifyFunction,\n  restOfExp,\n  semiColon,\n  setLispType,\n  splitByCommasDestructure,\n}: RegisterLispTypesDeps) {\n  setLispType(['initializeDestructure'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    const keyword = res[1] as string;\n    const openBracket = res[2] as string;\n    const closeBracket = openBracket === '[' ? ']' : '}';\n\n    const patternContent = restOfExp(constants, part.substring(res[0].length), [], openBracket);\n    const patternStr = openBracket + patternContent.toString() + closeBracket;\n\n    const afterClose = part.substring(res[0].length + patternContent.length + 1).trimStart();\n    if (!afterClose.length || afterClose.char(0) !== '=') {\n      throw new SyntaxError('Destructuring declaration requires an initializer');\n    }\n\n    const rhsCode = restOfExp(constants, afterClose.substring(1).trimStart(), [semiColon]);\n    const rhsStr = rhsCode.toString();\n    const expandedCode = expandDestructure(keyword, patternStr, rhsStr);\n    const stmts = lispifyBlock(new CodeString(expandedCode), constants, false, ctx);\n\n    ctx.lispTree = createLisp<InternalCode>({\n      op: LispType.InternalBlock,\n      a: stmts,\n      b: LispType.None,\n    });\n  });\n\n  setLispType(['initialize'] as const, (ctx) => {\n    const { constants, part, res, expect } = ctx;\n    const lt =\n      res[1] === 'var'\n        ? LispType.Var\n        : res[1] === 'let'\n          ? LispType.Let\n          : res[1] === 'const'\n            ? LispType.Const\n            : LispType.Internal;\n    if (!res[3]) {\n      ctx.lispTree = lispify(\n        constants,\n        part.substring(res[0].length),\n        expectTypes[expect].next,\n        createLisp<Var | Let | Const | Internal>({\n          op: lt,\n          a: res[2],\n          b: LispType.None,\n        }),\n        false,\n        ctx,\n      );\n    } else {\n      const initExpr = part.substring(res[0].length);\n      if (!initExpr.trimStart().length) {\n        throw new SyntaxError('Unexpected end of expression');\n      }\n      ctx.lispTree = createLisp<Var | Let | Const | Internal>({\n        op: lt,\n        a: res[2],\n        b: lispify(constants, initExpr, expectTypes[expect].next, undefined, false, ctx),\n      });\n    }\n  });\n\n  setLispType(\n    ['function', 'inlineFunction', 'arrowFunction', 'arrowFunctionSingle'] as const,\n    (ctx) => {\n      const { constants, type, part, res, expect, generatorDepth, asyncDepth } = ctx;\n      const isArrow = type !== 'function' && type !== 'inlineFunction';\n      const isReturn = isArrow && !res[res.length - 1];\n      const isGenerator =\n        !isArrow && res[2] && res[2].trimStart().startsWith('*') ? LispType.True : LispType.None;\n      const isAsync = res[1] ? LispType.True : LispType.None;\n      let rawArgStr: string;\n      let bodyOffset: number;\n      if (type === 'function' || type === 'inlineFunction') {\n        const argsCode = restOfExp(constants, part.substring(res[0].length), [], '(');\n        rawArgStr = argsCode.toString().trim();\n        bodyOffset = res[0].length + argsCode.length + 1;\n        const afterParen = part.substring(bodyOffset).trimStart();\n        bodyOffset = part.length - afterParen.length + 1;\n      } else {\n        rawArgStr = res[2] ?? '';\n        bodyOffset = 0;\n      }\n      const rawArgs: string[] = rawArgStr\n        ? splitByCommasDestructure(rawArgStr)\n            .map((a) => a.trim())\n            .filter(Boolean)\n        : [];\n      const args: string[] = [...rawArgs];\n      if (!isArrow) {\n        args.unshift((res[3] || '').trimStart());\n      }\n      let ended = false;\n      args.forEach((arg: string) => {\n        if (ended) throw new SyntaxError('Rest parameter must be last formal parameter');\n        if (arg.startsWith('...')) ended = true;\n      });\n      const f = restOfExp(\n        constants,\n        isArrow ? part.substring(res[0].length) : part.substring(bodyOffset),\n        !isReturn ? [/^}/] : [/^[,)}\\]]/, semiColon],\n      );\n      let funcBody = isReturn ? 'return ' + f : f.toString();\n      const funcArgs = isArrow ? args : args.slice(1);\n      const expanded = expandFunctionParamDestructure(funcArgs, funcBody);\n      const finalArgs = isArrow ? expanded.args : [args[0], ...expanded.args];\n      funcBody = expanded.body;\n      finalArgs.forEach((arg: string) => {\n        if (reservedWords.has(arg.replace(/^\\.\\.\\./, ''))) {\n          throw new SyntaxError(`Unexpected token '${arg}'`);\n        }\n      });\n      const afterFunc = isArrow ? res[0].length + f.length + 1 : bodyOffset + f.length + 1;\n      ctx.lispTree = lispify(\n        constants,\n        part.substring(afterFunc),\n        expectTypes[expect].next,\n        createLisp<FunctionLisp | InlineFunction | ArrowFunction>({\n          op: isArrow\n            ? LispType.ArrowFunction\n            : type === 'function'\n              ? LispType.Function\n              : LispType.InlineFunction,\n          a: isArrow ? [isAsync, ...finalArgs] : [isAsync, isGenerator, ...finalArgs],\n          b: constants.eager\n            ? lispifyFunction(\n                new CodeString(funcBody),\n                constants,\n                false,\n                isArrow\n                  ? { generatorDepth: 0, asyncDepth: 0, lispDepth: 0 }\n                  : {\n                      generatorDepth: isGenerator === LispType.True ? generatorDepth + 1 : 0,\n                      asyncDepth: isAsync === LispType.True ? asyncDepth + 1 : 0,\n                      lispDepth: 0,\n                    },\n              )\n            : funcBody,\n        }),\n        false,\n        ctx,\n      );\n    },\n  );\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+import { RegisterLispTypesDeps } from './shared';
+export declare function registerLispTypes(deps: RegisterLispTypesDeps): void;
+export type { RegisterLispTypesDeps } from './shared';

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

@@ -0,0 +1,19 @@
+import { registerConditionalLispTypes } from "./conditionals.js";
+import { registerControlLispTypes } from "./control.js";
+import { registerDeclarationLispTypes } from "./declarations.js";
+import { registerOperatorLispTypes } from "./operators.js";
+import { registerStructureLispTypes } from "./structures.js";
+import { registerValueLispTypes } from "./values.js";
+//#region src/parser/lispTypes/index.ts
+function registerLispTypes(deps) {
+	registerStructureLispTypes(deps);
+	registerOperatorLispTypes(deps);
+	registerConditionalLispTypes(deps);
+	registerValueLispTypes(deps);
+	registerDeclarationLispTypes(deps);
+	registerControlLispTypes(deps);
+}
+//#endregion
+export { registerLispTypes };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/parser/lispTypes/index.ts"],"sourcesContent":["import type { RegisterLispTypesDeps } from './shared';\nimport { registerConditionalLispTypes } from './conditionals';\nimport { registerControlLispTypes } from './control';\nimport { registerDeclarationLispTypes } from './declarations';\nimport { registerOperatorLispTypes } from './operators';\nimport { registerStructureLispTypes } from './structures';\nimport { registerValueLispTypes } from './values';\n\nexport function registerLispTypes(deps: RegisterLispTypesDeps) {\n  registerStructureLispTypes(deps);\n  registerOperatorLispTypes(deps);\n  registerConditionalLispTypes(deps);\n  registerValueLispTypes(deps);\n  registerDeclarationLispTypes(deps);\n  registerControlLispTypes(deps);\n}\n\nexport type { RegisterLispTypesDeps } from './shared';\n"],"mappings":";;;;;;;AAQA,SAAgB,kBAAkB,MAA6B;AAC7D,4BAA2B,KAAK;AAChC,2BAA0B,KAAK;AAC/B,8BAA6B,KAAK;AAClC,wBAAuB,KAAK;AAC5B,8BAA6B,KAAK;AAClC,0BAAyB,KAAK"}

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

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