@nyariv/sandboxjs 0.8.22 → 0.8.24

package/build/parser.js

@@ -1,244 +1,158 @@
-import unraw from "./unraw.js";
-let lispTypes = new Map();
+import unraw from './unraw.js';
+import { CodeString, isLisp } from './utils.js';
+function createLisp(obj) {
+    return [obj.op, obj.a, obj.b];
+}
+const NullLisp = createLisp({ op: 0 /* LispType.None */, a: 0 /* LispType.None */, b: 0 /* LispType.None */ });
+const lispTypes = new Map();
 export class ParseError extends Error {
     constructor(message, code) {
-        super(message + ": " + code.substring(0, 40));
+        super(message + ': ' + code.substring(0, 40));
         this.code = code;
     }
 }
-export class Lisp {
-    constructor(obj) {
-        this.op = obj.op;
-        this.a = obj.a;
-        this.b = obj.b;
-    }
-}
-export class If {
-    constructor(t, f) {
-        this.t = t;
-        this.f = f;
-    }
-}
-export class KeyVal {
-    constructor(key, val) {
-        this.key = key;
-        this.val = val;
-    }
-}
-export class SpreadObject {
-    constructor(item) {
-        this.item = item;
-    }
-}
-export class SpreadArray {
-    constructor(item) {
-        this.item = item;
-    }
-}
-export const lispArrayKey = {};
-export function toLispArray(arr) {
-    arr.lisp = lispArrayKey;
-    return arr;
-}
+let lastType;
+let lastPart;
+let lastLastPart;
+let lastLastLastPart;
+let lastLastLastLastPart;
 const inlineIfElse = /^:/;
-const elseIf = /^else(?![\w\$])/;
-const ifElse = /^if(?![\w\$])/;
+const elseIf = /^else(?![\w$])/;
+const ifElse = /^if(?![\w$])/;
 const space = /^\s/;
-export let expectTypes = {
+export const expectTypes = {
     splitter: {
         types: {
-            opHigh: /^(\/|\*\*|\*(?!\*)|\%)(?!\=)/,
-            op: /^(\+(?!(\+))|\-(?!(\-)))(?!\=)/,
-            comparitor: /^(<=|>=|<(?!<)|>(?!>)|!==|!=(?!\=)|===|==)/,
-            boolOp: /^(&&|\|\||instanceof(?![\w\$])|in(?![\w\$]))/,
-            bitwise: /^(&(?!&)|\|(?!\|)|\^|<<|>>(?!>)|>>>)(?!\=)/,
+            opHigh: /^(\/|\*\*|\*(?!\*)|%)(?!=)/,
+            op: /^(\+(?!(\+))|-(?!(-)))(?!=)/,
+            comparitor: /^(<=|>=|<(?!<)|>(?!>)|!==|!=(?!=)|===|==)/,
+            boolOp: /^(&&|\|\||instanceof(?![\w$])|in(?![\w$]))/,
+            bitwise: /^(&(?!&)|\|(?!\|)|\^|<<|>>(?!>)|>>>)(?!=)/,
         },
-        next: [
-            'modifier',
-            'value',
-            'prop',
-            'incrementerBefore',
-        ]
+        next: ['modifier', 'value', 'prop', 'incrementerBefore'],
     },
     inlineIf: {
         types: {
             inlineIf: /^\?(?!\.(?!\d))/,
         },
-        next: [
-            'expEnd'
-        ]
+        next: ['expEnd'],
     },
     assignment: {
         types: {
-            assignModify: /^(\-=|\+=|\/=|\*\*=|\*=|%=|\^=|\&=|\|=|>>>=|>>=|<<=)/,
-            assign: /^(=)(?!=)/
+            assignModify: /^(-=|\+=|\/=|\*\*=|\*=|%=|\^=|&=|\|=|>>>=|>>=|<<=)/,
+            assign: /^(=)(?!=)/,
         },
-        next: [
-            'modifier',
-            'value',
-            'prop',
-            'incrementerBefore',
-        ]
+        next: ['modifier', 'value', 'prop', 'incrementerBefore'],
     },
     incrementerBefore: {
-        types: { incrementerBefore: /^(\+\+|\-\-)/ },
-        next: [
-            'prop',
-        ]
+        types: { incrementerBefore: /^(\+\+|--)/ },
+        next: ['prop'],
     },
     expEdge: {
         types: {
-            call: /^(\?\.)?[\(]/,
-            incrementerAfter: /^(\+\+|\-\-)/
+            call: /^(\?\.)?[(]/,
+            incrementerAfter: /^(\+\+|--)/,
         },
-        next: [
-            'splitter',
-            'expEdge',
-            'dot',
-            'inlineIf',
-            'expEnd'
-        ]
+        next: ['splitter', 'expEdge', 'dot', 'inlineIf', 'expEnd'],
     },
     modifier: {
         types: {
             not: /^!/,
             inverse: /^~/,
-            negative: /^\-(?!\-)/,
+            negative: /^-(?!-)/,
             positive: /^\+(?!\+)/,
-            typeof: /^typeof(?![\w\$])/,
-            delete: /^delete(?![\w\$])/,
+            typeof: /^typeof(?![\w$])/,
+            delete: /^delete(?![\w$])/,
         },
-        next: [
-            'modifier',
-            'value',
-            'prop',
-            'incrementerBefore',
-        ]
+        next: ['modifier', 'value', 'prop', 'incrementerBefore'],
     },
     dot: {
         types: {
             arrayProp: /^(\?\.)?\[/,
-            dot: /^(\?)?\.(?=\s*[a-zA-Z\$\_])/,
+            dot: /^(\?)?\.(?=\s*[a-zA-Z$_])/,
         },
-        next: [
-            'splitter',
-            'assignment',
-            'expEdge',
-            'dot',
-            'inlineIf',
-            'expEnd'
-        ]
+        next: ['splitter', 'assignment', 'expEdge', 'dot', 'inlineIf', 'expEnd'],
     },
     prop: {
         types: {
-            prop: /^[a-zA-Z\$\_][a-zA-Z\d\$\_]*/,
+            prop: /^[a-zA-Z$_][a-zA-Z\d$_]*/,
         },
-        next: [
-            'splitter',
-            'assignment',
-            'expEdge',
-            'dot',
-            'inlineIf',
-            'expEnd'
-        ]
+        next: ['splitter', 'assignment', 'expEdge', 'dot', 'inlineIf', 'expEnd'],
     },
     value: {
         types: {
             createObject: /^\{/,
             createArray: /^\[/,
-            number: /^(0x[\da-f]+(_[\da-f]+)*|(\d+(_\d+)*(\.\d+(_\d+)*)?|\.\d+(_\d+)*))(e[\+\-]?\d+(_\d+)*)?(n)?(?!\d)/i,
+            number: /^(0x[\da-f]+(_[\da-f]+)*|(\d+(_\d+)*(\.\d+(_\d+)*)?|\.\d+(_\d+)*))(e[+-]?\d+(_\d+)*)?(n)?(?!\d)/i,
             string: /^"(\d+)"/,
             literal: /^`(\d+)`/,
-            regex: /^\/(\d+)\/r(?![\w\$])/,
-            boolean: /^(true|false)(?![\w\$])/,
-            null: /^null(?![\w\$])/,
-            und: /^undefined(?![\w\$])/,
-            arrowFunctionSingle: /^(async\s+)?([a-zA-Z\$_][a-zA-Z\d\$_]*)\s*=>\s*({)?/,
-            arrowFunction: /^(async\s*)?\(\s*((\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*)*)?\s*\)\s*=>\s*({)?/,
-            inlineFunction: /^(async\s+)?function(\s*[a-zA-Z\$_][a-zA-Z\d\$_]*)?\s*\(\s*((\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*)*)?\s*\)\s*{/,
+            regex: /^\/(\d+)\/r(?![\w$])/,
+            boolean: /^(true|false)(?![\w$])/,
+            null: /^null(?![\w$])/,
+            und: /^undefined(?![\w$])/,
+            arrowFunctionSingle: /^(async\s+)?([a-zA-Z$_][a-zA-Z\d$_]*)\s*=>\s*({)?/,
+            arrowFunction: /^(async\s*)?\(\s*((\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*)*)?\s*\)\s*=>\s*({)?/,
+            inlineFunction: /^(async\s+)?function(\s*[a-zA-Z$_][a-zA-Z\d$_]*)?\s*\(\s*((\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*)*)?\s*\)\s*{/,
             group: /^\(/,
-            NaN: /^NaN(?![\w\$])/,
-            Infinity: /^Infinity(?![\w\$])/,
-            void: /^void(?![\w\$])\s*/,
-            await: /^await(?![\w\$])\s*/,
-            new: /^new(?![\w\$])\s*/,
-            throw: /^throw(?![\w\$])\s*/
+            NaN: /^NaN(?![\w$])/,
+            Infinity: /^Infinity(?![\w$])/,
+            void: /^void(?![\w$])\s*/,
+            await: /^await(?![\w$])\s*/,
+            new: /^new(?![\w$])\s*/,
         },
-        next: [
-            'splitter',
-            'expEdge',
-            'dot',
-            'inlineIf',
-            'expEnd'
-        ]
+        next: ['splitter', 'expEdge', 'dot', 'inlineIf', 'expEnd'],
     },
     initialize: {
         types: {
-            initialize: /^(var|let|const)\s+([a-zA-Z\$_][a-zA-Z\d\$_]*)\s*(=)?/,
-            return: /^return(?![\w\$])/,
+            initialize: /^(var|let|const)\s+([a-zA-Z$_][a-zA-Z\d$_]*)\s*(=)?/,
+            return: /^return(?![\w$])/,
+            throw: /^throw(?![\w$])\s*/,
         },
-        next: [
-            'modifier',
-            'value',
-            'prop',
-            'incrementerBefore',
-            'expEnd'
-        ]
+        next: ['modifier', 'value', 'prop', 'incrementerBefore', 'expEnd'],
     },
     spreadObject: {
         types: {
-            spreadObject: /^\.\.\./
+            spreadObject: /^\.\.\./,
         },
-        next: [
-            'value',
-            'prop',
-        ]
+        next: ['value', 'prop'],
     },
     spreadArray: {
         types: {
-            spreadArray: /^\.\.\./
+            spreadArray: /^\.\.\./,
         },
-        next: [
-            'value',
-            'prop',
-        ]
+        next: ['value', 'prop'],
     },
     expEnd: { types: {}, next: [] },
     expFunction: {
         types: {
-            function: /^(async\s+)?function(\s*[a-zA-Z\$_][a-zA-Z\d\$_]*)\s*\(\s*((\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z\$_][a-zA-Z\d\$_]*)*)?\s*\)\s*{/,
+            function: /^(async\s+)?function(\s*[a-zA-Z$_][a-zA-Z\d$_]*)\s*\(\s*((\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*(\s*,\s*(\.\.\.)?\s*[a-zA-Z$_][a-zA-Z\d$_]*)*)?\s*\)\s*{/,
         },
-        next: [
-            'expEdge',
-            'expEnd'
-        ]
+        next: ['expEdge', 'expEnd'],
     },
     expSingle: {
         types: {
-            for: /^(([a-zA-Z\$\_][\w\$]*)\s*:)?\s*for\s*\(/,
-            do: /^(([a-zA-Z\$\_][\w\$]*)\s*:)?\s*do(?![\w\$])\s*(\{)?/,
-            while: /^(([a-zA-Z\$\_][\w\$]*)\s*:)?\s*while\s*\(/,
-            loopAction: /^(break|continue)(?![\w\$])\s*([a-zA-Z\$\_][\w\$]*)?/,
-            if: /^((([a-zA-Z\$\_][\w\$]*)\s*:)?\s*)if\s*\(/,
+            for: /^(([a-zA-Z$_][\w$]*)\s*:)?\s*for\s*\(/,
+            do: /^(([a-zA-Z$_][\w$]*)\s*:)?\s*do(?![\w$])\s*(\{)?/,
+            while: /^(([a-zA-Z$_][\w$]*)\s*:)?\s*while\s*\(/,
+            loopAction: /^(break|continue)(?![\w$])\s*([a-zA-Z$_][\w$]*)?/,
+            if: /^((([a-zA-Z$_][\w$]*)\s*:)?\s*)if\s*\(/,
             try: /^try\s*{/,
             block: /^{/,
-            switch: /^(([a-zA-Z\$\_][\w\$]*)\s*:)?\s*switch\s*\(/,
+            switch: /^(([a-zA-Z$_][\w$]*)\s*:)?\s*switch\s*\(/,
         },
-        next: [
-            'expEnd'
-        ]
-    }
+        next: ['expEnd'],
+    },
 };
-let closings = {
-    "(": ")",
-    "[": "]",
-    "{": "}",
+const closings = {
+    '(': ')',
+    '[': ']',
+    '{': '}',
     "'": "'",
     '"': '"',
-    "`": "`"
+    '`': '`',
 };
 export function testMultiple(str, tests) {
-    let found;
+    let found = null;
     for (let i = 0; i < tests.length; i++) {
         const test = tests[i];
         found = test.exec(str);
@@ -247,97 +161,10 @@ export function testMultiple(str, tests) {
     }
     return found;
 }
-export class CodeString {
-    constructor(str) {
-        this.ref = { str: "" };
-        if (str instanceof CodeString) {
-            this.ref = str.ref;
-            this.start = str.start;
-            this.end = str.end;
-        }
-        else {
-            this.ref.str = str;
-            this.start = 0;
-            this.end = str.length;
-        }
-    }
-    substring(start, end) {
-        if (!this.length)
-            return this;
-        start = this.start + start;
-        if (start < 0) {
-            start = 0;
-        }
-        if (start > this.end) {
-            start = this.end;
-        }
-        end = end === undefined ? this.end : this.start + end;
-        if (end < 0) {
-            end = 0;
-        }
-        if (end > this.end) {
-            end = this.end;
-        }
-        const code = new CodeString(this);
-        code.start = start;
-        code.end = end;
-        return code;
-    }
-    get length() {
-        const len = this.end - this.start;
-        return len < 0 ? 0 : len;
-    }
-    char(i) {
-        if (this.start === this.end)
-            return undefined;
-        return this.ref.str[this.start + i];
-    }
-    toString() {
-        return this.ref.str.substring(this.start, this.end);
-    }
-    trimStart() {
-        const found = /^\s+/.exec(this.toString());
-        const code = new CodeString(this);
-        if (found) {
-            code.start += found[0].length;
-        }
-        return code;
-    }
-    slice(start, end) {
-        if (start < 0) {
-            start = this.end - this.start + start;
-        }
-        if (start < 0) {
-            start = 0;
-        }
-        if (end === undefined) {
-            end = this.end - this.start;
-        }
-        if (end < 0) {
-            end = this.end - this.start + end;
-        }
-        if (end < 0) {
-            end = 0;
-        }
-        return this.substring(start, end);
-    }
-    trim() {
-        const code = this.trimStart();
-        const found = /\s+$/.exec(code.toString());
-        if (found) {
-            code.end -= found[0].length;
-        }
-        return code;
-    }
-    valueOf() {
-        return this.toString();
-    }
-}
-const emptyString = new CodeString("");
-const okFirstChars = /^[\+\-~ !]/;
-const aChar = /^[\w\$]/;
+const emptyString = new CodeString('');
+const okFirstChars = /^[+\-~ !]/;
 const aNumber = expectTypes.value.types.number;
-const wordReg = /^((if|for|else|while|do|function)(?![\w\$])|[\w\$]+)/;
+const wordReg = /^((if|for|else|while|do|function)(?![\w$])|[\w$]+)/;
 const semiColon = /^;/;
 const insertedSemicolons = new WeakMap();
 const quoteCache = new WeakMap();
@@ -360,21 +187,21 @@ export function restOfExp(constants, part, tests, quote, firstOpening, closingsT
     }
     let escape = false;
     let done = false;
-    let lastChar = "";
+    let lastChar = '';
     let isOneLiner = false;
     let i;
     let lastInertedSemi = false;
     for (i = 0; i < part.length && !done; i++) {
         let char = part.char(i);
-        if (quote === '"' || quote === "'" || quote === "`") {
-            if (quote === "`" && char === "$" && part.char(i + 1) === "{" && !escape) {
-                let skip = restOfExp(constants, part.substring(i + 2), [], "{");
+        if (quote === '"' || quote === "'" || quote === '`') {
+            if (quote === '`' && char === '$' && part.char(i + 1) === '{' && !escape) {
+                const skip = restOfExp(constants, part.substring(i + 2), [], '{');
                 i += skip.length + 2;
             }
             else if (char === quote && !escape) {
                 return part.substring(0, i);
             }
-            escape = !escape && char === "\\";
+            escape = !escape && char === '\\';
         }
         else if (closings[char]) {
             if (!lastInertedSemi && insertedSemis[i + part.start]) {
@@ -386,7 +213,7 @@ export function restOfExp(constants, part, tests, quote, firstOpening, closingsT
                 lastChar = ';';
                 continue;
             }
-            if (isOneLiner && char === "{") {
+            if (isOneLiner && char === '{') {
                 isOneLiner = false;
             }
             if (char === firstOpening) {
@@ -394,14 +221,14 @@ export function restOfExp(constants, part, tests, quote, firstOpening, closingsT
                 break;
             }
             else {
-                let skip = restOfExp(constants, part.substring(i + 1), [], char);
+                const skip = restOfExp(constants, part.substring(i + 1), [], char);
                 cache.set(skip.start - 1, skip.end);
                 i += skip.length + 1;
                 isStart = false;
                 if (closingsTests) {
-                    let sub = part.substring(i);
+                    const sub = part.substring(i);
                     let found;
-                    if (found = testMultiple(sub.toString(), closingsTests)) {
+                    if ((found = testMultiple(sub.toString(), closingsTests))) {
                         details.regRes = found;
                         done = true;
                     }
@@ -414,22 +241,22 @@ export function restOfExp(constants, part, tests, quote, firstOpening, closingsT
             let foundNumber;
             if (closingsTests) {
                 let found;
-                if (found = testMultiple(sub, closingsTests)) {
+                if ((found = testMultiple(sub, closingsTests))) {
                     details.regRes = found;
                     i++;
                     done = true;
                     break;
                 }
             }
-            if (foundNumber = aNumber.exec(sub)) {
+            if ((foundNumber = aNumber.exec(sub))) {
                 i += foundNumber[0].length - 1;
                 sub = part.substring(i).toString();
             }
             else if (lastChar != char) {
-                let found;
+                let found = null;
                 if (char === ';' || (insertedSemis[i + part.start] && !isStart && !lastInertedSemi)) {
                     if (hasSemiTest) {
-                        found = [";"];
+                        found = [';'];
                     }
                     else if (insertedSemis[i + part.start]) {
                         lastInertedSemi = true;
@@ -486,37 +313,49 @@ export function restOfExp(constants, part, tests, quote, firstOpening, closingsT
     }
     return part.substring(0, i);
 }
-restOfExp.next = [
-    'splitter',
+restOfExp.next = ['splitter', 'expEnd', 'inlineIf'];
+const startingExecpted = [
+    'initialize',
+    'expSingle',
+    'expFunction',
+    'value',
+    'modifier',
+    'prop',
+    'incrementerBefore',
     'expEnd',
-    'inlineIf'
 ];
-const startingExecpted = ['initialize', 'expSingle', 'expFunction', 'value', 'modifier', 'prop', 'incrementerBefore', 'expEnd'];
 export const setLispType = (types, fn) => {
     types.forEach((type) => {
         lispTypes.set(type, fn);
     });
 };
 const closingsCreate = {
-    'createArray': /^\]/,
-    'createObject': /^\}/,
-    'group': /^\)/,
-    'arrayProp': /^\]/,
-    'call': /^\)/
+    createArray: /^\]/,
+    createObject: /^\}/,
+    group: /^\)/,
+    arrayProp: /^\]/,
+    call: /^\)/,
+};
+const typesCreate = {
+    createArray: 12 /* LispType.CreateArray */,
+    createObject: 22 /* LispType.CreateObject */,
+    group: 23 /* LispType.Group */,
+    arrayProp: 19 /* LispType.ArrayProp */,
+    call: 5 /* LispType.Call */,
+    prop: 1 /* LispType.Prop */,
+    '?prop': 20 /* LispType.PropOptional */,
+    '?call': 21 /* LispType.CallOptional */,
 };
 setLispType(['createArray', 'createObject', 'group', 'arrayProp', 'call'], (constants, type, part, res, expect, ctx) => {
     let extract = emptyString;
-    let arg = [];
+    const arg = [];
     let end = false;
     let i = res[0].length;
     const start = i;
     while (i < part.length && !end) {
-        extract = restOfExp(constants, part.substring(i), [
-            closingsCreate[type],
-            /^,/
-        ]);
+        extract = restOfExp(constants, part.substring(i), [closingsCreate[type], /^,/]);
         i += extract.length;
-        if (extract.length) {
+        if (extract.trim().length) {
             arg.push(extract);
         }
         if (part.char(i) !== ',') {
@@ -537,76 +376,136 @@ setLispType(['createArray', 'createObject', 'group', 'arrayProp', 'call'], (cons
         case 'call':
         case 'createArray':
             // @TODO: support 'empty' values
-            l = toLispArray(arg.map((e) => lispify(constants, e, [...next, 'spreadArray'])));
+            l = arg.map((e) => lispify(constants, e, [...next, 'spreadArray']));
             break;
         case 'createObject':
-            l = toLispArray(arg.map((str) => {
+            l = arg.map((str) => {
                 str = str.trimStart();
                 let value;
-                let key;
+                let key = '';
                 funcFound = expectTypes.expFunction.types.function.exec('function ' + str);
                 if (funcFound) {
                     key = funcFound[2].trimStart();
-                    value = lispify(constants, new CodeString('function ' + str.toString().replace(key, "")));
+                    value = lispify(constants, new CodeString('function ' + str.toString().replace(key, '')));
                 }
                 else {
-                    let extract = restOfExp(constants, str, [/^:/]);
+                    const extract = restOfExp(constants, str, [/^:/]);
                     key = lispify(constants, extract, [...next, 'spreadObject']);
-                    if (key instanceof Lisp && key.op === 'prop') {
-                        key = key.b;
+                    if (key[0] === 1 /* LispType.Prop */) {
+                        key = key[2];
                     }
-                    if (extract.length === str.length)
-                        return key;
                     value = lispify(constants, str.substring(extract.length + 1));
                 }
-                return new Lisp({
-                    op: 'keyVal',
+                return createLisp({
+                    op: 6 /* LispType.KeyVal */,
                     a: key,
-                    b: value
+                    b: value,
                 });
-            }));
+            });
             break;
     }
-    type = type === 'arrayProp' ? (res[1] ? '?prop' : 'prop') : (type === 'call' ? (res[1] ? '?call' : 'call') : type);
-    ctx.lispTree = lispify(constants, part.substring(i + 1), expectTypes[expect].next, new Lisp({
-        op: type,
+    const lisptype = (type === 'arrayProp'
+        ? res[1]
+            ? 20 /* LispType.PropOptional */
+            : 1 /* LispType.Prop */
+        : type === 'call'
+            ? res[1]
+                ? 21 /* LispType.CallOptional */
+                : 5 /* LispType.Call */
+            : typesCreate[type]);
+    ctx.lispTree = lispify(constants, part.substring(i + 1), expectTypes[expect].next, createLisp({
+        op: lisptype,
         a: ctx.lispTree,
         b: l,
     }));
 });
+const modifierTypes = {
+    inverse: 64 /* LispType.Inverse */,
+    not: 24 /* LispType.Not */,
+    positive: 59 /* LispType.Positive */,
+    negative: 58 /* LispType.Negative */,
+    typeof: 60 /* LispType.Typeof */,
+    delete: 61 /* LispType.Delete */,
+};
 setLispType(['inverse', 'not', 'negative', 'positive', 'typeof', 'delete'], (constants, type, part, res, expect, ctx) => {
-    let extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s\.\?\w\$]|\?[^\.])/]);
-    ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, new Lisp({
-        op: ['positive', 'negative'].includes(type) ? '$' + res[0] : res[0],
+    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
+    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),
     }));
 });
+const incrementTypes = {
+    '++$': 25 /* LispType.IncrementBefore */,
+    '--$': 27 /* LispType.DecrementBefore */,
+    '$++': 26 /* LispType.IncrementAfter */,
+    '$--': 28 /* LispType.DecrementAfter */,
+};
 setLispType(['incrementerBefore'], (constants, type, part, res, expect, ctx) => {
-    let extract = restOfExp(constants, part.substring(2), [/^[^\s\.\w\$]/]);
-    ctx.lispTree = lispify(constants, part.substring(extract.length + 2), restOfExp.next, new Lisp({
-        op: res[0] + "$",
+    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[expect].next),
+        b: 0 /* LispType.None */,
     }));
 });
 setLispType(['incrementerAfter'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, new Lisp({
-        op: "$" + res[0],
+    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+        op: incrementTypes['$' + res[0]],
         a: ctx.lispTree,
+        b: 0 /* LispType.None */,
     }));
 });
+const adderTypes = {
+    '&&': 29 /* LispType.And */,
+    '||': 30 /* LispType.Or */,
+    instanceof: 62 /* LispType.Instanceof */,
+    in: 63 /* LispType.In */,
+    '=': 9 /* LispType.Assign */,
+    '-=': 65 /* LispType.SubractEquals */,
+    '+=': 66 /* LispType.AddEquals */,
+    '/=': 67 /* LispType.DivideEquals */,
+    '**=': 68 /* LispType.PowerEquals */,
+    '*=': 69 /* LispType.MultiplyEquals */,
+    '%=': 70 /* LispType.ModulusEquals */,
+    '^=': 71 /* LispType.BitNegateEquals */,
+    '&=': 72 /* LispType.BitAndEquals */,
+    '|=': 73 /* LispType.BitOrEquals */,
+    '>>>=': 74 /* LispType.UnsignedShiftRightEquals */,
+    '<<=': 76 /* LispType.ShiftLeftEquals */,
+    '>>=': 75 /* LispType.ShiftRightEquals */,
+};
 setLispType(['assign', 'assignModify', 'boolOp'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = new Lisp({
-        op: res[0],
+    ctx.lispTree = createLisp({
+        op: adderTypes[res[0]],
         a: ctx.lispTree,
-        b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)
+        b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next),
     });
 });
+const opTypes = {
+    '&': 77 /* LispType.BitAnd */,
+    '|': 78 /* LispType.BitOr */,
+    '^': 79 /* LispType.BitNegate */,
+    '<<': 80 /* LispType.BitShiftLeft */,
+    '>>': 81 /* LispType.BitShiftRight */,
+    '>>>': 82 /* LispType.BitUnsignedShiftRight */,
+    '<=': 54 /* LispType.SmallerEqualThan */,
+    '>=': 55 /* LispType.LargerEqualThan */,
+    '<': 56 /* LispType.SmallerThan */,
+    '>': 57 /* LispType.LargerThan */,
+    '!==': 31 /* LispType.StrictNotEqual */,
+    '!=': 53 /* LispType.NotEqual */,
+    '===': 32 /* LispType.StrictEqual */,
+    '==': 52 /* LispType.Equal */,
+    '+': 33 /* LispType.Plus */,
+    '-': 47 /* LispType.Minus */,
+    '/': 48 /* LispType.Divide */,
+    '**': 49 /* LispType.Power */,
+    '*': 50 /* LispType.Multiply */,
+    '%': 51 /* LispType.Modulus */,
+};
 setLispType(['opHigh', 'op', 'comparitor', 'bitwise'], (constants, type, part, res, expect, ctx) => {
-    const next = [
-        expectTypes.inlineIf.types.inlineIf,
-        inlineIfElse
-    ];
+    const next = [expectTypes.inlineIf.types.inlineIf, inlineIfElse];
     switch (type) {
         case 'opHigh':
             next.push(expectTypes.splitter.types.opHigh);
@@ -618,21 +517,21 @@ setLispType(['opHigh', 'op', 'comparitor', 'bitwise'], (constants, type, part, r
             next.push(expectTypes.splitter.types.bitwise);
             next.push(expectTypes.splitter.types.boolOp);
     }
-    let extract = restOfExp(constants, part.substring(res[0].length), next);
-    ctx.lispTree = lispify(constants, part.substring(extract.length + res[0].length), restOfExp.next, new Lisp({
-        op: res[0],
+    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[expect].next),
     }));
 });
 setLispType(['inlineIf'], (constants, type, part, res, expect, ctx) => {
     let found = false;
-    let extract = part.substring(0, 0);
+    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
+            inlineIfElse,
         ]).end;
         if (part.char(extract.length) === '?') {
             quoteCount++;
@@ -645,14 +544,17 @@ setLispType(['inlineIf'], (constants, type, part, res, expect, ctx) => {
         }
     }
     extract.start = part.start + 1;
-    ctx.lispTree = new Lisp({
-        op: '?',
+    ctx.lispTree = createLisp({
+        op: 15 /* LispType.InlineIf */,
         a: ctx.lispTree,
-        b: new If(lispifyExpr(constants, extract), lispifyExpr(constants, part.substring(res[0].length + extract.length + 1)))
+        b: createLisp({
+            op: 16 /* LispType.InlineIfCase */,
+            a: lispifyExpr(constants, extract),
+            b: lispifyExpr(constants, part.substring(res[0].length + extract.length + 1)),
+        }),
     });
 });
 function extractIfElse(constants, part) {
-    var _a;
     let count = 0;
     let found = part.substring(0, 0);
     let foundElse = emptyString;
@@ -660,10 +562,11 @@ function extractIfElse(constants, part) {
     let first = true;
     let elseReg;
     let details = {};
-    while ((found = restOfExp(constants, part.substring(found.end - part.start), [elseIf, ifElse, semiColon], undefined, undefined, undefined, details)).length || first) {
+    while ((found = restOfExp(constants, part.substring(found.end - part.start), [elseIf, ifElse, semiColon], undefined, undefined, undefined, details)).length ||
+        first) {
         first = false;
         const f = part.substring(found.end - part.start).toString();
-        if (f.startsWith("if")) {
+        if (f.startsWith('if')) {
             found.end++;
             count++;
         }
@@ -675,7 +578,7 @@ function extractIfElse(constants, part) {
                 found.end--;
             }
         }
-        else if (elseReg = /^;?\s*else(?![\w\$])/.exec(f)) {
+        else if ((elseReg = /^;?\s*else(?![\w$])/.exec(f))) {
             foundTrue = part.substring(0, found.end - part.start);
             found.end += elseReg[0].length - 1;
             count--;
@@ -688,64 +591,71 @@ function extractIfElse(constants, part) {
             break;
         }
         if (!count) {
-            let ie = extractIfElse(constants, part.substring(found.end - part.start + ((_a = /^;?\s*else(?![\w\$])/.exec(f)) === null || _a === void 0 ? void 0 : _a[0].length)));
+            const ie = extractIfElse(constants, part.substring(found.end - part.start + (/^;?\s*else(?![\w$])/.exec(f)?.[0].length || 0)));
             foundElse = ie.all;
             break;
         }
         details = {};
     }
     foundTrue = foundTrue || part.substring(0, found.end - part.start);
-    return { all: part.substring(0, Math.max(foundTrue.end, foundElse.end) - part.start), true: foundTrue, false: foundElse };
+    return {
+        all: part.substring(0, Math.max(foundTrue.end, foundElse.end) - part.start),
+        true: foundTrue,
+        false: foundElse,
+    };
 }
 setLispType(['if'], (constants, type, part, res, expect, ctx) => {
-    let condition = restOfExp(constants, part.substring(res[0].length), [], "(");
+    let condition = restOfExp(constants, part.substring(res[0].length), [], '(');
     const ie = extractIfElse(constants, part.substring(res[1].length));
-    const isBlock = /^\s*\{/.exec(part.substring(res[0].length + condition.length + 1).toString());
     const startTrue = res[0].length - res[1].length + condition.length + 1;
     let trueBlock = ie.true.substring(startTrue);
     let elseBlock = ie.false;
     condition = condition.trim();
     trueBlock = trueBlock.trim();
     elseBlock = elseBlock.trim();
-    if (trueBlock.char(0) === "{")
+    if (trueBlock.char(0) === '{')
         trueBlock = trueBlock.slice(1, -1);
-    if (elseBlock.char(0) === "{")
+    if (elseBlock.char(0) === '{')
         elseBlock = elseBlock.slice(1, -1);
-    ctx.lispTree = new Lisp({
-        op: 'if',
+    ctx.lispTree = createLisp({
+        op: 13 /* LispType.If */,
         a: lispifyExpr(constants, condition),
-        b: new If(lispifyBlock(trueBlock, constants), elseBlock.length ? lispifyBlock(elseBlock, constants) : undefined)
+        b: createLisp({
+            op: 14 /* LispType.IfCase */,
+            a: lispifyBlock(trueBlock, constants),
+            b: lispifyBlock(elseBlock, constants),
+        }),
     });
 });
 setLispType(['switch'], (constants, type, part, res, expect, ctx) => {
-    const test = restOfExp(constants, part.substring(res[0].length), [], "(");
-    let start = part.toString().indexOf("{", res[0].length + test.length + 1);
+    const test = restOfExp(constants, part.substring(res[0].length), [], '(');
+    let start = part.toString().indexOf('{', res[0].length + test.length + 1);
     if (start === -1)
-        throw new SyntaxError("Invalid switch");
-    let statement = insertSemicolons(constants, restOfExp(constants, part.substring(start + 1), [], "{"));
+        throw new SyntaxError('Invalid switch');
+    let statement = insertSemicolons(constants, restOfExp(constants, part.substring(start + 1), [], '{'));
     let caseFound;
     const caseTest = /^\s*(case\s|default)\s*/;
-    let cases = [];
+    const cases = [];
     let defaultFound = false;
-    while (caseFound = caseTest.exec(statement.toString())) {
+    while ((caseFound = caseTest.exec(statement.toString()))) {
         if (caseFound[1] === 'default') {
             if (defaultFound)
-                throw new SyntaxError("Only one default switch case allowed");
+                throw new SyntaxError('Only one default switch case allowed');
             defaultFound = true;
         }
-        let cond = restOfExp(constants, statement.substring(caseFound[0].length), [/^:/]);
+        const cond = restOfExp(constants, statement.substring(caseFound[0].length), [/^:/]);
         let found = emptyString;
-        let i = start = caseFound[0].length + cond.length + 1;
-        let bracketFound = /^\s*\{/.exec(statement.substring(i).toString());
+        let i = (start = caseFound[0].length + cond.length + 1);
+        const bracketFound = /^\s*\{/.exec(statement.substring(i).toString());
         let exprs = [];
         if (bracketFound) {
             i += bracketFound[0].length;
-            found = restOfExp(constants, statement.substring(i), [], "{");
+            found = restOfExp(constants, statement.substring(i), [], '{');
             i += found.length + 1;
             exprs = lispifyBlock(found, constants);
         }
         else {
-            let notEmpty = restOfExp(constants, statement.substring(i), [caseTest]);
+            const notEmpty = restOfExp(constants, statement.substring(i), [caseTest]);
             if (!notEmpty.trim().length) {
                 exprs = [];
                 i += notEmpty.length;
@@ -761,16 +671,16 @@ setLispType(['switch'], (constants, type, part, res, expect, ctx) => {
             }
         }
         statement = statement.substring(i);
-        cases.push(new Lisp({
-            op: "case",
-            a: caseFound[1] === "default" ? undefined : lispifyExpr(constants, cond),
-            b: toLispArray(exprs)
+        cases.push(createLisp({
+            op: 41 /* LispType.SwitchCase */,
+            a: caseFound[1] === 'default' ? 0 /* LispType.None */ : lispifyExpr(constants, cond),
+            b: exprs,
         }));
     }
-    ctx.lispTree = new Lisp({
-        op: 'switch',
+    ctx.lispTree = createLisp({
+        op: 40 /* LispType.Switch */,
         a: lispifyExpr(constants, test),
-        b: toLispArray(cases)
+        b: cases,
     });
 });
 setLispType(['dot', 'prop'], (constants, type, part, res, expect, ctx) => {
@@ -781,7 +691,7 @@ setLispType(['dot', 'prop'], (constants, type, part, res, expect, ctx) => {
         if (res[1]) {
             op = '?prop';
         }
-        let matches = part.substring(res[0].length).toString().match(expectTypes.prop.types.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;
@@ -790,53 +700,58 @@ setLispType(['dot', 'prop'], (constants, type, part, res, expect, ctx) => {
             throw new SyntaxError('Hanging  dot');
         }
     }
-    ctx.lispTree = lispify(constants, part.substring(index), expectTypes[expect].next, new Lisp({
-        op: op,
+    ctx.lispTree = lispify(constants, part.substring(index), expectTypes[expect].next, createLisp({
+        op: typesCreate[op],
         a: ctx.lispTree,
-        b: prop
+        b: prop,
     }));
 });
 setLispType(['spreadArray', 'spreadObject'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = new Lisp({
-        op: type,
-        b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)
+    ctx.lispTree = createLisp({
+        op: type === 'spreadArray' ? 18 /* LispType.SpreadArray */ : 17 /* LispType.SpreadObject */,
+        a: 0 /* LispType.None */,
+        b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next),
     });
 });
 setLispType(['return', 'throw'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = new Lisp({
-        op: type,
-        b: lispifyExpr(constants, part.substring(res[0].length))
+    ctx.lispTree = createLisp({
+        op: type === 'return' ? 8 /* LispType.Return */ : 46 /* LispType.Throw */,
+        a: 0 /* LispType.None */,
+        b: lispifyExpr(constants, part.substring(res[0].length)),
     });
 });
-const primitives = {
-    "true": true,
-    "false": false,
-    "null": null,
-    Infinity,
-    NaN,
-    "und": undefined
-};
 setLispType(['number', 'boolean', 'null', 'und', 'NaN', 'Infinity'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, type === "number" ? (res[10] ? BigInt(res[1]) : Number(res[0])) : primitives[type === "boolean" ? res[0] : type]);
+    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+        op: type === 'number' ? (res[10] ? 83 /* LispType.BigInt */ : 7 /* LispType.Number */) : 35 /* LispType.GlobalSymbol */,
+        a: 0 /* LispType.None */,
+        b: res[10] ? res[1] : res[0],
+    }));
 });
 setLispType(['string', 'literal', 'regex'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, new Lisp({
-        op: type,
-        b: parseInt(JSON.parse(res[1]), 10),
+    ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+        op: type === 'string'
+            ? 2 /* LispType.StringIndex */
+            : type === 'literal'
+                ? 84 /* LispType.LiteralIndex */
+                : 85 /* LispType.RegexIndex */,
+        a: 0 /* LispType.None */,
+        b: res[1],
     }));
 });
 setLispType(['initialize'], (constants, type, part, res, expect, ctx) => {
+    const lt = res[1] === 'var' ? 34 /* LispType.Var */ : res[1] === 'let' ? 3 /* LispType.Let */ : 4 /* LispType.Const */;
     if (!res[3]) {
-        ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, new Lisp({
-            op: res[1],
-            a: res[2]
+        ctx.lispTree = lispify(constants, part.substring(res[0].length), expectTypes[expect].next, createLisp({
+            op: lt,
+            a: res[2],
+            b: 0 /* LispType.None */,
         }));
     }
     else {
-        ctx.lispTree = new Lisp({
-            op: res[1],
+        ctx.lispTree = createLisp({
+            op: lt,
             a: res[2],
-            b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next)
+            b: lispify(constants, part.substring(res[0].length), expectTypes[expect].next),
         });
     }
 });
@@ -844,10 +759,10 @@ setLispType(['function', 'inlineFunction', 'arrowFunction', 'arrowFunctionSingle
     const isArrow = type !== 'function' && type !== 'inlineFunction';
     const isReturn = isArrow && !res[res.length - 1];
     const argPos = isArrow ? 2 : 3;
-    const isAsync = !!res[1];
-    const args = res[argPos] ? res[argPos].replace(/\s+/g, "").split(/,/g) : [];
+    const isAsync = res[1] ? 88 /* LispType.True */ : 0 /* LispType.None */;
+    const args = res[argPos] ? res[argPos].replace(/\s+/g, '').split(/,/g) : [];
     if (!isArrow) {
-        args.unshift((res[2] || "").trimStart());
+        args.unshift((res[2] || '').trimStart());
     }
     let ended = false;
     args.forEach((arg) => {
@@ -856,64 +771,62 @@ setLispType(['function', 'inlineFunction', 'arrowFunction', 'arrowFunctionSingle
         if (arg.startsWith('...'))
             ended = true;
     });
-    args.unshift(isAsync);
-    const f = restOfExp(constants, part.substring(res[0].length), !isReturn ? [/^}/] : [/^[,\)\}\]]/, semiColon]);
-    const func = (isReturn ? 'return ' + f : f);
-    ctx.lispTree = lispify(constants, part.substring(res[0].length + func.length + 1), expectTypes[expect].next, new Lisp({
-        op: isArrow ? 'arrowFunc' : type,
-        a: toLispArray(args),
-        b: constants.eager ? lispifyFunction(new CodeString(func), constants) : func
+    const f = restOfExp(constants, part.substring(res[0].length), !isReturn ? [/^}/] : [/^[,)}\]]/, semiColon]);
+    const func = isReturn ? 'return ' + f : f.toString();
+    ctx.lispTree = lispify(constants, part.substring(res[0].length + func.length + 1), expectTypes[expect].next, createLisp({
+        op: isArrow
+            ? 11 /* LispType.ArrowFunction */
+            : type === 'function'
+                ? 37 /* LispType.Function */
+                : 10 /* LispType.InlineFunction */,
+        a: [isAsync, ...args],
+        b: constants.eager ? lispifyFunction(new CodeString(func), constants) : func,
     }));
 });
-const iteratorRegex = /^((let|var|const)\s+)?\s*([a-zA-Z\$_][a-zA-Z\d\$_]*)\s+(in|of)(?![\w\$])/;
+const iteratorRegex = /^((let|var|const)\s+)?\s*([a-zA-Z$_][a-zA-Z\d$_]*)\s+(in|of)(?![\w$])/;
 setLispType(['for', 'do', 'while'], (constants, type, part, res, expect, ctx) => {
     let i = 0;
-    let startStep = true;
-    let startInternal = toLispArray([]);
-    let getIterator;
-    let beforeStep = false;
-    let checkFirst = true;
+    let startStep = 88 /* LispType.True */;
+    let startInternal = [];
+    let getIterator = 0 /* LispType.None */;
+    let beforeStep = 0 /* LispType.None */;
+    let checkFirst = 88 /* LispType.True */;
     let condition;
-    let step = true;
+    let step = 88 /* LispType.True */;
     let body;
     switch (type) {
-        case 'while':
-            i = part.toString().indexOf("(") + 1;
-            let extract = restOfExp(constants, part.substring(i), [], "(");
+        case 'while': {
+            i = part.toString().indexOf('(') + 1;
+            const extract = restOfExp(constants, part.substring(i), [], '(');
             condition = lispifyReturnExpr(constants, extract);
             body = restOfExp(constants, part.substring(i + extract.length + 1)).trim();
-            if (body[0] === "{")
+            if (body.char(0) === '{')
                 body = body.slice(1, -1);
             break;
-        case 'for':
-            i = part.toString().indexOf("(") + 1;
-            let args = [];
+        }
+        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), [/^[;\)]/]);
+                extract2 = restOfExp(constants, part.substring(i), [/^[;)]/]);
                 args.push(extract2.trim());
                 i += extract2.length + 1;
-                if (part.char(i - 1) === ")")
+                if (part.char(i - 1) === ')')
                     break;
             }
             let iterator;
             if (args.length === 1 && (iterator = iteratorRegex.exec(args[0].toString()))) {
                 if (iterator[4] === 'of') {
-                    getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length)),
-                        startInternal = toLispArray([
-                            ofStart2,
-                            ofStart3
-                        ]);
+                    (getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length))),
+                        (startInternal = [ofStart2, ofStart3]);
                     condition = ofCondition;
                     step = ofStep;
                     beforeStep = lispify(constants, new CodeString((iterator[1] || 'let ') + iterator[3] + ' = $$next.value'), ['initialize']);
                 }
                 else {
-                    getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length)),
-                        startInternal = toLispArray([
-                            inStart2,
-                            inStart3
-                        ]);
+                    (getIterator = lispifyReturnExpr(constants, args[0].substring(iterator[0].length))),
+                        (startInternal = [inStart2, inStart3]);
                     step = inStep;
                     condition = inCondition;
                     beforeStep = lispify(constants, new CodeString((iterator[1] || 'let ') + iterator[3] + ' = $$keys[$$keyIndex]'), ['initialize']);
@@ -925,80 +838,97 @@ setLispType(['for', 'do', 'while'], (constants, type, part, res, expect, ctx) =>
                 step = lispifyExpr(constants, args.shift());
             }
             else {
-                throw new SyntaxError("Invalid for loop definition");
+                throw new SyntaxError('Invalid for loop definition');
             }
             body = restOfExp(constants, part.substring(i)).trim();
-            if (body[0] === "{")
+            if (body.char(0) === '{')
                 body = body.slice(1, -1);
             break;
-        case 'do':
-            checkFirst = false;
+        }
+        case 'do': {
+            checkFirst = 0 /* LispType.None */;
             const isBlock = !!res[3];
             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), [], "("));
+            condition = lispifyReturnExpr(constants, restOfExp(constants, part.substring(part.toString().indexOf('(', res[0].length + body.length) + 1), [], '('));
             break;
+        }
     }
-    const a = toLispArray([checkFirst, startInternal, getIterator, startStep, step, condition, beforeStep]);
-    ctx.lispTree = new Lisp({
-        op: 'loop',
+    const a = [
+        checkFirst,
+        startInternal,
+        getIterator,
+        startStep,
+        step,
+        condition,
+        beforeStep,
+    ];
+    ctx.lispTree = createLisp({
+        op: 38 /* LispType.Loop */,
         a,
-        b: lispifyBlock(body, constants)
+        b: lispifyBlock(body, constants),
     });
 });
 setLispType(['block'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = lispifyBlock(restOfExp(constants, part.substring(1), [], "{"), constants);
+    ctx.lispTree = createLisp({
+        op: 42 /* LispType.Block */,
+        a: lispifyBlock(restOfExp(constants, part.substring(1), [], '{'), constants),
+        b: 0 /* LispType.None */,
+    });
 });
 setLispType(['loopAction'], (constants, type, part, res, expect, ctx) => {
-    ctx.lispTree = new Lisp({
-        op: 'loopAction',
+    ctx.lispTree = createLisp({
+        op: 86 /* LispType.LoopAction */,
         a: res[1],
+        b: 0 /* LispType.None */,
     });
 });
-const catchReg = /^\s*(catch\s*(\(\s*([a-zA-Z\$_][a-zA-Z\d\$_]*)\s*\))?|finally)\s*\{/;
+const catchReg = /^\s*(catch\s*(\(\s*([a-zA-Z$_][a-zA-Z\d$_]*)\s*\))?|finally)\s*\{/;
 setLispType(['try'], (constants, type, part, res, expect, ctx) => {
-    const body = restOfExp(constants, part.substring(res[0].length), [], "{");
+    const body = restOfExp(constants, part.substring(res[0].length), [], '{');
     let catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());
     let finallyBody;
-    let exception;
+    let exception = '';
     let catchBody;
     let offset = 0;
     if (catchRes[1].startsWith('catch')) {
         catchRes = catchReg.exec(part.substring(res[0].length + body.length + 1).toString());
         exception = catchRes[2];
-        catchBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], "{");
+        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), [], "{");
+        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), [], "{");
+        finallyBody = restOfExp(constants, part.substring(res[0].length + body.length + 1 + catchRes[0].length), [], '{');
     }
-    const b = toLispArray([
+    const b = [
         exception,
         lispifyBlock(insertSemicolons(constants, catchBody || emptyString), constants),
         lispifyBlock(insertSemicolons(constants, finallyBody || emptyString), constants),
-    ]);
-    ctx.lispTree = new Lisp({
-        op: 'try',
+    ];
+    ctx.lispTree = createLisp({
+        op: 39 /* LispType.Try */,
         a: lispifyBlock(insertSemicolons(constants, body), constants),
-        b
+        b,
     });
 });
 setLispType(['void', 'await'], (constants, type, part, res, expect, ctx) => {
-    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s\.\?\w\$]|\?[^\.])/]);
-    ctx.lispTree = lispify(constants, part.substring(res[0].length + extract.length), expectTypes[expect].next, new Lisp({
-        op: type,
+    const extract = restOfExp(constants, part.substring(res[0].length), [/^([^\s.?\w$]|\?[^.])/]);
+    ctx.lispTree = lispify(constants, part.substring(res[0].length + extract.length), expectTypes[expect].next, createLisp({
+        op: type === 'void' ? 87 /* LispType.Void */ : 44 /* LispType.Await */,
         a: lispify(constants, extract),
+        b: 0 /* LispType.None */,
     }));
 });
 setLispType(['new'], (constants, type, part, res, expect, ctx) => {
     let i = res[0].length;
-    const obj = restOfExp(constants, part.substring(i), [], undefined, "(");
+    const obj = restOfExp(constants, part.substring(i), [], undefined, '(');
     i += obj.length + 1;
     const args = [];
-    if (part.char(i - 1) === "(") {
-        const argsString = restOfExp(constants, part.substring(i), [], "(");
+    if (part.char(i - 1) === '(') {
+        const argsString = restOfExp(constants, part.substring(i), [], '(');
         i += argsString.length + 1;
         let found;
         let j = 0;
@@ -1007,54 +937,58 @@ setLispType(['new'], (constants, type, part, res, expect, ctx) => {
             args.push(found.trim());
         }
     }
-    ctx.lispTree = lispify(constants, part.substring(i), expectTypes.expEdge.next, new Lisp({
-        op: type,
+    ctx.lispTree = lispify(constants, part.substring(i), expectTypes.expEdge.next, createLisp({
+        op: 45 /* LispType.New */,
         a: lispify(constants, obj, expectTypes.initialize.next),
-        b: toLispArray(args.map((arg) => lispify(constants, arg, expectTypes.initialize.next))),
+        b: args.map((arg) => lispify(constants, arg, expectTypes.initialize.next)),
     }));
 });
 const ofStart2 = lispify(undefined, new CodeString('let $$iterator = $$obj[Symbol.iterator]()'), ['initialize']);
-const ofStart3 = lispify(undefined, new CodeString('let $$next = $$iterator.next()'), ['initialize']);
-const ofCondition = lispify(undefined, new CodeString('return !$$next.done'), ['initialize']);
+const ofStart3 = lispify(undefined, new CodeString('let $$next = $$iterator.next()'), [
+    'initialize',
+]);
+const ofCondition = lispify(undefined, new CodeString('return !$$next.done'), [
+    'initialize',
+]);
 const ofStep = lispify(undefined, new CodeString('$$next = $$iterator.next()'));
-const inStart2 = lispify(undefined, new CodeString('let $$keys = Object.keys($$obj)'), ['initialize']);
+const inStart2 = lispify(undefined, new CodeString('let $$keys = Object.keys($$obj)'), [
+    'initialize',
+]);
 const inStart3 = lispify(undefined, new CodeString('let $$keyIndex = 0'), ['initialize']);
 const inStep = lispify(undefined, new CodeString('$$keyIndex++'));
-const inCondition = lispify(undefined, new CodeString('return $$keyIndex < $$keys.length'), ['initialize']);
-var lastType;
-var lastPart;
-var lastLastPart;
-var lastLastLastPart;
-var lastLastLastLastPart;
+const inCondition = lispify(undefined, new CodeString('return $$keyIndex < $$keys.length'), [
+    'initialize',
+]);
 function lispify(constants, part, expected, lispTree, topLevel = false) {
+    lispTree = lispTree || NullLisp;
     expected = expected || expectTypes.initialize.next;
     if (part === undefined)
         return lispTree;
     part = part.trimStart();
     const str = part.toString();
     if (!part.length && !expected.includes('expEnd')) {
-        throw new SyntaxError("Unexpected end of expression");
+        throw new SyntaxError('Unexpected end of expression');
     }
     if (!part.length)
         return lispTree;
-    let ctx = { lispTree: lispTree };
+    const ctx = { lispTree: lispTree };
     let res;
-    for (let expect of expected) {
+    for (const expect of expected) {
         if (expect === 'expEnd') {
             continue;
         }
-        for (let type in expectTypes[expect].types) {
+        for (const type in expectTypes[expect].types) {
             if (type === 'expEnd') {
                 continue;
             }
-            if (res = expectTypes[expect].types[type].exec(str)) {
+            if ((res = expectTypes[expect].types[type].exec(str))) {
                 lastType = type;
                 lastLastLastLastPart = lastLastLastPart;
                 lastLastLastPart = lastLastPart;
                 lastLastPart = lastPart;
                 lastPart = part;
                 try {
-                    lispTypes.get(type)(constants, type, part, res, expect, ctx);
+                    lispTypes.get(type)?.(constants, type, part, res, expect, ctx);
                 }
                 catch (e) {
                     if (topLevel && e instanceof SyntaxError) {
@@ -1069,7 +1003,6 @@ function lispify(constants, part, expected, lispTree, topLevel = false) {
             break;
     }
     if (!res && part.length) {
-        let msg = `Unexpected token after ${lastType}: ${part.char(0)}`;
         if (topLevel) {
             throw new ParseError(`Unexpected token after ${lastType}: ${part.char(0)}`, str);
         }
@@ -1080,8 +1013,8 @@ function lispify(constants, part, expected, lispTree, topLevel = false) {
 const startingExpectedWithoutSingle = startingExecpted.filter((r) => r !== 'expSingle');
 function lispifyExpr(constants, str, expected) {
     if (!str.trimStart().length)
-        return undefined;
-    let subExpressions = [];
+        return NullLisp;
+    const subExpressions = [];
     let sub;
     let pos = 0;
     expected = expected || expectTypes.initialize.next;
@@ -1100,25 +1033,33 @@ function lispifyExpr(constants, str, expected) {
         return lispify(constants, str, expected, undefined, true);
     }
     if (expected.includes('initialize')) {
-        let defined = expectTypes.initialize.types.initialize.exec(subExpressions[0].toString());
+        const defined = expectTypes.initialize.types.initialize.exec(subExpressions[0].toString());
         if (defined) {
-            return toLispArray(subExpressions.map((str, i) => lispify(constants, i ? new CodeString(defined[1] + ' ' + str) : str, ['initialize'], undefined, true)));
+            return createLisp({
+                op: 42 /* LispType.Block */,
+                a: subExpressions.map((str, i) => lispify(constants, i ? new CodeString(defined[1] + ' ' + str) : str, ['initialize'], undefined, true)),
+                b: 0 /* LispType.None */,
+            });
         }
         else if (expectTypes.initialize.types.return.exec(subExpressions[0].toString())) {
             return lispify(constants, str, expected, undefined, true);
         }
     }
-    const exprs = toLispArray(subExpressions.map((str, i) => lispify(constants, str, expected, undefined, true)));
-    return new Lisp({ op: "multi", a: exprs });
+    const exprs = subExpressions.map((str) => lispify(constants, str, expected, undefined, true));
+    return createLisp({ op: 43 /* LispType.Expression */, a: exprs, b: 0 /* LispType.None */ });
 }
 export function lispifyReturnExpr(constants, str) {
-    return new Lisp({ op: 'return', b: lispifyExpr(constants, str) });
+    return createLisp({
+        op: 8 /* LispType.Return */,
+        a: 0 /* LispType.None */,
+        b: lispifyExpr(constants, str),
+    });
 }
 export function lispifyBlock(str, constants, expression = false) {
     str = insertSemicolons(constants, str);
     if (!str.trim().length)
-        return toLispArray([]);
-    let parts = [];
+        return [];
+    const parts = [];
     let part;
     let pos = 0;
     let start = 0;
@@ -1126,12 +1067,13 @@ export function lispifyBlock(str, constants, expression = false) {
     let skipped = false;
     let isInserted = false;
     while ((part = restOfExp(constants, str.substring(pos), [semiColon], undefined, undefined, undefined, details)).length) {
-        isInserted = str.char(pos + part.length) && str.char(pos + part.length) !== ';';
+        isInserted = !!(str.char(pos + part.length) && str.char(pos + part.length) !== ';');
         pos += part.length + (isInserted ? 0 : 1);
-        if (/^\s*else(?![\w\$])/.test(str.substring(pos).toString())) {
+        if (/^\s*else(?![\w$])/.test(str.substring(pos).toString())) {
             skipped = true;
         }
-        else if (details.words.includes('do') && /^\s*while(?![\w\$])/.test(str.substring(pos).toString())) {
+        else if (details['words']?.includes('do') &&
+            /^\s*while(?![\w$])/.test(str.substring(pos).toString())) {
             skipped = true;
         }
         else {
@@ -1146,22 +1088,44 @@ export function lispifyBlock(str, constants, expression = false) {
     if (skipped) {
         parts.push(str.substring(start, pos - (isInserted ? 0 : 1)));
     }
-    return toLispArray(parts.map((str) => str.trimStart()).filter((str) => str.length).map((str, j) => {
+    return parts
+        .map((str) => str.trimStart())
+        .filter((str) => str.length)
+        .map((str) => {
         return lispifyExpr(constants, str.trimStart(), startingExecpted);
-    }).flat());
+    });
 }
 export function lispifyFunction(str, constants, expression = false) {
     if (!str.trim().length)
-        return toLispArray([]);
+        return [];
     const tree = lispifyBlock(str, constants, expression);
-    let hoisted = toLispArray([]);
+    const hoisted = [];
     hoist(tree, hoisted);
-    return toLispArray(hoisted.concat(tree));
+    return hoisted.concat(tree);
 }
 function hoist(item, res) {
-    if (Array.isArray(item)) {
+    if (isLisp(item)) {
+        if (!isLisp(item))
+            return false;
+        const [op, a, b] = item;
+        if (op === 39 /* LispType.Try */ ||
+            op === 13 /* LispType.If */ ||
+            op === 38 /* LispType.Loop */ ||
+            op === 40 /* LispType.Switch */) {
+            hoist(a, res);
+            hoist(b, res);
+        }
+        else if (op === 34 /* LispType.Var */) {
+            res.push(createLisp({ op: 34 /* LispType.Var */, a: a, b: 0 /* LispType.None */ }));
+        }
+        else if (op === 37 /* LispType.Function */ && a[1]) {
+            res.push(item);
+            return true;
+        }
+    }
+    else if (Array.isArray(item)) {
         const rep = [];
-        for (let it of item) {
+        for (const it of item) {
             if (!hoist(it, res)) {
                 rep.push(it);
             }
@@ -1171,24 +1135,11 @@ function hoist(item, res) {
             item.push(...rep);
         }
     }
-    else if (item instanceof Lisp) {
-        if (item.op === "try" || item.op === "if" || item.op === "loop" || item.op === "switch") {
-            hoist(item.a, res);
-            hoist(item.b, res);
-        }
-        else if (item.op === "var") {
-            res.push(new Lisp({ op: 'var', a: item.a }));
-        }
-        else if (item.op === "function" && item.a[1]) {
-            res.push(item);
-            return true;
-        }
-    }
     return false;
 }
-const closingsNoInsertion = /^(\})\s*(catch|finally|else|while|instanceof)(?![\w\$])/;
-//  \w|)|] \n \w = 2                                  // \} \w|\{ = 5 
-const colonsRegex = /^((([\w\$\]\)\"\'\`]|\+\+|\-\-)\s*\r?\n\s*([\w\$\+\-\!~]))|(\}\s*[\w\$\!~\+\-\{\(\"\'\`]))/;
+const closingsNoInsertion = /^(\})\s*(catch|finally|else|while|instanceof)(?![\w$])/;
+//  \w|)|] \n \w = 2                                  // \} \w|\{ = 5
+const colonsRegex = /^((([\w$\])"'`]|\+\+|--)\s*\r?\n\s*([\w$+\-!~]))|(\}\s*[\w$!~+\-{("'`]))/;
 // if () \w \n; \w              == \w \n \w    | last === if             a
 // if () { }; \w                == \} ^else    | last === if             b
 // if () \w \n; else \n \w \n;  == \w \n \w    | last === else           a
@@ -1214,10 +1165,10 @@ export function insertSemicolons(constants, str) {
         if (details.regRes) {
             valid = true;
             const [, , a, , , b] = details.regRes;
-            edge = details.regRes[3] === "++" || details.regRes[3] === "--" ? sub.length + 1 : sub.length;
+            edge = details.regRes[3] === '++' || details.regRes[3] === '--' ? sub.length + 1 : sub.length;
             part = rest.substring(0, edge);
             if (b) {
-                let res = closingsNoInsertion.exec(rest.substring(sub.length - 1).toString());
+                const res = closingsNoInsertion.exec(rest.substring(sub.length - 1).toString());
                 if (res) {
                     if (res[2] === 'while') {
                         valid = details.lastWord !== 'do';
@@ -1226,12 +1177,17 @@ export function insertSemicolons(constants, str) {
                         valid = false;
                     }
                 }
-                else if (details.lastWord === 'function' && details.regRes[5][0] === "}" && details.regRes[5].slice(-1) === '(') {
+                else if (details.lastWord === 'function' &&
+                    details.regRes[5][0] === '}' &&
+                    details.regRes[5].slice(-1) === '(') {
                     valid = false;
                 }
             }
             else if (a) {
-                if (details.lastWord === 'if' || details.lastWord === 'while' || details.lastWord === 'for' || details.lastWord === 'else') {
+                if (details.lastWord === 'if' ||
+                    details.lastWord === 'while' ||
+                    details.lastWord === 'for' ||
+                    details.lastWord === 'else') {
                     valid = false;
                 }
             }
@@ -1251,49 +1207,50 @@ export function checkRegex(str) {
     let done = false;
     let cancel = false;
     while (i < str.length && !done && !cancel) {
-        done = (str[i] === '/' && !escape);
+        done = str[i] === '/' && !escape;
         escape = str[i] === '\\' && !escape;
         cancel = str[i] === '\n';
         i++;
     }
-    let after = str.substring(i);
-    cancel = (cancel || !done) || /^\s*\d/.test(after);
+    const after = str.substring(i);
+    cancel = cancel || !done || /^\s*\d/.test(after);
     if (cancel)
         return null;
-    let flags = /^[a-z]*/.exec(after);
-    if (/^\s+[\w\$]/.test(str.substring(i + flags[0].length))) {
+    const flags = /^[a-z]*/.exec(after);
+    if (/^\s+[\w$]/.test(str.substring(i + flags[0].length))) {
         return null;
     }
     return {
         regex: str.substring(1, i - 1),
-        flags: (flags && flags[0]) || "",
-        length: i + ((flags && flags[0].length) || 0)
+        flags: (flags && flags[0]) || '',
+        length: i + ((flags && flags[0].length) || 0),
     };
 }
 const notDivide = /(typeof|delete|instanceof|return|in|of|throw|new|void|do|if)$/;
-const possibleDivide = /^([\w\$\]\)]|\+\+|\-\-)[\s\/]/;
-export function extractConstants(constants, str, currentEnclosure = "") {
+const possibleDivide = /^([\w$\])]|\+\+|--)[\s/]/;
+export function extractConstants(constants, str, currentEnclosure = '') {
     let quote;
     let extract = [];
     let escape = false;
     let regexFound;
-    let comment = "";
+    let comment = '';
     let commentStart = -1;
-    let currJs = toLispArray([]);
-    let char = "";
+    let currJs = [];
+    let char = '';
     const strRes = [];
     const enclosures = [];
-    let isPossibleDivide;
-    for (var i = 0; i < str.length; i++) {
+    let isPossibleDivide = null;
+    let i = 0;
+    for (i = 0; i < str.length; i++) {
         char = str[i];
         if (comment) {
             if (char === comment) {
-                if (comment === "*" && str[i + 1] === "/") {
-                    comment = "";
+                if (comment === '*' && str[i + 1] === '/') {
+                    comment = '';
                     i++;
                 }
-                else if (comment === "\n") {
-                    comment = "";
+                else if (comment === '\n') {
+                    comment = '';
                 }
             }
         }
@@ -1304,23 +1261,25 @@ export function extractConstants(constants, str, currentEnclosure = "") {
                 continue;
             }
             if (quote) {
-                if (quote === "`" && char === "$" && str[i + 1] === "{") {
-                    let skip = extractConstants(constants, str.substring(i + 2), "{");
+                if (quote === '`' && char === '$' && str[i + 1] === '{') {
+                    const skip = extractConstants(constants, str.substring(i + 2), '{');
                     currJs.push(skip.str);
                     extract.push('${', currJs.length - 1, `}`);
                     i += skip.length + 2;
                 }
                 else if (quote === char) {
                     if (quote === '`') {
-                        constants.literals.push({
-                            op: 'literal',
-                            a: unraw(extract.join("")),
-                            b: currJs
+                        const li = createLisp({
+                            op: 36 /* LispType.Literal */,
+                            a: unraw(extract.join('')),
+                            b: [],
                         });
+                        li.tempJsStrings = currJs;
+                        constants.literals.push(li);
                         strRes.push(`\``, constants.literals.length - 1, `\``);
                     }
                     else {
-                        constants.strings.push(unraw(extract.join("")));
+                        constants.strings.push(unraw(extract.join('')));
                         strRes.push(`"`, constants.strings.length - 1, `"`);
                     }
                     quote = null;
@@ -1331,12 +1290,12 @@ export function extractConstants(constants, str, currentEnclosure = "") {
                 }
             }
             else {
-                if ((char === "'" || char === '"' || char === '`')) {
-                    currJs = toLispArray([]);
+                if (char === "'" || char === '"' || char === '`') {
+                    currJs = [];
                     quote = char;
                 }
                 else if (closings[currentEnclosure] === char && !enclosures.length) {
-                    return { str: strRes.join(""), length: i };
+                    return { str: strRes.join(''), length: i };
                 }
                 else if (closings[char]) {
                     enclosures.push(char);
@@ -1346,11 +1305,13 @@ export function extractConstants(constants, str, currentEnclosure = "") {
                     enclosures.pop();
                     strRes.push(char);
                 }
-                else if (char === "/" && (str[i + 1] === "*" || str[i + 1] === "/")) {
-                    comment = str[i + 1] === "*" ? "*" : "\n";
+                else if (char === '/' && (str[i + 1] === '*' || str[i + 1] === '/')) {
+                    comment = str[i + 1] === '*' ? '*' : '\n';
                     commentStart = i;
                 }
-                else if (char === '/' && !isPossibleDivide && (regexFound = checkRegex(str.substring(i)))) {
+                else if (char === '/' &&
+                    !isPossibleDivide &&
+                    (regexFound = checkRegex(str.substring(i)))) {
                     constants.regexes.push(regexFound);
                     strRes.push(`/`, constants.regexes.length - 1, `/r`);
                     i += regexFound.length - 1;
@@ -1359,31 +1320,32 @@ export function extractConstants(constants, str, currentEnclosure = "") {
                     strRes.push(char);
                 }
                 if (!isPossibleDivide || !space.test(char)) {
-                    if (isPossibleDivide = possibleDivide.exec(str.substring(i))) {
+                    if ((isPossibleDivide = possibleDivide.exec(str.substring(i)))) {
                         if (notDivide.test(str.substring(0, i + isPossibleDivide[1].length))) {
                             isPossibleDivide = null;
                         }
                     }
                 }
             }
-            escape = quote && char === "\\";
+            escape = !!(quote && char === '\\');
         }
     }
     if (comment) {
-        if (comment === "*") {
+        if (comment === '*') {
             throw new SyntaxError(`Unclosed comment '/*': ${str.substring(commentStart)}`);
         }
     }
-    return { str: strRes.join(""), length: i };
+    return { str: strRes.join(''), length: i };
 }
-export function parse(code, eager = false, expression = false) {
+export default function parse(code, eager = false, expression = false) {
     if (typeof code !== 'string')
         throw new ParseError(`Cannot parse ${code}`, code);
     let str = ' ' + code;
     const constants = { strings: [], literals: [], regexes: [], eager };
     str = extractConstants(constants, str).str;
-    for (let l of constants.literals) {
-        l.b = toLispArray(l.b.map((js) => lispifyExpr(constants, new CodeString(js))));
+    for (const l of constants.literals) {
+        l[2] = l.tempJsStrings.map((js) => lispifyExpr(constants, new CodeString(js)));
+        delete l.tempJsStrings;
     }
     return { tree: lispifyFunction(new CodeString(str), constants, expression), constants };
 }