@cuxt/sandboxjs 0.1.1 → 0.1.4

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

@@ -0,0 +1,204 @@
+const require_CodeString = require("../../utils/CodeString.js");
+const require_types = require("../../utils/types.js");
+require("../../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 require_CodeString.CodeString("let $$iterator = $$obj[Symbol.iterator]()"), ["initialize"]);
+	const ofStart3 = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("let $$next = $$iterator.next()"), ["initialize"]);
+	const ofCondition = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("return !$$next.done"), ["initialize"]);
+	const ofStep = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("$$next = $$iterator.next()"));
+	const asyncOfStart2 = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("let $$iterator = $$obj"), ["initialize"]);
+	const asyncOfStart3 = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("let $$next = $$iterator.next()"), ["initialize"]);
+	const asyncOfStep = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("$$next = $$iterator.next()"));
+	const inStart2 = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("let $$keys = Object.keys($$obj)"), ["initialize"]);
+	const inStart3 = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("let $$keyIndex = 0"), ["initialize"]);
+	const inStep = lispify({ maxDepth: 10 }, new require_CodeString.CodeString("$$keyIndex++"));
+	const inCondition = lispify({ maxDepth: 10 }, new require_CodeString.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 = require_types.LispType.True;
+		let startInternal = [];
+		let getIterator = require_types.LispType.None;
+		let beforeStep = require_types.LispType.None;
+		let checkFirst = require_types.LispType.True;
+		let condition;
+		let step = require_types.LispType.True;
+		let body;
+		const isForAwait = type === "for" && res[2] ? require_types.LispType.True : require_types.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 require_CodeString.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 require_CodeString.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 require_CodeString.CodeString(expandDestructure(keyword, patternStr, tempVarName)), constants, false, ctx);
+						beforeStep = createLisp({
+							op: require_types.LispType.InternalBlock,
+							a: [lispify(constants, new require_CodeString.CodeString(`${keyword} ${tempVarName} = $$next.value`), ["initialize"]), ...stmts],
+							b: require_types.LispType.None
+						});
+					} else {
+						getIterator = lispifyReturnExpr(constants, iterExpr);
+						startInternal = [inStart2, inStart3];
+						step = inStep;
+						condition = inCondition;
+						const stmts = lispifyBlock(new require_CodeString.CodeString(expandDestructure(keyword, patternStr, tempVarName)), constants, false, ctx);
+						beforeStep = createLisp({
+							op: require_types.LispType.InternalBlock,
+							a: [lispify(constants, new require_CodeString.CodeString(`${keyword} ${tempVarName} = $$keys[$$keyIndex]`), ["initialize"]), ...stmts],
+							b: require_types.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) : require_types.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 = require_types.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: require_types.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: require_types.LispType.Block,
+			a: lispifyBlock(restOfExp(constants, part.substring(res[0].length), [], "{"), constants, false, ctx),
+			b: require_types.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: require_types.LispType.LoopAction,
+			a: res[1],
+			b: res[2] || require_types.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: require_types.LispType.Try,
+			a: lispifyBlock(insertSemicolons(constants, body), constants, false, ctx),
+			b
+		}));
+	});
+}
+//#endregion
+exports.registerControlLispTypes = registerControlLispTypes;

package/dist/cjs/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/cjs/parser/lispTypes/declarations.js

@@ -0,0 +1,99 @@
+const require_CodeString = require("../../utils/CodeString.js");
+const require_types = require("../../utils/types.js");
+require("../../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 require_CodeString.CodeString(expandDestructure(keyword, patternStr, restOfExp(constants, afterClose.substring(1).trimStart(), [semiColon]).toString())), constants, false, ctx);
+		ctx.lispTree = createLisp({
+			op: require_types.LispType.InternalBlock,
+			a: stmts,
+			b: require_types.LispType.None
+		});
+	});
+	setLispType(["initialize"], (ctx) => {
+		const { constants, part, res, expect } = ctx;
+		const lt = res[1] === "var" ? require_types.LispType.Var : res[1] === "let" ? require_types.LispType.Let : res[1] === "const" ? require_types.LispType.Const : require_types.LispType.Internal;
+		if (!res[3]) ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: lt,
+			a: res[2],
+			b: require_types.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("*") ? require_types.LispType.True : require_types.LispType.None;
+		const isAsync = res[1] ? require_types.LispType.True : require_types.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 (require_types.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 ? require_types.LispType.ArrowFunction : type === "function" ? require_types.LispType.Function : require_types.LispType.InlineFunction,
+			a: isArrow ? [isAsync, ...finalArgs] : [
+				isAsync,
+				isGenerator,
+				...finalArgs
+			],
+			b: constants.eager ? lispifyFunction(new require_CodeString.CodeString(funcBody), constants, false, isArrow ? {
+				generatorDepth: 0,
+				asyncDepth: 0,
+				lispDepth: 0
+			} : {
+				generatorDepth: isGenerator === require_types.LispType.True ? generatorDepth + 1 : 0,
+				asyncDepth: isAsync === require_types.LispType.True ? asyncDepth + 1 : 0,
+				lispDepth: 0
+			}) : funcBody
+		}), false, ctx);
+	});
+}
+//#endregion
+exports.registerDeclarationLispTypes = registerDeclarationLispTypes;

package/dist/cjs/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/cjs/parser/lispTypes/index.js

