@mojir/lits 2.1.0 → 2.1.2

package/dist/lits.iife.js

@@ -180,23 +180,25 @@ var Lits = (function (exports) {
         return error instanceof LitsError;
     }
 
-    var astNodeTypeNames = [
-        'Number',
-        'String',
-        'NormalExpression',
-        'SpecialExpression',
-        'Symbol',
-        'Modifier',
-        'ReservedSymbol',
-        'Binding',
-        'Argument',
-        'Partial',
-        'Comment',
-        'Spread',
-    ];
-    var astNodeTypeSet = new Set(astNodeTypeNames);
-    function isAstNodeType(type) {
-        return typeof type === 'string' && astNodeTypeSet.has(type);
+    var NodeTypes = {
+        Number: 1,
+        String: 2,
+        NormalExpression: 3,
+        SpecialExpression: 4,
+        UserDefinedSymbol: 5,
+        NormalBuiltinSymbol: 6,
+        SpecialBuiltinSymbol: 7,
+        ReservedSymbol: 8,
+        Binding: 9,
+        Spread: 10,
+    };
+    var NodeTypesSet = new Set(Object.values(NodeTypes));
+    function getNodeTypeName(type) {
+        return Object.keys(NodeTypes).find(function (key) { return NodeTypes[key] === type; });
+    }
+    // TODO, is this needed?
+    function isNodeType(type) {
+        return typeof type === 'number' && NodeTypesSet.has(type);
     }
     var functionTypes = [
         'UserDefined',
@@ -224,17 +226,17 @@ var Lits = (function (exports) {
             return false;
         return FUNCTION_SYMBOL in func && 'functionType' in func && isFunctionType(func.functionType);
     }
-    function isAstNode$1(value) {
-        if (value === null || typeof value !== 'object')
+    function isNode(value) {
+        if (!Array.isArray(value) || value.length < 2)
             return false;
-        return 'type' in value && isAstNodeType(value.type);
+        return isNodeType(value[0]);
     }
     function valueToString(value) {
         if (isLitsFunction$1(value))
             // eslint-disable-next-line ts/no-unsafe-member-access
             return "<function ".concat(value.name || '\u03BB', ">");
-        if (isAstNode$1(value))
-            return "".concat(value.type, "-node");
+        if (isNode(value))
+            return "".concat(getNodeTypeName(value[0]), "-node");
         if (value === null)
             return 'null';
         if (typeof value === 'object' && value instanceof RegExp)
@@ -255,59 +257,56 @@ var Lits = (function (exports) {
     }
 
     function assertNumberOfParams(count, node) {
-        assertCount({
-            count: count,
-            length: node.params.length,
-            name: node.name,
-            sourceCodeInfo: node.sourceCodeInfo,
-        });
-    }
-    function isNonUndefined(value) {
-        return value !== undefined;
-    }
-    function asNonUndefined(value, sourceCodeInfo) {
-        assertNonUndefined(value, sourceCodeInfo);
-        return value;
-    }
-    function assertNonUndefined(value, sourceCodeInfo) {
-        if (!isNonUndefined(value))
-            throw new LitsError('Unexpected undefined', getSourceCodeInfo(value, sourceCodeInfo));
-    }
-    function isUnknownRecord(value) {
-        return value !== null && typeof value === 'object' && !Array.isArray(value);
-    }
-    function assertUnknownRecord(value, sourceCodeInfo) {
-        if (!isUnknownRecord(value)) {
-            throw new LitsError("Expected ".concat('UnknownRecord', ", got ").concat(valueToString(value), "."), getSourceCodeInfo(value, sourceCodeInfo));
-        }
-    }
-    function assertCount(_a) {
-        var count = _a.count, length = _a.length, name = _a.name, sourceCodeInfo = _a.sourceCodeInfo;
+        var length = node[1][1].length;
         if (typeof count === 'number') {
             if (length !== count) {
-                throw new LitsError("Wrong number of arguments to \"".concat(name, "\", expected ").concat(count, ", got ").concat(valueToString(length), "."), sourceCodeInfo);
+                var name_1 = getNodeTypeName(node[0]);
+                throw new LitsError("Wrong number of arguments to \"".concat(name_1, "\", expected ").concat(count, ", got ").concat(valueToString(length), "."), node[2]);
             }
         }
         else {
             var min = count.min, max = count.max, even = count.even, odd = count.odd;
             if (even) {
+                var name_2 = getNodeTypeName(node[0]);
                 if (length % 2 !== 0) {
-                    throw new LitsError("Wrong number of arguments to \"".concat(name, "\",, expected an even number, got ").concat(valueToString(length), "."), sourceCodeInfo);
+                    throw new LitsError("Wrong number of arguments to \"".concat(name_2, "\",, expected an even number, got ").concat(valueToString(length), "."), node[2]);
                 }
             }
             if (odd) {
                 if (length % 2 !== 1) {
-                    throw new LitsError("Wrong number of arguments to \"".concat(name, "\",, expected an odd number, got ").concat(valueToString(length), "."), sourceCodeInfo);
+                    var name_3 = getNodeTypeName(node[0]);
+                    throw new LitsError("Wrong number of arguments to \"".concat(name_3, "\",, expected an odd number, got ").concat(valueToString(length), "."), node[2]);
                 }
             }
             if (typeof min === 'number' && length < min) {
-                throw new LitsError("Wrong number of arguments to \"".concat(name, "\", expected at least ").concat(min, ", got ").concat(valueToString(length), "."), sourceCodeInfo);
+                var name_4 = getNodeTypeName(node[0]);
+                throw new LitsError("Wrong number of arguments to \"".concat(name_4, "\", expected at least ").concat(min, ", got ").concat(valueToString(length), "."), node[2]);
             }
             if (typeof max === 'number' && length > max) {
-                throw new LitsError("Wrong number of arguments to \"".concat(name, "\", expected at most ").concat(max, ", got ").concat(valueToString(length), "."), sourceCodeInfo);
+                var name_5 = getNodeTypeName(node[0]);
+                throw new LitsError("Wrong number of arguments to \"".concat(name_5, "\", expected at most ").concat(max, ", got ").concat(valueToString(length), "."), node[2]);
             }
         }
     }
+    function isNonUndefined(value) {
+        return value !== undefined;
+    }
+    function asNonUndefined(value, sourceCodeInfo) {
+        assertNonUndefined(value, sourceCodeInfo);
+        return value;
+    }
+    function assertNonUndefined(value, sourceCodeInfo) {
+        if (!isNonUndefined(value))
+            throw new LitsError('Unexpected undefined', getSourceCodeInfo(value, sourceCodeInfo));
+    }
+    function isUnknownRecord(value) {
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    }
+    function assertUnknownRecord(value, sourceCodeInfo) {
+        if (!isUnknownRecord(value)) {
+            throw new LitsError("Expected ".concat('UnknownRecord', ", got ").concat(valueToString(value), "."), getSourceCodeInfo(value, sourceCodeInfo));
+        }
+    }
     function canBeOperator(count) {
         if (typeof count === 'number') {
             return count === 2;
@@ -745,12 +744,6 @@ var Lits = (function (exports) {
             _a.functionType = 'NativeJsFunction',
             _a;
     }
-    function arrayToPairs(arr) {
-        var pairs = [];
-        for (var i = 0; i < arr.length; i += 2)
-            pairs.push([arr[i], arr[i + 1]]);
-        return pairs;
-    }
     function joinSets() {
         var e_1, _a;
         var results = [];
@@ -3648,17 +3641,24 @@ var Lits = (function (exports) {
         });
     });
     var normalExpressions = __assign(__assign({}, expressions), aliases);
+    var normalExpressionTypes = {};
+    var allNormalExpressions = [];
+    Object.entries(normalExpressions).forEach(function (_a, index) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        normalExpressionTypes[key] = index;
+        allNormalExpressions.push(value);
+    });
 
     var andSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var value = true;
             try {
-                for (var _c = __values(node.params), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = __values(node[1][1]), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var param = _d.value;
-                    value = evaluateAstNode(param, contextStack);
+                    value = evaluateNode(param, contextStack);
                     if (!value)
                         break;
                 }
@@ -3673,8 +3673,8 @@ var Lits = (function (exports) {
             return value;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
         },
     };
 
@@ -3682,28 +3682,29 @@ var Lits = (function (exports) {
         paramCount: { even: true },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
+            var params = node[1][1];
             try {
-                for (var _c = __values(arrayToPairs(node.params)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var _e = __read(_d.value, 2), test = _e[0], form = _e[1];
-                    var value = evaluateAstNode(test, contextStack);
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var _c = __read(params_1_1.value, 2), test = _c[0], form = _c[1];
+                    var value = evaluateNode(test, contextStack);
                     if (!value)
                         continue;
-                    return evaluateAstNode(form, contextStack);
+                    return evaluateNode(form, contextStack);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    if (params_1_1 && !params_1_1.done && (_b = params_1.return)) _b.call(params_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1].flat(), contextStack, builtin, evaluateNode);
         },
     };
 
@@ -3711,66 +3712,141 @@ var Lits = (function (exports) {
         paramCount: { odd: true },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
-            var switchValue = evaluateAstNode(node.params[0], contextStack);
+            var evaluateNode = _a.evaluateNode;
+            var _c = __read(node[1], 3), switchValueNode = _c[1], cases = _c[2];
+            var switchValue = evaluateNode(switchValueNode, contextStack);
             try {
-                for (var _c = __values(arrayToPairs(node.params.slice(1))), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var _e = __read(_d.value, 2), test = _e[0], form = _e[1];
-                    var value = evaluateAstNode(test, contextStack);
+                for (var cases_1 = __values(cases), cases_1_1 = cases_1.next(); !cases_1_1.done; cases_1_1 = cases_1.next()) {
+                    var _d = __read(cases_1_1.value, 2), test = _d[0], form = _d[1];
+                    var value = evaluateNode(test, contextStack);
                     if (value === switchValue) {
-                        return evaluateAstNode(form, contextStack);
+                        return evaluateNode(form, contextStack);
                     }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    if (cases_1_1 && !cases_1_1.done && (_b = cases_1.return)) _b.call(cases_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(__spreadArray([node[1][1]], __read(node[1][2].flat()), false), contextStack, builtin, evaluateNode);
         },
     };
 
-    var declaredSpecialExpression = {
+    function isSymbolNode(node) {
+        var nodeType = node[0];
+        return NodeTypes.UserDefinedSymbol === nodeType
+            || NodeTypes.NormalBuiltinSymbol === nodeType
+            || NodeTypes.SpecialBuiltinSymbol === nodeType;
+    }
+    function assertSymbolNode(node, sourceCodeInfo) {
+        if (!isSymbolNode(node))
+            throw getAssertionError('SymbolNode', node, sourceCodeInfo);
+    }
+    function isUserDefinedSymbolNode(node) {
+        return NodeTypes.UserDefinedSymbol === node[0];
+    }
+    function asUserDefinedSymbolNode(node, sourceCodeInfo) {
+        assertUserDefinedSymbolNode(node, sourceCodeInfo);
+        return node;
+    }
+    function assertUserDefinedSymbolNode(node, sourceCodeInfo) {
+        if (!isUserDefinedSymbolNode(node))
+            throw getAssertionError('UserDefinedSymbolNode', node, sourceCodeInfo);
+    }
+    function isNormalBuiltinSymbolNode(node) {
+        return NodeTypes.NormalBuiltinSymbol === node[0];
+    }
+    function isSpecialBuiltinSymbolNode(node) {
+        return NodeTypes.SpecialBuiltinSymbol === node[0];
+    }
+    function isNormalExpressionNode(node) {
+        return node[0] === NodeTypes.NormalExpression;
+    }
+    function isNormalExpressionNodeWithName(node) {
+        if (!isNormalExpressionNode(node)) {
+            return false;
+        }
+        return isSymbolNode(node[1][0]);
+    }
+    function isSpreadNode(node) {
+        return node[0] === NodeTypes.Spread;
+    }
+
+    var definedSpecialExpression = {
         paramCount: 1,
         evaluate: function (node, contextStack) {
-            var lookUpResult = contextStack.lookUp(node.params[0]);
+            var symbolNode = node[1][1];
+            assertSymbolNode(symbolNode);
+            if (!isUserDefinedSymbolNode(symbolNode)) {
+                return true; // If the symbol is not a user defined symbol, it is defined. normal or special builtin
+            }
+            var lookUpResult = contextStack.lookUp(symbolNode);
             return lookUpResult !== null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode);
         },
     };
 
-    function evalueateBindingNodeValues(input, value, evaluate) {
-        var target = 'target' in input ? input.target : input;
-        var sourceCodeInfo = input.sourceCodeInfo;
+    var bindingTargetTypes = {
+        symbol: 11,
+        rest: 12,
+        object: 13,
+        array: 14,
+    };
+
+    function walkDefaults(bindingTarget, onDefault) {
+        var _a;
+        if (bindingTarget[0] === bindingTargetTypes.object) {
+            Object.values(bindingTarget[1][0]).forEach(function (element) {
+                if (element[1][1]) {
+                    onDefault(element[1][1]);
+                }
+                walkDefaults(element, onDefault);
+            });
+        }
+        else if (bindingTarget[0] === bindingTargetTypes.array) {
+            for (var index = 0; index < bindingTarget[1][0].length; index += 1) {
+                var element = (_a = bindingTarget[1][0][index]) !== null && _a !== void 0 ? _a : null;
+                if (element === null) {
+                    continue;
+                }
+                if (element[1][1]) {
+                    onDefault(element[1][1]);
+                }
+                walkDefaults(element, onDefault);
+            }
+        }
+    }
+    function evalueateBindingNodeValues(target, value, evaluate) {
+        var sourceCodeInfo = target[2];
         var record = {};
         createRecord(target, value, evaluate, sourceCodeInfo, record);
         return record;
     }
     function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
         var _a, _b;
-        if (bindingTarget.type === 'object') {
+        if (bindingTarget[0] === bindingTargetTypes.object) {
             assertUnknownRecord(value, sourceCodeInfo);
             var capturedKeys_1 = new Set();
             var restElement_1;
-            Object.entries(bindingTarget.elements).forEach(function (_a) {
+            Object.entries(bindingTarget[1][0]).forEach(function (_a) {
                 var _b;
                 var _c = __read(_a, 2), key = _c[0], element = _c[1];
-                if (element.type === 'rest') {
+                if (element[0] === bindingTargetTypes.rest) {
                     restElement_1 = element;
                     return;
                 }
                 capturedKeys_1.add(key);
-                var val = (_b = (value[key] !== undefined ? value[key] : element.default && evaluate(element.default))) !== null && _b !== void 0 ? _b : null;
+                var val = (_b = (value[key] !== undefined ? value[key] : element[1][1] && evaluate(element[1][1]))) !== null && _b !== void 0 ? _b : null;
                 assertAny(val, sourceCodeInfo);
                 createRecord(element, val, evaluate, sourceCodeInfo, record);
             });
@@ -3785,33 +3861,36 @@ var Lits = (function (exports) {
                     acc[key] = asAny(val);
                     return acc;
                 }, {});
-                record[restElement_1.name] = restValues;
+                record[restElement_1[1][0]] = restValues;
             }
         }
-        else if (bindingTarget.type === 'array') {
+        else if (bindingTarget[0] === bindingTargetTypes.array) {
             var restIndex = null;
             assertArray(value, sourceCodeInfo);
-            for (var index = 0; index < bindingTarget.elements.length; index += 1) {
-                var element = (_a = bindingTarget.elements[index]) !== null && _a !== void 0 ? _a : null;
+            for (var index = 0; index < bindingTarget[1][0].length; index += 1) {
+                var element = (_a = bindingTarget[1][0][index]) !== null && _a !== void 0 ? _a : null;
                 if (element === null) {
                     continue;
                 }
-                if (element.type === 'rest') {
+                if (element[0] === bindingTargetTypes.rest) {
                     restIndex = index;
                     break;
                 }
-                var val = (_b = (value[index] !== undefined ? value[index] : element.default && evaluate(element.default))) !== null && _b !== void 0 ? _b : null;
+                var val = (_b = (value[index] !== undefined ? value[index] : element[1][1] && evaluate(element[1][1]))) !== null && _b !== void 0 ? _b : null;
                 assertAny(val, sourceCodeInfo);
                 createRecord(element, val, evaluate, sourceCodeInfo, record);
             }
             if (restIndex !== null) {
                 var restValues = value.slice(restIndex);
-                var restElement = bindingTarget.elements[restIndex];
-                record[restElement.name] = restValues;
+                var restElement = bindingTarget[1][0][restIndex];
+                record[restElement[1][0]] = restValues;
             }
         }
+        else if (bindingTarget[0] === bindingTargetTypes.rest) {
+            record[bindingTarget[1][0]] = asAny(value);
+        }
         else {
-            record[bindingTarget.name] = asAny(value);
+            record[bindingTarget[1][0][1]] = asAny(value);
         }
     }
     function getAllBindingTargetNames(bindingTarget) {
@@ -3824,9 +3903,9 @@ var Lits = (function (exports) {
         if (target === null) {
             return;
         }
-        if (target.type === 'array') {
+        if (target[0] === bindingTargetTypes.array) {
             try {
-                for (var _c = __values(target.elements), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = __values(target[1][0]), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var element = _d.value;
                     getNamesFromBindingTarget(element, names);
                 }
@@ -3839,9 +3918,9 @@ var Lits = (function (exports) {
                 finally { if (e_1) throw e_1.error; }
             }
         }
-        else if (target.type === 'object') {
+        else if (target[0] === bindingTargetTypes.object) {
             try {
-                for (var _e = __values(Object.values(target.elements)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = __values(Object.values(target[1][0])), _f = _e.next(); !_f.done; _f = _e.next()) {
                     var element = _f.value;
                     getNamesFromBindingTarget(element, names);
                 }
@@ -3854,27 +3933,42 @@ var Lits = (function (exports) {
                 finally { if (e_2) throw e_2.error; }
             }
         }
+        else if (target[0] === bindingTargetTypes.rest) {
+            if (names[target[1][0]]) {
+                throw new LitsError("Duplicate binding name: ".concat(target[1][0]), target[2]);
+            }
+            names[target[1][0]] = true;
+        }
         else {
-            if (names[target.name]) {
-                throw new LitsError("Duplicate binding name: ".concat(target.name), target.sourceCodeInfo);
+            if (names[target[1][0][1]]) {
+                throw new LitsError("Duplicate binding name: ".concat(target[1][0]), target[2]);
             }
-            names[target.name] = true;
+            names[target[1][0][1]] = true;
         }
     }
 
     var defSpecialExpression = {
         paramCount: 2,
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var bindingValue = evaluateAstNode(node.bindingNode.value, contextStack);
-            var values = evalueateBindingNodeValues(node.bindingNode, bindingValue, function (astNode) { return evaluateAstNode(astNode, contextStack); });
+            var evaluateNode = _a.evaluateNode;
+            var bindingNode = node[1][1];
+            var target = bindingNode[1][0];
+            var value = bindingNode[1][1];
+            var bindingValue = evaluateNode(value, contextStack);
+            var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
             contextStack.exportValues(values);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            var bindingResult = getUndefinedSymbols([node.bindingNode.value], contextStack, builtin, evaluateAstNode);
-            contextStack.addValues(getAllBindingTargetNames(node.bindingNode.target));
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var bindingNode = node[1][1];
+            var target = bindingNode[1][0];
+            var value = bindingNode[1][1];
+            var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
+            walkDefaults(target, function (defaultNode) {
+                addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+            });
+            contextStack.addValues(getAllBindingTargetNames(target));
             return bindingResult;
         },
     };
@@ -3883,14 +3977,14 @@ var Lits = (function (exports) {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var newContext = {};
             var newContextStack = contextStack.create(newContext);
             var result = null;
             try {
-                for (var _c = __values(node.params), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = __values(node[1][1]), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var form = _d.value;
-                    result = evaluateAstNode(form, newContextStack);
+                    result = evaluateNode(form, newContextStack);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -3903,8 +3997,8 @@ var Lits = (function (exports) {
             return result;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack.create({}), builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack.create({}), builtin, evaluateNode);
         },
     };
 
@@ -3962,10 +4056,36 @@ var Lits = (function (exports) {
         return symbol in numberReservedSymbolRecord;
     }
 
+    var specialExpressionTypes = {
+        '??': 0,
+        '&&': 1,
+        '||': 2,
+        'array': 3,
+        'cond': 4,
+        '0_def': 5,
+        'defined?': 6,
+        '0_defn': 7,
+        'do': 8,
+        'doseq': 9,
+        '0_fn': 10,
+        'for': 11,
+        'function': 12,
+        'if': 13,
+        'let': 14,
+        'loop': 15,
+        'object': 16,
+        'recur': 17,
+        'switch': 18,
+        'throw': 19,
+        'try': 20,
+        'unless': 21,
+    };
+
     function assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo) {
         if (typeof name !== 'string')
             return;
-        if (builtin.specialExpressions[name])
+        // TODO only subset of special expressions are necessary to check (CommonSpecialExpressionType)
+        if (specialExpressionTypes[name])
             throw new LitsError("Cannot define variable ".concat(name, ", it's a special expression."), sourceCodeInfo);
         if (builtin.normalExpressions[name])
             throw new LitsError("Cannot define variable ".concat(name, ", it's a builtin function."), sourceCodeInfo);
@@ -3979,63 +4099,69 @@ var Lits = (function (exports) {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b, _c;
-            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateAstNode = _a.evaluateAstNode;
-            var name = node.functionName.value;
-            assertNameNotDefined(name, contextStack, builtin, node.sourceCodeInfo);
-            var evaluatedFunction = evaluateFunction(node, contextStack, builtin, getUndefinedSymbols, evaluateAstNode);
+            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
+            var _d = __read(node[1], 3), functionSymbol = _d[1], fn = _d[2];
+            assertUserDefinedSymbolNode(functionSymbol, node[2]);
+            assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
+            var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
             var litsFunction = (_b = {},
                 _b[FUNCTION_SYMBOL] = true,
-                _b.sourceCodeInfo = node.sourceCodeInfo,
+                _b.sourceCodeInfo = node[2],
                 _b.functionType = 'UserDefined',
-                _b.name = name,
+                _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunction,
                 _b);
-            contextStack.addValues((_c = {}, _c[name] = litsFunction, _c));
+            contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var _b, _c;
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            contextStack.addValues((_b = {}, _b[node.functionName.value] = true, _b));
-            var newContext = (_c = {}, _c[node.functionName.value] = { value: true }, _c);
-            return addFunctionUnresolvedSymbols(node.function, contextStack, getUndefinedSymbols, builtin, evaluateAstNode, newContext);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var functionName = node[1][1][1];
+            contextStack.addValues((_b = {}, _b[functionName] = true, _b));
+            var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
+            return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
     };
     var defnSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b, _c;
-            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateAstNode = _a.evaluateAstNode;
-            var name = node.functionName.value;
-            assertNameNotDefined(name, contextStack, builtin, node.sourceCodeInfo);
-            var evaluatedFunctionOverloades = evaluateFunction(node, contextStack, builtin, getUndefinedSymbols, evaluateAstNode);
+            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
+            var _d = __read(node[1], 3), functionSymbol = _d[1], fn = _d[2];
+            assertUserDefinedSymbolNode(functionSymbol, node[2]);
+            assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
+            var evaluatedFunctionOverloades = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
             var litsFunction = (_b = {},
                 _b[FUNCTION_SYMBOL] = true,
-                _b.sourceCodeInfo = node.sourceCodeInfo,
+                _b.sourceCodeInfo = node[2],
                 _b.functionType = 'UserDefined',
-                _b.name = name,
+                _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunctionOverloades,
                 _b);
-            contextStack.exportValues((_c = {}, _c[name] = litsFunction, _c));
+            contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var _b, _c;
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            contextStack.exportValues((_b = {}, _b[node.functionName.value] = true, _b));
-            var newContext = (_c = {}, _c[node.functionName.value] = { value: true }, _c);
-            return addFunctionUnresolvedSymbols(node.function, contextStack, getUndefinedSymbols, builtin, evaluateAstNode, newContext);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var functionName = node[1][1][1];
+            var fn = node[1][2];
+            contextStack.exportValues((_b = {}, _b[functionName] = true, _b));
+            var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
+            return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
     };
     var fnSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b;
-            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateAstNode = _a.evaluateAstNode;
-            var evaluatedFunction = evaluateFunction(node, contextStack, builtin, getUndefinedSymbols, evaluateAstNode);
+            var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
+            var fn = node[1][1];
+            var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
             var litsFunction = (_b = {},
                 _b[FUNCTION_SYMBOL] = true,
-                _b.sourceCodeInfo = node.sourceCodeInfo,
+                _b.sourceCodeInfo = node[2],
                 _b.functionType = 'UserDefined',
                 _b.name = undefined,
                 _b.evaluatedfunction = evaluatedFunction,
@@ -4043,129 +4169,109 @@ var Lits = (function (exports) {
             return litsFunction;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return addFunctionUnresolvedSymbols(node.function, contextStack, getUndefinedSymbols, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var fn = node[1][1];
+            return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
         },
     };
-    function evaluateFunction(node, contextStack, builtin, getUndefinedSymbols, evaluateAstNode) {
-        var fn = node.function;
+    function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode) {
         var functionContext = {};
-        var context = fn.arguments.reduce(function (ctx, arg) {
+        var context = fn[0].reduce(function (ctx, arg) {
             Object.keys(getAllBindingTargetNames(arg)).forEach(function (name) {
                 ctx[name] = { value: null };
             });
             return ctx;
         }, {});
-        var undefinedSymbols = getUndefinedSymbols(fn.body, contextStack.new(context), builtin, evaluateAstNode);
+        var undefinedSymbols = getUndefinedSymbols(fn[1], contextStack.new(context), builtin, evaluateNode);
         undefinedSymbols.forEach(function (name) {
             var value = contextStack.getValue(name);
             if (isAny(value)) {
                 functionContext[name] = { value: value };
             }
         });
-        var evaluatedFunction = {
-            arguments: fn.arguments,
-            body: fn.body,
-            context: functionContext,
-        };
+        var evaluatedFunction = [
+            fn[0],
+            fn[1],
+            functionContext,
+        ];
         return evaluatedFunction;
     }
-    function addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateAstNode, functionNameContext) {
+    function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
         var result = new Set();
         var contextStackWithFunctionName = functionNameContext ? contextStack.create(functionNameContext) : contextStack;
         var newContext = {};
-        fn.arguments.forEach(function (arg) {
+        fn[0].forEach(function (arg) {
             Object.assign(newContext, getAllBindingTargetNames(arg));
+            walkDefaults(arg, function (defaultNode) {
+                addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+            });
         });
         var newContextStack = contextStackWithFunctionName.create(newContext);
-        var overloadResult = getUndefinedSymbols(fn.body, newContextStack, builtin, evaluateAstNode);
+        var overloadResult = getUndefinedSymbols(fn[1], newContextStack, builtin, evaluateNode);
         addToSet(result, overloadResult);
         return result;
     }
 
-    function isAstNode(value) {
-        if (value === null || typeof value !== 'object')
-            return false;
-        if (!isAstNodeType(value.type))
-            return false;
-        return true;
-    }
-    function asAstNode(value, sourceCodeInfo) {
-        assertAstNode(value, sourceCodeInfo);
-        return value;
-    }
-    function assertAstNode(value, sourceCodeInfo) {
-        if (!isAstNode(value))
-            throw getAssertionError('AstNode', value, sourceCodeInfo);
-    }
-    function isSymbolNode(value) {
-        if (!isAstNode(value))
-            return false;
-        return value.type === 'Symbol';
-    }
-    function isNormalExpressionNodeWithName(value) {
-        if (!isAstNode(value))
-            return false;
-        return value.type === 'NormalExpression' && typeof value.name === 'string';
-    }
-
     var ifSpecialExpression = {
         paramCount: { min: 2, max: 3 },
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var sourceCodeInfo = node.sourceCodeInfo;
-            var _b = __read(node.params, 3), conditionNode = _b[0], trueNode = _b[1], falseNode = _b[2];
-            if (evaluateAstNode(asAstNode(conditionNode, sourceCodeInfo), contextStack)) {
-                return evaluateAstNode(asAstNode(trueNode, sourceCodeInfo), contextStack);
+            var evaluateNode = _a.evaluateNode;
+            var _b = __read(node[1][1], 3), conditionNode = _b[0], trueNode = _b[1], falseNode = _b[2];
+            if (evaluateNode(conditionNode, contextStack)) {
+                return evaluateNode(trueNode, contextStack);
             }
-            else {
-                if (node.params.length === 3)
-                    return evaluateAstNode(asAstNode(falseNode, sourceCodeInfo), contextStack);
-                else
-                    return null;
+            else if (falseNode) {
+                return evaluateNode(falseNode, contextStack);
             }
+            return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
         },
     };
 
     var unlessSpecialExpression = {
         paramCount: { min: 2, max: 3 },
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var sourceCodeInfo = node.sourceCodeInfo;
-            var _b = __read(node.params, 3), conditionNode = _b[0], trueNode = _b[1], falseNode = _b[2];
-            if (!evaluateAstNode(asAstNode(conditionNode, sourceCodeInfo), contextStack)) {
-                return evaluateAstNode(asAstNode(trueNode, sourceCodeInfo), contextStack);
+            var evaluateNode = _a.evaluateNode;
+            var _b = __read(node[1][1], 3), conditionNode = _b[0], trueNode = _b[1], falseNode = _b[2];
+            if (!evaluateNode(conditionNode, contextStack)) {
+                return evaluateNode(trueNode, contextStack);
             }
-            else {
-                if (node.params.length === 3)
-                    return evaluateAstNode(asAstNode(falseNode, sourceCodeInfo), contextStack);
-                else
-                    return null;
+            else if (falseNode) {
+                return evaluateNode(falseNode, contextStack);
             }
+            return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
         },
     };
 
     var letSpecialExpression = {
         paramCount: 0,
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var bindingValue = evaluateAstNode(node.bindingNode.value, contextStack);
-            var values = evalueateBindingNodeValues(node.bindingNode, bindingValue, function (astNode) { return evaluateAstNode(astNode, contextStack); });
+            var evaluateNode = _a.evaluateNode;
+            var bindingNode = node[1][1];
+            var target = bindingNode[1][0];
+            var value = bindingNode[1][1];
+            var bindingValue = evaluateNode(value, contextStack);
+            var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
             contextStack.addValues(values);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            var bindingResult = getUndefinedSymbols([node.bindingNode.value], contextStack, builtin, evaluateAstNode);
-            contextStack.addValues(getAllBindingTargetNames(node.bindingNode.target));
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var bindingNode = node[1][1];
+            var target = bindingNode[1][0];
+            var value = bindingNode[1][1];
+            var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
+            walkDefaults(target, function (defaultNode) {
+                addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+            });
+            contextStack.addValues(getAllBindingTargetNames(target));
             return bindingResult;
         },
     };
@@ -4173,11 +4279,11 @@ var Lits = (function (exports) {
     var loopSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var sourceCodeInfo = node.sourceCodeInfo;
-            var bindingContext = node.bindingNodes.reduce(function (result, binding) {
-                var val = evaluateAstNode(binding.value, contextStack.create(result));
-                var valueRecord = evalueateBindingNodeValues(binding, val, function (astNode) { return evaluateAstNode(astNode, contextStack); });
+            var evaluateNode = _a.evaluateNode;
+            var bindingNodes = node[1][1];
+            var bindingContext = bindingNodes.reduce(function (result, bindingNode) {
+                var val = evaluateNode(bindingNode[1][1], contextStack.create(result));
+                var valueRecord = evalueateBindingNodeValues(bindingNode[1][0], val, function (Node) { return evaluateNode(Node, contextStack); });
                 Object.entries(valueRecord).forEach(function (_a) {
                     var _b = __read(_a, 2), name = _b[0], value = _b[1];
                     result[name] = { value: value };
@@ -4185,20 +4291,21 @@ var Lits = (function (exports) {
                 return result;
             }, {});
             var newContextStack = contextStack.create(bindingContext);
+            var body = node[1][2];
             var _loop_1 = function () {
                 var e_1, _b;
                 var result = null;
                 try {
                     try {
-                        for (var _c = (e_1 = void 0, __values(node.params)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                            var form = _d.value;
-                            result = evaluateAstNode(form, newContextStack);
+                        for (var body_1 = (e_1 = void 0, __values(body)), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
+                            var form = body_1_1.value;
+                            result = evaluateNode(form, newContextStack);
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                            if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
@@ -4206,16 +4313,16 @@ var Lits = (function (exports) {
                 catch (error) {
                     if (error instanceof RecurSignal) {
                         var params_1 = error.params;
-                        if (params_1.length !== node.bindingNodes.length) {
-                            throw new LitsError("recur expected ".concat(node.bindingNodes.length, " parameters, got ").concat(valueToString(params_1.length)), sourceCodeInfo);
+                        if (params_1.length !== bindingNodes.length) {
+                            throw new LitsError("recur expected ".concat(bindingNodes.length, " parameters, got ").concat(valueToString(params_1.length)), node[2]);
                         }
-                        node.bindingNodes.forEach(function (binding, index) {
+                        bindingNodes.forEach(function (bindingNode, index) {
                             var e_2, _a;
-                            var valueRecord = evalueateBindingNodeValues(binding, asAny(params_1[index], sourceCodeInfo), function (astNode) { return evaluateAstNode(astNode, contextStack); });
+                            var valueRecord = evalueateBindingNodeValues(bindingNode[1][0], asAny(params_1[index]), function (Node) { return evaluateNode(Node, contextStack); });
                             try {
                                 for (var _b = (e_2 = void 0, __values(Object.entries(valueRecord))), _c = _b.next(); !_c.done; _c = _b.next()) {
                                     var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
-                                    asNonUndefined(bindingContext[name_1], sourceCodeInfo).value = value;
+                                    bindingContext[name_1].value = value;
                                 }
                             }
                             catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -4239,29 +4346,31 @@ var Lits = (function (exports) {
             }
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            var newContext = node.bindingNodes
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var bindingNodes = node[1][1];
+            var newContext = bindingNodes
                 .reduce(function (context, bindingNode) {
-                var names = getAllBindingTargetNames(bindingNode.target);
+                var names = getAllBindingTargetNames(bindingNode[1][0]);
                 Object.keys(names).forEach(function (name) {
                     context[name] = { value: true };
                 });
                 return context;
             }, {});
-            var bindingValueNodes = node.bindingNodes.map(function (binding) { return binding.value; });
-            var bindingsResult = getUndefinedSymbols(bindingValueNodes, contextStack, builtin, evaluateAstNode);
-            var paramsResult = getUndefinedSymbols(node.params, contextStack.create(newContext), builtin, evaluateAstNode);
+            var bindingValueNodes = bindingNodes.map(function (bindingNode) { return bindingNode[1][1]; });
+            var bindingsResult = getUndefinedSymbols(bindingValueNodes, contextStack, builtin, evaluateNode);
+            var paramsResult = getUndefinedSymbols(node[1][2], contextStack.create(newContext), builtin, evaluateNode);
             return joinSets(bindingsResult, paramsResult);
         },
     };
 
-    function addToContext(bindings, context, contextStack, evaluateAstNode) {
+    function addToContext(bindings, context, contextStack, evaluateNode) {
         var e_1, _a;
         try {
             for (var bindings_1 = __values(bindings), bindings_1_1 = bindings_1.next(); !bindings_1_1.done; bindings_1_1 = bindings_1.next()) {
-                var binding = bindings_1_1.value;
-                var val = evaluateAstNode(binding.value, contextStack);
-                var valueRecord = evalueateBindingNodeValues(binding, val, function (astNode) { return evaluateAstNode(astNode, contextStack); });
+                var bindingNode = bindings_1_1.value;
+                var _b = __read(bindingNode[1], 2), target = _b[0], bindingValue = _b[1];
+                var val = evaluateNode(bindingValue, contextStack);
+                var valueRecord = evalueateBindingNodeValues(target, val, function (Node) { return evaluateNode(Node, contextStack); });
                 Object.entries(valueRecord).forEach(function (_a) {
                     var _b = __read(_a, 2), name = _b[0], value = _b[1];
                     context[name] = { value: value };
@@ -4276,9 +4385,9 @@ var Lits = (function (exports) {
             finally { if (e_1) throw e_1.error; }
         }
     }
-    function evaluateLoop(returnResult, node, contextStack, evaluateAstNode) {
-        var sourceCodeInfo = node.sourceCodeInfo;
-        var _a = node, loopBindings = _a.l, params = _a.params;
+    function evaluateLoop(returnResult, loopNode, contextStack, evaluateNode) {
+        var sourceCodeInfo = loopNode[2];
+        var _a = __read(loopNode[1], 3), loopBindings = _a[1], body = _a[2];
         var result = [];
         var bindingIndices = loopBindings.map(function () { return 0; });
         var abort = false;
@@ -4288,8 +4397,9 @@ var Lits = (function (exports) {
             var newContextStack = contextStack.create(context);
             var skip = false;
             bindingsLoop: for (var bindingIndex = 0; bindingIndex < loopBindings.length; bindingIndex += 1) {
-                var _c = asNonUndefined(loopBindings[bindingIndex], sourceCodeInfo), binding = _c.b, letBindings = _c.l, whenNode = _c.wn, whileNode = _c.we, modifiers = _c.m;
-                var coll = asColl(evaluateAstNode(binding.value, newContextStack), sourceCodeInfo);
+                var _c = __read(loopBindings[bindingIndex], 4), bindingNode = _c[0], letBindings = _c[1], whenNode = _c[2], whileNode = _c[3];
+                var _d = __read(bindingNode[1], 2), targetNode = _d[0], valueNode = _d[1];
+                var coll = asColl(evaluateNode(valueNode, newContextStack), sourceCodeInfo);
                 var seq = isSeq(coll) ? coll : Object.entries(coll);
                 if (seq.length === 0) {
                     skip = true;
@@ -4308,45 +4418,40 @@ var Lits = (function (exports) {
                     break;
                 }
                 var val = asAny(seq[index], sourceCodeInfo);
-                var valueRecord = evalueateBindingNodeValues(binding, val, function (astNode) { return evaluateAstNode(astNode, newContextStack); });
+                var valueRecord = evalueateBindingNodeValues(targetNode, val, function (Node) { return evaluateNode(Node, newContextStack); });
                 Object.entries(valueRecord).forEach(function (_a) {
                     var _b = __read(_a, 2), name = _b[0], value = _b[1];
                     context[name] = { value: value };
                 });
+                if (letBindings) {
+                    addToContext(letBindings, context, newContextStack, evaluateNode);
+                }
+                if (whenNode && !evaluateNode(whenNode, newContextStack)) {
+                    bindingIndices[bindingIndex] = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo) + 1;
+                    skip = true;
+                    break bindingsLoop;
+                }
+                if (whileNode && !evaluateNode(whileNode, newContextStack)) {
+                    bindingIndices[bindingIndex] = Number.POSITIVE_INFINITY;
+                    skip = true;
+                    break bindingsLoop;
+                }
+            }
+            if (!skip) {
+                var value = null;
                 try {
-                    for (var modifiers_1 = (e_2 = void 0, __values(modifiers)), modifiers_1_1 = modifiers_1.next(); !modifiers_1_1.done; modifiers_1_1 = modifiers_1.next()) {
-                        var modifier = modifiers_1_1.value;
-                        switch (modifier) {
-                            case '&let':
-                                addToContext(asNonUndefined(letBindings, sourceCodeInfo), context, newContextStack, evaluateAstNode);
-                                break;
-                            case '&when':
-                                if (!evaluateAstNode(asAstNode(whenNode, sourceCodeInfo), newContextStack)) {
-                                    bindingIndices[bindingIndex] = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo) + 1;
-                                    skip = true;
-                                    break bindingsLoop;
-                                }
-                                break;
-                            case '&while':
-                                if (!evaluateAstNode(asAstNode(whileNode, sourceCodeInfo), newContextStack)) {
-                                    bindingIndices[bindingIndex] = Number.POSITIVE_INFINITY;
-                                    skip = true;
-                                    break bindingsLoop;
-                                }
-                                break;
-                        }
+                    for (var body_1 = (e_2 = void 0, __values(body)), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
+                        var form = body_1_1.value;
+                        value = evaluateNode(form, newContextStack);
                     }
                 }
                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
                 finally {
                     try {
-                        if (modifiers_1_1 && !modifiers_1_1.done && (_b = modifiers_1.return)) _b.call(modifiers_1);
+                        if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
                     }
                     finally { if (e_2) throw e_2.error; }
                 }
-            }
-            if (!skip) {
-                var value = evaluateAstNode(params[0], newContextStack);
                 if (returnResult)
                     result.push(value);
                 if (bindingIndices.length > 0)
@@ -4358,57 +4463,59 @@ var Lits = (function (exports) {
         }
         return returnResult ? result : null;
     }
-    function analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateAstNode) {
+    function analyze(loopNode, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
         var result = new Set();
         var newContext = {};
-        var loopBindings = node.l;
-        loopBindings.forEach(function (loopBinding) {
-            var binding = loopBinding.b, letBindings = loopBinding.l, whenNode = loopBinding.wn, whileNode = loopBinding.we;
-            getUndefinedSymbols([binding.value], contextStack.create(newContext), builtin, evaluateAstNode).forEach(function (symbol) {
+        var _a = __read(loopNode[1], 3), loopBindings = _a[1], body = _a[2];
+        loopBindings.forEach(function (loopBindingNode) {
+            var _a = __read(loopBindingNode, 4), bindingNode = _a[0], letBindings = _a[1], whenNode = _a[2], whileNode = _a[3];
+            var _b = __read(bindingNode[1], 2), target = _b[0], value = _b[1];
+            getUndefinedSymbols([value], contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
                 return result.add(symbol);
             });
-            Object.assign(newContext, getAllBindingTargetNames(binding.target));
+            Object.assign(newContext, getAllBindingTargetNames(target));
             if (letBindings) {
-                letBindings.forEach(function (letBinding) {
-                    getUndefinedSymbols([letBinding.value], contextStack.create(newContext), builtin, evaluateAstNode).forEach(function (symbol) {
+                letBindings.forEach(function (letBindingNode) {
+                    var _a = __read(letBindingNode[1], 2), letTarget = _a[0], letValue = _a[1];
+                    getUndefinedSymbols([letValue], contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
                         return result.add(symbol);
                     });
-                    Object.assign(newContext, getAllBindingTargetNames(letBinding.target));
+                    Object.assign(newContext, getAllBindingTargetNames(letTarget));
                 });
             }
             if (whenNode) {
-                getUndefinedSymbols([whenNode], contextStack.create(newContext), builtin, evaluateAstNode).forEach(function (symbol) {
+                getUndefinedSymbols([whenNode], contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
                     return result.add(symbol);
                 });
             }
             if (whileNode) {
-                getUndefinedSymbols([whileNode], contextStack.create(newContext), builtin, evaluateAstNode).forEach(function (symbol) {
+                getUndefinedSymbols([whileNode], contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
                     return result.add(symbol);
                 });
             }
         });
-        getUndefinedSymbols(node.params, contextStack.create(newContext), builtin, evaluateAstNode).forEach(function (symbol) {
+        getUndefinedSymbols(body, contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
             return result.add(symbol);
         });
         return result;
     }
     var forSpecialExpression = {
         paramCount: 1,
-        evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateAstNode); },
+        evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateNode); },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateNode);
         },
     };
     var doseqSpecialExpression = {
         paramCount: 1,
         evaluate: function (node, contextStack, helpers) {
-            evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
+            evaluateLoop(false, node, contextStack, helpers.evaluateNode);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateNode);
         },
     };
 
@@ -4416,12 +4523,12 @@ var Lits = (function (exports) {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var value = false;
             try {
-                for (var _c = __values(node.params), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = __values(node[1][1]), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var param = _d.value;
-                    value = evaluateAstNode(param, contextStack);
+                    value = evaluateNode(param, contextStack);
                     if (value)
                         break;
                 }
@@ -4436,55 +4543,55 @@ var Lits = (function (exports) {
             return value;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
         },
     };
 
     var qqSpecialExpression = {
         paramCount: { min: 1, max: 2 },
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var _b = __read(node.params, 2), firstNode = _b[0], secondNode = _b[1];
-            if (isSymbolNode(firstNode)) {
-                if (contextStack.lookUp(firstNode) === null)
-                    return secondNode ? evaluateAstNode(secondNode, contextStack) : null;
+            var evaluateNode = _a.evaluateNode;
+            var _b = __read(node[1][1], 2), firstNode = _b[0], secondNode = _b[1];
+            if (isUserDefinedSymbolNode(firstNode) && contextStack.lookUp(firstNode) === null) {
+                return secondNode ? evaluateNode(secondNode, contextStack) : null;
             }
-            assertAny(firstNode, node.sourceCodeInfo);
-            var firstResult = evaluateAstNode(firstNode, contextStack);
-            return firstResult !== null && firstResult !== void 0 ? firstResult : (secondNode ? evaluateAstNode(secondNode, contextStack) : null);
+            assertAny(firstNode, node[2]);
+            var firstResult = evaluateNode(firstNode, contextStack);
+            return firstResult !== null && firstResult !== void 0 ? firstResult : (secondNode ? evaluateNode(secondNode, contextStack) : null);
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
         },
     };
 
     var recurSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var params = node.params.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
-            throw new RecurSignal(params);
+            var evaluateNode = _a.evaluateNode;
+            var params = node[1][1];
+            var evaluatedParams = params.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
+            throw new RecurSignal(evaluatedParams);
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
         },
     };
 
     var throwSpecialExpression = {
         paramCount: 1,
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var message = asString(evaluateAstNode(node.params[0], contextStack), node.sourceCodeInfo, {
+            var evaluateNode = _a.evaluateNode;
+            var message = asString(evaluateNode(node[1][1], contextStack), node[2], {
                 nonEmpty: true,
             });
-            throw new UserDefinedError(message, node.sourceCodeInfo);
+            throw new UserDefinedError(message, node[2]);
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode);
         },
     };
 
@@ -4492,29 +4599,29 @@ var Lits = (function (exports) {
         paramCount: 1,
         evaluate: function (node, contextStack, _a) {
             var _b;
-            var evaluateAstNode = _a.evaluateAstNode;
-            var tryExpressions = node.params, catchExpression = node.ce, errorNode = node.e;
+            var evaluateNode = _a.evaluateNode;
+            var _c = __read(node[1], 4), tryExpression = _c[1], errorSymbol = _c[2], catchExpression = _c[3];
             try {
-                return evaluateAstNode(tryExpressions[0], contextStack);
+                return evaluateNode(tryExpression, contextStack);
             }
             catch (error) {
-                var newContext = errorNode
+                var newContext = errorSymbol
                     ? (_b = {},
-                        _b[errorNode.value] = { value: asAny(error, node.sourceCodeInfo) },
+                        _b[errorSymbol[1]] = { value: error },
                         _b) : {};
-                return evaluateAstNode(catchExpression, contextStack.create(newContext));
+                return evaluateNode(catchExpression, contextStack.create(newContext));
             }
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var _b;
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            var tryExpressions = node.params, catchExpression = node.ce, errorNode = node.e;
-            var tryResult = getUndefinedSymbols(tryExpressions, contextStack, builtin, evaluateAstNode);
-            var newContext = errorNode
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            var _c = __read(node[1], 4), tryExpression = _c[1], errorSymbol = _c[2], catchExpression = _c[3];
+            var tryResult = getUndefinedSymbols([tryExpression], contextStack, builtin, evaluateNode);
+            var newContext = errorSymbol
                 ? (_b = {},
-                    _b[errorNode.value] = { value: true },
+                    _b[errorSymbol[1]] = { value: true },
                     _b) : {};
-            var catchResult = getUndefinedSymbols([catchExpression], contextStack.create(newContext), builtin, evaluateAstNode);
+            var catchResult = getUndefinedSymbols([catchExpression], contextStack.create(newContext), builtin, evaluateNode);
             return joinSets(tryResult, catchResult);
         },
     };
@@ -4523,20 +4630,20 @@ var Lits = (function (exports) {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var result = [];
             try {
-                for (var _c = __values(node.params), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = __values(node[1][1]), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var param = _d.value;
-                    if (param.type === 'Spread') {
-                        var spreadValue = evaluateAstNode(param.value, contextStack);
+                    if (isSpreadNode(param)) {
+                        var spreadValue = evaluateNode(param[1], contextStack);
                         if (!Array.isArray(spreadValue)) {
-                            throw new LitsError('Spread value is not an array', param.sourceCodeInfo);
+                            throw new LitsError('Spread value is not an array', param[2]);
                         }
                         result.push.apply(result, __spreadArray([], __read(spreadValue), false));
                     }
                     else {
-                        result.push(evaluateAstNode(param, contextStack));
+                        result.push(evaluateNode(param, contextStack));
                     }
                 }
             }
@@ -4550,156 +4657,169 @@ var Lits = (function (exports) {
             return result;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
         },
     };
 
     var objectSpecialExpression = {
         paramCount: {},
         evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var result = {};
-            for (var i = 0; i < node.params.length; i += 2) {
-                var keyNode = asAstNode(node.params[i]);
-                if ((keyNode === null || keyNode === void 0 ? void 0 : keyNode.type) === 'Spread') {
-                    var spreadObject = evaluateAstNode(keyNode.value, contextStack);
+            var params = node[1][1];
+            for (var i = 0; i < params.length; i += 2) {
+                var keyNode = params[i];
+                if (isSpreadNode(keyNode)) {
+                    var spreadObject = evaluateNode(keyNode[1], contextStack);
                     if (!isUnknownRecord(spreadObject)) {
-                        throw new LitsError('Spread value is not an object', keyNode.sourceCodeInfo);
+                        throw new LitsError('Spread value is not an object', keyNode[2]);
                     }
                     Object.assign(result, spreadObject);
                     i -= 1;
                 }
                 else {
-                    var key = evaluateAstNode(keyNode, contextStack);
-                    var value = evaluateAstNode(node.params[i + 1], contextStack);
-                    assertString(key, keyNode.sourceCodeInfo);
+                    var key = evaluateNode(keyNode, contextStack);
+                    var value = evaluateNode(params[i + 1], contextStack);
+                    assertString(key, keyNode[2]);
                     result[key] = value;
                 }
             }
             return result;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
-            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-            return getUndefinedSymbols(node.params, contextStack, builtin, evaluateAstNode);
+            var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
+            return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
         },
     };
 
-    var specialExpressions = {
-        '&&': andSpecialExpression,
-        'cond': condSpecialExpression,
-        'switch': switchSpecialExpression,
-        'def': defSpecialExpression,
-        'defn': defnSpecialExpression,
-        'function': functionSpecialExpression,
-        'do': doSpecialExpression,
-        'doseq': doseqSpecialExpression,
-        'for': forSpecialExpression,
-        'fn': fnSpecialExpression,
-        'if': ifSpecialExpression,
-        'unless': unlessSpecialExpression,
-        'let': letSpecialExpression,
-        'loop': loopSpecialExpression,
-        '||': orSpecialExpression,
-        'recur': recurSpecialExpression,
-        'throw': throwSpecialExpression,
-        'try': trySpecialExpression,
-        'defined?': declaredSpecialExpression,
-        '??': qqSpecialExpression,
-        'array': arraySpecialExpression,
-        'object': objectSpecialExpression,
-    };
+    var specialExpressions = [
+        qqSpecialExpression,
+        andSpecialExpression,
+        orSpecialExpression,
+        arraySpecialExpression,
+        condSpecialExpression,
+        defSpecialExpression,
+        definedSpecialExpression,
+        defnSpecialExpression,
+        doSpecialExpression,
+        doseqSpecialExpression,
+        fnSpecialExpression,
+        forSpecialExpression,
+        functionSpecialExpression,
+        ifSpecialExpression,
+        letSpecialExpression,
+        loopSpecialExpression,
+        objectSpecialExpression,
+        recurSpecialExpression,
+        switchSpecialExpression,
+        throwSpecialExpression,
+        trySpecialExpression,
+        unlessSpecialExpression,
+    ];
     var builtin = {
         normalExpressions: normalExpressions,
         specialExpressions: specialExpressions,
+        allNormalExpressions: allNormalExpressions,
     };
     var normalExpressionKeys = Object.keys(normalExpressions);
-    var specialExpressionKeys = Object.keys(specialExpressions);
+    var specialExpressionKeys = Object.keys(specialExpressionTypes);
+    new Set(specialExpressionKeys);
 
-    var getUndefinedSymbols = function (ast, contextStack, builtin, evaluateAstNode) {
+    var getUndefinedSymbols = function (ast, contextStack, builtin, evaluateNode) {
         var e_1, _a;
         var _b;
-        var astNodes = Array.isArray(ast)
+        var nodes = Array.isArray(ast)
             ? ast
-            : [{
-                    type: 'SpecialExpression',
-                    name: 'do',
-                    params: ast.body,
-                    sourceCodeInfo: undefined,
-                }];
+            : [[NodeTypes.SpecialExpression, [specialExpressionTypes.do, ast.body]]];
         var unresolvedSymbols = new Set();
         try {
-            for (var astNodes_1 = __values(astNodes), astNodes_1_1 = astNodes_1.next(); !astNodes_1_1.done; astNodes_1_1 = astNodes_1.next()) {
-                var subNode = astNodes_1_1.value;
-                (_b = findUnresolvedSymbolsInAstNode(subNode, contextStack, builtin, evaluateAstNode)) === null || _b === void 0 ? void 0 : _b.forEach(function (symbol) { return unresolvedSymbols.add(symbol); });
+            for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                var subNode = nodes_1_1.value;
+                (_b = findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)) === null || _b === void 0 ? void 0 : _b.forEach(function (symbol) { return unresolvedSymbols.add(symbol); });
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (astNodes_1_1 && !astNodes_1_1.done && (_a = astNodes_1.return)) _a.call(astNodes_1);
+                if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
             }
             finally { if (e_1) throw e_1.error; }
         }
         return unresolvedSymbols;
     };
-    function findUnresolvedSymbolsInAstNode(astNode, contextStack, builtin, evaluateAstNode) {
+    function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode) {
         var e_2, _a;
-        var _b;
-        switch (astNode.type) {
-            case 'Symbol': {
-                var lookUpResult = contextStack.lookUp(astNode);
+        var _b, _c;
+        var nodeType = node[0];
+        switch (nodeType) {
+            case NodeTypes.UserDefinedSymbol: {
+                var symbolNode = node;
+                var lookUpResult = contextStack.lookUp(symbolNode);
                 if (lookUpResult === null)
-                    return new Set([astNode.value]);
+                    return new Set([symbolNode[1]]);
                 return null;
             }
-            case 'String':
-            case 'Number':
-            case 'Modifier':
-            case 'ReservedSymbol':
-            case 'Comment':
+            case NodeTypes.NormalBuiltinSymbol:
+            case NodeTypes.SpecialBuiltinSymbol:
+            case NodeTypes.String:
+            case NodeTypes.Number:
+            case NodeTypes.ReservedSymbol:
+            case NodeTypes.Binding:
                 return null;
-            case 'NormalExpression': {
+            case NodeTypes.NormalExpression: {
+                var normalExpressionNode = node;
                 var unresolvedSymbols_1 = new Set();
-                var name_1 = astNode.name, sourceCodeInfo = astNode.sourceCodeInfo;
-                if (typeof name_1 === 'string') {
-                    var lookUpResult = contextStack.lookUp({ type: 'Symbol', value: name_1, sourceCodeInfo: sourceCodeInfo });
-                    if (lookUpResult === null)
-                        unresolvedSymbols_1.add(name_1);
+                if (isNormalExpressionNodeWithName(normalExpressionNode)) {
+                    var _d = __read(normalExpressionNode, 2), _e = __read(_d[1], 1), symbolNode = _e[0];
+                    if (isUserDefinedSymbolNode(symbolNode)) {
+                        var lookUpResult = contextStack.lookUp(symbolNode);
+                        if (lookUpResult === null)
+                            unresolvedSymbols_1.add(symbolNode[1]);
+                    }
+                }
+                else {
+                    var _f = __read(normalExpressionNode, 2), _g = __read(_f[1], 1), expressionNode = _g[0];
+                    (_b = findUnresolvedSymbolsInNode(expressionNode, contextStack, builtin, evaluateNode)) === null || _b === void 0 ? void 0 : _b.forEach(function (symbol) { return unresolvedSymbols_1.add(symbol); });
                 }
                 try {
-                    for (var _c = __values(astNode.params), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var subNode = _d.value;
-                        (_b = findUnresolvedSymbolsInAstNode(subNode, contextStack, builtin, evaluateAstNode)) === null || _b === void 0 ? void 0 : _b.forEach(function (symbol) { return unresolvedSymbols_1.add(symbol); });
+                    for (var _h = __values(normalExpressionNode[1][1]), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var subNode = _j.value;
+                        (_c = findUnresolvedSymbolsInNode(subNode, contextStack, builtin, evaluateNode)) === null || _c === void 0 ? void 0 : _c.forEach(function (symbol) { return unresolvedSymbols_1.add(symbol); });
                     }
                 }
                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
                 finally {
                     try {
-                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
                     }
                     finally { if (e_2) throw e_2.error; }
                 }
                 return unresolvedSymbols_1;
             }
-            case 'SpecialExpression': {
-                var specialExpression = asNonUndefined(builtin.specialExpressions[astNode.name], astNode.sourceCodeInfo);
-                // eslint-disable-next-line ts/no-unsafe-argument
-                return specialExpression.getUndefinedSymbols(astNode, contextStack, {
+            case NodeTypes.SpecialExpression: {
+                var specialExpressionNode = node;
+                var specialExpressionType = specialExpressionNode[1][0];
+                var specialExpression = builtin.specialExpressions[specialExpressionType];
+                var castedGetUndefinedSymbols = specialExpression.getUndefinedSymbols;
+                return castedGetUndefinedSymbols(specialExpressionNode, contextStack, {
                     getUndefinedSymbols: getUndefinedSymbols,
                     builtin: builtin,
-                    evaluateAstNode: evaluateAstNode,
+                    evaluateNode: evaluateNode,
                 });
             }
-            case 'Spread':
-                return findUnresolvedSymbolsInAstNode(astNode.value, contextStack, builtin, evaluateAstNode);
+            case NodeTypes.Spread:
+                return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
+            /* v8 ignore next 2 */
+            default:
+                throw new Error("Unhandled node type: ".concat(nodeType));
         }
     }
 
     function checkParams(evaluatedFunction, nbrOfParams, sourceCodeInfo) {
-        var hasRest = evaluatedFunction.arguments.some(function (arg) { return arg.type === 'rest'; });
-        var minArity = evaluatedFunction.arguments.filter(function (arg) { return arg.type !== 'rest' && !arg.default; }).length;
-        var maxArity = hasRest ? Number.MAX_SAFE_INTEGER : evaluatedFunction.arguments.length;
+        var hasRest = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; });
+        var minArity = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
+        var maxArity = hasRest ? Number.MAX_SAFE_INTEGER : evaluatedFunction[0].length;
         if (nbrOfParams < minArity || nbrOfParams > maxArity) {
             throw new LitsError("Unexpected number of arguments, got ".concat(valueToString(nbrOfParams), "."), sourceCodeInfo);
         }
@@ -4723,21 +4843,21 @@ var Lits = (function (exports) {
             }
         },
         UserDefined: function (fn, params, sourceCodeInfo, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
+            var evaluateNode = _a.evaluateNode;
             var _loop_1 = function () {
                 var e_1, _b;
                 checkParams(fn.evaluatedfunction, params.length, sourceCodeInfo);
                 var evaluatedFunction = fn.evaluatedfunction;
-                var args = evaluatedFunction.arguments;
-                var nbrOfNonRestArgs = args.filter(function (arg) { return arg.type !== 'rest'; }).length;
-                var newContextStack = contextStack.create(fn.evaluatedfunction.context);
+                var args = evaluatedFunction[0];
+                var nbrOfNonRestArgs = args.filter(function (arg) { return arg[0] !== bindingTargetTypes.rest; }).length;
+                var newContextStack = contextStack.create(fn.evaluatedfunction[2]);
                 var newContext = {};
                 var rest = [];
                 for (var i = 0; i < params.length; i += 1) {
                     if (i < nbrOfNonRestArgs) {
                         var param = toAny(params[i]);
-                        var valueRecord = evalueateBindingNodeValues(args[i], param, function (astNode) {
-                            return evaluateAstNode(astNode, newContextStack.create(newContext));
+                        var valueRecord = evalueateBindingNodeValues(args[i], param, function (Node) {
+                            return evaluateNode(Node, newContextStack.create(newContext));
                         });
                         Object.entries(valueRecord).forEach(function (_a) {
                             var _b = __read(_a, 2), key = _b[0], value = _b[1];
@@ -4750,18 +4870,18 @@ var Lits = (function (exports) {
                 }
                 for (var i = params.length; i < nbrOfNonRestArgs; i++) {
                     var arg = args[i];
-                    var defaultValue = evaluateAstNode(arg.default, contextStack.create(newContext));
-                    var valueRecord = evalueateBindingNodeValues(arg, defaultValue, function (astNode) {
-                        return evaluateAstNode(astNode, contextStack.create(newContext));
+                    var defaultValue = evaluateNode(arg[1][1], contextStack.create(newContext));
+                    var valueRecord = evalueateBindingNodeValues(arg, defaultValue, function (Node) {
+                        return evaluateNode(Node, contextStack.create(newContext));
                     });
                     Object.entries(valueRecord).forEach(function (_a) {
                         var _b = __read(_a, 2), key = _b[0], value = _b[1];
                         newContext[key] = { value: value };
                     });
                 }
-                var restArgument = args.find(function (arg) { return arg.type === 'rest'; });
+                var restArgument = args.find(function (arg) { return arg[0] === bindingTargetTypes.rest; });
                 if (restArgument !== undefined) {
-                    var valueRecord = evalueateBindingNodeValues(restArgument, rest, function (astNode) { return evaluateAstNode(astNode, contextStack.create(newContext)); });
+                    var valueRecord = evalueateBindingNodeValues(restArgument, rest, function (Node) { return evaluateNode(Node, contextStack.create(newContext)); });
                     Object.entries(valueRecord).forEach(function (_a) {
                         var _b = __read(_a, 2), key = _b[0], value = _b[1];
                         newContext[key] = { value: value };
@@ -4771,9 +4891,9 @@ var Lits = (function (exports) {
                     var result = null;
                     var newContextStack2 = newContextStack.create(newContext);
                     try {
-                        for (var _c = (e_1 = void 0, __values(evaluatedFunction.body)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        for (var _c = (e_1 = void 0, __values(evaluatedFunction[1])), _d = _c.next(); !_d.done; _d = _c.next()) {
                             var node = _d.value;
-                            result = evaluateAstNode(node, newContextStack2);
+                            result = evaluateNode(node, newContextStack2);
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -4897,7 +5017,7 @@ var Lits = (function (exports) {
         },
         Builtin: function (fn, params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
-            var normalExpression = asNonUndefined(normalExpressions[fn.n], sourceCodeInfo);
+            var normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuitinSymbolType], sourceCodeInfo);
             return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
         },
     };
@@ -4908,7 +5028,7 @@ var Lits = (function (exports) {
         try {
             for (var _b = __values(ast.body), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var node = _c.value;
-                result = evaluateAstNode(node, contextStack);
+                result = evaluateNode(node, contextStack);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -4920,53 +5040,66 @@ var Lits = (function (exports) {
         }
         return result;
     }
-    function evaluateAstNode(node, contextStack) {
-        switch (node.type) {
-            case 'Number':
+    function evaluateNode(node, contextStack) {
+        switch (node[0]) {
+            case NodeTypes.Number:
                 return evaluateNumber(node);
-            case 'String':
+            case NodeTypes.String:
                 return evaluateString(node);
-            case 'Symbol':
-                return contextStack.evaluateName(node);
-            case 'ReservedSymbol':
-                return evaluateReservedName(node);
-            case 'NormalExpression':
+            case NodeTypes.NormalBuiltinSymbol:
+            case NodeTypes.SpecialBuiltinSymbol:
+            case NodeTypes.UserDefinedSymbol:
+                return contextStack.evaluateSymbol(node);
+            case NodeTypes.ReservedSymbol:
+                return evaluateReservedSymbol(node);
+            case NodeTypes.NormalExpression:
                 return evaluateNormalExpression(node, contextStack);
-            case 'SpecialExpression':
+            case NodeTypes.SpecialExpression:
                 return evaluateSpecialExpression(node, contextStack);
             /* v8 ignore next 2 */
             default:
-                throw new LitsError("".concat(node.type, "-node cannot be evaluated"), node.sourceCodeInfo);
+                throw new LitsError("".concat(getNodeTypeName(node[0]), "-node cannot be evaluated"), node[2]);
         }
     }
     function evaluateNumber(node) {
-        return node.value;
+        return node[1];
     }
     function evaluateString(node) {
-        return node.value;
+        return node[1];
     }
-    function evaluateReservedName(node) {
-        var reservedName = node.value;
+    function evaluateReservedSymbol(node) {
+        var reservedName = node[1];
         var value = reservedSymbolRecord[reservedName];
-        return asNonUndefined(value, node.sourceCodeInfo);
+        return asNonUndefined(value, node[2]);
     }
     function evaluateNormalExpression(node, contextStack) {
-        var params = node.params.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
-        var sourceCodeInfo = node.sourceCodeInfo;
+        var sourceCodeInfo = node[2];
+        var paramNodes = node[1][1];
+        var params = paramNodes.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
         if (isNormalExpressionNodeWithName(node)) {
-            var value = contextStack.getValue(node.name);
-            if (value !== undefined)
-                return executeFunction(asAny(value), params, contextStack, sourceCodeInfo);
-            return evaluateBuiltinNormalExpression(node, params, contextStack);
+            var nameSymbol = node[1][0];
+            if (isNormalBuiltinSymbolNode(nameSymbol)) {
+                var type = nameSymbol[1];
+                var normalExpression = builtin.allNormalExpressions[type];
+                return normalExpression.evaluate(params, node[2], contextStack, { executeFunction: executeFunction });
+            }
+            else {
+                var fn = contextStack.getValue(nameSymbol[1]);
+                if (fn !== undefined) {
+                    return executeFunction(asAny(fn), params, contextStack, sourceCodeInfo);
+                }
+                throw new UndefinedSymbolError(nameSymbol[1], node[2]);
+            }
         }
         else {
-            var fn = params[0];
-            return executeFunction(fn, params.slice(1), contextStack, sourceCodeInfo);
+            var fnNode = node[1][0];
+            var fn = evaluateNode(fnNode, contextStack);
+            return executeFunction(fn, params, contextStack, sourceCodeInfo);
         }
     }
     function executeFunction(fn, params, contextStack, sourceCodeInfo) {
         if (isLitsFunction(fn))
-            return functionExecutors[fn.functionType](fn, params, sourceCodeInfo, contextStack, { evaluateAstNode: evaluateAstNode, executeFunction: executeFunction });
+            return functionExecutors[fn.functionType](fn, params, sourceCodeInfo, contextStack, { evaluateNode: evaluateNode, executeFunction: executeFunction });
         if (Array.isArray(fn))
             return evaluateArrayAsFunction(fn, params, sourceCodeInfo);
         if (isObj(fn))
@@ -4977,16 +5110,11 @@ var Lits = (function (exports) {
             return evaluateNumberAsFunction(fn, params, sourceCodeInfo);
         throw new NotAFunctionError(fn, sourceCodeInfo);
     }
-    function evaluateBuiltinNormalExpression(node, params, contextStack) {
-        var normalExpression = builtin.normalExpressions[node.name];
-        if (!normalExpression)
-            throw new UndefinedSymbolError(node.name, node.sourceCodeInfo);
-        return normalExpression.evaluate(params, node.sourceCodeInfo, contextStack, { executeFunction: executeFunction });
-    }
     function evaluateSpecialExpression(node, contextStack) {
-        var specialExpression = asNonUndefined(builtin.specialExpressions[node.name], node.sourceCodeInfo);
-        // eslint-disable-next-line ts/no-unsafe-argument
-        return specialExpression.evaluate(node, contextStack, { evaluateAstNode: evaluateAstNode, builtin: builtin, getUndefinedSymbols: getUndefinedSymbols });
+        var specialExpressionType = node[1][0];
+        var specialExpression = asNonUndefined(builtin.specialExpressions[specialExpressionType], node[2]);
+        var castedEvaluate = specialExpression.evaluate;
+        return castedEvaluate(node, contextStack, { evaluateNode: evaluateNode, builtin: builtin, getUndefinedSymbols: getUndefinedSymbols });
     }
     function evalueateObjectAsFunction(fn, params, sourceCodeInfo) {
         if (params.length !== 1)
@@ -5128,13 +5256,13 @@ var Lits = (function (exports) {
             return (_d = this.values) === null || _d === void 0 ? void 0 : _d[name];
         };
         ContextStackImpl.prototype.lookUp = function (node) {
-            var e_4, _a, _b;
-            var _c, _d, _e;
-            var value = node.value;
-            var sourceCodeInfo = node.sourceCodeInfo;
+            var e_4, _a;
+            var _b, _c, _d;
+            var value = node[1];
             try {
-                for (var _f = __values(this.contexts), _g = _f.next(); !_g.done; _g = _f.next()) {
-                    var context = _g.value;
+                // const sourceCodeInfo = node[2]
+                for (var _e = __values(this.contexts), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var context = _f.value;
                     var contextEntry = context[value];
                     if (contextEntry)
                         return contextEntry;
@@ -5143,32 +5271,23 @@ var Lits = (function (exports) {
             catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
-                    if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
                 }
                 finally { if (e_4) throw e_4.error; }
             }
-            var lazyHostValue = (_c = this.lazyValues) === null || _c === void 0 ? void 0 : _c[value];
+            var lazyHostValue = (_b = this.lazyValues) === null || _b === void 0 ? void 0 : _b[value];
             if (lazyHostValue !== undefined) {
                 return {
                     value: toAny(lazyHostValue.read()),
                 };
             }
-            var hostValue = (_d = this.values) === null || _d === void 0 ? void 0 : _d[value];
+            var hostValue = (_c = this.values) === null || _c === void 0 ? void 0 : _c[value];
             if (hostValue !== undefined) {
                 return {
                     value: toAny(hostValue),
                 };
             }
-            if (builtin.normalExpressions[value]) {
-                var builtinFunction = (_b = {},
-                    _b[FUNCTION_SYMBOL] = true,
-                    _b.sourceCodeInfo = sourceCodeInfo,
-                    _b.functionType = 'Builtin',
-                    _b.n = value,
-                    _b);
-                return builtinFunction;
-            }
-            var nativeJsFunction = (_e = this.nativeJsFunctions) === null || _e === void 0 ? void 0 : _e[value];
+            var nativeJsFunction = (_d = this.nativeJsFunctions) === null || _d === void 0 ? void 0 : _d[value];
             if (nativeJsFunction) {
                 return {
                     value: nativeJsFunction,
@@ -5176,13 +5295,24 @@ var Lits = (function (exports) {
             }
             return null;
         };
-        ContextStackImpl.prototype.evaluateName = function (node) {
+        ContextStackImpl.prototype.evaluateSymbol = function (node) {
+            var _a;
+            if (isSpecialBuiltinSymbolNode(node)) {
+                throw new Error('Special builtin symbols should not be evaluated');
+            }
+            if (isNormalBuiltinSymbolNode(node)) {
+                var type = node[1];
+                return _a = {},
+                    _a[FUNCTION_SYMBOL] = true,
+                    _a.functionType = 'Builtin',
+                    _a.normalBuitinSymbolType = type,
+                    _a.sourceCodeInfo = node[2],
+                    _a;
+            }
             var lookUpResult = this.lookUp(node);
             if (isContextEntry(lookUpResult))
                 return lookUpResult.value;
-            else if (isBuiltinFunction(lookUpResult))
-                return lookUpResult;
-            throw new UndefinedSymbolError(node.value, node.sourceCodeInfo);
+            throw new UndefinedSymbolError(node[1], node[2]);
         };
         return ContextStackImpl;
     }());
@@ -5265,10 +5395,10 @@ var Lits = (function (exports) {
         'cond',
         'def',
         'defined?',
-        'defn',
+        // 'defn',
         'do',
         'doseq',
-        'fn',
+        // 'fn',
         'if',
         'let',
         'loop',
@@ -5717,6 +5847,10 @@ var Lits = (function (exports) {
             throwUnexpectedToken('ReservedSymbol', symbolName, token);
         }
     }
+    function asReservedSymbolToken(token, symbolName) {
+        assertReservedSymbolToken(token, symbolName);
+        return token;
+    }
     function isSingleLineCommentToken(token) {
         return (token === null || token === void 0 ? void 0 : token[0]) === 'SingleLineComment';
     }
@@ -5799,6 +5933,9 @@ var Lits = (function (exports) {
             throwUnexpectedToken('RBrace', undefined, token);
         }
     }
+    function isStringToken(token) {
+        return (token === null || token === void 0 ? void 0 : token[0]) === 'String';
+    }
     function isA_BinaryOperatorToken(token) {
         return (token === null || token === void 0 ? void 0 : token[0]) === 'Operator' && isBinaryOperator(token[1]);
     }
@@ -5836,6 +5973,12 @@ var Lits = (function (exports) {
     var exponentiationPrecedence = 10;
     var binaryFunctionalOperatorPrecedence = 1;
     var placeholderRegexp = /^\$([1-9]\d?)?$/;
+    function withSourceCodeInfo(node, sourceCodeInfo) {
+        if (sourceCodeInfo) {
+            node[2] = sourceCodeInfo;
+        }
+        return node;
+    }
     function getPrecedence(operatorSign) {
         switch (operatorSign) {
             case '**': // exponentiation
@@ -5878,29 +6021,18 @@ var Lits = (function (exports) {
                 throw new Error("Unknown binary operator: ".concat(operatorSign));
         }
     }
-    function createNamedNormalExpressionNode(name, params, sourceCodeInfo) {
-        var node = {
-            type: 'NormalExpression',
-            name: name,
-            params: params,
-            sourceCodeInfo: sourceCodeInfo,
-        };
-        var builtinExpression = builtin.normalExpressions[node.name];
-        if (builtinExpression) {
-            assertNumberOfParams(builtinExpression.paramCount, node);
+    function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
+        var node = withSourceCodeInfo([NodeTypes.NormalExpression, [symbolNode, params]], sourceCodeInfo);
+        if (isNormalBuiltinSymbolNode(symbolNode)) {
+            assertNumberOfParams(allNormalExpressions[symbolNode[1]].paramCount, node);
         }
         return node;
     }
     function createAccessorNode(left, right, sourceCodeInfo) {
         // Unnamed normal expression
-        return {
-            type: 'NormalExpression',
-            params: [left, right],
-            name: undefined,
-            sourceCodeInfo: sourceCodeInfo,
-        };
+        return withSourceCodeInfo([NodeTypes.NormalExpression, [left, [right]]], sourceCodeInfo);
     }
-    function fromBinaryOperatorToAstNode(operator, left, right, sourceCodeInfo) {
+    function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeInfo) {
         var operatorName = operator[1];
         switch (operatorName) {
             case '**': // exponentiation
@@ -5925,16 +6057,11 @@ var Lits = (function (exports) {
             case '&':
             case '^':
             case '|':
-                return createNamedNormalExpressionNode(operatorName, [left, right], sourceCodeInfo);
+                return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
             case '&&':
             case '||':
             case '??':
-                return {
-                    type: 'SpecialExpression',
-                    name: operatorName,
-                    params: [left, right],
-                    sourceCodeInfo: sourceCodeInfo,
-                };
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes[operatorName], [left, right]]], sourceCodeInfo);
             /* v8 ignore next 10 */
             case '.':
             case ';':
@@ -6030,9 +6157,12 @@ var Lits = (function (exports) {
                         && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
                         break;
                     }
+                    var symbol = specialExpressionTypes[name_1]
+                        ? withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[name_1]], operator[2])
+                        : withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[name_1]], operator[2]);
                     this.advance();
                     var right = this.parseExpression(newPrecedece);
-                    left = fromBinaryOperatorToAstNode(operator, left, right, operator[2]);
+                    left = fromBinaryOperatorToNode(operator, symbol, left, right, operator[2]);
                 }
                 else if (isSymbolToken(operator)) {
                     if (!isFunctionOperator(operator[1])) {
@@ -6042,9 +6172,12 @@ var Lits = (function (exports) {
                     if (newPrecedece <= precedence) {
                         break;
                     }
-                    this.advance();
+                    var operatorSymbol = this.parseSymbol();
                     var right = this.parseExpression(newPrecedece);
-                    left = createNamedNormalExpressionNode(operator[1], [left, right], operator[2]);
+                    if (isSpecialBuiltinSymbolNode(operatorSymbol)) {
+                        throw new LitsError('Special expressions are not allowed in binary functional operators', operatorSymbol[2]);
+                    }
+                    left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
                 }
                 else {
                     break;
@@ -6063,11 +6196,7 @@ var Lits = (function (exports) {
                     if (!isSymbolToken(symbolToken)) {
                         throw new LitsError('Expected symbol', this.peek()[2]);
                     }
-                    var stringNode = {
-                        type: 'String',
-                        value: symbolToken[1],
-                        sourceCodeInfo: symbolToken[2],
-                    };
+                    var stringNode = withSourceCodeInfo([NodeTypes.String, symbolToken[1]], symbolToken[2]);
                     operand = createAccessorNode(operand, stringNode, token[2]);
                     this.advance();
                     token = this.peek();
@@ -6107,16 +6236,14 @@ var Lits = (function (exports) {
                 this.advance();
                 return expression;
             }
-            // Unary operators
             else if (isOperatorToken(token)) {
                 var operatorName = token[1];
                 if (isBinaryOperator(operatorName)) {
                     this.advance();
-                    return {
-                        type: 'Symbol',
-                        value: operatorName,
-                        sourceCodeInfo: token[2],
-                    };
+                    if (specialExpressionTypes[operatorName] !== undefined) {
+                        return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[operatorName]], token[2]);
+                    }
+                    return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
                 }
                 if (operatorName === '->') {
                     return this.parseShorthandLamdaFunction();
@@ -6164,22 +6291,24 @@ var Lits = (function (exports) {
             while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
                 if (isOperatorToken(this.peek(), '...')) {
                     this.advance();
-                    params.push({
-                        type: 'Spread',
-                        value: this.parseExpression(),
-                        sourceCodeInfo: this.peek()[2],
-                    });
+                    params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
                 }
                 else {
-                    var key = this.parseOperand();
-                    if (key.type !== 'Symbol' && key.type !== 'String') {
+                    var token = this.peek();
+                    if (isStringToken(token)) {
+                        var stringNode = this.parseString();
+                        params.push(withSourceCodeInfo([NodeTypes.String, stringNode[1]], token[2]));
+                    }
+                    else if (isSymbolToken(token)) {
+                        var value = token[1].startsWith('\'')
+                            ? this.stringFromQuotedSymbol(token[1])
+                            : token[1];
+                        params.push(withSourceCodeInfo([NodeTypes.String, value], token[2]));
+                        this.advance();
+                    }
+                    else {
                         throw new LitsError('Expected key to be a symbol or a string', this.peek()[2]);
                     }
-                    params.push({
-                        type: 'String',
-                        value: key.value,
-                        sourceCodeInfo: key.sourceCodeInfo,
-                    });
                     assertOperatorToken(this.peek(), ':=');
                     this.advance();
                     params.push(this.parseExpression());
@@ -6194,12 +6323,7 @@ var Lits = (function (exports) {
             }
             assertRBraceToken(this.peek());
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'object',
-                params: params,
-                sourceCodeInfo: firstToken[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.object, params]], firstToken[2]);
         };
         Parser.prototype.parseArray = function () {
             var firstToken = asLBracketToken(this.peek());
@@ -6208,11 +6332,7 @@ var Lits = (function (exports) {
             while (!this.isAtEnd() && !isRBracketToken(this.peek())) {
                 if (isOperatorToken(this.peek(), '...')) {
                     this.advance();
-                    params.push({
-                        type: 'Spread',
-                        value: this.parseExpression(),
-                        sourceCodeInfo: this.peek()[2],
-                    });
+                    params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
                 }
                 else {
                     params.push(this.parseExpression());
@@ -6227,15 +6347,9 @@ var Lits = (function (exports) {
             }
             assertRBracketToken(this.peek());
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'array',
-                params: params,
-                sourceCodeInfo: firstToken[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.array, params]], firstToken[2]);
         };
         Parser.prototype.parseFunctionCall = function (symbol) {
-            var isNamedFunction = symbol.type === 'Symbol';
             this.advance();
             var params = [];
             while (!this.isAtEnd() && !isRParenToken(this.peek())) {
@@ -6252,45 +6366,57 @@ var Lits = (function (exports) {
                 throw new LitsError('Expected closing parenthesis', this.peek()[2]);
             }
             this.advance();
-            if (isNamedFunction) {
-                if (specialExpressionKeys.includes(symbol.value)) {
-                    var name_2 = symbol.value;
-                    switch (name_2) {
-                        case '??':
-                        case '&&':
-                        case 'defined?':
-                        case '||':
-                        case 'recur':
-                        case 'array':
-                        case 'object':
-                        case 'throw': {
-                            var node = {
-                                type: 'SpecialExpression',
-                                name: name_2,
-                                params: params,
-                                sourceCodeInfo: symbol.sourceCodeInfo,
-                            };
-                            assertNumberOfParams(builtin.specialExpressions[node.name].paramCount, node);
-                            return node;
+            if (isSpecialBuiltinSymbolNode(symbol)) { // Named function
+                var specialExpressionType = symbol[1];
+                var type = specialExpressionType;
+                switch (type) {
+                    case specialExpressionTypes['||']:
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+                    case specialExpressionTypes['&&']:
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+                    case specialExpressionTypes.recur:
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+                    case specialExpressionTypes.array:
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+                    case specialExpressionTypes.object:
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+                    case specialExpressionTypes['??']: {
+                        if (params.length === 1) {
+                            return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, [params[0], undefined]]], symbol[2]);
                         }
-                        case 'fn':
-                        case 'def':
-                        case 'defn':
-                            throw new Error("".concat(name_2, " is not allowed"));
-                        /* v8 ignore next 2 */
-                        default:
-                            throw new Error("Unknown special expression: ".concat(name_2));
+                        if (params.length === 2) {
+                            return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, [params[0], params[1]]]], symbol[2]);
+                        }
+                        throw new LitsError('Expected exactly two parameters', symbol[2]);
+                    }
+                    case specialExpressionTypes['defined?']: {
+                        if (params.length !== 1) {
+                            throw new LitsError('Expected exactly one parameter', symbol[2]);
+                        }
+                        var _a = __read(params, 1), param = _a[0];
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
+                    }
+                    case specialExpressionTypes.throw: {
+                        if (params.length !== 1) {
+                            throw new LitsError('Expected exactly one parameter', symbol[2]);
+                        }
+                        var _b = __read(params, 1), param = _b[0];
+                        return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                     }
+                    case specialExpressionTypes['0_fn']:
+                    case specialExpressionTypes['0_def']:
+                    case specialExpressionTypes['0_defn']:
+                        throw new LitsError("".concat(type, " is not allowed"), symbol[2]);
+                    /* v8 ignore next 2 */
+                    default:
+                        throw new Error("Unknown special expression: ".concat(type));
                 }
-                return createNamedNormalExpressionNode(symbol.value, params, symbol.sourceCodeInfo);
+            }
+            else if (isNormalBuiltinSymbolNode(symbol) || isNormalBuiltinSymbolNode(symbol)) {
+                return createNamedNormalExpressionNode(symbol, params, symbol[2]);
             }
             else {
-                return {
-                    type: 'NormalExpression',
-                    name: undefined,
-                    params: __spreadArray([symbol], __read(params), false),
-                    sourceCodeInfo: symbol.sourceCodeInfo,
-                };
+                return withSourceCodeInfo([NodeTypes.NormalExpression, [symbol, params]], symbol[2]);
             }
         };
         Parser.prototype.parseLambdaFunction = function () {
@@ -6307,16 +6433,10 @@ var Lits = (function (exports) {
                 }
                 this.advance();
                 var body = this.parseExpression();
-                return {
-                    type: 'SpecialExpression',
-                    name: 'fn',
-                    params: [],
-                    function: {
-                        arguments: functionArguments,
-                        body: [body],
-                    },
-                    sourceCodeInfo: firstToken[2],
-                };
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+                            functionArguments,
+                            [body],
+                        ]]], firstToken[2]);
             }
             catch (_a) {
                 return null;
@@ -6325,11 +6445,7 @@ var Lits = (function (exports) {
         Parser.prototype.parseFunctionArguments = function () {
             var firstToken = this.peek();
             if (isSymbolToken(firstToken)) {
-                return [{
-                        type: 'symbol',
-                        name: this.parseSymbol().value,
-                        sourceCodeInfo: firstToken[2],
-                    }];
+                return [withSourceCodeInfo([bindingTargetTypes.symbol, [this.parseSymbol(), undefined]], firstToken[2])];
             }
             assertLParenToken(firstToken);
             this.advance();
@@ -6341,13 +6457,13 @@ var Lits = (function (exports) {
                     throw new LitsError('Rest argument must be last', this.peek()[2]);
                 }
                 var bindingTarget = this.parseBindingTarget();
-                if (bindingTarget.default) {
+                if (bindingTarget[1][1] !== undefined) {
                     defaults = true;
                 }
-                if (bindingTarget.type === 'rest') {
+                if (bindingTarget[0] === bindingTargetTypes.rest) {
                     rest = true;
                 }
-                if (defaults && !bindingTarget.default) {
+                if (defaults && !bindingTarget[1][1]) {
                     throw new LitsError('Default arguments must be last', this.peek()[2]);
                 }
                 functionArguments.push(bindingTarget);
@@ -6394,22 +6510,16 @@ var Lits = (function (exports) {
             var functionArguments = [];
             for (var i = 1; i <= arity; i += 1) {
                 if (i === 1 && dollar1 === 'NAKED') {
-                    functionArguments.push({ type: 'symbol', name: '$', sourceCodeInfo: firstToken[2] });
+                    functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, '$'], undefined]], firstToken[2]));
                 }
                 else {
-                    functionArguments.push({ type: 'symbol', name: "$".concat(i), sourceCodeInfo: firstToken[2] });
+                    functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, "$".concat(i)], undefined]], firstToken[2]));
                 }
             }
-            var node = {
-                type: 'SpecialExpression',
-                name: 'fn',
-                params: [],
-                function: {
-                    arguments: functionArguments,
-                    body: [exprNode],
-                },
-                sourceCodeInfo: firstToken[2],
-            };
+            var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+                        functionArguments,
+                        [exprNode],
+                    ]]], firstToken[2]);
             return node;
         };
         Parser.prototype.parseOptionalDefaulValue = function () {
@@ -6425,16 +6535,14 @@ var Lits = (function (exports) {
             // Symbol
             if (isSymbolToken(firstToken)) {
                 var symbol = this.parseSymbol();
+                if (!isUserDefinedSymbolNode(symbol)) {
+                    throw new LitsError('Expected user defined symbol', firstToken[2]);
+                }
                 var defaultValue = this.parseOptionalDefaulValue();
                 if (requireDefaultValue && !defaultValue) {
                     throw new LitsError('Expected assignment', this.peek()[2]);
                 }
-                return {
-                    type: 'symbol',
-                    name: symbol.value,
-                    default: defaultValue,
-                    sourceCodeInfo: firstToken[2],
-                };
+                return withSourceCodeInfo([bindingTargetTypes.symbol, [symbol, defaultValue]], firstToken[2]);
             }
             // Rest
             if (isOperatorToken(firstToken, '...')) {
@@ -6442,15 +6550,11 @@ var Lits = (function (exports) {
                     throw new LitsError('Rest element not allowed', firstToken[2]);
                 }
                 this.advance();
-                var symbol = this.parseSymbol();
+                var symbol = asUserDefinedSymbolNode(this.parseSymbol());
                 if (isOperatorToken(this.peek(), ':=')) {
                     throw new LitsError('Rest argument can not have default value', this.peek()[2]);
                 }
-                return {
-                    type: 'rest',
-                    name: symbol.value,
-                    sourceCodeInfo: firstToken[2],
-                };
+                return withSourceCodeInfo([bindingTargetTypes.rest, [symbol[1], undefined]], firstToken[2]);
             }
             // Array
             if (isLBracketToken(firstToken)) {
@@ -6469,7 +6573,7 @@ var Lits = (function (exports) {
                         continue;
                     }
                     var target = this.parseBindingTarget();
-                    if (target.type === 'rest') {
+                    if (target[0] === bindingTargetTypes.rest) {
                         rest = true;
                     }
                     elements.push(target);
@@ -6485,12 +6589,7 @@ var Lits = (function (exports) {
                 if (requireDefaultValue && !defaultValue) {
                     throw new LitsError('Expected assignment', this.peek()[2]);
                 }
-                return {
-                    type: 'array',
-                    elements: elements,
-                    default: defaultValue,
-                    sourceCodeInfo: firstToken[2],
-                };
+                return withSourceCodeInfo([bindingTargetTypes.array, [elements, defaultValue]], firstToken[2]);
             }
             // Object
             if (isLBraceToken(firstToken)) {
@@ -6506,40 +6605,32 @@ var Lits = (function (exports) {
                         rest = true;
                         this.advance();
                     }
-                    var key = this.parseSymbol().value;
+                    var key = asUserDefinedSymbolNode(this.parseSymbol());
                     token = this.peek();
                     if (isReservedSymbolToken(token, 'as')) {
                         if (rest) {
                             throw new LitsError('Rest argument can not have alias', token[2]);
                         }
                         this.advance();
-                        var name_3 = this.parseSymbol().value;
-                        if (elements[name_3]) {
-                            throw new LitsError("Duplicate binding name: ".concat(name_3), token[2]);
+                        var name_2 = asUserDefinedSymbolNode(this.parseSymbol());
+                        if (elements[name_2[1]]) {
+                            throw new LitsError("Duplicate binding name: ".concat(name_2), token[2]);
                         }
-                        elements[key] = {
-                            type: 'symbol',
-                            name: name_3,
-                            default: this.parseOptionalDefaulValue(),
-                            sourceCodeInfo: firstToken[2],
-                        };
+                        elements[key[1]] = withSourceCodeInfo([bindingTargetTypes.symbol, [name_2, this.parseOptionalDefaulValue()]], firstToken[2]);
                     }
                     else if (isRBraceToken(token) || isOperatorToken(token, ',') || isOperatorToken(token, ':=')) {
-                        if (elements[key]) {
+                        if (elements[key[1]]) {
                             throw new LitsError("Duplicate binding name: ".concat(key), token[2]);
                         }
                         if (rest && isOperatorToken(this.peek(), ':=')) {
                             throw new LitsError('Rest argument can not have default value', this.peek()[2]);
                         }
-                        elements[key] = {
-                            type: rest ? 'rest' : 'symbol',
-                            name: key,
-                            default: this.parseOptionalDefaulValue(),
-                            sourceCodeInfo: firstToken[2],
-                        };
+                        elements[key[1]] = rest
+                            ? withSourceCodeInfo([bindingTargetTypes.rest, [key[1], this.parseOptionalDefaulValue()]], firstToken[2])
+                            : withSourceCodeInfo([bindingTargetTypes.symbol, [key, this.parseOptionalDefaulValue()]], firstToken[2]);
                     }
                     else if (isLBraceToken(token) || isLBracketToken(token)) {
-                        elements[key] = this.parseBindingTarget();
+                        elements[key[1]] = this.parseBindingTarget();
                     }
                     if (!isRBraceToken(this.peek())) {
                         assertOperatorToken(this.peek(), ',');
@@ -6553,12 +6644,7 @@ var Lits = (function (exports) {
                 if (requireDefaultValue && !defaultValue) {
                     throw new LitsError('Expected assignment', token[2]);
                 }
-                return {
-                    type: 'object',
-                    elements: elements,
-                    default: defaultValue,
-                    sourceCodeInfo: firstToken[2],
-                };
+                return withSourceCodeInfo([bindingTargetTypes.object, [elements, defaultValue]], firstToken[2]);
             }
             throw new LitsError('Expected symbol', this.peek()[2]);
         };
@@ -6566,22 +6652,13 @@ var Lits = (function (exports) {
             if (optionalSemicolon === void 0) { optionalSemicolon = false; }
             this.advance();
             var target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
-            var value = target.default;
-            delete target.default;
+            var value = target[1][1];
+            target[1][1] = undefined;
             if (!optionalSemicolon) {
                 assertOperatorToken(this.peek(), ';');
             }
-            return {
-                type: 'SpecialExpression',
-                name: 'let',
-                bindingNode: {
-                    type: 'Binding',
-                    target: target,
-                    value: value,
-                    sourceCodeInfo: token[2],
-                },
-                sourceCodeInfo: token[2],
-            };
+            var bindingTarget = withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]);
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.let, bindingTarget]], token[2]);
         };
         Parser.prototype.parseDo = function (token) {
             this.advance();
@@ -6597,12 +6674,7 @@ var Lits = (function (exports) {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'do',
-                params: expressions,
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
         };
         Parser.prototype.parseLoop = function (firstToken) {
             this.advance();
@@ -6612,14 +6684,9 @@ var Lits = (function (exports) {
                 assertSymbolToken(token, 'let');
                 this.advance();
                 var target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
-                var value = target.default;
-                delete target.default;
-                bindingNodes.push({
-                    type: 'Binding',
-                    target: target,
-                    value: value,
-                    sourceCodeInfo: token[2],
-                });
+                var value = target[1][1];
+                target[1][1] = undefined;
+                bindingNodes.push(withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]));
                 if (isOperatorToken(this.peek(), ',')) {
                     this.advance();
                 }
@@ -6642,13 +6709,7 @@ var Lits = (function (exports) {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'loop',
-                params: params,
-                bindingNodes: bindingNodes,
-                sourceCodeInfo: firstToken[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, params]], firstToken[2]);
         };
         Parser.prototype.parseTry = function (token) {
             this.advance();
@@ -6664,12 +6725,7 @@ var Lits = (function (exports) {
             }
             var tryExpression = tryExpressions.length === 1
                 ? tryExpressions[0]
-                : {
-                    type: 'SpecialExpression',
-                    name: 'do',
-                    params: tryExpressions,
-                    sourceCodeInfo: token[2],
-                };
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, tryExpressions]], token[2]);
             assertReservedSymbolToken(this.peek(), 'catch');
             this.advance();
             var errorSymbol;
@@ -6693,20 +6749,8 @@ var Lits = (function (exports) {
             this.advance();
             var catchExpression = catchExpressions.length === 1
                 ? catchExpressions[0]
-                : {
-                    type: 'SpecialExpression',
-                    name: 'do',
-                    params: catchExpressions,
-                    sourceCodeInfo: token[2],
-                };
-            return {
-                type: 'SpecialExpression',
-                name: 'try',
-                params: [tryExpression],
-                ce: catchExpression,
-                e: errorSymbol,
-                sourceCodeInfo: token[2],
-            };
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, catchExpressions]], token[2]);
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.try, tryExpression, errorSymbol, catchExpression]], token[2]);
         };
         Parser.prototype.parseForOrDoseq = function (firstToken) {
             var isDoseq = firstToken[1] === 'doseq';
@@ -6714,10 +6758,10 @@ var Lits = (function (exports) {
             var forLoopBindings = [];
             var _loop_1 = function () {
                 var loopBinding = this_1.parseForLoopBinding();
-                var existingBoundNames = forLoopBindings.flatMap(function (b) { return Object.keys(getAllBindingTargetNames(b.b.target)); });
-                var newBoundNames = getAllBindingTargetNames(loopBinding.b.target);
+                var existingBoundNames = forLoopBindings.flatMap(function (b) { return Object.keys(getAllBindingTargetNames(b[0][1][0])); });
+                var newBoundNames = getAllBindingTargetNames(loopBinding[0][1][0]);
                 if (Object.keys(newBoundNames).some(function (n) { return existingBoundNames.includes(n); })) {
-                    throw new LitsError('Duplicate binding', loopBinding.b.sourceCodeInfo);
+                    throw new LitsError('Duplicate binding', loopBinding[0][2]);
                 }
                 forLoopBindings.push(loopBinding);
             };
@@ -6739,13 +6783,9 @@ var Lits = (function (exports) {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: isDoseq ? 'doseq' : 'for',
-                params: expressions,
-                sourceCodeInfo: firstToken[2],
-                l: forLoopBindings,
-            };
+            return isDoseq
+                ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expressions]], firstToken[2])
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.for, forLoopBindings, expressions]], firstToken[2]);
         };
         Parser.prototype.parseForLoopBinding = function () {
             assertReservedSymbolToken(this.peek(), 'each');
@@ -6767,18 +6807,17 @@ var Lits = (function (exports) {
                 && !isReservedSymbolToken(token, 'each')) {
                 throw new LitsError('Expected symbol each, do, let, when or while', token[2]);
             }
-            var letBindings;
+            var letBindings = [];
             if (token[1] === 'let') {
                 modifiers.push('&let');
-                letBindings = [];
                 var _loop_2 = function () {
                     var letNode = this_2.parseLet(token, true);
-                    var existingBoundNames = letBindings.flatMap(function (b) { return Object.keys(getAllBindingTargetNames(b.target)); });
-                    var newBoundNames = Object.keys(getAllBindingTargetNames(letNode.bindingNode.target));
+                    var existingBoundNames = letBindings.flatMap(function (b) { return Object.keys(getAllBindingTargetNames(b[1][0])); });
+                    var newBoundNames = Object.keys(getAllBindingTargetNames(letNode[1][1][1][0]));
                     if (newBoundNames.some(function (n) { return existingBoundNames.includes(n); })) {
-                        throw new LitsError('Duplicate binding', letNode.bindingNode.sourceCodeInfo);
+                        throw new LitsError('Duplicate binding', letNode[1][1][2]);
                     }
-                    letBindings.push(letNode.bindingNode);
+                    letBindings.push(letNode[1][1]);
                     token = this_2.peek();
                     if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this_2.peek(), 'each') && !isOperatorToken(token, ',')) {
                         throw new LitsError('Expected do, each or comma', token[2]);
@@ -6824,31 +6863,21 @@ var Lits = (function (exports) {
             if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each')) {
                 throw new LitsError('Expected do or each', token[2]);
             }
-            return {
-                b: bindingNode,
-                m: modifiers,
-                l: letBindings,
-                wn: whenNode,
-                we: whileNode,
-            };
+            return [bindingNode, letBindings, whenNode, whileNode];
         };
         Parser.prototype.parseBinding = function () {
             var firstToken = asSymbolToken(this.peek());
-            var name = firstToken[1];
-            this.advance();
+            var name = asUserDefinedSymbolNode(this.parseSymbol());
             assertReservedSymbolToken(this.peek(), 'in');
             this.advance();
             var value = this.parseExpression();
-            var node = {
-                type: 'Binding',
-                target: {
-                    type: 'symbol',
-                    name: name,
-                    sourceCodeInfo: firstToken[2],
-                },
-                value: value,
-                sourceCodeInfo: firstToken[2],
-            };
+            var node = withSourceCodeInfo([
+                NodeTypes.Binding,
+                [
+                    withSourceCodeInfo([bindingTargetTypes.symbol, [name, undefined]], firstToken[2]),
+                    value,
+                ],
+            ], firstToken[2]);
             return node;
         };
         Parser.prototype.parseIfOrUnless = function (token) {
@@ -6871,12 +6900,7 @@ var Lits = (function (exports) {
             }
             var thenExpression = thenExpressions.length === 1
                 ? thenExpressions[0]
-                : {
-                    type: 'SpecialExpression',
-                    name: 'do',
-                    params: thenExpressions,
-                    sourceCodeInfo: token[2],
-                };
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, thenExpressions]], token[2]);
             var elseExpression;
             if (isReservedSymbolToken(this.peek(), 'else')) {
                 this.advance();
@@ -6892,25 +6916,13 @@ var Lits = (function (exports) {
                 }
                 elseExpression = elseExpressions.length === 1
                     ? elseExpressions[0]
-                    : {
-                        type: 'SpecialExpression',
-                        name: 'do',
-                        params: elseExpressions,
-                        sourceCodeInfo: token[2],
-                    };
+                    : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, elseExpressions]], token[2]);
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            var params = [condition, thenExpression];
-            if (elseExpression) {
-                params.push(elseExpression);
-            }
-            return {
-                type: 'SpecialExpression',
-                name: isUnless ? 'unless' : 'if',
-                params: params,
-                sourceCodeInfo: token[2],
-            };
+            return isUnless
+                ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.unless, [condition, thenExpression, elseExpression]]], token[2])
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [condition, thenExpression, elseExpression]]], token[2]);
         };
         Parser.prototype.parseCond = function (token) {
             this.advance();
@@ -6918,7 +6930,7 @@ var Lits = (function (exports) {
             while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
                 assertReservedSymbolToken(this.peek(), 'case');
                 this.advance();
-                params.push(this.parseExpression());
+                var caseExpression = this.parseExpression();
                 assertReservedSymbolToken(this.peek(), 'then');
                 this.advance();
                 var expressions = [];
@@ -6933,14 +6945,10 @@ var Lits = (function (exports) {
                         throw new LitsError('Expected ;', this.peek()[2]);
                     }
                 }
-                params.push(expressions.length === 1
+                var thenExpression = expressions.length === 1
                     ? expressions[0]
-                    : {
-                        type: 'SpecialExpression',
-                        name: 'do',
-                        params: expressions,
-                        sourceCodeInfo: token[2],
-                    });
+                    : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
+                params.push([caseExpression, thenExpression]);
                 if (isReservedSymbolToken(this.peek(), 'end')) {
                     break;
                 }
@@ -6948,20 +6956,16 @@ var Lits = (function (exports) {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'cond',
-                params: params,
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
         };
         Parser.prototype.parseSwitch = function (token) {
             this.advance();
-            var params = [this.parseExpression()];
+            var valueExpression = this.parseExpression();
+            var params = [];
             while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
                 assertReservedSymbolToken(this.peek(), 'case');
                 this.advance();
-                params.push(this.parseExpression());
+                var caseExpression = this.parseExpression();
                 assertReservedSymbolToken(this.peek(), 'then');
                 this.advance();
                 var expressions = [];
@@ -6976,14 +6980,10 @@ var Lits = (function (exports) {
                         throw new LitsError('Expected ;', this.peek()[2]);
                     }
                 }
-                params.push(expressions.length === 1
+                var thenExpression = expressions.length === 1
                     ? expressions[0]
-                    : {
-                        type: 'SpecialExpression',
-                        name: 'do',
-                        params: expressions,
-                        sourceCodeInfo: token[2],
-                    });
+                    : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
+                params.push([caseExpression, thenExpression]);
                 if (isReservedSymbolToken(this.peek(), 'end')) {
                     break;
                 }
@@ -6991,12 +6991,7 @@ var Lits = (function (exports) {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return {
-                type: 'SpecialExpression',
-                name: 'switch',
-                params: params,
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
         };
         Parser.prototype.parseFunction = function (token) {
             this.advance();
@@ -7015,17 +7010,10 @@ var Lits = (function (exports) {
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
             assertOperatorToken(this.peek(), ';');
-            return {
-                type: 'SpecialExpression',
-                name: 'function',
-                functionName: symbol,
-                params: [],
-                function: {
-                    arguments: functionArguments,
-                    body: body,
-                },
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.function, symbol, [
+                        functionArguments,
+                        body,
+                    ]]], token[2]);
         };
         Parser.prototype.isAtEnd = function () {
             return this.parseState.position >= this.tokenStream.tokens.length;
@@ -7047,7 +7035,7 @@ var Lits = (function (exports) {
             this.advance();
             if (isSymbolToken(this.peek(), 'let')) {
                 var letNode = this.parseLet(asSymbolToken(this.peek()));
-                return __assign(__assign({}, letNode), { name: 'def' });
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], token[2]);
             }
             else if (isReservedSymbolToken(this.peek(), 'function')) {
                 this.advance();
@@ -7065,71 +7053,57 @@ var Lits = (function (exports) {
                 }
                 assertReservedSymbolToken(this.peek(), 'end');
                 this.advance();
-                return {
-                    type: 'SpecialExpression',
-                    name: 'defn',
-                    functionName: symbol,
-                    params: [],
-                    function: {
-                        arguments: functionArguments,
-                        body: body,
-                    },
-                    sourceCodeInfo: token[2],
-                };
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_defn'], symbol, [
+                            functionArguments,
+                            body,
+                        ]]], token[2]);
             }
             else {
                 throw new LitsError('Expected let or function', this.peek()[2]);
             }
         };
+        Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
+            if (specialExpressionTypes[value] !== undefined && value !== 'fn' && value !== 'def' && value !== 'defn') {
+                return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[value]], sourceCodeInfo);
+            }
+            if (normalExpressionTypes[value] !== undefined) {
+                return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[value]], sourceCodeInfo);
+            }
+            return withSourceCodeInfo([NodeTypes.UserDefinedSymbol, value], sourceCodeInfo);
+        };
+        Parser.prototype.stringFromQuotedSymbol = function (value) {
+            return value.substring(1, value.length - 1)
+                .replace(/(\\{2})|(\\')|\\(.)/g, function (_, backslash, singleQuote, normalChar) {
+                if (backslash) {
+                    return '\\';
+                }
+                if (singleQuote) {
+                    return '\'';
+                }
+                return "\\".concat(normalChar);
+            });
+        };
         Parser.prototype.parseSymbol = function () {
             var token = this.peek();
             this.advance();
             if (!isSymbolToken(token)) {
                 throw new LitsError("Expected symbol token, got ".concat(token[0]), token[2]);
             }
-            if (token[1][0] !== '\'') {
-                return {
-                    type: 'Symbol',
-                    value: token[1],
-                    sourceCodeInfo: token[2],
-                };
+            if (token[1][0] === '\'') {
+                return this.stringToSymbolNode(this.stringFromQuotedSymbol(token[1]), token[2]);
             }
             else {
-                var value = token[1].substring(1, token[1].length - 1)
-                    .replace(/(\\{2})|(\\')|\\(.)/g, function (_, backslash, singleQuote, normalChar) {
-                    if (backslash) {
-                        return '\\';
-                    }
-                    if (singleQuote) {
-                        return '\'';
-                    }
-                    return "\\".concat(normalChar);
-                });
-                return {
-                    type: 'Symbol',
-                    value: value,
-                    sourceCodeInfo: token[2],
-                };
+                return this.stringToSymbolNode(token[1], token[2]);
             }
         };
         Parser.prototype.parseReservedSymbol = function () {
-            var token = this.peek();
+            var token = asReservedSymbolToken(this.peek());
             this.advance();
-            if (isReservedSymbolToken(token)) {
-                var symbol = token[1];
-                if (isNumberReservedSymbol(symbol)) {
-                    return {
-                        type: 'Number',
-                        value: numberReservedSymbolRecord[symbol],
-                        sourceCodeInfo: token[2],
-                    };
-                }
+            var symbol = token[1];
+            if (isNumberReservedSymbol(symbol)) {
+                return withSourceCodeInfo([NodeTypes.Number, numberReservedSymbolRecord[symbol]], token[2]);
             }
-            return {
-                type: 'ReservedSymbol',
-                value: token[1],
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.ReservedSymbol, token[1]], token[2]);
         };
         Parser.prototype.parseNumber = function () {
             var token = this.peek();
@@ -7137,11 +7111,7 @@ var Lits = (function (exports) {
             var value = token[1];
             var negative = value[0] === '-';
             var numberString = (negative ? value.substring(1) : value).replace(/_/g, '');
-            return {
-                type: 'Number',
-                value: negative ? -Number(numberString) : Number(numberString),
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
         };
         Parser.prototype.parseString = function () {
             var token = this.peek();
@@ -7173,11 +7143,7 @@ var Lits = (function (exports) {
                 }
                 return normalChar;
             });
-            return {
-                type: 'String',
-                value: value,
-                sourceCodeInfo: token[2],
-            };
+            return withSourceCodeInfo([NodeTypes.String, value], token[2]);
         };
         Parser.prototype.parseRegexpShorthand = function () {
             var token = this.peek();
@@ -7185,22 +7151,15 @@ var Lits = (function (exports) {
             var endStringPosition = token[1].lastIndexOf('"');
             var regexpString = token[1].substring(2, endStringPosition);
             var optionsString = token[1].substring(endStringPosition + 1);
-            var stringNode = {
-                type: 'String',
-                value: regexpString,
-                sourceCodeInfo: token[2],
-            };
-            var optionsNode = {
-                type: 'String',
-                value: optionsString,
-                sourceCodeInfo: token[2],
-            };
-            var node = {
-                type: 'NormalExpression',
-                name: 'regexp',
-                params: [stringNode, optionsNode],
-                sourceCodeInfo: token[2],
-            };
+            var stringNode = withSourceCodeInfo([NodeTypes.String, regexpString], token[2]);
+            var optionsNode = withSourceCodeInfo([NodeTypes.String, optionsString], token[2]);
+            var node = withSourceCodeInfo([
+                NodeTypes.NormalExpression,
+                [
+                    withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.regexp], token[2]),
+                    [stringNode, optionsNode],
+                ],
+            ], token[2]);
             return node;
         };
         return Parser;
@@ -7317,7 +7276,7 @@ var Lits = (function (exports) {
             if (params === void 0) { params = {}; }
             var ast = typeof programOrAst === 'string' ? this.generateAst(programOrAst, params) : programOrAst;
             var contextStack = createContextStack(params);
-            return getUndefinedSymbols(ast, contextStack, builtin, evaluateAstNode);
+            return getUndefinedSymbols(ast, contextStack, builtin, evaluateNode);
         };
         Lits.prototype.tokenize = function (program, tokenizeParams) {
             if (tokenizeParams === void 0) { tokenizeParams = {}; }
@@ -7562,28 +7521,6 @@ var Lits = (function (exports) {
             'replace',
             'replace-all',
         ],
-        specialExpressions: [
-            '&&',
-            '||',
-            'def',
-            'let',
-            'fn',
-            'defn',
-            'function',
-            'try',
-            'throw',
-            'if',
-            'unless',
-            'cond',
-            'switch',
-            'do',
-            'recur',
-            'loop',
-            'doseq',
-            'for',
-            'defined?',
-            '??',
-        ],
         string: [
             'string-repeat',
             'str',
@@ -13219,8 +13156,7 @@ var Lits = (function (exports) {
         var _b;
         var _c = __read(_a, 2), key = _c[0], obj = _c[1];
         if (isFunctionReference(obj)) {
-            var specialExpressions = builtin.specialExpressions;
-            var paramCount = (_b = specialExpressions[key]) === null || _b === void 0 ? void 0 : _b.paramCount;
+            var paramCount = (_b = specialExpressions[specialExpressionTypes[key]]) === null || _b === void 0 ? void 0 : _b.paramCount;
             if (paramCount && canBeOperator(paramCount)) {
                 obj._isOperator = true;
             }