@mojir/lits 2.0.19 → 2.0.20

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.0.19";
+var version = "2.0.20";
 
 var AstNodeType;
 (function (AstNodeType) {
@@ -282,9 +282,6 @@ var commonSimpleTokenTypes = [
     'RBrace',
     'RBracket',
     'RParen',
-    'AlgNotation',
-    'PolNotation',
-    'EndNotation',
 ];
 var commomValueTokenTypes = [
     'String',
@@ -374,20 +371,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 = [
@@ -847,20 +830,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({
@@ -892,9 +861,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);
         }
@@ -1005,7 +982,7 @@ var bitwiseNormalExpression = {
             assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
             return num << count;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     '>>': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1014,7 +991,7 @@ var bitwiseNormalExpression = {
             assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
             return num >> count;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     '>>>': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1023,7 +1000,7 @@ var bitwiseNormalExpression = {
             assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
             return num >>> count;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     '~': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1031,7 +1008,7 @@ var bitwiseNormalExpression = {
             assertNumber(num, sourceCodeInfo, { integer: true });
             return ~num;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '&': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1042,7 +1019,7 @@ var bitwiseNormalExpression = {
                 return result & value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '&!': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1053,7 +1030,7 @@ var bitwiseNormalExpression = {
                 return result & ~value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '|': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1064,7 +1041,7 @@ var bitwiseNormalExpression = {
                 return result | value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '^': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1075,7 +1052,7 @@ var bitwiseNormalExpression = {
                 return result ^ value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     'bit_flip': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1085,7 +1062,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return (num ^= mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'bit_set': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1095,7 +1072,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return (num |= mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'bit_clear': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1105,7 +1082,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return (num &= ~mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'bit_test': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1115,7 +1092,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return !!(num & mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -1486,7 +1463,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) {
@@ -1521,7 +1498,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) {
@@ -1535,7 +1512,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) {
@@ -1552,7 +1529,7 @@ var collectionNormalExpression = {
             }
             return !!Object.getOwnPropertyDescriptor(coll, key);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1573,7 +1550,7 @@ var collectionNormalExpression = {
             }
             return Object.values(coll).includes(value);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1633,7 +1610,7 @@ var collectionNormalExpression = {
             }
             return false;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1695,7 +1672,7 @@ var collectionNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'assoc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1705,7 +1682,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) {
@@ -1730,7 +1707,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'update': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1741,7 +1718,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) {
@@ -1767,7 +1744,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'concat': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1791,7 +1768,7 @@ var collectionNormalExpression = {
                 }, {});
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1805,7 +1782,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) {
@@ -1819,7 +1796,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) {
@@ -1833,7 +1810,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) {
@@ -1847,7 +1824,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) {
@@ -1861,13 +1838,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) {
@@ -1905,7 +1883,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) {
@@ -1916,7 +1894,7 @@ var arrayNormalExpression = {
                 result.push(value);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     flatten: {
         evaluate: function (_a) {
@@ -1925,7 +1903,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) {
@@ -1935,7 +1913,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,
     },
 };
 
@@ -1950,7 +1928,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) {
@@ -1965,7 +1943,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) {
@@ -1975,7 +1953,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[0]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1985,7 +1963,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) {
@@ -2007,7 +1985,7 @@ var sequenceNormalExpression = {
                     .join('');
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2018,7 +1996,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) {
@@ -2037,7 +2015,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2056,7 +2034,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'last_index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2075,7 +2053,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'push': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2089,7 +2067,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) {
@@ -2150,7 +2128,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) {
@@ -2197,7 +2175,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) {
@@ -2245,7 +2223,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2258,7 +2236,7 @@ var sequenceNormalExpression = {
             }
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2270,7 +2248,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) {
@@ -2285,7 +2263,7 @@ var sequenceNormalExpression = {
                 return null;
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2299,7 +2277,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) {
@@ -2311,7 +2289,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) {
@@ -2321,7 +2299,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return toAny(seq[1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'shift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2333,7 +2311,7 @@ var sequenceNormalExpression = {
             copy.shift();
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'slice': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2347,7 +2325,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) {
@@ -2364,7 +2342,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) {
@@ -2402,7 +2380,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) {
@@ -2453,7 +2431,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) {
@@ -2463,7 +2441,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) {
@@ -2474,7 +2452,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) {
@@ -2502,7 +2480,7 @@ var sequenceNormalExpression = {
             }
             return typeof seq === 'string' ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2512,7 +2490,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) {
@@ -2523,7 +2501,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) {
@@ -2539,7 +2517,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) {
@@ -2553,7 +2531,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) {
@@ -2563,7 +2541,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) {
@@ -2578,7 +2556,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) {
@@ -2595,7 +2573,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) {
@@ -2605,7 +2583,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) {
@@ -2620,7 +2598,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) {
@@ -2636,7 +2614,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2654,7 +2632,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'partition': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2666,7 +2644,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) {
@@ -2675,7 +2653,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) {
@@ -2696,7 +2674,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) {
@@ -2708,7 +2686,7 @@ var sequenceNormalExpression = {
             }
             return str.at(-1) === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'starts_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2720,7 +2698,7 @@ var sequenceNormalExpression = {
             }
             return str[0] === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'interleave': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2758,7 +2736,7 @@ var sequenceNormalExpression = {
             }
             return isStringSeq ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'interpose': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2777,7 +2755,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) {
@@ -2815,7 +2793,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'dec': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2823,7 +2801,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2832,6 +2810,7 @@ var mathNormalExpression = {
                 return result + param;
             }, 0);
         },
+        paramCount: {},
     },
     '*': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2840,6 +2819,7 @@ var mathNormalExpression = {
                 return result * param;
             }, 1);
         },
+        paramCount: {},
     },
     '/': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2856,6 +2836,7 @@ var mathNormalExpression = {
                 return result / param;
             }, first);
         },
+        paramCount: {},
     },
     '-': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2870,6 +2851,7 @@ var mathNormalExpression = {
                 return result - param;
             }, first);
         },
+        paramCount: {},
     },
     'quot': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2879,7 +2861,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) {
@@ -2889,7 +2871,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) {
@@ -2899,7 +2881,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) {
@@ -2907,7 +2889,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.sqrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cbrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2915,7 +2897,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.cbrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '**': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2924,7 +2906,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) {
@@ -2936,7 +2918,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) {
@@ -2944,7 +2926,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.trunc(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'floor': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2952,7 +2934,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.floor(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'ceil': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2960,7 +2942,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.ceil(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2973,7 +2955,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) {
@@ -2986,7 +2968,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) {
@@ -2994,7 +2976,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.abs(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sign': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3002,67 +2984,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) {
@@ -3070,7 +3052,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.exp(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3078,7 +3060,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log2': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3086,7 +3068,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log2(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log10': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3094,7 +3076,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log10(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3102,7 +3084,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3110,7 +3092,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3118,7 +3100,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3126,7 +3108,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3134,7 +3116,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3142,7 +3124,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3150,7 +3132,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3158,7 +3140,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3166,7 +3148,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3174,7 +3156,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3182,7 +3164,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3190,7 +3172,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3205,7 +3187,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '==': {
         evaluate: function (_a) {
@@ -3227,14 +3209,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) {
@@ -3258,7 +3240,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<': {
         evaluate: function (_a) {
@@ -3282,7 +3264,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>=': {
         evaluate: function (_a) {
@@ -3306,7 +3288,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<=': {
         evaluate: function (_a) {
@@ -3330,14 +3312,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) {
@@ -3345,7 +3327,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) {
@@ -3355,7 +3337,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo, { finite: true });
             return ms;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'write!': {
         evaluate: function (params, sourceCodeInfo) {
@@ -3365,20 +3347,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) {
@@ -3387,7 +3370,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) {
@@ -3398,7 +3381,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 },
     },
 };
 
@@ -3412,7 +3395,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) {
@@ -3422,7 +3405,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) {
@@ -3432,7 +3415,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) {
@@ -3443,7 +3426,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) {
@@ -3454,7 +3437,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) {
@@ -3464,7 +3447,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) {
@@ -3474,7 +3457,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) {
@@ -3484,7 +3467,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) {
@@ -3494,7 +3477,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) {
@@ -3504,7 +3487,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) {
@@ -3514,7 +3497,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) {
@@ -3524,7 +3507,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) {
@@ -3534,7 +3517,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) {
@@ -3544,7 +3527,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) {
@@ -3560,7 +3543,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) {
@@ -3581,7 +3564,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) {
@@ -3597,7 +3580,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
 
@@ -3613,7 +3596,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertEvenNumberOfParams(node); },
+        paramCount: { even: true },
     },
     keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3621,7 +3604,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.keys(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     vals: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3629,7 +3612,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.values(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     entries: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3637,7 +3620,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.entries(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     find: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3648,7 +3631,7 @@ var objectNormalExpression = {
                 return [key, obj[key]];
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     dissoc: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3659,7 +3642,7 @@ var objectNormalExpression = {
             delete newObj[key];
             return newObj;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     merge: {
         evaluate: function (params, sourceCodeInfo) {
@@ -3672,7 +3655,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) {
@@ -3695,7 +3678,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     zipmap: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3710,7 +3693,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     select_keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3723,7 +3706,7 @@ var objectNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -3733,42 +3716,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) {
@@ -3776,7 +3759,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) {
@@ -3784,7 +3767,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) {
@@ -3792,7 +3775,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) {
@@ -3800,7 +3783,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) {
@@ -3808,42 +3791,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) {
@@ -3851,7 +3834,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isFinite(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nan?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3859,7 +3842,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) {
@@ -3867,7 +3850,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) {
@@ -3875,21 +3858,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) {
@@ -3903,7 +3886,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) {
@@ -3917,7 +3900,7 @@ var predicatesNormalExpression = {
                 return coll.length > 0;
             return Object.keys(coll).length > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3936,7 +3919,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) {
@@ -3950,7 +3933,7 @@ var regexpNormalExpression = {
                 return __spreadArray([], __read(match), false);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     replace: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3961,7 +3944,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) {
@@ -3972,7 +3955,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,
     },
 };
 
@@ -3988,7 +3971,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) {
@@ -3997,7 +3980,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) {
@@ -4012,6 +3995,7 @@ var stringNormalExpression = {
                 return result + paramStr;
             }, '');
         },
+        paramCount: {},
     },
     'number': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4022,7 +4006,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) {
@@ -4036,7 +4020,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'to_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4044,7 +4028,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) {
@@ -4052,7 +4036,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'upper_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4060,7 +4044,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toUpperCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4068,7 +4052,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.trim();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4076,7 +4060,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) {
@@ -4084,7 +4068,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/\s+$/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '++': {
         evaluate: function (params, sourceCodeInfo) {
@@ -4108,7 +4092,7 @@ var stringNormalExpression = {
                 return "".concat(acc).concat(str);
             }, first === null ? '' : "".concat(first));
         },
-        validate: function () { return undefined; },
+        paramCount: {},
     },
     'join': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4118,7 +4102,7 @@ var stringNormalExpression = {
             assertString(delimiter, sourceCodeInfo);
             return stringList.join(delimiter);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4132,7 +4116,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) {
@@ -4140,7 +4124,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) {
@@ -4151,7 +4135,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) {
@@ -4162,7 +4146,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) {
@@ -4193,7 +4177,7 @@ var stringNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+        paramCount: { min: 1, max: 10 },
     },
     'encode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4204,7 +4188,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) {
@@ -4222,7 +4206,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'encode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4230,7 +4214,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) {
@@ -4243,7 +4227,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'blank?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4254,7 +4238,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return blankRegexp.test(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'capitalize': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4262,7 +4246,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;
@@ -4293,14 +4277,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) {
@@ -4314,7 +4298,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     comp: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4332,6 +4316,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
+        paramCount: {},
     },
     constantly: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4344,7 +4329,7 @@ var functionalNormalExpression = {
                 _b.v = toAny(value),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     juxt: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4356,7 +4341,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     complement: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4369,7 +4354,7 @@ var functionalNormalExpression = {
                 _b.f = toAny(fn),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4381,7 +4366,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     some_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4393,7 +4378,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     fnil: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4407,7 +4392,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
 };
 
@@ -4426,7 +4411,7 @@ var andSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4470,14 +4455,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;
@@ -4507,7 +4492,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;
@@ -4538,7 +4523,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;
@@ -4586,7 +4571,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;
@@ -4611,7 +4596,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;
@@ -4683,7 +4668,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4722,7 +4707,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4947,7 +4932,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;
@@ -4971,7 +4956,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;
@@ -5008,7 +4993,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;
@@ -5063,7 +5048,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5329,7 +5314,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;
@@ -5351,7 +5336,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;
@@ -5364,7 +5349,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;
@@ -5394,7 +5379,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;
@@ -5426,7 +5411,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); });
@@ -5440,7 +5425,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;
@@ -5481,7 +5466,7 @@ var trySpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5918,8 +5903,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;
@@ -6314,7 +6300,6 @@ function getPrecedence(operatorSign) {
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    var _a;
     var node = {
         t: AstNodeType.NormalExpression,
         n: name,
@@ -6323,7 +6308,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;
 }
@@ -6424,7 +6409,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;
             }
@@ -6432,9 +6417,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)) {
@@ -6470,6 +6456,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());
@@ -6507,7 +6496,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;
     };
@@ -6615,32 +6604,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);
         }
@@ -6745,7 +6708,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':
@@ -6798,7 +6761,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();
@@ -6813,62 +6776,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;
             }
-            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);
+            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 (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 {
@@ -7318,6 +7273,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
+        assertA_OperatorToken(this.peek(), ';');
         var fnNode = {
             t: AstNodeType.SpecialExpression,
             n: 'fn',
@@ -7480,7 +7436,7 @@ function parseObjectLitteral(tokenStream, parseState) {
         p: params,
         token: getTokenDebugData(firstToken) && firstToken,
     };
-    assertEvenNumberOfParams(node);
+    assertNumberOfParams({ even: true }, node);
     return node;
 }
 var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7586,7 +7542,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);
@@ -7610,7 +7566,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;
 }
@@ -7619,7 +7575,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,
@@ -7628,7 +7584,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
-    validateParameterCount(node);
+    assertNumberOfParams(paramCount, node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7658,47 +7614,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:
@@ -7708,19 +7629,24 @@ function parsePolishToken(tokenStream, parseState) {
 }
 
 function parse(tokenStream) {
-    var _a;
-    var safeTokenStream = removeUnnecessaryTokens(tokenStream);
+    tokenStream = removeUnnecessaryTokens(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();
+    }
+    else {
+        while (parseState.position < tokenStream.tokens.length) {
+            ast.b.push(parseToken(tokenStream, parseState));
+        }
     }
     return ast;
 }
@@ -7738,19 +7664,6 @@ function removeUnnecessaryTokens(tokenStream) {
     return __assign(__assign({}, tokenStream), { tokens: tokens });
 }
 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);
 }
 
@@ -7781,15 +7694,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;
@@ -7842,9 +7746,6 @@ function tokenizeSimpleToken(type, value, input, position) {
         return NO_MATCH;
 }
 var commonTokenizers = [
-    tokenizePolishNotation,
-    tokenizeAlgebraicNotation,
-    tokenizeEndNotation,
     tokenizeLParen,
     tokenizeRParen,
     tokenizeLBracket,
@@ -8354,7 +8255,6 @@ function getSugar() {
 
 function tokenize(input, params) {
     var debug = !!params.debug;
-    var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
     var position = 0;
     var tokenStream = {
         tokens: [],
@@ -8363,7 +8263,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
             ? {
@@ -8380,23 +8280,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;
 }
@@ -8481,9 +8366,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: