@mojir/lits 2.0.19 → 2.0.21

package/dist/testFramework.esm.js

@@ -275,9 +275,6 @@ var commonSimpleTokenTypes = [
     'RBrace',
     'RBracket',
     'RParen',
-    'AlgNotation',
-    'PolNotation',
-    'EndNotation',
 ];
 var commomValueTokenTypes = [
     'String',
@@ -367,20 +364,6 @@ function asRegexpShorthandToken(token) {
     assertRegexpShorthandToken(token);
     return token;
 }
-function isAlgebraicNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'AlgNotation';
-}
-function isPolishNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'PolNotation';
-}
-function isEndNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'EndNotation';
-}
-function assertEndNotationToken(token) {
-    if (!isEndNotationToken(token)) {
-        throwUnexpectedToken('EndNotation', undefined, token);
-    }
-}
 
 var algebraicSimpleTokenTypes = __spreadArray([], __read(commonSimpleTokenTypes), false);
 var algebraicOnlyValueTokenTypes = [
@@ -769,6 +752,128 @@ function asNumber(value, sourceCodeInfo, options) {
     return value;
 }
 
+var bitwiseNormalExpression = {
+    '<<': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num << count;
+        },
+        paramCount: 2,
+    },
+    '>>': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num >> count;
+        },
+        paramCount: 2,
+    },
+    '>>>': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num >>> count;
+        },
+        paramCount: 2,
+    },
+    '~': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), num = _b[0];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            return ~num;
+        },
+        paramCount: 1,
+    },
+    '&': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result & value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '&!': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result & ~value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '|': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result | value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '^': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result ^ value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    'bit_flip': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num ^= mask);
+        },
+        paramCount: 2,
+    },
+    'bit_set': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num |= mask);
+        },
+        paramCount: 2,
+    },
+    'bit_clear': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num &= ~mask);
+        },
+        paramCount: 2,
+    },
+    'bit_test': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return !!(num & mask);
+        },
+        paramCount: 2,
+    },
+};
+
 function getAssertionError(typeName, value, sourceCodeInfo) {
     return new LitsError("Expected ".concat(typeName, ", got ").concat(valueToString(value), "."), getSourceCodeInfo(value, sourceCodeInfo));
 }
@@ -920,20 +1025,6 @@ function withoutCommentNodes(astNodes) {
     return astNodes.filter(function (n) { return n.t !== AstNodeType.Comment; });
 }
 
