@mojir/lits 2.0.19 → 2.0.21

package/dist/index.esm.js

@@ -275,9 +275,6 @@ var commonSimpleTokenTypes = [
     'RBrace',
     'RBracket',
     'RParen',
-    'AlgNotation',
-    'PolNotation',
-    'EndNotation',
 ];
 var commomValueTokenTypes = [
     'String',
@@ -367,20 +364,6 @@ function asRegexpShorthandToken(token) {
     assertRegexpShorthandToken(token);
     return token;
 }
-function isAlgebraicNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'AlgNotation';
-}
-function isPolishNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'PolNotation';
-}
-function isEndNotationToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'EndNotation';
-}
-function assertEndNotationToken(token) {
-    if (!isEndNotationToken(token)) {
-        throwUnexpectedToken('EndNotation', undefined, token);
-    }
-}
 
 var algebraicSimpleTokenTypes = __spreadArray([], __read(commonSimpleTokenTypes), false);
 var algebraicOnlyValueTokenTypes = [
@@ -840,20 +823,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({
@@ -885,9 +854,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);
         }
@@ -1024,7 +1001,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) {
@@ -1033,7 +1010,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) {
@@ -1042,7 +1019,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) {
@@ -1050,7 +1027,7 @@ var bitwiseNormalExpression = {
             assertNumber(num, sourceCodeInfo, { integer: true });
             return ~num;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '&': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1061,7 +1038,7 @@ var bitwiseNormalExpression = {
                 return result & value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '&!': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1072,7 +1049,7 @@ var bitwiseNormalExpression = {
                 return result & ~value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '|': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1083,7 +1060,7 @@ var bitwiseNormalExpression = {
                 return result | value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '^': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1094,7 +1071,7 @@ var bitwiseNormalExpression = {
                 return result ^ value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     'bit_flip': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1104,7 +1081,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) {
@@ -1114,7 +1091,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) {
@@ -1124,7 +1101,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) {
@@ -1134,7 +1111,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return !!(num & mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -1516,7 +1493,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) {
@@ -1551,7 +1528,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) {
@@ -1565,7 +1542,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) {
@@ -1582,7 +1559,7 @@ var collectionNormalExpression = {
             }
             return !!Object.getOwnPropertyDescriptor(coll, key);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1603,7 +1580,7 @@ var collectionNormalExpression = {
             }
             return Object.values(coll).includes(value);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1663,7 +1640,7 @@ var collectionNormalExpression = {
             }
             return false;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1725,7 +1702,7 @@ var collectionNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'assoc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1735,7 +1712,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) {
@@ -1760,7 +1737,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'update': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1771,7 +1748,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) {
@@ -1797,7 +1774,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'concat': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1821,7 +1798,7 @@ var collectionNormalExpression = {
                 }, {});
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1835,7 +1812,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) {
@@ -1849,7 +1826,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) {
@@ -1863,7 +1840,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) {
@@ -1877,7 +1854,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) {
@@ -1891,13 +1868,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) {
@@ -1935,7 +1913,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) {
@@ -1946,7 +1924,7 @@ var arrayNormalExpression = {
                 result.push(value);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     flatten: {
         evaluate: function (_a) {
@@ -1955,7 +1933,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) {
@@ -1965,7 +1943,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,
     },
 };
 
@@ -1980,7 +1958,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) {
@@ -1995,7 +1973,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) {
@@ -2005,7 +1983,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[0]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2015,7 +1993,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) {
@@ -2037,7 +2015,7 @@ var sequenceNormalExpression = {
                     .join('');
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2048,7 +2026,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) {
@@ -2067,7 +2045,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2086,7 +2064,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'last_index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2105,7 +2083,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'push': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2119,7 +2097,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) {
@@ -2180,7 +2158,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) {
@@ -2227,7 +2205,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) {
@@ -2275,7 +2253,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2288,7 +2266,7 @@ var sequenceNormalExpression = {
             }
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2300,7 +2278,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) {
@@ -2315,7 +2293,7 @@ var sequenceNormalExpression = {
                 return null;
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2329,7 +2307,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) {
@@ -2341,7 +2319,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) {
@@ -2351,7 +2329,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return toAny(seq[1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'shift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2363,7 +2341,7 @@ var sequenceNormalExpression = {
             copy.shift();
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'slice': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2377,7 +2355,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) {
@@ -2394,7 +2372,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) {
@@ -2432,7 +2410,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) {
@@ -2483,7 +2461,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) {
@@ -2493,7 +2471,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) {
@@ -2504,7 +2482,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) {
@@ -2532,7 +2510,7 @@ var sequenceNormalExpression = {
             }
             return typeof seq === 'string' ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2542,7 +2520,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) {
@@ -2553,7 +2531,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) {
@@ -2569,7 +2547,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) {
@@ -2583,7 +2561,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) {
@@ -2593,7 +2571,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) {
@@ -2608,7 +2586,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) {
@@ -2625,7 +2603,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) {
@@ -2635,7 +2613,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) {
@@ -2650,7 +2628,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) {
@@ -2666,7 +2644,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2684,7 +2662,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'partition': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2696,7 +2674,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) {
@@ -2705,7 +2683,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) {
@@ -2726,7 +2704,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) {
@@ -2738,7 +2716,7 @@ var sequenceNormalExpression = {
             }
             return str.at(-1) === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'starts_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2750,7 +2728,7 @@ var sequenceNormalExpression = {
             }
             return str[0] === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'interleave': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2788,7 +2766,7 @@ var sequenceNormalExpression = {
             }
             return isStringSeq ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'interpose': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2807,7 +2785,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) {
@@ -2845,7 +2823,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'dec': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2853,7 +2831,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2862,6 +2840,7 @@ var mathNormalExpression = {
                 return result + param;
             }, 0);
         },
+        paramCount: {},
     },
     '*': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2870,6 +2849,7 @@ var mathNormalExpression = {
                 return result * param;
             }, 1);
         },
+        paramCount: {},
     },
     '/': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2886,6 +2866,7 @@ var mathNormalExpression = {
                 return result / param;
             }, first);
         },
+        paramCount: {},
     },
     '-': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2900,6 +2881,7 @@ var mathNormalExpression = {
                 return result - param;
             }, first);
         },
