@mojir/lits 2.1.1 → 2.1.2

package/dist/index.esm.js

@@ -3736,31 +3736,6 @@ var switchSpecialExpression = {
     },
 };
 
-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
@@ -3785,25 +3760,9 @@ function assertUserDefinedSymbolNode(node, sourceCodeInfo) {
 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;
 }
@@ -3841,6 +3800,29 @@ var bindingTargetTypes = {
     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 = {};
@@ -3980,6 +3962,9 @@ var defSpecialExpression = {
         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;
     },
@@ -4068,6 +4053,31 @@ function isNumberReservedSymbol(symbol) {
     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;
@@ -4107,7 +4117,7 @@ var functionSpecialExpression = {
         var functionName = node[1][1][1];
         contextStack.addValues((_b = {}, _b[functionName] = true, _b));
         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 = {
@@ -4136,7 +4146,7 @@ var defnSpecialExpression = {
         var fn = node[1][2];
         contextStack.exportValues((_b = {}, _b[functionName] = true, _b));
         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 = {
@@ -4158,7 +4168,7 @@ var fnSpecialExpression = {
     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) {
@@ -4183,12 +4193,15 @@ function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evalua
     ];
     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);
@@ -4252,6 +4265,9 @@ var letSpecialExpression = {
         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;
     },
@@ -4746,6 +4762,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
         case NodeTypes.String:
         case NodeTypes.Number:
         case NodeTypes.ReservedSymbol:
+        case NodeTypes.Binding:
             return null;
         case NodeTypes.NormalExpression: {
             var normalExpressionNode = node;
@@ -4790,10 +4807,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
         }
         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));
     }
@@ -5295,8 +5309,6 @@ var ContextStackImpl = /** @class */ (function () {
         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;
@@ -5380,10 +5392,10 @@ var nonFunctionOperators = [
     'cond',
     'def',
     'defined?',
-    'defn',
+    // 'defn',
     'do',
     'doseq',
-    'fn',
+    // 'fn',
     'if',
     'let',
     'loop',
@@ -6228,10 +6240,7 @@ var Parser = /** @class */ (function () {
                 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();
@@ -6391,9 +6400,9 @@ var Parser = /** @class */ (function () {
                     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:
@@ -6421,7 +6430,7 @@ var Parser = /** @class */ (function () {
             }
             this.advance();
             var body = this.parseExpression();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.fn, [
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
                         functionArguments,
                         [body],
                     ]]], firstToken[2]);
@@ -6504,7 +6513,7 @@ var Parser = /** @class */ (function () {
                 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]);
@@ -7023,7 +7032,7 @@ var Parser = /** @class */ (function () {
         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();
@@ -7041,7 +7050,7 @@ var Parser = /** @class */ (function () {
             }
             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]);
@@ -7051,7 +7060,7 @@ var Parser = /** @class */ (function () {
         }
     };
     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) {
@@ -7509,28 +7518,6 @@ var api = {
         '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',