@cuxt/sandboxjs 0.1.1 → 0.1.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","names":[],"sources":["../../../../src/parser/lispTypes/values.ts"],"sourcesContent":["import { LispType } from '../../utils';\nimport type {\n  Await,\n  BigInt as BigIntLisp,\n  GlobalSymbol,\n  LiteralIndex,\n  Number as NumberLisp,\n  RegexIndex,\n  Return,\n  StringIndex,\n  Throw,\n  Void,\n  Yield,\n  YieldDelegate,\n} from '../lisp';\nimport type { RegisterLispTypesDeps } from './shared';\n\nexport function registerValueLispTypes({\n  createLisp,\n  expectTypes,\n  lispify,\n  lispifyExpr,\n  restOfExp,\n  semiColon,\n  setLispType,\n}: RegisterLispTypesDeps) {\n  setLispType(['return', 'throw'] as const, (ctx) => {\n    const { constants, type, part, res } = ctx;\n    const expr = part.substring(res[0].length);\n    if (type === 'throw' && !expr.trimStart().length) {\n      throw new SyntaxError('Unexpected end of expression');\n    }\n    ctx.lispTree = createLisp<Return | Throw>({\n      op: type === 'return' ? LispType.Return : LispType.Throw,\n      a: LispType.None,\n      b: lispifyExpr(constants, expr, undefined, ctx),\n    });\n  });\n\n  setLispType(['number', 'boolean', 'null', 'und', 'NaN', 'Infinity'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length),\n      expectTypes[expect].next,\n      createLisp<NumberLisp | BigIntLisp | GlobalSymbol>({\n        op:\n          type === 'number' ? (res[12] ? LispType.BigInt : LispType.Number) : LispType.GlobalSymbol,\n        a: LispType.None,\n        b: res[12] ? res[1] : res[0],\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['string', 'literal', 'regex'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length),\n      expectTypes[expect].next,\n      createLisp<StringIndex | LiteralIndex | RegexIndex>({\n        op:\n          type === 'string'\n            ? LispType.StringIndex\n            : type === 'literal'\n              ? LispType.LiteralIndex\n              : LispType.RegexIndex,\n        a: LispType.None,\n        b: res[1],\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['void', 'await'] as const, (ctx) => {\n    const { constants, type, part, res, expect } = ctx;\n    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\\s.?\\w$]|\\?[^.])/]);\n    if (!extract.trimStart().length) {\n      throw new SyntaxError('Unexpected end of expression');\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length + extract.length),\n      expectTypes[expect].next,\n      createLisp<Void | Await>({\n        op: type === 'void' ? LispType.Void : LispType.Await,\n        a: lispify(constants, extract),\n        b: LispType.None,\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['yield'] as const, (ctx) => {\n    const { constants, part, res, expect, generatorDepth } = ctx;\n    if (generatorDepth === 0) {\n      throw new SyntaxError('Unexpected token');\n    }\n    const isDelegate = res[0].trimEnd().endsWith('*');\n    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\\s.?\\w$]|\\?[^.])/]);\n    if (isDelegate && !extract.trimStart().length) {\n      throw new SyntaxError('Unexpected end of expression');\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(res[0].length + extract.length),\n      expectTypes[expect].next,\n      createLisp<Yield | YieldDelegate>({\n        op: isDelegate ? LispType.YieldDelegate : LispType.Yield,\n        a: lispify(constants, extract),\n        b: LispType.None,\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  setLispType(['new'] as const, (ctx) => {\n    const { constants, part, res } = ctx;\n    let i = res[0].length;\n    const obj = restOfExp(constants, part.substring(i), [], undefined, '(');\n    if (!obj.trimStart().length) {\n      throw new SyntaxError('Unexpected end of expression');\n    }\n    i += obj.length + 1;\n    const args = [];\n    if (part.char(i - 1) === '(') {\n      const argsString = restOfExp(constants, part.substring(i), [], '(');\n      i += argsString.length + 1;\n      let found;\n      let j = 0;\n      while ((found = restOfExp(constants, argsString.substring(j), [/^,/])).length) {\n        j += found.length + 1;\n        args.push(found.trim());\n      }\n    }\n    ctx.lispTree = lispify(\n      constants,\n      part.substring(i),\n      expectTypes.expEdge.next,\n      createLisp({\n        op: LispType.New,\n        a: lispify(constants, obj, expectTypes.initialize.next),\n        b: args.map((arg) => lispify(constants, arg, expectTypes.initialize.next)),\n      }),\n      false,\n      ctx,\n    );\n  });\n\n  void semiColon;\n}\n"],"mappings":";;;AAiBA,SAAgB,uBAAuB,EACrC,YACA,aACA,SACA,aACA,WACA,WACA,eACwB;AACxB,aAAY,CAAC,UAAU,QAAQ,GAAY,QAAQ;EACjD,MAAM,EAAE,WAAW,MAAM,MAAM,QAAQ;EACvC,MAAM,OAAO,KAAK,UAAU,IAAI,GAAG,OAAO;AAC1C,MAAI,SAAS,WAAW,CAAC,KAAK,WAAW,CAAC,OACxC,OAAM,IAAI,YAAY,+BAA+B;AAEvD,MAAI,WAAW,WAA2B;GACxC,IAAI,SAAS,WAAW,SAAS,SAAS,SAAS;GACnD,GAAG,SAAS;GACZ,GAAG,YAAY,WAAW,MAAM,KAAA,GAAW,IAAI;GAChD,CAAC;GACF;AAEF,aAAY;EAAC;EAAU;EAAW;EAAQ;EAAO;EAAO;EAAW,GAAY,QAAQ;EACrF,MAAM,EAAE,WAAW,MAAM,MAAM,KAAK,WAAW;AAC/C,MAAI,WAAW,QACb,WACA,KAAK,UAAU,IAAI,GAAG,OAAO,EAC7B,YAAY,QAAQ,MACpB,WAAmD;GACjD,IACE,SAAS,WAAY,IAAI,MAAM,SAAS,SAAS,SAAS,SAAU,SAAS;GAC/E,GAAG,SAAS;GACZ,GAAG,IAAI,MAAM,IAAI,KAAK,IAAI;GAC3B,CAAC,EACF,OACA,IACD;GACD;AAEF,aAAY;EAAC;EAAU;EAAW;EAAQ,GAAY,QAAQ;EAC5D,MAAM,EAAE,WAAW,MAAM,MAAM,KAAK,WAAW;AAC/C,MAAI,WAAW,QACb,WACA,KAAK,UAAU,IAAI,GAAG,OAAO,EAC7B,YAAY,QAAQ,MACpB,WAAoD;GAClD,IACE,SAAS,WACL,SAAS,cACT,SAAS,YACP,SAAS,eACT,SAAS;GACjB,GAAG,SAAS;GACZ,GAAG,IAAI;GACR,CAAC,EACF,OACA,IACD;GACD;AAEF,aAAY,CAAC,QAAQ,QAAQ,GAAY,QAAQ;EAC/C,MAAM,EAAE,WAAW,MAAM,MAAM,KAAK,WAAW;EAC/C,MAAM,UAAU,UAAU,WAAW,KAAK,UAAU,IAAI,GAAG,OAAO,EAAE,CAAC,uBAAuB,CAAC;AAC7F,MAAI,CAAC,QAAQ,WAAW,CAAC,OACvB,OAAM,IAAI,YAAY,+BAA+B;AAEvD,MAAI,WAAW,QACb,WACA,KAAK,UAAU,IAAI,GAAG,SAAS,QAAQ,OAAO,EAC9C,YAAY,QAAQ,MACpB,WAAyB;GACvB,IAAI,SAAS,SAAS,SAAS,OAAO,SAAS;GAC/C,GAAG,QAAQ,WAAW,QAAQ;GAC9B,GAAG,SAAS;GACb,CAAC,EACF,OACA,IACD;GACD;AAEF,aAAY,CAAC,QAAQ,GAAY,QAAQ;EACvC,MAAM,EAAE,WAAW,MAAM,KAAK,QAAQ,mBAAmB;AACzD,MAAI,mBAAmB,EACrB,OAAM,IAAI,YAAY,mBAAmB;EAE3C,MAAM,aAAa,IAAI,GAAG,SAAS,CAAC,SAAS,IAAI;EACjD,MAAM,UAAU,UAAU,WAAW,KAAK,UAAU,IAAI,GAAG,OAAO,EAAE,CAAC,uBAAuB,CAAC;AAC7F,MAAI,cAAc,CAAC,QAAQ,WAAW,CAAC,OACrC,OAAM,IAAI,YAAY,+BAA+B;AAEvD,MAAI,WAAW,QACb,WACA,KAAK,UAAU,IAAI,GAAG,SAAS,QAAQ,OAAO,EAC9C,YAAY,QAAQ,MACpB,WAAkC;GAChC,IAAI,aAAa,SAAS,gBAAgB,SAAS;GACnD,GAAG,QAAQ,WAAW,QAAQ;GAC9B,GAAG,SAAS;GACb,CAAC,EACF,OACA,IACD;GACD;AAEF,aAAY,CAAC,MAAM,GAAY,QAAQ;EACrC,MAAM,EAAE,WAAW,MAAM,QAAQ;EACjC,IAAI,IAAI,IAAI,GAAG;EACf,MAAM,MAAM,UAAU,WAAW,KAAK,UAAU,EAAE,EAAE,EAAE,EAAE,KAAA,GAAW,IAAI;AACvE,MAAI,CAAC,IAAI,WAAW,CAAC,OACnB,OAAM,IAAI,YAAY,+BAA+B;AAEvD,OAAK,IAAI,SAAS;EAClB,MAAM,OAAO,EAAE;AACf,MAAI,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK;GAC5B,MAAM,aAAa,UAAU,WAAW,KAAK,UAAU,EAAE,EAAE,EAAE,EAAE,IAAI;AACnE,QAAK,WAAW,SAAS;GACzB,IAAI;GACJ,IAAI,IAAI;AACR,WAAQ,QAAQ,UAAU,WAAW,WAAW,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ;AAC7E,SAAK,MAAM,SAAS;AACpB,SAAK,KAAK,MAAM,MAAM,CAAC;;;AAG3B,MAAI,WAAW,QACb,WACA,KAAK,UAAU,EAAE,EACjB,YAAY,QAAQ,MACpB,WAAW;GACT,IAAI,SAAS;GACb,GAAG,QAAQ,WAAW,KAAK,YAAY,WAAW,KAAK;GACvD,GAAG,KAAK,KAAK,QAAQ,QAAQ,WAAW,KAAK,YAAY,WAAW,KAAK,CAAC;GAC3E,CAAC,EACF,OACA,IACD;GACD"}

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