+        paramCount: {},
     },
     'quot': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2909,7 +2891,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) {
@@ -2919,7 +2901,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) {
@@ -2929,7 +2911,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) {
@@ -2937,7 +2919,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.sqrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cbrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2945,7 +2927,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.cbrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '**': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2954,7 +2936,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) {
@@ -2966,7 +2948,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) {
@@ -2974,7 +2956,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.trunc(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'floor': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2982,7 +2964,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.floor(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'ceil': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2990,7 +2972,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.ceil(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3003,7 +2985,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) {
@@ -3016,7 +2998,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) {
@@ -3024,7 +3006,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.abs(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sign': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3032,67 +3014,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) {
@@ -3100,7 +3082,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.exp(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3108,7 +3090,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log2': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3116,7 +3098,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log2(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log10': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3124,7 +3106,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log10(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3132,7 +3114,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3140,7 +3122,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3148,7 +3130,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3156,7 +3138,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3164,7 +3146,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3172,7 +3154,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3180,7 +3162,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3188,7 +3170,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3196,7 +3178,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3204,7 +3186,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3212,7 +3194,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3220,7 +3202,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3235,7 +3217,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '==': {
         evaluate: function (_a) {
@@ -3257,14 +3239,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) {
@@ -3288,7 +3270,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<': {
         evaluate: function (_a) {
@@ -3312,7 +3294,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>=': {
         evaluate: function (_a) {
@@ -3336,7 +3318,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<=': {
         evaluate: function (_a) {
@@ -3360,14 +3342,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) {
@@ -3375,7 +3357,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) {
@@ -3385,7 +3367,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo, { finite: true });
             return ms;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'write!': {
         evaluate: function (params, sourceCodeInfo) {
@@ -3395,20 +3377,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) {
@@ -3417,7 +3400,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) {
@@ -3428,7 +3411,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 },
     },
 };
 
@@ -3442,7 +3425,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) {
@@ -3452,7 +3435,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) {
@@ -3462,7 +3445,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) {
@@ -3473,7 +3456,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) {
@@ -3484,7 +3467,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) {
@@ -3494,7 +3477,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) {
@@ -3504,7 +3487,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) {
@@ -3514,7 +3497,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) {
@@ -3524,7 +3507,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) {
@@ -3534,7 +3517,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) {
@@ -3544,7 +3527,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) {
@@ -3554,7 +3537,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) {
@@ -3564,7 +3547,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) {
@@ -3574,7 +3557,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) {
@@ -3590,7 +3573,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) {
@@ -3611,7 +3594,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) {
@@ -3627,7 +3610,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
 
@@ -3643,7 +3626,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertEvenNumberOfParams(node); },
+        paramCount: { even: true },
     },
     keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3651,7 +3634,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.keys(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     vals: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3659,7 +3642,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.values(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     entries: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3667,7 +3650,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.entries(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     find: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3678,7 +3661,7 @@ var objectNormalExpression = {
                 return [key, obj[key]];
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     dissoc: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3689,7 +3672,7 @@ var objectNormalExpression = {
             delete newObj[key];
             return newObj;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     merge: {
         evaluate: function (params, sourceCodeInfo) {
@@ -3702,7 +3685,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) {
@@ -3725,7 +3708,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     zipmap: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3740,7 +3723,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     select_keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3753,7 +3736,7 @@ var objectNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -3763,42 +3746,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) {
@@ -3806,7 +3789,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) {
@@ -3814,7 +3797,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) {
@@ -3822,7 +3805,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) {
@@ -3830,7 +3813,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) {
@@ -3838,42 +3821,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) {
@@ -3881,7 +3864,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isFinite(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nan?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3889,7 +3872,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) {
@@ -3897,7 +3880,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) {
@@ -3905,21 +3888,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) {
@@ -3933,7 +3916,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) {
@@ -3947,7 +3930,7 @@ var predicatesNormalExpression = {
                 return coll.length > 0;
             return Object.keys(coll).length > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3966,7 +3949,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) {
@@ -3980,7 +3963,7 @@ var regexpNormalExpression = {
                 return __spreadArray([], __read(match), false);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     replace: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3991,7 +3974,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) {
@@ -4002,7 +3985,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,
     },
 };
 
@@ -4018,7 +4001,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) {
@@ -4027,7 +4010,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) {
@@ -4042,6 +4025,7 @@ var stringNormalExpression = {
                 return result + paramStr;
             }, '');
         },
+        paramCount: {},
     },
     'number': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4052,7 +4036,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) {
@@ -4066,7 +4050,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'to_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4074,7 +4058,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) {
@@ -4082,7 +4066,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'upper_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4090,7 +4074,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toUpperCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4098,7 +4082,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.trim();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4106,7 +4090,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) {
@@ -4114,7 +4098,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/\s+$/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '++': {
         evaluate: function (params, sourceCodeInfo) {
@@ -4138,7 +4122,7 @@ var stringNormalExpression = {
                 return "".concat(acc).concat(str);
             }, first === null ? '' : "".concat(first));
         },
-        validate: function () { return undefined; },
+        paramCount: {},
     },
     'join': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4148,7 +4132,7 @@ var stringNormalExpression = {
             assertString(delimiter, sourceCodeInfo);
             return stringList.join(delimiter);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4162,7 +4146,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) {
@@ -4170,7 +4154,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) {
@@ -4181,7 +4165,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) {
@@ -4192,7 +4176,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) {
@@ -4223,7 +4207,7 @@ var stringNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+        paramCount: { min: 1, max: 10 },
     },
     'encode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4234,7 +4218,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) {
@@ -4252,7 +4236,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'encode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4260,7 +4244,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) {
@@ -4273,7 +4257,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'blank?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4284,7 +4268,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return blankRegexp.test(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'capitalize': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4292,7 +4276,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;
@@ -4323,14 +4307,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) {
@@ -4344,7 +4328,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     comp: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4362,6 +4346,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
+        paramCount: {},
     },
     constantly: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4374,7 +4359,7 @@ var functionalNormalExpression = {
                 _b.v = toAny(value),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     juxt: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4386,7 +4371,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     complement: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4399,7 +4384,7 @@ var functionalNormalExpression = {
                 _b.f = toAny(fn),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4411,7 +4396,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     some_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4423,7 +4408,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     fnil: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4437,7 +4422,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
 };
 
@@ -4456,7 +4441,7 @@ var andSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4500,14 +4485,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;
@@ -4537,7 +4522,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;
@@ -4568,7 +4553,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;
@@ -4616,7 +4601,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;
@@ -4641,7 +4626,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;
@@ -4713,7 +4698,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4752,7 +4737,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4977,7 +4962,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;
@@ -5001,7 +4986,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;
@@ -5038,7 +5023,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;
@@ -5093,7 +5078,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5359,7 +5344,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;
@@ -5381,7 +5366,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;
@@ -5394,7 +5379,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;
@@ -5424,7 +5409,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;
@@ -5456,7 +5441,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); });
@@ -5470,7 +5455,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;
@@ -5511,7 +5496,7 @@ var trySpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5948,8 +5933,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;
@@ -6155,6 +6141,20 @@ function analyze(ast, params) {
     };
 }
 
+function minifyTokenStream(tokenStream) {
+    var tokens = tokenStream.tokens.filter(function (token) {
+        if (isP_CommentToken(token)
+            || isA_CommentToken(token)
+            || isA_MultiLineCommentToken(token)
+            || isA_WhitespaceToken(token)
+            || isP_WhitespaceToken(token)) {
+            return false;
+        }
+        return true;
+    });
+    return __assign(__assign({}, tokenStream), { tokens: tokens });
+}
+
 function parseSymbol(tokenStream, parseState) {
     var _a;
     var tkn = asToken(tokenStream.tokens[parseState.position++]);
@@ -6344,7 +6344,6 @@ function getPrecedence(operatorSign) {
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    var _a;
     var node = {
         t: AstNodeType.NormalExpression,
         n: name,
@@ -6353,7 +6352,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;
 }
@@ -6454,7 +6453,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;
             }
@@ -6462,9 +6461,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)) {
@@ -6500,6 +6500,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());
@@ -6537,7 +6540,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;
     };
@@ -6645,32 +6648,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);
         }
@@ -6775,7 +6752,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':
@@ -6828,7 +6805,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();
@@ -6843,62 +6820,54 @@ var AlgebraicParser = /** @class */ (function () {
         }
         this.advance();
         var rest = false;
-        var letBindingObject;
         var args = [];
         var restArg;
-        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (letBindingObject) {
-                throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-            }
-            if (isLBraceToken(this.peek())) {
-                letBindingObject = this.parseObject();
-            }
-            else {
-                if (isA_OperatorToken(this.peek(), '...')) {
-                    if (rest) {
-                        throw new LitsError('Multiple spread operators in lambda function', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-                    }
-                    this.advance();
-                    rest = true;
-                }
-                var symbolToken = this.peek();
-                if (!isA_SymbolToken(symbolToken)) {
-                    throw new LitsError('Expected symbol', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-                }
+        while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+            if (isA_OperatorToken(this.peek(), '...')) {
                 if (rest) {
-                    restArg = symbolToken[1];
-                }
-                else {
-                    args.push(symbolToken[1]);
+                    throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
                 }
                 this.advance();
+                rest = true;
+            }
+            var symbolToken = this.peek();
+            if (!isA_SymbolToken(symbolToken)) {
+                throw new LitsError('Expected symbol', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
             }
-            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
-                throw new LitsError('Expected comma or closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+            if (rest) {
+                restArg = symbolToken[1];
+            }
+            else {
+                args.push(symbolToken[1]);
+            }
+            this.advance();
+            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+                throw new LitsError('Expected comma or closing parenthesis', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
             }
             if (isA_OperatorToken(this.peek(), ',')) {
                 this.advance();
             }
         }
         var arity = restArg !== undefined ? { min: args.length } : args.length;
+        // let bindings, to be able to pass on values in the context down to the body
+        // This is needed since lits is dynamically scoped
+        // E.g.
+        // x => y => x + y // would not work, x is not available in the second lambda
+        // x => (y, let x = x) => x + y // would work, x is available in the second lambda
+        var bindingNodess = [];
+        var token = this.peek();
+        while (isA_SymbolToken(token, 'let')) {
+            var letNode = this.parseLet(token, true);
+            bindingNodess.push(letNode.bs[0]);
+            token = this.peek();
+        }
         if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
+            throw new LitsError('Expected closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
         }
-        var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
         var functionArguments = {
             m: args,
             r: restArg,
-            b: letBindings.map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
-                    t: AstNodeType.Binding,
-                    n: key.v,
-                    v: value,
-                    p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            }),
+            b: bindingNodess,
         };
         this.advance();
         return {
@@ -7348,6 +7317,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
+        assertA_OperatorToken(this.peek(), ';');
         var fnNode = {
             t: AstNodeType.SpecialExpression,
             n: 'fn',
@@ -7510,7 +7480,7 @@ function parseObjectLitteral(tokenStream, parseState) {
         p: params,
         token: getTokenDebugData(firstToken) && firstToken,
     };
-    assertEvenNumberOfParams(node);
+    assertNumberOfParams({ even: true }, node);
     return node;
 }
 var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7616,7 +7586,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);
@@ -7640,7 +7610,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;
 }
@@ -7649,7 +7619,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,
@@ -7658,7 +7628,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
-    validateParameterCount(node);
+    assertNumberOfParams(paramCount, node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7688,47 +7658,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:
@@ -7738,49 +7673,28 @@ function parsePolishToken(tokenStream, parseState) {
 }
 
 function parse(tokenStream) {
-    var _a;
-    var safeTokenStream = removeUnnecessaryTokens(tokenStream);
+    tokenStream = minifyTokenStream(tokenStream);
+    var algebraic = tokenStream.algebraic;
     var ast = {
         b: [],
-        hasDebugData: safeTokenStream.hasDebugData,
+        hasDebugData: tokenStream.hasDebugData,
     };
     var parseState = {
         position: 0,
-        algebraic: (_a = safeTokenStream.algebraic) !== null && _a !== void 0 ? _a : false,
         parseToken: parseToken,
     };
-    while (parseState.position < safeTokenStream.tokens.length) {
-        ast.b.push(parseToken(safeTokenStream, parseState));
+    if (algebraic) {
+        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
+        ast.b = algebraicParser.parse();
     }
-    return ast;
-}
-function removeUnnecessaryTokens(tokenStream) {
-    var tokens = tokenStream.tokens.filter(function (token) {
-        if (isP_CommentToken(token)
-            || isA_CommentToken(token)
-            || isA_MultiLineCommentToken(token)
-            || isA_WhitespaceToken(token)
-            || isP_WhitespaceToken(token)) {
-            return false;
+    else {
+        while (parseState.position < tokenStream.tokens.length) {
+            ast.b.push(parseToken(tokenStream, parseState));
         }
-        return true;
-    });
-    return __assign(__assign({}, tokenStream), { tokens: tokens });
+    }
+    return ast;
 }
 function parseToken(tokenStream, parseState) {
-    if (parseState.algebraic) {
-        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-        var nodes = algebraicParser.parse();
-        if (nodes.length === 1) {
-            return nodes[0];
-        }
-        return {
-            t: AstNodeType.SpecialExpression,
-            n: 'do',
-            p: nodes,
-            token: nodes[0].token,
-        };
-    }
     return parsePolishToken(tokenStream, parseState);
 }
 
@@ -7811,15 +7725,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;
@@ -7872,9 +7777,6 @@ function tokenizeSimpleToken(type, value, input, position) {
         return NO_MATCH;
 }
 var commonTokenizers = [
-    tokenizePolishNotation,
-    tokenizeAlgebraicNotation,
-    tokenizeEndNotation,
     tokenizeLParen,
     tokenizeRParen,
     tokenizeLBracket,
@@ -8384,7 +8286,6 @@ function getSugar() {
 
 function tokenize(input, params) {
     var debug = !!params.debug;
-    var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
     var position = 0;
     var tokenStream = {
         tokens: [],
@@ -8393,7 +8294,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
             ? {
@@ -8410,23 +8311,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;
 }
@@ -8511,9 +8397,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:
@@ -8638,7 +8521,8 @@ var Lits = /** @class */ (function () {
         if (tokenizeParams === void 0) { tokenizeParams = {}; }
         var debug = this.debug;
         var algebraic = this.algebraic;
-        return tokenize(program, __assign(__assign({}, tokenizeParams), { debug: debug, algebraic: algebraic }));
+        var tokenStream = tokenize(program, __assign(__assign({}, tokenizeParams), { debug: debug, algebraic: algebraic }));
+        return tokenizeParams.minify ? minifyTokenStream(tokenStream) : tokenStream;
     };
     Lits.prototype.parse = function (tokenStream) {
         return parse(tokenStream);