@@ -0,0 +1,17 @@
+const require_conditionals = require("./conditionals.js");
+const require_control = require("./control.js");
+const require_declarations = require("./declarations.js");
+const require_operators = require("./operators.js");
+const require_structures = require("./structures.js");
+const require_values = require("./values.js");
+//#region src/parser/lispTypes/index.ts
+function registerLispTypes(deps) {
+	require_structures.registerStructureLispTypes(deps);
+	require_operators.registerOperatorLispTypes(deps);
+	require_conditionals.registerConditionalLispTypes(deps);
+	require_values.registerValueLispTypes(deps);
+	require_declarations.registerDeclarationLispTypes(deps);
+	require_control.registerControlLispTypes(deps);
+}
+//#endregion
+exports.registerLispTypes = registerLispTypes;

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

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

@@ -0,0 +1,252 @@
+const require_CodeString = require("../../utils/CodeString.js");
+const require_types = require("../../utils/types.js");
+const require_ExecContext = require("../../utils/ExecContext.js");
+require("../../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: require_types.LispType.Inverse,
+		not: require_types.LispType.Not,
+		positive: require_types.LispType.Positive,
+		negative: require_types.LispType.Negative,
+		typeof: require_types.LispType.Typeof,
+		delete: require_types.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: require_types.LispType.StringIndex,
+			a: require_types.LispType.None,
+			b: String(constants.strings.push(str) - 1)
+		}));
+		const stringsArrayLisp = createLisp({
+			op: require_types.LispType.CreateArray,
+			a: createLisp({
+				op: require_types.LispType.None,
+				a: require_types.LispType.None,
+				b: require_types.LispType.None
+			}),
+			b: stringsArray
+		});
+		ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+			op: require_types.LispType.Call,
+			a: ctx.lispTree,
+			b: [stringsArrayLisp, ...expressions]
+		}), false, ctx);
+	});
+	const incrementTypes = {
+		"++$": require_types.LispType.IncrementBefore,
+		"--$": require_types.LispType.DecrementBefore,
+		"$++": require_types.LispType.IncrementAfter,
+		"$--": require_types.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: require_types.LispType.None
+		}), false, ctx);
+	});
+	setLispType(["incrementerAfter"], (ctx) => {
+		const { constants, part, res, expect } = ctx;
+		if (ctx.lispTree[0] === require_types.LispType.Number || ctx.lispTree[0] === require_types.LispType.BigInt || ctx.lispTree[0] === require_types.LispType.GlobalSymbol || ctx.lispTree[0] === require_types.LispType.StringIndex || ctx.lispTree[0] === require_types.LispType.LiteralIndex || ctx.lispTree[0] === require_types.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: require_types.LispType.None
+		}), false, ctx);
+	});
+	const adderTypes = {
+		"&&": require_types.LispType.And,
+		"||": require_types.LispType.Or,
+		"??": require_types.LispType.NullishCoalescing,
+		instanceof: require_types.LispType.Instanceof,
+		in: require_types.LispType.In,
+		"=": require_types.LispType.Assign,
+		"-=": require_types.LispType.SubractEquals,
+		"+=": require_types.LispType.AddEquals,
+		"/=": require_types.LispType.DivideEquals,
+		"**=": require_types.LispType.PowerEquals,
+		"*=": require_types.LispType.MultiplyEquals,
+		"%=": require_types.LispType.ModulusEquals,
+		"^=": require_types.LispType.BitNegateEquals,
+		"&=": require_types.LispType.BitAndEquals,
+		"|=": require_types.LispType.BitOrEquals,
+		">>>=": require_types.LispType.UnsignedShiftRightEquals,
+		"<<=": require_types.LispType.ShiftLeftEquals,
+		">>=": require_types.LispType.ShiftRightEquals,
+		"&&=": require_types.LispType.AndEquals,
+		"||=": require_types.LispType.OrEquals,
+		"??=": require_types.LispType.NullishCoalescingEquals
+	};
+	setLispType([
+		"assign",
+		"assignModify",
+		"nullishCoalescing"
+	], (ctx) => {
+		const { constants, type, part, res } = ctx;
+		if (type !== "nullishCoalescing" && require_ExecContext.isLisp(ctx.lispTree) && (ctx.lispTree[0] === require_types.LispType.PropOptional || ctx.lispTree[0] === require_types.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: require_types.LispType.InternalBlock,
+					a: lispifyBlock(new require_CodeString.CodeString(expandedCode), constants, false, ctx),
+					b: require_types.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 = {
+		"&": require_types.LispType.BitAnd,
+		"|": require_types.LispType.BitOr,
+		"^": require_types.LispType.BitNegate,
+		"<<": require_types.LispType.BitShiftLeft,
+		">>": require_types.LispType.BitShiftRight,
+		">>>": require_types.LispType.BitUnsignedShiftRight,
+		"<=": require_types.LispType.SmallerEqualThan,
+		">=": require_types.LispType.LargerEqualThan,
+		"<": require_types.LispType.SmallerThan,
+		">": require_types.LispType.LargerThan,
+		"!==": require_types.LispType.StrictNotEqual,
+		"!=": require_types.LispType.NotEqual,
+		"===": require_types.LispType.StrictEqual,
+		"==": require_types.LispType.Equal,
+		"+": require_types.LispType.Plus,
+		"-": require_types.LispType.Minus,
+		"/": require_types.LispType.Divide,
+		"**": require_types.LispType.Power,
+		"*": require_types.LispType.Multiply,
+		"%": require_types.LispType.Modulus,
+		"&&": require_types.LispType.And,
+		"||": require_types.LispType.Or,
+		instanceof: require_types.LispType.Instanceof,
+		in: require_types.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: require_types.LispType.InlineIf,
+			a: ctx.lispTree,
+			b: createLisp({
+				op: require_types.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
+exports.registerOperatorLispTypes = registerOperatorLispTypes;

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