@cuxt/sandboxjs 0.1.0 → 0.1.3

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

@@ -0,0 +1,188 @@
+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/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: require_types.LispType.CreateArray,
+		createObject: require_types.LispType.CreateObject,
+		group: require_types.LispType.Group,
+		arrayProp: require_types.LispType.ArrayProp,
+		call: require_types.LispType.Call,
+		prop: require_types.LispType.Prop,
+		"?prop": require_types.LispType.PropOptional,
+		"?call": require_types.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: require_types.LispType.InternalBlock,
+							a: lispifyBlock(new require_CodeString.CodeString(expandedCode), constants, false, ctx),
+							b: require_types.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: require_types.LispType.Hole,
+					a: require_types.LispType.None,
+					b: require_types.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 require_CodeString.CodeString("function" + afterBracket.toString()));
+						else throw new SyntaxError("Unexpected token in computed property");
+						return createLisp({
+							op: require_types.LispType.KeyVal,
+							a: key,
+							b: value
+						});
+					}
+					funcFound = expectTypes.expFunction.types.function.exec("function " + str);
+					if (funcFound) {
+						key = funcFound[3].trimStart();
+						value = lispify(constants, new require_CodeString.CodeString("function " + str.toString().replace(key, "")));
+					} else {
+						const extract = restOfExp(constants, str, [/^:/]);
+						key = lispify(constants, extract, [...next, "spreadObject"]);
+						if (require_ExecContext.isLisp(key) && key[0] === require_types.LispType.SpreadObject) value = NullLisp;
+						else {
+							if (key[0] === require_types.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: require_types.LispType.KeyVal,
+						a: key,
+						b: value
+					});
+				});
+				break;
+		}
+		const lisptype = type === "arrayProp" ? res[1] ? require_types.LispType.PropOptional : require_types.LispType.Prop : type === "call" ? res[1] ? require_types.LispType.CallOptional : require_types.LispType.Call : typesCreate[type];
+		const currentTree = createLisp({
+			op: lisptype,
+			a: ctx.lispTree,
+			b: l
+		});
+		if (lisptype === require_types.LispType.Group || lisptype === require_types.LispType.CreateArray || lisptype === require_types.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 (require_types.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" ? require_types.LispType.SpreadArray : require_types.LispType.SpreadObject,
+			a: require_types.LispType.None,
+			b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)
+		});
+	});
+}
+//#endregion
+exports.registerStructureLispTypes = registerStructureLispTypes;

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

@@ -0,0 +1,89 @@
+const require_types = require("../../utils/types.js");
+require("../../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" ? require_types.LispType.Return : require_types.LispType.Throw,
+			a: require_types.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] ? require_types.LispType.BigInt : require_types.LispType.Number : require_types.LispType.GlobalSymbol,
+			a: require_types.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" ? require_types.LispType.StringIndex : type === "literal" ? require_types.LispType.LiteralIndex : require_types.LispType.RegexIndex,
+			a: require_types.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" ? require_types.LispType.Void : require_types.LispType.Await,
+			a: lispify(constants, extract),
+			b: require_types.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 ? require_types.LispType.YieldDelegate : require_types.LispType.Yield,
+			a: lispify(constants, extract),
+			b: require_types.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: require_types.LispType.New,
+			a: lispify(constants, obj, expectTypes.initialize.next),
+			b: args.map((arg) => lispify(constants, arg, expectTypes.initialize.next))
+		}), false, ctx);
+	});
+}
+//#endregion
+exports.registerValueLispTypes = registerValueLispTypes;

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

@@ -0,0 +1,34 @@
+import { CodeString } from '../utils';
+import { IConstants, IExecutionTree, IRegEx, Lisp, LispCallback, LispDepthCtx, Return } from './lisp';
+export declare class ParseError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare const expectTypes: Record<string, {
+    types: Record<string, RegExp>;
+    next: string[];
+}>;
+export declare function testMultiple(str: string, tests: RegExp[]): RegExpExecArray | null;
+export interface restDetails {
+    oneliner?: boolean;
+    words?: string[];
+    lastWord?: string;
+    lastAnyWord?: string;
+    regRes?: RegExpExecArray;
+    bodyContentAfterKeyword?: boolean;
+}
+export declare function restOfExp(constants: IConstants, part: CodeString, tests?: RegExp[], quote?: string, firstOpening?: string, closingsTests?: RegExp[], details?: restDetails, depth?: number): CodeString;
+export declare namespace restOfExp {
+    var next: string[];
+}
+export declare const setLispType: <T extends readonly string[]>(types: T, fn: LispCallback<T[number]>) => void;
+export declare function lispifyReturnExpr(constants: IConstants, str: CodeString): Return;
+export declare function lispifyBlock(str: CodeString, constants: IConstants, expression?: boolean, depthCtx?: LispDepthCtx): Lisp[];
+export declare function lispifyFunction(str: CodeString, constants: IConstants, expression?: boolean, depthCtx?: LispDepthCtx): Lisp[];
+export declare function insertSemicolons(constants: IConstants, str: CodeString): CodeString;
+export declare function checkRegex(str: string): IRegEx | null;
+export declare function extractConstants(constants: IConstants, str: string, currentEnclosure?: string, depth?: number): {
+    str: string;
+    length: number;
+};
+export default function parse(code: string, eager?: boolean, expression?: boolean, maxParserRecursionDepth?: number): IExecutionTree;