@mojir/lits 2.1.1 → 2.1.3

package/dist/lits.iife.js

@@ -96,9 +96,15 @@ var Lits = (function (exports) {
     }
 
     function getLitsErrorMessage(message, sourceCodeInfo) {
-        var filePathLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.filePath) ? "\n".concat(sourceCodeInfo.filePath) : '';
-        var codeLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.code) ? "\n".concat(sourceCodeInfo.code) : '';
-        var codeMarker = sourceCodeInfo && codeLine ? "\n".concat(getCodeMarker(sourceCodeInfo)) : '';
+        if (!sourceCodeInfo) {
+            return message;
+        }
+        var location = "".concat(sourceCodeInfo.position.line, ":").concat(sourceCodeInfo.position.column);
+        var filePathLine = sourceCodeInfo.filePath
+            ? "\n".concat(sourceCodeInfo.filePath, ":").concat(location)
+            : "\nLocation ".concat(location);
+        var codeLine = "\n".concat(sourceCodeInfo.code);
+        var codeMarker = "\n".concat(getCodeMarker(sourceCodeInfo));
         return "".concat(message).concat(filePathLine).concat(codeLine).concat(codeMarker);
     }
     var RecurSignal = /** @class */ (function (_super) {
@@ -211,6 +217,7 @@ var Lits = (function (exports) {
         'SomePred',
         'Fnull',
         'Builtin',
+        'SpecialBuiltin',
         'NativeJsFunction',
     ];
     var functionTypeSet = new Set(functionTypes);
@@ -3672,6 +3679,26 @@ var Lits = (function (exports) {
             }
             return value;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var value = true;
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    value = asAny(param, sourceCodeInfo);
+                    if (!value)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return value;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -3739,31 +3766,6 @@ var Lits = (function (exports) {
         },
     };
 
-    var specialExpressionTypes = {
-        '??': 0,
-        '&&': 1,
-        '||': 2,
-        'array': 3,
-        'cond': 4,
-        'def': 5,
-        'defined?': 6,
-        'defn': 7,
-        'do': 8,
-        'doseq': 9,
-        '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 isSymbolNode(node) {
         var nodeType = node[0];
         return NodeTypes.UserDefinedSymbol === nodeType
@@ -3788,25 +3790,9 @@ var Lits = (function (exports) {
     function isNormalBuiltinSymbolNode(node) {
         return NodeTypes.NormalBuiltinSymbol === node[0];
     }
-    function isSpecialBuiltinSymbolNode(node, name) {
-        if (NodeTypes.SpecialBuiltinSymbol !== node[0]) {
-            return false;
-        }
-        {
-            return true;
-        }
+    function isSpecialBuiltinSymbolNode(node) {
+        return NodeTypes.SpecialBuiltinSymbol === node[0];
     }
-    // export function isNumberNode(node: Node): node is NumberNode {
-    //   return node[0] === NodeTypes.Number
-    // }
-    // export function asNumberNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NumberNode {
-    //   assertNumberNode(node, sourceCodeInfo)
-    //   return node
-    // }
-    // export function assertNumberNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NumberNode {
-    //   if (!isNumberNode(node))
-    //     throw getAssertionError('NumberNode', node, sourceCodeInfo)
-    // }
     function isNormalExpressionNode(node) {
         return node[0] === NodeTypes.NormalExpression;
     }
@@ -3844,6 +3830,29 @@ var Lits = (function (exports) {
         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 = {};
@@ -3974,7 +3983,7 @@ var Lits = (function (exports) {
             var value = bindingNode[1][1];
             var bindingValue = evaluateNode(value, contextStack);
             var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-            contextStack.exportValues(values);
+            contextStack.exportValues(values, target[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -3983,7 +3992,10 @@ var Lits = (function (exports) {
             var target = bindingNode[1][0];
             var value = bindingNode[1][1];
             var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
-            contextStack.addValues(getAllBindingTargetNames(target));
+            walkDefaults(target, function (defaultNode) {
+                addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+            });
+            contextStack.addValues(getAllBindingTargetNames(target), target[2]);
             return bindingResult;
         },
     };
@@ -4071,6 +4083,31 @@ 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;
@@ -4101,16 +4138,16 @@ var Lits = (function (exports) {
                 _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunction,
                 _b);
-            contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+            contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var _b, _c;
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             var functionName = node[1][1][1];
-            contextStack.addValues((_b = {}, _b[functionName] = true, _b));
+            contextStack.addValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
             var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-            return addFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
+            return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
     };
     var defnSpecialExpression = {
@@ -4129,7 +4166,7 @@ var Lits = (function (exports) {
                 _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunctionOverloades,
                 _b);
-            contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+            contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4137,9 +4174,9 @@ var Lits = (function (exports) {
             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));
+            contextStack.exportValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
             var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-            return addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
+            return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
     };
     var fnSpecialExpression = {
@@ -4161,7 +4198,7 @@ var Lits = (function (exports) {
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             var fn = node[1][1];
-            return addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
+            return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
         },
     };
     function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode) {
@@ -4186,12 +4223,15 @@ var Lits = (function (exports) {
         ];
         return evaluatedFunction;
     }
-    function addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
+    function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
         var result = new Set();
         var contextStackWithFunctionName = functionNameContext ? contextStack.create(functionNameContext) : contextStack;
         var newContext = {};
         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[1], newContextStack, builtin, evaluateNode);
@@ -4246,7 +4286,7 @@ var Lits = (function (exports) {
             var value = bindingNode[1][1];
             var bindingValue = evaluateNode(value, contextStack);
             var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-            contextStack.addValues(values);
+            contextStack.addValues(values, target[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4255,7 +4295,10 @@ var Lits = (function (exports) {
             var target = bindingNode[1][0];
             var value = bindingNode[1][1];
             var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
-            contextStack.addValues(getAllBindingTargetNames(target));
+            walkDefaults(target, function (defaultNode) {
+                addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+            });
+            contextStack.addValues(getAllBindingTargetNames(target), target[2]);
             return bindingResult;
         },
     };
@@ -4526,6 +4569,26 @@ var Lits = (function (exports) {
             }
             return value;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var value = false;
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    value = asAny(param, sourceCodeInfo);
+                    if (value)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return value;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4544,6 +4607,11 @@ var Lits = (function (exports) {
             var firstResult = evaluateNode(firstNode, contextStack);
             return firstResult !== null && firstResult !== void 0 ? firstResult : (secondNode ? evaluateNode(secondNode, contextStack) : null);
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var firstParam = asAny(params[0], sourceCodeInfo);
+            var secondParam = params[1] !== undefined ? asAny(params[1], sourceCodeInfo) : null;
+            return firstParam !== null && firstParam !== void 0 ? firstParam : secondParam;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
@@ -4558,6 +4626,9 @@ var Lits = (function (exports) {
             var evaluatedParams = params.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
             throw new RecurSignal(evaluatedParams);
         },
+        evaluateAsNormalExpression: function (params) {
+            throw new RecurSignal(params);
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4573,6 +4644,12 @@ var Lits = (function (exports) {
             });
             throw new UserDefinedError(message, node[2]);
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var message = asString(params[0], sourceCodeInfo, {
+                nonEmpty: true,
+            });
+            throw new UserDefinedError(message, undefined);
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode);
@@ -4640,6 +4717,24 @@ var Lits = (function (exports) {
             }
             return result;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var result = [];
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    result.push(asAny(param, sourceCodeInfo));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return result;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4671,6 +4766,16 @@ var Lits = (function (exports) {
             }
             return result;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var result = {};
+            for (var i = 0; i < params.length; i += 2) {
+                var key = params[i];
+                var value = params[i + 1];
+                assertString(key, sourceCodeInfo);
+                result[key] = value !== null && value !== void 0 ? value : null;
+            }
+            return result;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4749,6 +4854,7 @@ var Lits = (function (exports) {
             case NodeTypes.String:
             case NodeTypes.Number:
             case NodeTypes.ReservedSymbol:
+            case NodeTypes.Binding:
                 return null;
             case NodeTypes.NormalExpression: {
                 var normalExpressionNode = node;
@@ -4793,12 +4899,9 @@ var Lits = (function (exports) {
             }
             case NodeTypes.Spread:
                 return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
-            case NodeTypes.Binding: {
-                var bindingNode = node;
-                return findUnresolvedSymbolsInNode(bindingNode[1][1], contextStack, builtin, evaluateNode);
-            }
+            /* v8 ignore next 2 */
             default:
-                throw new Error("Unhandled node type: ".concat(nodeType));
+                throw new LitsError("Unhandled node type: ".concat(nodeType), node[2]);
         }
     }
 
@@ -5006,6 +5109,16 @@ var Lits = (function (exports) {
             var normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuitinSymbolType], sourceCodeInfo);
             return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
         },
+        SpecialBuiltin: function (fn, params, sourceCodeInfo, contextStack, _a) {
+            var executeFunction = _a.executeFunction;
+            var specialExpression = asNonUndefined(specialExpressions[fn.specialBuiltinSymbolType], sourceCodeInfo);
+            if (specialExpression.evaluateAsNormalExpression) {
+                return specialExpression.evaluateAsNormalExpression(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
+            }
+            else {
+                throw new LitsError("Special builtin function ".concat(fn.specialBuiltinSymbolType, " is not supported as normal expression."), sourceCodeInfo);
+            }
+        },
     };
 
     function evaluate(ast, contextStack) {
@@ -5061,7 +5174,21 @@ var Lits = (function (exports) {
     function evaluateNormalExpression(node, contextStack) {
         var sourceCodeInfo = node[2];
         var paramNodes = node[1][1];
-        var params = paramNodes.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
+        var params = [];
+        paramNodes.forEach(function (paramNode) {
+            if (isSpreadNode(paramNode)) {
+                var spreadValue = evaluateNode(paramNode[1], contextStack);
+                if (Array.isArray(spreadValue)) {
+                    params.push.apply(params, __spreadArray([], __read(spreadValue), false));
+                }
+                else {
+                    throw new LitsError("Spread operator requires an array, got ".concat(valueToString(paramNode)), paramNode[2]);
+                }
+            }
+            else {
+                params.push(evaluateNode(paramNode, contextStack));
+            }
+        });
         if (isNormalExpressionNodeWithName(node)) {
             var nameSymbol = node[1][0];
             if (isNormalBuiltinSymbolNode(nameSymbol)) {
@@ -5163,19 +5290,19 @@ var Lits = (function (exports) {
             var contexts = [{}, context];
             return new ContextStackImpl({ contexts: contexts });
         };
-        ContextStackImpl.prototype.exportValues = function (values) {
+        ContextStackImpl.prototype.exportValues = function (values, sourceCodeInfo) {
             var e_1, _a;
             try {
                 for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
                     if (this.globalContext[name_1]) {
-                        throw new Error("Cannot redefine exported value \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot redefine exported value \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     if (specialExpressionKeys.includes(name_1)) {
-                        throw new Error("Cannot shadow special expression \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot shadow special expression \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     if (normalExpressionKeys.includes(name_1)) {
-                        throw new Error("Cannot shadow builtin function \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot shadow builtin function \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     this.globalContext[name_1] = { value: value };
                 }
@@ -5187,22 +5314,22 @@ var Lits = (function (exports) {
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            this.addValues(values);
+            this.addValues(values, sourceCodeInfo);
         };
-        ContextStackImpl.prototype.addValues = function (values) {
+        ContextStackImpl.prototype.addValues = function (values, sourceCodeInfo) {
             var e_2, _a;
             var currentContext = this.contexts[0];
             try {
                 for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_2 = _d[0], value = _d[1];
                     if (currentContext[name_2]) {
-                        throw new Error("Cannot redefine value \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot redefine value \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     if (specialExpressionKeys.includes(name_2)) {
-                        throw new Error("Cannot shadow special expression \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot shadow special expression \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     if (normalExpressionKeys.includes(name_2)) {
-                        throw new Error("Cannot shadow builtin function \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot shadow builtin function \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     currentContext[name_2] = { value: toAny(value) };
                 }
@@ -5282,24 +5409,40 @@ var Lits = (function (exports) {
             return null;
         };
         ContextStackImpl.prototype.evaluateSymbol = function (node) {
-            var _a;
+            var _a, _b;
             if (isSpecialBuiltinSymbolNode(node)) {
-                throw new Error('Special builtin symbols should not be evaluated');
+                var functionType = node[1];
+                switch (functionType) {
+                    case specialExpressionTypes['&&']:
+                    case specialExpressionTypes['||']:
+                    case specialExpressionTypes.array:
+                    case specialExpressionTypes.object:
+                    case specialExpressionTypes['defined?']:
+                    case specialExpressionTypes.recur:
+                    case specialExpressionTypes.throw:
+                    case specialExpressionTypes['??']:
+                        return _a = {},
+                            _a[FUNCTION_SYMBOL] = true,
+                            _a.functionType = 'SpecialBuiltin',
+                            _a.specialBuiltinSymbolType = functionType,
+                            _a.sourceCodeInfo = node[2],
+                            _a;
+                    default:
+                        throw new LitsError("Unknown special builtin symbol type: ".concat(functionType), node[2]);
+                }
             }
             if (isNormalBuiltinSymbolNode(node)) {
                 var type = node[1];
-                return _a = {},
-                    _a[FUNCTION_SYMBOL] = true,
-                    _a.functionType = 'Builtin',
-                    _a.normalBuitinSymbolType = type,
-                    _a.sourceCodeInfo = node[2],
-                    _a;
+                return _b = {},
+                    _b[FUNCTION_SYMBOL] = true,
+                    _b.functionType = 'Builtin',
+                    _b.normalBuitinSymbolType = type,
+                    _b.sourceCodeInfo = node[2],
+                    _b;
             }
             var lookUpResult = this.lookUp(node);
             if (isContextEntry(lookUpResult))
                 return lookUpResult.value;
-            else if (isBuiltinFunction(lookUpResult))
-                return lookUpResult;
             throw new UndefinedSymbolError(node[1], node[2]);
         };
         return ContextStackImpl;
@@ -5383,10 +5526,10 @@ var Lits = (function (exports) {
         'cond',
         'def',
         'defined?',
-        'defn',
+        // 'defn',
         'do',
         'doseq',
-        'fn',
+        // 'fn',
         'if',
         'let',
         'loop',
@@ -5967,7 +6110,7 @@ var Lits = (function (exports) {
         }
         return node;
     }
-    function getPrecedence(operatorSign) {
+    function getPrecedence(operatorSign, sourceCodeInfo) {
         switch (operatorSign) {
             case '**': // exponentiation
                 return exponentiationPrecedence;
@@ -6006,7 +6149,7 @@ var Lits = (function (exports) {
             // leave room for binaryFunctionalOperatorPrecedence = 1
             /* v8 ignore next 2 */
             default:
-                throw new Error("Unknown binary operator: ".concat(operatorSign));
+                throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
         }
     }
     function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
@@ -6139,7 +6282,7 @@ var Lits = (function (exports) {
             while (!this.isAtExpressionEnd()) {
                 if (isA_BinaryOperatorToken(operator)) {
                     var name_1 = operator[1];
-                    var newPrecedece = getPrecedence(name_1);
+                    var newPrecedece = getPrecedence(name_1, operator[2]);
                     if (newPrecedece <= precedence
                         // ** (exponentiation) is right associative
                         && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
@@ -6219,7 +6362,7 @@ var Lits = (function (exports) {
                 this.advance();
                 var expression = this.parseExpression();
                 if (!isRParenToken(this.peek())) {
-                    throw new Error('Expected closing parenthesis');
+                    throw new LitsError('Expected closing parenthesis', this.peek()[2]);
                 }
                 this.advance();
                 return expression;
@@ -6231,10 +6374,7 @@ var Lits = (function (exports) {
                     if (specialExpressionTypes[operatorName] !== undefined) {
                         return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[operatorName]], token[2]);
                     }
-                    else if (normalExpressionTypes[operatorName] !== undefined) {
-                        return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
-                    }
-                    return withSourceCodeInfo([NodeTypes.UserDefinedSymbol, operatorName], token[2]);
+                    return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
                 }
                 if (operatorName === '->') {
                     return this.parseShorthandLamdaFunction();
@@ -6344,7 +6484,13 @@ var Lits = (function (exports) {
             this.advance();
             var params = [];
             while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-                params.push(this.parseExpression());
+                if (isOperatorToken(this.peek(), '...')) {
+                    this.advance();
+                    params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+                }
+                else {
+                    params.push(this.parseExpression());
+                }
                 var nextToken = this.peek();
                 if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
                     throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
@@ -6394,13 +6540,13 @@ var Lits = (function (exports) {
                         var _b = __read(params, 1), param = _b[0];
                         return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                     }
-                    case specialExpressionTypes.fn:
-                    case specialExpressionTypes.def:
-                    case specialExpressionTypes.defn:
+                    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));
+                        throw new LitsError("Unknown special expression: ".concat(type), symbol[2]);
                 }
             }
             else if (isNormalBuiltinSymbolNode(symbol) || isNormalBuiltinSymbolNode(symbol)) {
@@ -6424,7 +6570,7 @@ var Lits = (function (exports) {
                 }
                 this.advance();
                 var body = this.parseExpression();
-                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.fn, [
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
                             functionArguments,
                             [body],
                         ]]], firstToken[2]);
@@ -6507,7 +6653,7 @@ var Lits = (function (exports) {
                     functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, "$".concat(i)], undefined]], firstToken[2]));
                 }
             }
-            var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.fn, [
+            var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
                         functionArguments,
                         [exprNode],
                     ]]], firstToken[2]);
@@ -7026,7 +7172,7 @@ var Lits = (function (exports) {
             this.advance();
             if (isSymbolToken(this.peek(), 'let')) {
                 var letNode = this.parseLet(asSymbolToken(this.peek()));
-                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.def, letNode[1][1]]], token[2]);
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], token[2]);
             }
             else if (isReservedSymbolToken(this.peek(), 'function')) {
                 this.advance();
@@ -7044,7 +7190,7 @@ var Lits = (function (exports) {
                 }
                 assertReservedSymbolToken(this.peek(), 'end');
                 this.advance();
-                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.defn, symbol, [
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_defn'], symbol, [
                             functionArguments,
                             body,
                         ]]], token[2]);
@@ -7054,7 +7200,7 @@ var Lits = (function (exports) {
             }
         };
         Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
-            if (specialExpressionTypes[value] !== undefined) {
+            if (specialExpressionTypes[value] !== undefined && value !== 'fn' && value !== 'def' && value !== 'defn') {
                 return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[value]], sourceCodeInfo);
             }
             if (normalExpressionTypes[value] !== undefined) {
@@ -7512,28 +7658,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',