@mojir/lits 2.0.9 → 2.0.11

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.0.9";
+var version = "2.0.11";
 
 var AstNodeType;
 (function (AstNodeType) {
@@ -420,6 +420,12 @@ function isA_SymbolToken(token) {
 function isA_ReservedSymbolToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'A_ReservedSymbol';
 }
+function isA_CommentToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_SingleLineComment';
+}
+function isA_MultiLineCommentToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_MultiLineComment';
+}
 function isA_OperatorToken(token, operatorName) {
     if ((token === null || token === void 0 ? void 0 : token[0]) !== 'A_Operator') {
         return false;
@@ -4332,7 +4338,7 @@ var functionalNormalExpression = {
 var normalExpressions = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, bitwiseNormalExpression), collectionNormalExpression), arrayNormalExpression), sequenceNormalExpression), mathNormalExpression), miscNormalExpression), assertNormalExpression), objectNormalExpression), predicatesNormalExpression), regexpNormalExpression), stringNormalExpression), functionalNormalExpression);
 
 var andSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -4344,6 +4350,7 @@ var andSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4371,42 +4378,30 @@ var andSpecialExpression = {
     },
 };
 
-var commentSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseToken = _a.parseToken;
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'comment',
-            p: [],
-            token: undefined,
-        };
-        var tkn = asToken(tokenStream.tokens[parseState.position]);
-        while (!isRParenToken(tkn)) {
-            node.p.push(parseToken(tokenStream, parseState));
-            tkn = asToken(tokenStream.tokens[parseState.position]);
-        }
-        parseState.position += 1;
-        node.token = getTokenDebugData(firstToken) && firstToken;
-        return node;
-    },
-    evaluate: function () { return null; },
-    findUnresolvedIdentifiers: function () { return new Set(); },
-};
-
-var condSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+function getCommonPolishSpecialExpressionParser(name) {
+    return function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
+        return {
             t: AstNodeType.SpecialExpression,
-            n: 'cond',
+            n: name,
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertEvenNumberOfParams(node);
-        return node;
-    },
+    };
+}
+
+var commentSpecialExpression = {
+    polishParse: getCommonPolishSpecialExpressionParser('comment'),
+    validateParameterCount: function () { return undefined; },
+    evaluate: function () { return null; },
+    findUnresolvedIdentifiers: function () { return new Set(); },
+};
+
+var condSpecialExpression = {
+    polishParse: getCommonPolishSpecialExpressionParser('cond'),
+    validateParameterCount: function (node) { return assertEvenNumberOfParams(node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4435,19 +4430,8 @@ var condSpecialExpression = {
 };
 
 var declaredSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'declared?',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('declared?'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
         return lookUpResult !== null;
@@ -4481,7 +4465,7 @@ function assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo) {
 }
 
 var defSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b;
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -4493,9 +4477,9 @@ var defSpecialExpression = {
             token: getTokenDebugData(firstToken) && firstToken,
         };
         assertSymbolNode(node.p[0], (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        assertNumberOfParams(2, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4521,7 +4505,7 @@ var defSpecialExpression = {
 };
 
 var defsSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -4531,9 +4515,9 @@ var defsSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(2, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
         var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4561,23 +4545,8 @@ var defsSpecialExpression = {
 };
 
 var doSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseToken = _a.parseToken;
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'do',
-            p: [],
-            token: undefined,
-        };
-        var tkn = asToken(tokenStream.tokens[parseState.position]);
-        while (!isRParenToken(tkn)) {
-            node.p.push(parseToken(tokenStream, parseState));
-            tkn = asToken(tokenStream.tokens[parseState.position]);
-        }
-        parseState.position += 1;
-        node.token = getTokenDebugData(firstToken) && firstToken;
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('do'),
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4637,7 +4606,7 @@ function combinate(arrays) {
 }
 
 var defnSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var _a;
         var parseToken = parsers.parseToken;
         var functionName = parseToken(tokenStream, parseState);
@@ -4654,6 +4623,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4680,7 +4650,7 @@ var defnSpecialExpression = {
     },
 };
 var defnsSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseToken = parsers.parseToken;
         var functionName = parseToken(tokenStream, parseState);
         var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
@@ -4695,6 +4665,7 @@ var defnsSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4726,7 +4697,7 @@ var defnsSpecialExpression = {
     },
 };
 var fnSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
@@ -4738,6 +4709,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4969,19 +4941,8 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
 }
 
 var ifSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 2, max: 3 }, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('if'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5004,7 +4965,7 @@ var ifSpecialExpression = {
 };
 
 var ifLetSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5020,9 +4981,9 @@ var ifLetSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams({ min: 1, max: 2 }, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5052,19 +5013,8 @@ var ifLetSpecialExpression = {
 };
 
 var ifNotSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if-not',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 2, max: 3 }, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('if-not'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5087,7 +5037,7 @@ var ifNotSpecialExpression = {
 };
 
 var letSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5101,6 +5051,7 @@ var letSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b, e_2, _c;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5158,7 +5109,7 @@ var letSpecialExpression = {
 };
 
 var loopSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket, parseBindings = _a.parseBindings;
         var bindings = parseBindings(tokenStream, parseState);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5172,6 +5123,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5423,7 +5375,7 @@ function analyze$1(node, contextStack, findUnresolvedIdentifiers, builtin) {
     return result;
 }
 var forSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseTokensUntilClosingBracket = parsers.parseTokensUntilClosingBracket;
         var loopBindings = parseLoopBindings(tokenStream, parseState, parsers);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5435,9 +5387,9 @@ var forSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateAstNode); },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5445,7 +5397,7 @@ var forSpecialExpression = {
     },
 };
 var doseqSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseTokensUntilClosingBracket = parsers.parseTokensUntilClosingBracket;
         var loopBindings = parseLoopBindings(tokenStream, parseState, parsers);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5457,9 +5409,9 @@ var doseqSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, helpers) {
         evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
         return null;
@@ -5471,18 +5423,8 @@ var doseqSpecialExpression = {
 };
 
 var orSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'or',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('or'),
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5511,19 +5453,8 @@ var orSpecialExpression = {
 };
 
 var qqSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: '??',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1, max: 2 }, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('??'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5543,7 +5474,7 @@ var qqSpecialExpression = {
 };
 
 var recurSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -5555,6 +5486,7 @@ var recurSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
         var params = node.p.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
@@ -5567,19 +5499,8 @@ var recurSpecialExpression = {
 };
 
 var throwSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'throw',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('throw'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5595,19 +5516,8 @@ var throwSpecialExpression = {
 };
 
 var timeSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'time!',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('time!'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
         var param = node.p[0];
@@ -5625,7 +5535,7 @@ var timeSpecialExpression = {
 };
 
 var trySpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c, _d;
         var parseToken = _a.parseToken;
         var tryExpression = parseToken(tokenStream, parseState);
@@ -5648,9 +5558,9 @@ var trySpecialExpression = {
             e: error,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5680,19 +5590,8 @@ var trySpecialExpression = {
 };
 
 var whenSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1 }, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('when'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -5724,7 +5623,7 @@ var whenSpecialExpression = {
 };
 
 var whenFirstSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5742,6 +5641,7 @@ var whenFirstSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -5785,7 +5685,7 @@ var whenFirstSpecialExpression = {
 };
 
 var whenLetSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5803,6 +5703,7 @@ var whenLetSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5841,19 +5742,8 @@ var whenLetSpecialExpression = {
 };
 
 var whenNotSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when-not',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1 }, node);
-        return node;
-    },
+    polishParse: getCommonPolishSpecialExpressionParser('when-not'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -7453,7 +7343,7 @@ var AlgebraicParser = /** @class */ (function () {
         };
     };
     AlgebraicParser.prototype.parseFunctionCall = function (symbol) {
-        var _a, _b;
+        var _a, _b, _c;
         var params = [];
         this.advance();
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
@@ -7485,16 +7375,21 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'when':
                     case 'when-not':
                     case 'do':
-                    case 'throw':
-                        return {
+                    case 'time!':
+                    case 'throw': {
+                        var node_1 = {
                             t: AstNodeType.SpecialExpression,
                             n: name_1,
                             p: params,
                             token: getTokenDebugData(symbol.token) && symbol.token,
                         };
+                        builtin.specialExpressions[node_1.n].validateParameterCount(node_1);
+                        return node_1;
+                    }
+                    case 'let':
+                        return this.parseLet(symbol, params);
                     case 'def':
                     case 'defs':
-                    case 'let':
                     case 'if-let':
                     case 'when-let':
                     case 'when-first':
@@ -7504,7 +7399,6 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'try':
                     case 'recur':
                     case 'loop':
-                    case 'time!':
                     case 'doseq':
                     case 'for':
                         throw new Error("Special expression ".concat(name_1, " is not available in algebraic notation"));
@@ -7512,7 +7406,12 @@ var AlgebraicParser = /** @class */ (function () {
                         throw new Error("Unknown special expression: ".concat(name_1));
                 }
             }
-            return createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+            var node = createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+            var builtinExpression = builtin.normalExpressions[node.n];
+            if (builtinExpression) {
+                (_c = builtinExpression.validate) === null || _c === void 0 ? void 0 : _c.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+            }
+            return node;
         }
         else {
             return {
@@ -7524,31 +7423,40 @@ var AlgebraicParser = /** @class */ (function () {
         }
     };
     AlgebraicParser.prototype.parseLambdaFunction = function () {
-        var _a;
+        var _a, _b;
         var firstToken = this.peek();
         this.advance();
-        var spread = false;
+        var rest = false;
+        var letBindingObject;
         var args = [];
         var restArg;
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (isA_OperatorToken(this.peek(), '...')) {
-                if (spread) {
-                    throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-                }
-                this.advance();
-                spread = true;
-            }
-            var symbolToken = this.peek();
-            if (!isA_SymbolToken(symbolToken)) {
-                return null;
+            if (letBindingObject) {
+                throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
             }
-            if (spread) {
-                restArg = symbolToken[1];
+            if (isLBraceToken(this.peek())) {
+                letBindingObject = this.parseObject();
             }
             else {
-                args.push(symbolToken[1]);
+                if (isA_OperatorToken(this.peek(), '...')) {
+                    if (rest) {
+                        throw new LitsError('Multiple spread operators in lambda function', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                    }
+                    this.advance();
+                    rest = true;
+                }
+                var symbolToken = this.peek();
+                if (!isA_SymbolToken(symbolToken)) {
+                    return null;
+                }
+                if (rest) {
+                    restArg = symbolToken[1];
+                }
+                else {
+                    args.push(symbolToken[1]);
+                }
+                this.advance();
             }
-            this.advance();
             if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
                 return null;
             }
@@ -7564,6 +7472,7 @@ var AlgebraicParser = /** @class */ (function () {
             return null;
         }
         this.advance();
+        var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
         var body = this.parseExpression();
         var arity = restArg !== undefined ? { min: args.length } : args.length;
         return {
@@ -7574,7 +7483,17 @@ var AlgebraicParser = /** @class */ (function () {
                     as: {
                         m: args,
                         r: restArg,
-                        b: [],
+                        b: letBindings.map(function (pair) {
+                            var key = pair[0];
+                            var value = pair[1];
+                            return {
+                                t: AstNodeType.Binding,
+                                n: key.v,
+                                v: value,
+                                p: [],
+                                token: getTokenDebugData(key.token) && key.token,
+                            };
+                        }),
                     },
                     b: [body],
                     a: arity,
@@ -7638,6 +7557,35 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
+    AlgebraicParser.prototype.parseLet = function (nameSymbol, params) {
+        var _a, _b;
+        if (params.length !== 2) {
+            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(nameSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        var letObject = params[0];
+        if (letObject.t !== AstNodeType.NormalExpression || letObject.n !== 'object') {
+            throw new LitsError('let expects an object as first argument', (_b = getTokenDebugData(letObject.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+        }
+        var letBindings = arrayToPairs(letObject.p);
+        var expression = params[1];
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'let',
+            p: [expression],
+            token: getTokenDebugData(nameSymbol.token) && nameSymbol.token,
+            bs: letBindings.map(function (pair) {
+                var key = pair[0];
+                var value = pair[1];
+                return {
+                    t: AstNodeType.Binding,
+                    n: key.v,
+                    v: value,
+                    p: [],
+                    token: getTokenDebugData(key.token) && key.token,
+                };
+            }),
+        };
+    };
     AlgebraicParser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
@@ -7881,7 +7829,7 @@ function parseSpecialExpression(tokenStream, parseState) {
     var firstToken = asLParenToken(tokenStream.tokens[parseState.position++]);
     var nameToken = asP_SymbolToken(tokenStream.tokens[parseState.position++]);
     var expressionName = nameToken[1];
-    var parse = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo).parse;
+    var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.polishParse, validateParameterCount = _b.validateParameterCount;
     var node = parse(tokenStream, parseState, firstToken, {
         parseExpression: parseExpression,
         parseTokensUntilClosingBracket: parseTokensUntilClosingBracket,
@@ -7890,6 +7838,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
+    validateParameterCount(node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7979,7 +7928,11 @@ function parse(tokenStream) {
 }
 function removeUnnecessaryTokens(tokenStream) {
     var tokens = tokenStream.tokens.filter(function (token) {
-        if (isP_CommentToken(token) || isA_WhitespaceToken(token) || isP_WhitespaceToken(token)) {
+        if (isP_CommentToken(token)
+            || isA_CommentToken(token)
+            || isA_MultiLineCommentToken(token)
+            || isA_WhitespaceToken(token)
+            || isP_WhitespaceToken(token)) {
             return false;
         }
         return true;
@@ -8295,7 +8248,6 @@ var algebraicReservedNamesRecord = {
     'null': { value: null },
     'def': { value: null, forbidden: true },
     'defs': { value: null, forbidden: true },
-    'let': { value: null, forbidden: true },
     'if-let': { value: null, forbidden: true },
     'when-let': { value: null, forbidden: true },
     'when-first': { value: null, forbidden: true },