-function assertEvenNumberOfParams(node) {
-    var _a;
-    var length = withoutCommentNodes(node.p).length;
-    if (length % 2 !== 0) {
-        throw new LitsError("Wrong number of arguments, expected an even number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-    }
-}
-function assertOddNumberOfParams(node) {
-    var _a;
-    var length = withoutCommentNodes(node.p).length;
-    if (length % 2 !== 1) {
-        throw new LitsError("Wrong number of arguments, expected an odd number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-    }
-}
 function assertNumberOfParams(count, node) {
     var _a, _b;
     assertCount({
@@ -965,9 +1056,17 @@ function assertCount(_a) {
         }
     }
     else {
-        var min = count.min, max = count.max;
-        if (min === undefined && max === undefined)
-            throw new LitsError('Min or max must be specified.', sourceCodeInfo);
+        var min = count.min, max = count.max, even = count.even, odd = count.odd;
+        if (even) {
+            if (length % 2 !== 0) {
+                throw new LitsError("Wrong number of arguments to \"".concat(name, "\",, expected an even number, got ").concat(valueToString(length), "."), sourceCodeInfo);
+            }
+        }
+        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);
+            }
+        }
         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);
         }
@@ -977,128 +1076,6 @@ function assertCount(_a) {
     }
 }
 
-var bitwiseNormalExpression = {
-    '<<': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num << count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '>>': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num >> count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '>>>': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num >>> count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '~': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), num = _b[0];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            return ~num;
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    '&': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result & value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '&!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result & ~value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '|': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result | value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '^': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result ^ value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    'bit_flip': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num ^= mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_set': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num |= mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_clear': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num &= ~mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_test': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return !!(num & mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-};
-
 function isLitsFunction(value) {
     if (value === null || typeof value !== 'object')
         return false;
@@ -1479,7 +1456,7 @@ var collectionNormalExpression = {
             var result = get(coll, key);
             return result === undefined ? defaultValue : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'get_in': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1514,7 +1491,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'count': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1528,7 +1505,7 @@ var collectionNormalExpression = {
                 return coll.length;
             return Object.keys(coll).length;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'contains?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1545,7 +1522,7 @@ var collectionNormalExpression = {
             }
             return !!Object.getOwnPropertyDescriptor(coll, key);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1566,7 +1543,7 @@ var collectionNormalExpression = {
             }
             return Object.values(coll).includes(value);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1626,7 +1603,7 @@ var collectionNormalExpression = {
             }
             return false;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1688,7 +1665,7 @@ var collectionNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'assoc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1698,7 +1675,7 @@ var collectionNormalExpression = {
             assertAny(value, sourceCodeInfo);
             return assoc(coll, key, value, sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'assoc_in': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1723,7 +1700,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'update': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1734,7 +1711,7 @@ var collectionNormalExpression = {
             assertLitsFunction(fn, sourceCodeInfo);
             return update(coll, key, fn, params, contextStack, executeFunction, sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'update_in': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1760,7 +1737,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'concat': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1784,7 +1761,7 @@ var collectionNormalExpression = {
                 }, {});
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1798,7 +1775,7 @@ var collectionNormalExpression = {
                 return coll.length > 0 ? coll : null;
             return Object.keys(coll).length > 0 ? coll : null;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'every?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1812,7 +1789,7 @@ var collectionNormalExpression = {
                 return coll.split('').every(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return Object.entries(coll).every(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'any?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1826,7 +1803,7 @@ var collectionNormalExpression = {
                 return coll.split('').some(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return Object.entries(coll).some(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'not_any?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1840,7 +1817,7 @@ var collectionNormalExpression = {
                 return !coll.split('').some(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return !Object.entries(coll).some(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'not_every?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1854,13 +1831,14 @@ var collectionNormalExpression = {
                 return !coll.split('').every(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return !Object.entries(coll).every(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
 var arrayNormalExpression = {
     array: {
         evaluate: function (params) { return params; },
+        paramCount: {},
     },
     range: {
         evaluate: function (params, sourceCodeInfo) {
@@ -1898,7 +1876,7 @@ var arrayNormalExpression = {
                 result.push(i);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
+        paramCount: { min: 1, max: 3 },
     },
     repeat: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1909,7 +1887,7 @@ var arrayNormalExpression = {
                 result.push(value);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     flatten: {
         evaluate: function (_a) {
@@ -1918,7 +1896,7 @@ var arrayNormalExpression = {
                 return [];
             return seq.flat(Number.POSITIVE_INFINITY);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     mapcat: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1928,7 +1906,7 @@ var arrayNormalExpression = {
             assertLitsFunction(fn, sourceCodeInfo);
             return arr.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); }).flat(1);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -1943,7 +1921,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return i >= 0 && i < seq.length ? toAny(seq[i]) : defaultValue;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'filter': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1958,7 +1936,7 @@ var sequenceNormalExpression = {
                 .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
                 .join('');
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'first': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1968,7 +1946,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[0]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1978,7 +1956,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[array.length - 1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'map': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2000,7 +1978,7 @@ var sequenceNormalExpression = {
                     .join('');
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2011,7 +1989,7 @@ var sequenceNormalExpression = {
             }
             return seq.slice(0, seq.length - 1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'position': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2030,7 +2008,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2049,7 +2027,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'last_index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2068,7 +2046,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'push': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2082,7 +2060,7 @@ var sequenceNormalExpression = {
                 return __spreadArray(__spreadArray([], __read(seq), false), __read(values), false);
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     'reductions': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2143,7 +2121,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'reduce': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2190,7 +2168,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'reduce_right': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2238,7 +2216,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2251,7 +2229,7 @@ var sequenceNormalExpression = {
             }
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2263,7 +2241,7 @@ var sequenceNormalExpression = {
                 return seq.slice(integerCount);
             return seq.substring(integerCount);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'next': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2278,7 +2256,7 @@ var sequenceNormalExpression = {
                 return null;
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2292,7 +2270,7 @@ var sequenceNormalExpression = {
                 return seq.slice(integerCount);
             return seq.substring(integerCount);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'reverse': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2304,7 +2282,7 @@ var sequenceNormalExpression = {
                 return __spreadArray([], __read(seq), false).reverse();
             return seq.split('').reverse().join('');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'second': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2314,7 +2292,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return toAny(seq[1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'shift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2326,7 +2304,7 @@ var sequenceNormalExpression = {
             copy.shift();
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'slice': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2340,7 +2318,7 @@ var sequenceNormalExpression = {
             assertNumber(to, sourceCodeInfo, { integer: true });
             return seq.slice(from, to);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
+        paramCount: { min: 1, max: 3 },
     },
     'some': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2357,7 +2335,7 @@ var sequenceNormalExpression = {
                 return (_c = seq.split('').find(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })) !== null && _c !== void 0 ? _c : null;
             return toAny(seq.find(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); }));
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'sort': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2395,7 +2373,7 @@ var sequenceNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'sort_by': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2446,7 +2424,7 @@ var sequenceNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'take': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2456,7 +2434,7 @@ var sequenceNormalExpression = {
             var num = Math.max(Math.ceil(n), 0);
             return input.slice(0, num);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'take_last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2467,7 +2445,7 @@ var sequenceNormalExpression = {
             var from = array.length - num;
             return array.slice(from);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'take_while': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2495,7 +2473,7 @@ var sequenceNormalExpression = {
             }
             return typeof seq === 'string' ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2505,7 +2483,7 @@ var sequenceNormalExpression = {
             assertSeq(input, sourceCodeInfo);
             return input.slice(num);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop_last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2516,7 +2494,7 @@ var sequenceNormalExpression = {
             var from = array.length - num;
             return array.slice(0, from);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop_while': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2532,7 +2510,7 @@ var sequenceNormalExpression = {
             var from = charArray.findIndex(function (elem) { return !executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return charArray.slice(from).join('');
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'unshift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2546,7 +2524,7 @@ var sequenceNormalExpression = {
             copy.unshift.apply(copy, __spreadArray([], __read(values), false));
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     'distinct': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2556,7 +2534,7 @@ var sequenceNormalExpression = {
                 return Array.from(new Set(input));
             return Array.from(new Set(input.split(''))).join('');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'remove': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2571,7 +2549,7 @@ var sequenceNormalExpression = {
                 .filter(function (elem) { return !executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
                 .join('');
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'remove_at': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2588,7 +2566,7 @@ var sequenceNormalExpression = {
             }
             return "".concat(input.substring(0, index)).concat(input.substring(index + 1));
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split_at': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2598,7 +2576,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return [seq.slice(0, intPos), seq.slice(intPos)];
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split_with': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2613,7 +2591,7 @@ var sequenceNormalExpression = {
                 return [seq, seqIsArray ? [] : ''];
             return [seq.slice(0, index), seq.slice(index)];
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'frequencies': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2629,7 +2607,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2647,7 +2625,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'partition': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2659,7 +2637,7 @@ var sequenceNormalExpression = {
                 : undefined;
             return partition(n, step, seq, pad, sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 4 }, node); },
+        paramCount: { min: 2, max: 4 },
     },
     'partition_all': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2668,7 +2646,7 @@ var sequenceNormalExpression = {
             var step = params.length === 3 ? toNonNegativeInteger(asNumber(params[2], sourceCodeInfo)) : n;
             return partition(n, step, seq, [], sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'partition_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2689,7 +2667,7 @@ var sequenceNormalExpression = {
             }, []);
             return isStringSeq ? result.map(function (elem) { return elem.join(''); }) : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'ends_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2701,7 +2679,7 @@ var sequenceNormalExpression = {
             }
             return str.at(-1) === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'starts_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2713,7 +2691,7 @@ var sequenceNormalExpression = {
             }
             return str[0] === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'interleave': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2751,7 +2729,7 @@ var sequenceNormalExpression = {
             }
             return isStringSeq ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'interpose': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2770,7 +2748,7 @@ var sequenceNormalExpression = {
             result.push(seq[seq.length - 1]);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 function partition(n, step, seq, pad, sourceCodeInfo) {
@@ -2808,7 +2786,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'dec': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2816,7 +2794,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2825,6 +2803,7 @@ var mathNormalExpression = {
                 return result + param;
             }, 0);
         },
+        paramCount: {},
     },
     '*': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2833,6 +2812,7 @@ var mathNormalExpression = {
                 return result * param;
             }, 1);
         },
+        paramCount: {},
     },
     '/': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2849,6 +2829,7 @@ var mathNormalExpression = {
                 return result / param;
             }, first);
         },
+        paramCount: {},
     },
     '-': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2863,6 +2844,7 @@ var mathNormalExpression = {
                 return result - param;
             }, first);
         },
+        paramCount: {},
     },
     'quot': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2872,7 +2854,7 @@ var mathNormalExpression = {
             var quotient = Math.trunc(dividend / divisor);
             return quotient;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'mod': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2882,7 +2864,7 @@ var mathNormalExpression = {
             var quotient = Math.floor(dividend / divisor);
             return dividend - divisor * quotient;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     '%': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2892,7 +2874,7 @@ var mathNormalExpression = {
             var quotient = Math.trunc(dividend / divisor);
             return dividend - divisor * quotient;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'sqrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2900,7 +2882,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.sqrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cbrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2908,7 +2890,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.cbrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '**': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2917,7 +2899,7 @@ var mathNormalExpression = {
             assertNumber(second, sourceCodeInfo);
             return Math.pow(first, second);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'round': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2929,7 +2911,7 @@ var mathNormalExpression = {
             var factor = Math.pow(10, decimals);
             return Math.round(value * factor) / factor;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'trunc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2937,7 +2919,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.trunc(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'floor': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2945,7 +2927,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.floor(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'ceil': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2953,7 +2935,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.ceil(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2966,7 +2948,7 @@ var mathNormalExpression = {
                 return Math.min(min, value);
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'max': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2979,7 +2961,7 @@ var mathNormalExpression = {
                 return Math.max(min, value);
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'abs': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2987,7 +2969,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.abs(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sign': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2995,67 +2977,67 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sign(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'max_safe_integer': {
         evaluate: function () {
             return Number.MAX_SAFE_INTEGER;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'min_safe_integer': {
         evaluate: function () {
             return Number.MIN_SAFE_INTEGER;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'max_value': {
         evaluate: function () {
             return Number.MAX_VALUE;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'min_value': {
         evaluate: function () {
             return Number.MIN_VALUE;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'epsilon': {
         evaluate: function () {
             return Number.EPSILON;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'positive_infinity': {
         evaluate: function () {
             return Number.POSITIVE_INFINITY;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'negative_infinity': {
         evaluate: function () {
             return Number.NEGATIVE_INFINITY;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'nan': {
         evaluate: function () {
             return Number.NaN;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'e': {
         evaluate: function () {
             return Math.E;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'pi': {
         evaluate: function () {
             return Math.PI;
         },
-        validate: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
     },
     'exp': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3063,7 +3045,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.exp(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3071,7 +3053,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log2': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3079,7 +3061,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log2(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log10': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3087,7 +3069,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log10(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3095,7 +3077,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3103,7 +3085,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3111,7 +3093,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3119,7 +3101,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3127,7 +3109,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3135,7 +3117,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3143,7 +3125,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3151,7 +3133,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3159,7 +3141,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3167,7 +3149,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3175,7 +3157,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3183,7 +3165,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3198,7 +3180,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '==': {
         evaluate: function (_a) {
@@ -3220,14 +3202,14 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'equal?': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), a = _b[0], b = _b[1];
             return deepEqual(asAny(a, sourceCodeInfo), asAny(b, sourceCodeInfo), sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>': {
         evaluate: function (_a) {
@@ -3251,7 +3233,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<': {
         evaluate: function (_a) {
@@ -3275,7 +3257,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>=': {
         evaluate: function (_a) {
@@ -3299,7 +3281,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<=': {
         evaluate: function (_a) {
@@ -3323,14 +3305,14 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '!': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return !first;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'epoch>iso_date': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3338,7 +3320,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo);
             return new Date(ms).toISOString();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'iso_date>epoch': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3348,7 +3330,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo, { finite: true });
             return ms;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'write!': {
         evaluate: function (params, sourceCodeInfo) {
@@ -3358,20 +3340,21 @@ var miscNormalExpression = {
                 return asAny(params[params.length - 1], sourceCodeInfo);
             return null;
         },
+        paramCount: {},
     },
     'boolean': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return !!value;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'compare': {
         evaluate: function (_a) {
             var _b = __read(_a, 2), a = _b[0], b = _b[1];
             return compare(a, b);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'json_parse': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3380,7 +3363,7 @@ var miscNormalExpression = {
             // eslint-disable-next-line ts/no-unsafe-return
             return JSON.parse(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'json_stringify': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3391,7 +3374,7 @@ var miscNormalExpression = {
             assertNumber(second, sourceCodeInfo);
             return JSON.stringify(first, null, second);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
 
@@ -3405,7 +3388,7 @@ var assertNormalExpression = {
                 throw new AssertionError(message, sourceCodeInfo);
             return asAny(value, sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert=': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3415,7 +3398,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert!=': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3425,7 +3408,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " not to be ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_equal': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3436,7 +3419,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_not_equal': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3447,7 +3430,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_gt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3457,7 +3440,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be grater than ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_gte': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3467,7 +3450,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be grater than or equal to ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_lt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3477,7 +3460,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be less than ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_lte': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3487,7 +3470,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be less than or equal to ").concat(second, ".").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_true': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3497,7 +3480,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be true.").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_false': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3507,7 +3490,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be false.").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_truthy': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3517,7 +3500,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be truthy.").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_falsy': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3527,7 +3510,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be falsy.").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_null': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3537,7 +3520,7 @@ var assertNormalExpression = {
                 throw new AssertionError("Expected ".concat(first, " to be nil.").concat(message), sourceCodeInfo);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_throws': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -3553,7 +3536,7 @@ var assertNormalExpression = {
             }
             throw new AssertionError("Expected function to throw.".concat(message), sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     'assert_throws_error': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -3574,7 +3557,7 @@ var assertNormalExpression = {
             }
             throw new AssertionError("Expected function to throw \"".concat(throwMessage, "\".").concat(message), sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'assert_not_throws': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -3590,7 +3573,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
 
@@ -3606,7 +3589,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertEvenNumberOfParams(node); },
+        paramCount: { even: true },
     },
     keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3614,7 +3597,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.keys(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     vals: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3622,7 +3605,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.values(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     entries: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3630,7 +3613,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.entries(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     find: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3641,7 +3624,7 @@ var objectNormalExpression = {
                 return [key, obj[key]];
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     dissoc: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3652,7 +3635,7 @@ var objectNormalExpression = {
             delete newObj[key];
             return newObj;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     merge: {
         evaluate: function (params, sourceCodeInfo) {
@@ -3665,7 +3648,7 @@ var objectNormalExpression = {
                 return __assign(__assign({}, result), obj);
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 0 }, node); },
+        paramCount: { min: 0 },
     },
     merge_with: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -3688,7 +3671,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     zipmap: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3703,7 +3686,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     select_keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3716,7 +3699,7 @@ var objectNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -3726,42 +3709,42 @@ var predicatesNormalExpression = {
             var _b = __read(_a, 1), first = _b[0];
             return isLitsFunction(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'string?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return typeof first === 'string';
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'number?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return typeof first === 'number';
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'integer?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return typeof first === 'number' && isNumber(first, { integer: true });
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'boolean?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return typeof first === 'boolean';
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nil?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return first === null || first === undefined;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'zero?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3769,7 +3752,7 @@ var predicatesNormalExpression = {
             assertNumber(first, sourceCodeInfo, { finite: true });
             return first === 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'pos?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3777,7 +3760,7 @@ var predicatesNormalExpression = {
             assertNumber(first, sourceCodeInfo, { finite: true });
             return first > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'neg?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3785,7 +3768,7 @@ var predicatesNormalExpression = {
             assertNumber(first, sourceCodeInfo, { finite: true });
             return first < 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'even?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3793,7 +3776,7 @@ var predicatesNormalExpression = {
             assertNumber(first, sourceCodeInfo, { finite: true });
             return first % 2 === 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'odd?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3801,42 +3784,42 @@ var predicatesNormalExpression = {
             assertNumber(first, sourceCodeInfo, { finite: true });
             return isNumber(first, { integer: true }) && first % 2 !== 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'array?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return Array.isArray(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'coll?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return isColl(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'seq?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return isSeq(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'object?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), first = _b[0];
             return isObj(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'regexp?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return isRegularExpression(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'finite?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3844,7 +3827,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isFinite(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nan?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3852,7 +3835,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isNaN(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'positive_infinity?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3860,7 +3843,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return value === Number.POSITIVE_INFINITY;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'negative_infinity?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3868,21 +3851,21 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return value === Number.NEGATIVE_INFINITY;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'true?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return value === true;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'false?': {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return value === false;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'empty?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3896,7 +3879,7 @@ var predicatesNormalExpression = {
                 return coll.length === 0;
             return Object.keys(coll).length === 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'not_empty?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3910,7 +3893,7 @@ var predicatesNormalExpression = {
                 return coll.length > 0;
             return Object.keys(coll).length > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3929,7 +3912,7 @@ var regexpNormalExpression = {
                 _b.f = flags,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
     match: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3943,7 +3926,7 @@ var regexpNormalExpression = {
                 return __spreadArray([], __read(match), false);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     replace: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3954,7 +3937,7 @@ var regexpNormalExpression = {
             var matcher = isRegularExpression(regexp) ? new RegExp(regexp.s, "".concat(regexp.f)) : regexp;
             return str.replace(matcher, value);
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     replace_all: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3965,7 +3948,7 @@ var regexpNormalExpression = {
             var matcher = isRegularExpression(regexp) ? new RegExp(regexp.s, "".concat(regexp.f.includes('g') ? regexp.f : "".concat(regexp.f, "g"))) : regexp;
             return str.replaceAll(matcher, value);
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
 };
 
@@ -3981,7 +3964,7 @@ var stringNormalExpression = {
             assertNumber(third, sourceCodeInfo, { gte: second });
             return (first).substring(second, third);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'string_repeat': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3990,7 +3973,7 @@ var stringNormalExpression = {
             assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
             return str.repeat(count);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'str': {
         evaluate: function (params) {
@@ -4005,6 +3988,7 @@ var stringNormalExpression = {
                 return result + paramStr;
             }, '');
         },
+        paramCount: {},
     },
     'number': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4015,7 +3999,7 @@ var stringNormalExpression = {
                 throw new LitsError("Could not convert '".concat(str, "' to a number."), sourceCodeInfo);
             return number;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'from_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4029,7 +4013,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'to_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4037,7 +4021,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo, { nonEmpty: true });
             return asNonUndefined(str.codePointAt(0), sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'lower_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4045,7 +4029,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'upper_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4053,7 +4037,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toUpperCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4061,7 +4045,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.trim();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4069,7 +4053,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/^\s+/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_right': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4077,7 +4061,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/\s+$/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '++': {
         evaluate: function (params, sourceCodeInfo) {
@@ -4101,7 +4085,7 @@ var stringNormalExpression = {
                 return "".concat(acc).concat(str);
             }, first === null ? '' : "".concat(first));
         },
-        validate: function () { return undefined; },
+        paramCount: {},
     },
     'join': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4111,7 +4095,7 @@ var stringNormalExpression = {
             assertString(delimiter, sourceCodeInfo);
             return stringList.join(delimiter);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4125,7 +4109,7 @@ var stringNormalExpression = {
                 : new RegExp(stringOrRegExpValue.s, stringOrRegExpValue.f);
             return str.split(delimiter, limit);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'split_lines': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4133,7 +4117,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.split((/\r\n|\n|\r/)).filter(function (line) { return line !== ''; });
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'pad_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4144,7 +4128,7 @@ var stringNormalExpression = {
                 assertString(padString, sourceCodeInfo);
             return str.padStart(length, padString);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'pad_right': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4155,7 +4139,7 @@ var stringNormalExpression = {
                 assertString(padString, sourceCodeInfo);
             return str.padEnd(length, padString);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'template': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4186,7 +4170,7 @@ var stringNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+        paramCount: { min: 1, max: 10 },
     },
     'encode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4197,7 +4181,7 @@ var stringNormalExpression = {
                 return String.fromCharCode(Number.parseInt(p1, 16));
             }));
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'decode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4215,7 +4199,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'encode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4223,7 +4207,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return encodeURIComponent(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'decode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4236,7 +4220,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'blank?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4247,7 +4231,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return blankRegexp.test(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'capitalize': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4255,7 +4239,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 var doubleDollarRegexp = /\$\$/g;
@@ -4286,14 +4270,14 @@ var functionalNormalExpression = {
             var applyArray = __spreadArray(__spreadArray([], __read(params.slice(0, -1)), false), __read(last), false);
             return executeFunction(func, applyArray, contextStack, sourceCodeInfo);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     identity: {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return toAny(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     partial: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4307,7 +4291,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     comp: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4325,6 +4309,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
+        paramCount: {},
     },
     constantly: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4337,7 +4322,7 @@ var functionalNormalExpression = {
                 _b.v = toAny(value),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     juxt: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4349,7 +4334,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     complement: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4362,7 +4347,7 @@ var functionalNormalExpression = {
                 _b.f = toAny(fn),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4374,7 +4359,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     some_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4386,7 +4371,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     fnil: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4400,7 +4385,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
 };
 
@@ -4419,7 +4404,7 @@ var andSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4463,14 +4448,14 @@ function getCommonPolishSpecialExpressionParser(name) {
 
 var commentSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('comment'),
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function () { return null; },
     findUnresolvedIdentifiers: function () { return new Set(); },
 };
 
 var condSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('cond'),
-    validateParameterCount: function (node) { return assertEvenNumberOfParams(node); },
+    paramCount: { even: true },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4500,7 +4485,7 @@ var condSpecialExpression = {
 
 var switchSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('switch'),
-    validateParameterCount: function (node) { return assertOddNumberOfParams(node); },
+    paramCount: { odd: true },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4531,7 +4516,7 @@ var switchSpecialExpression = {
 
 var declaredSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('defined?'),
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
         return lookUpResult !== null;
@@ -4578,7 +4563,7 @@ var defSpecialExpression = {
         assertSymbolNode(node.p[0], (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
+    paramCount: 2,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4603,7 +4588,7 @@ var defSpecialExpression = {
 
 var doSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('do'),
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4675,7 +4660,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4714,7 +4699,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4939,7 +4924,7 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
 
 var ifSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('if'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+    paramCount: { min: 2, max: 3 },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4963,7 +4948,7 @@ var ifSpecialExpression = {
 
 var unlessSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('unless'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+    paramCount: { min: 2, max: 3 },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5000,7 +4985,7 @@ var letSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(0, node); },
+    paramCount: 0,
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5055,7 +5040,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5321,7 +5306,7 @@ var forSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateAstNode); },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5343,7 +5328,7 @@ var doseqSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, helpers) {
         evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
         return null;
@@ -5356,7 +5341,7 @@ var doseqSpecialExpression = {
 
 var orSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('||'),
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5386,7 +5371,7 @@ var orSpecialExpression = {
 
 var qqSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('??'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+    paramCount: { min: 1, max: 2 },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5418,7 +5403,7 @@ var recurSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
         var params = node.p.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
@@ -5432,7 +5417,7 @@ var recurSpecialExpression = {
 
 var throwSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('throw'),
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5473,7 +5458,7 @@ var trySpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5910,8 +5895,9 @@ function evaluate(ast, contextStack) {
     var e_1, _a;
     var result = null;
     var safeAstNode = ast.hasDebugData ? JSON.parse(JSON.stringify(ast)) : ast;
-    if (safeAstNode.hasDebugData)
+    if (safeAstNode.hasDebugData) {
         removeCommenNodes(safeAstNode);
+    }
     try {
         for (var _b = __values(safeAstNode.b), _c = _b.next(); !_c.done; _c = _b.next()) {
             var node = _c.value;
@@ -6117,6 +6103,20 @@ function analyze(ast, params) {
     };
 }
 
+function minifyTokenStream(tokenStream) {
+    var tokens = tokenStream.tokens.filter(function (token) {
+        if (isP_CommentToken(token)
+            || isA_CommentToken(token)
+            || isA_MultiLineCommentToken(token)
+            || isA_WhitespaceToken(token)
+            || isP_WhitespaceToken(token)) {
+            return false;
+        }
+        return true;
+    });
+    return __assign(__assign({}, tokenStream), { tokens: tokens });
+}
+
 function parseSymbol(tokenStream, parseState) {
     var _a;
     var tkn = asToken(tokenStream.tokens[parseState.position++]);
@@ -6306,7 +6306,6 @@ function getPrecedence(operatorSign) {
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    var _a;
     var node = {
         t: AstNodeType.NormalExpression,
         n: name,
@@ -6315,7 +6314,7 @@ function createNamedNormalExpressionNode(name, params, token) {
     };
     var builtinExpression = builtin.normalExpressions[node.n];
     if (builtinExpression) {
-        (_a = builtinExpression.validate) === null || _a === void 0 ? void 0 : _a.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+        assertNumberOfParams(builtinExpression.paramCount, node);
     }
     return node;
 }
@@ -6416,7 +6415,7 @@ var AlgebraicParser = /** @class */ (function () {
     AlgebraicParser.prototype.parse = function () {
         var nodes = [];
         while (!this.isAtEnd()) {
-            nodes.push(this.parseExpression());
+            nodes.push(this.parseExpression(0, true));
             if (!isA_OperatorToken(this.peek(), ';')) {
                 break;
             }
@@ -6424,9 +6423,10 @@ var AlgebraicParser = /** @class */ (function () {
         }
         return nodes;
     };
-    AlgebraicParser.prototype.parseExpression = function (precedence) {
-        var _a;
+    AlgebraicParser.prototype.parseExpression = function (precedence, moduleScope) {
+        var _a, _b;
         if (precedence === void 0) { precedence = 0; }
+        if (moduleScope === void 0) { moduleScope = false; }
         var firstToken = this.peek();
         var left;
         if (isA_SymbolToken(firstToken)) {
@@ -6462,6 +6462,9 @@ var AlgebraicParser = /** @class */ (function () {
             return this.parseFunction(firstToken);
         }
         else if (isA_ReservedSymbolToken(firstToken, 'export')) {
+            if (!moduleScope) {
+                throw new LitsError('export is only allowed in module scope', (_a = getTokenDebugData(firstToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+            }
             return this.parseExport(firstToken);
         }
         left || (left = this.parseOperand());
@@ -6499,7 +6502,7 @@ var AlgebraicParser = /** @class */ (function () {
             operator = this.peek();
         }
         if (!left) {
-            throw new LitsError('Expected operand', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+            throw new LitsError('Expected operand', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         }
         return left;
     };
@@ -6607,32 +6610,6 @@ var AlgebraicParser = /** @class */ (function () {
                 return parseReservedSymbol(this.tokenStream, this.parseState);
             case 'RegexpShorthand':
                 return parseRegexpShorthand(this.tokenStream, this.parseState);
-            case 'PolNotation': {
-                this.parseState.algebraic = false;
-                var astNodes = [];
-                this.advance();
-                do {
-                    astNodes.push(this.parseState.parseToken(this.tokenStream, this.parseState));
-                } while (!isEndNotationToken(this.peek()));
-                this.advance();
-                this.parseState.algebraic = true;
-                if (astNodes.length === 1) {
-                    return astNodes[0];
-                }
-                return {
-                    t: AstNodeType.SpecialExpression,
-                    n: 'do',
-                    p: astNodes,
-                    token: getTokenDebugData(token) && token,
-                };
-            }
-            case 'AlgNotation': {
-                this.advance();
-                var node = this.parseOperand();
-                assertEndNotationToken(this.peek());
-                this.advance();
-                return node;
-            }
             default:
                 throw new LitsError("Unknown token type: ".concat(tokenType), (_b = getTokenDebugData(token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         }
@@ -6737,7 +6714,7 @@ var AlgebraicParser = /** @class */ (function () {
                             p: params,
                             token: getTokenDebugData(symbol.token) && symbol.token,
                         };
-                        builtin.specialExpressions[node.n].validateParameterCount(node);
+                        assertNumberOfParams(builtin.specialExpressions[node.n].paramCount, node);
                         return node;
                     }
                     case 'fn':
@@ -6790,7 +6767,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
     };
     AlgebraicParser.prototype.parseFunctionArguments = function () {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         var firstToken = this.peek();
         if (isA_SymbolToken(firstToken)) {
             this.advance();
@@ -6805,62 +6782,54 @@ var AlgebraicParser = /** @class */ (function () {
         }
         this.advance();
         var rest = false;
-        var letBindingObject;
         var args = [];
         var restArg;
-        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (letBindingObject) {
-                throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-            }
-            if (isLBraceToken(this.peek())) {
-                letBindingObject = this.parseObject();
-            }
-            else {
-                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)) {
-                    throw new LitsError('Expected symbol', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-                }
+        while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+            if (isA_OperatorToken(this.peek(), '...')) {
                 if (rest) {
-                    restArg = symbolToken[1];
-                }
-                else {
-                    args.push(symbolToken[1]);
+                    throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
                 }
                 this.advance();
+                rest = true;
+            }
+            var symbolToken = this.peek();
+            if (!isA_SymbolToken(symbolToken)) {
+                throw new LitsError('Expected symbol', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
             }
-            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
-                throw new LitsError('Expected comma or closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+            if (rest) {
+                restArg = symbolToken[1];
+            }
+            else {
+                args.push(symbolToken[1]);
+            }
+            this.advance();
+            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+                throw new LitsError('Expected comma or closing parenthesis', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
             }
             if (isA_OperatorToken(this.peek(), ',')) {
                 this.advance();
             }
         }
         var arity = restArg !== undefined ? { min: args.length } : args.length;
+        // let bindings, to be able to pass on values in the context down to the body
+        // This is needed since lits is dynamically scoped
+        // E.g.
+        // x => y => x + y // would not work, x is not available in the second lambda
+        // x => (y, let x = x) => x + y // would work, x is available in the second lambda
+        var bindingNodess = [];
+        var token = this.peek();
+        while (isA_SymbolToken(token, 'let')) {
+            var letNode = this.parseLet(token, true);
+            bindingNodess.push(letNode.bs[0]);
+            token = this.peek();
+        }
         if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
+            throw new LitsError('Expected closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
         }
-        var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
         var functionArguments = {
             m: args,
             r: restArg,
-            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: bindingNodess,
         };
         this.advance();
         return {
@@ -7310,6 +7279,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
+        assertA_OperatorToken(this.peek(), ';');
         var fnNode = {
             t: AstNodeType.SpecialExpression,
             n: 'fn',
@@ -7472,7 +7442,7 @@ function parseObjectLitteral(tokenStream, parseState) {
         p: params,
         token: getTokenDebugData(firstToken) && firstToken,
     };
-    assertEvenNumberOfParams(node);
+    assertNumberOfParams({ even: true }, node);
     return node;
 }
 var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7578,7 +7548,7 @@ function parseBinding(tokenStream, parseState) {
     return node;
 }
 function parseNormalExpression(tokenStream, parseState) {
-    var _a, _b;
+    var _a;
     var startBracketToken = tokenStream.hasDebugData ? asLParenToken(tokenStream.tokens[parseState.position]) : undefined;
     parseState.position += 1;
     var fnNode = parseState.parseToken(tokenStream, parseState);
@@ -7602,7 +7572,7 @@ function parseNormalExpression(tokenStream, parseState) {
     };
     var builtinExpression = builtin.normalExpressions[node.n];
     if (builtinExpression) {
-        (_b = builtinExpression.validate) === null || _b === void 0 ? void 0 : _b.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+        assertNumberOfParams(builtinExpression.paramCount, node);
     }
     return node;
 }
@@ -7611,7 +7581,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 _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.polishParse, validateParameterCount = _b.validateParameterCount;
+    var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.polishParse, paramCount = _b.paramCount;
     var node = parse(tokenStream, parseState, firstToken, {
         parseExpression: parseExpression,
         parseTokensUntilClosingBracket: parseTokensUntilClosingBracket,
@@ -7620,7 +7590,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
-    validateParameterCount(node);
+    assertNumberOfParams(paramCount, node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7650,47 +7620,12 @@ function parsePolishToken(tokenStream, parseState) {
             return parseFnShorthand(tokenStream, parseState);
         case 'P_Comment':
             return parseComment(tokenStream, parseState);
-        case 'AlgNotation': {
-            parseState.position += 1;
-            parseState.algebraic = true;
-            var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-            var nodes = algebraicParser.parse();
-            assertEndNotationToken(tokenStream.tokens[parseState.position++]);
-            parseState.algebraic = false;
-            if (nodes.length === 1) {
-                return nodes[0];
-            }
-            return {
-                t: AstNodeType.SpecialExpression,
-                n: 'do',
-                p: nodes,
-                token: nodes[0].token,
-            };
-        }
-        case 'PolNotation': {
-            var astNodes = [];
-            parseState.position += 1;
-            do {
-                astNodes.push(parsePolishToken(tokenStream, parseState));
-            } while (!isEndNotationToken(asToken(tokenStream.tokens[parseState.position])));
-            parseState.position += 1;
-            if (astNodes.length === 1) {
-                return astNodes[0];
-            }
-            return {
-                t: AstNodeType.SpecialExpression,
-                n: 'do',
-                p: astNodes,
-                token: astNodes[0].token,
-            };
-        }
         case 'P_CollectionAccessor':
         case 'P_Modifier':
         case 'RParen':
         case 'RBracket':
         case 'RBrace':
         case 'P_Whitespace':
-        case 'EndNotation':
             break;
         /* v8 ignore next 2 */
         default:
@@ -7700,49 +7635,28 @@ function parsePolishToken(tokenStream, parseState) {
 }
 
 function parse(tokenStream) {
-    var _a;
-    var safeTokenStream = removeUnnecessaryTokens(tokenStream);
+    tokenStream = minifyTokenStream(tokenStream);
+    var algebraic = tokenStream.algebraic;
     var ast = {
         b: [],
-        hasDebugData: safeTokenStream.hasDebugData,
+        hasDebugData: tokenStream.hasDebugData,
     };
     var parseState = {
         position: 0,
-        algebraic: (_a = safeTokenStream.algebraic) !== null && _a !== void 0 ? _a : false,
         parseToken: parseToken,
     };
-    while (parseState.position < safeTokenStream.tokens.length) {
-        ast.b.push(parseToken(safeTokenStream, parseState));
+    if (algebraic) {
+        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
+        ast.b = algebraicParser.parse();
     }
-    return ast;
-}
-function removeUnnecessaryTokens(tokenStream) {
-    var tokens = tokenStream.tokens.filter(function (token) {
-        if (isP_CommentToken(token)
-            || isA_CommentToken(token)
-            || isA_MultiLineCommentToken(token)
-            || isA_WhitespaceToken(token)
-            || isP_WhitespaceToken(token)) {
-            return false;
+    else {
+        while (parseState.position < tokenStream.tokens.length) {
+            ast.b.push(parseToken(tokenStream, parseState));
         }
-        return true;
-    });
-    return __assign(__assign({}, tokenStream), { tokens: tokens });
+    }
+    return ast;
 }
 function parseToken(tokenStream, parseState) {
-    if (parseState.algebraic) {
-        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-        var nodes = algebraicParser.parse();
-        if (nodes.length === 1) {
-            return nodes[0];
-        }
-        return {
-            t: AstNodeType.SpecialExpression,
-            n: 'do',
-            p: nodes,
-            token: nodes[0].token,
-        };
-    }
     return parsePolishToken(tokenStream, parseState);
 }
 
@@ -7772,15 +7686,6 @@ var tokenizeLBrace = function (input, position) {
 var tokenizeRBrace = function (input, position) {
     return tokenizeSimpleToken('RBrace', '}', input, position);
 };
-var tokenizePolishNotation = function (input, position) {
-    return tokenizeSimpleToken('PolNotation', '$`', input, position);
-};
-var tokenizeAlgebraicNotation = function (input, position) {
-    return tokenizeSimpleToken('AlgNotation', '@`', input, position);
-};
-var tokenizeEndNotation = function (input, position) {
-    return tokenizeSimpleToken('EndNotation', '`', input, position);
-};
 var tokenizeString = function (input, position) {
     if (input[position] !== '"')
         return NO_MATCH;
@@ -7833,9 +7738,6 @@ function tokenizeSimpleToken(type, value, input, position) {
         return NO_MATCH;
 }
 var commonTokenizers = [
-    tokenizePolishNotation,
-    tokenizeAlgebraicNotation,
-    tokenizeEndNotation,
     tokenizeLParen,
     tokenizeRParen,
     tokenizeLBracket,
@@ -8345,7 +8247,6 @@ function getSugar() {
 
 function tokenize(input, params) {
     var debug = !!params.debug;
-    var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
     var position = 0;
     var tokenStream = {
         tokens: [],
@@ -8354,7 +8255,7 @@ function tokenize(input, params) {
         algebraic: !!params.algebraic,
     };
     while (position < input.length) {
-        var tokenizers = notationStack.at(-1) === 'algebraic' ? algebraicTokenizers : polishTokenizers;
+        var tokenizers = params.algebraic ? algebraicTokenizers : polishTokenizers;
         var tokenDescriptor = getCurrentToken(input, position, tokenizers);
         var debugData = debug
             ? {
@@ -8371,23 +8272,8 @@ function tokenize(input, params) {
                 addTokenDebugData(token, debugData);
             }
             tokenStream.tokens.push(token);
-            if (isAlgebraicNotationToken(token)) {
-                notationStack.push('algebraic');
-            }
-            if (isPolishNotationToken(token)) {
-                notationStack.push('polish');
-            }
-            if (isEndNotationToken(token)) {
-                notationStack.pop();
-                if (notationStack.length < 1) {
-                    throw new LitsError('Unexpected end directive `.', debugData === null || debugData === void 0 ? void 0 : debugData.sourceCodeInfo);
-                }
-            }
         }
     }
-    if (notationStack.length > 1) {
-        throw new LitsError('Missing end directive `.', createSourceCodeInfo(input, position, params.filePath));
-    }
     applySugar(tokenStream);
     return tokenStream;
 }
@@ -8472,9 +8358,6 @@ function untokenizeToken(token) {
         case 'RBracket': return ']';
         case 'LBrace': return '{';
         case 'RBrace': return '}';
-        case 'PolNotation': return '$`';
-        case 'AlgNotation': return '@`';
-        case 'EndNotation': return '`';
         case 'P_FnShorthand': return '#';
         /* v8 ignore next 2 */
         default:
@@ -8599,7 +8482,8 @@ var Lits = /** @class */ (function () {
         if (tokenizeParams === void 0) { tokenizeParams = {}; }
         var debug = this.debug;
         var algebraic = this.algebraic;
-        return tokenize(program, __assign(__assign({}, tokenizeParams), { debug: debug, algebraic: algebraic }));
+        var tokenStream = tokenize(program, __assign(__assign({}, tokenizeParams), { debug: debug, algebraic: algebraic }));
+        return tokenizeParams.minify ? minifyTokenStream(tokenStream) : tokenStream;
     };
     Lits.prototype.parse = function (tokenStream) {
         return parse(tokenStream);