@mojir/lits 2.0.19 → 2.0.21

package/dist/index.js

@@ -277,9 +277,6 @@ var commonSimpleTokenTypes = [
     'RBrace',
     'RBracket',
     'RParen',
-    'AlgNotation',
-    'PolNotation',
-    'EndNotation',
 ];
 var commomValueTokenTypes = [
     'String',
@@ -369,20 +366,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 = [
@@ -842,20 +825,6 @@ function withoutCommentNodes(astNodes) {
     return astNodes.filter(function (n) { return n.t !== exports.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({
@@ -887,9 +856,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);
         }
@@ -1026,7 +1003,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) {
@@ -1035,7 +1012,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) {
@@ -1044,7 +1021,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) {
@@ -1052,7 +1029,7 @@ var bitwiseNormalExpression = {
             assertNumber(num, sourceCodeInfo, { integer: true });
             return ~num;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '&': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1063,7 +1040,7 @@ var bitwiseNormalExpression = {
                 return result & value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '&!': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1074,7 +1051,7 @@ var bitwiseNormalExpression = {
                 return result & ~value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '|': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1085,7 +1062,7 @@ var bitwiseNormalExpression = {
                 return result | value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     '^': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1096,7 +1073,7 @@ var bitwiseNormalExpression = {
                 return result ^ value;
             }, first);
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     'bit_flip': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1106,7 +1083,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) {
@@ -1116,7 +1093,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) {
@@ -1126,7 +1103,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) {
@@ -1136,7 +1113,7 @@ var bitwiseNormalExpression = {
             var mask = 1 << index;
             return !!(num & mask);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -1518,7 +1495,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) {
@@ -1553,7 +1530,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) {
@@ -1567,7 +1544,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) {
@@ -1584,7 +1561,7 @@ var collectionNormalExpression = {
             }
             return !!Object.getOwnPropertyDescriptor(coll, key);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1605,7 +1582,7 @@ var collectionNormalExpression = {
             }
             return Object.values(coll).includes(value);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1665,7 +1642,7 @@ var collectionNormalExpression = {
             }
             return false;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1727,7 +1704,7 @@ var collectionNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'assoc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1737,7 +1714,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) {
@@ -1762,7 +1739,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'update': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1773,7 +1750,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) {
@@ -1799,7 +1776,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'concat': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1823,7 +1800,7 @@ var collectionNormalExpression = {
                 }, {});
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1837,7 +1814,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) {
@@ -1851,7 +1828,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) {
@@ -1865,7 +1842,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) {
@@ -1879,7 +1856,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) {
@@ -1893,13 +1870,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) {
@@ -1937,7 +1915,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) {
@@ -1948,7 +1926,7 @@ var arrayNormalExpression = {
                 result.push(value);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     flatten: {
         evaluate: function (_a) {
@@ -1957,7 +1935,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) {
@@ -1967,7 +1945,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,
     },
 };
 
@@ -1982,7 +1960,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) {
@@ -1997,7 +1975,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) {
@@ -2007,7 +1985,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[0]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2017,7 +1995,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) {
@@ -2039,7 +2017,7 @@ var sequenceNormalExpression = {
                     .join('');
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2050,7 +2028,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) {
@@ -2069,7 +2047,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2088,7 +2066,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'last_index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2107,7 +2085,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'push': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2121,7 +2099,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) {
@@ -2182,7 +2160,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) {
@@ -2229,7 +2207,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) {
@@ -2277,7 +2255,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2290,7 +2268,7 @@ var sequenceNormalExpression = {
             }
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2302,7 +2280,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) {
@@ -2317,7 +2295,7 @@ var sequenceNormalExpression = {
                 return null;
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2331,7 +2309,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) {
@@ -2343,7 +2321,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) {
@@ -2353,7 +2331,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return toAny(seq[1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'shift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2365,7 +2343,7 @@ var sequenceNormalExpression = {
             copy.shift();
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'slice': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2379,7 +2357,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) {
@@ -2396,7 +2374,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) {
@@ -2434,7 +2412,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) {
@@ -2485,7 +2463,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) {
@@ -2495,7 +2473,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) {
@@ -2506,7 +2484,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) {
@@ -2534,7 +2512,7 @@ var sequenceNormalExpression = {
             }
             return typeof seq === 'string' ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2544,7 +2522,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) {
@@ -2555,7 +2533,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) {
@@ -2571,7 +2549,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) {
@@ -2585,7 +2563,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) {
@@ -2595,7 +2573,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) {
@@ -2610,7 +2588,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) {
@@ -2627,7 +2605,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) {
@@ -2637,7 +2615,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) {
@@ -2652,7 +2630,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) {
@@ -2668,7 +2646,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2686,7 +2664,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'partition': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2698,7 +2676,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) {
@@ -2707,7 +2685,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) {
@@ -2728,7 +2706,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) {
@@ -2740,7 +2718,7 @@ var sequenceNormalExpression = {
             }
             return str.at(-1) === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'starts_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2752,7 +2730,7 @@ var sequenceNormalExpression = {
             }
             return str[0] === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'interleave': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2790,7 +2768,7 @@ var sequenceNormalExpression = {
             }
             return isStringSeq ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'interpose': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2809,7 +2787,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) {
@@ -2847,7 +2825,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'dec': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2855,7 +2833,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2864,6 +2842,7 @@ var mathNormalExpression = {
                 return result + param;
             }, 0);
         },
+        paramCount: {},
     },
     '*': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2872,6 +2851,7 @@ var mathNormalExpression = {
                 return result * param;
             }, 1);
         },
+        paramCount: {},
     },
     '/': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2888,6 +2868,7 @@ var mathNormalExpression = {
                 return result / param;
             }, first);
         },
+        paramCount: {},
     },
     '-': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2902,6 +2883,7 @@ var mathNormalExpression = {
                 return result - param;
             }, first);
         },
+        paramCount: {},
     },
     'quot': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2911,7 +2893,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) {
@@ -2921,7 +2903,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) {
@@ -2931,7 +2913,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) {
@@ -2939,7 +2921,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.sqrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cbrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2947,7 +2929,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.cbrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '**': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2956,7 +2938,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) {
@@ -2968,7 +2950,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) {
@@ -2976,7 +2958,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.trunc(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'floor': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2984,7 +2966,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.floor(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'ceil': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2992,7 +2974,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.ceil(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3005,7 +2987,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) {
@@ -3018,7 +3000,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) {
@@ -3026,7 +3008,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.abs(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sign': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3034,67 +3016,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) {
@@ -3102,7 +3084,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.exp(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3110,7 +3092,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log2': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3118,7 +3100,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log2(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log10': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3126,7 +3108,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log10(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3134,7 +3116,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3142,7 +3124,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3150,7 +3132,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3158,7 +3140,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3166,7 +3148,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3174,7 +3156,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3182,7 +3164,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3190,7 +3172,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3198,7 +3180,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3206,7 +3188,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3214,7 +3196,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3222,7 +3204,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3237,7 +3219,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '==': {
         evaluate: function (_a) {
@@ -3259,14 +3241,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) {
@@ -3290,7 +3272,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<': {
         evaluate: function (_a) {
@@ -3314,7 +3296,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>=': {
         evaluate: function (_a) {
@@ -3338,7 +3320,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<=': {
         evaluate: function (_a) {
@@ -3362,14 +3344,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) {
@@ -3377,7 +3359,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) {
@@ -3387,7 +3369,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo, { finite: true });
             return ms;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'write!': {
         evaluate: function (params, sourceCodeInfo) {
@@ -3397,20 +3379,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) {
@@ -3419,7 +3402,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) {
@@ -3430,7 +3413,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 },
     },
 };
 
@@ -3444,7 +3427,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) {
@@ -3454,7 +3437,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) {
@@ -3464,7 +3447,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) {
@@ -3475,7 +3458,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) {
@@ -3486,7 +3469,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) {
@@ -3496,7 +3479,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) {
@@ -3506,7 +3489,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) {
@@ -3516,7 +3499,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) {
@@ -3526,7 +3509,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) {
@@ -3536,7 +3519,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) {
@@ -3546,7 +3529,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) {
@@ -3556,7 +3539,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) {
@@ -3566,7 +3549,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) {
@@ -3576,7 +3559,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) {
@@ -3592,7 +3575,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) {
@@ -3613,7 +3596,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) {
@@ -3629,7 +3612,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
 
@@ -3645,7 +3628,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertEvenNumberOfParams(node); },
+        paramCount: { even: true },
     },
     keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3653,7 +3636,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.keys(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     vals: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3661,7 +3644,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.values(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     entries: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3669,7 +3652,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.entries(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     find: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3680,7 +3663,7 @@ var objectNormalExpression = {
                 return [key, obj[key]];
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     dissoc: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3691,7 +3674,7 @@ var objectNormalExpression = {
             delete newObj[key];
             return newObj;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     merge: {
         evaluate: function (params, sourceCodeInfo) {
@@ -3704,7 +3687,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) {
@@ -3727,7 +3710,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     zipmap: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3742,7 +3725,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     select_keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3755,7 +3738,7 @@ var objectNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
 
@@ -3765,42 +3748,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) {
@@ -3808,7 +3791,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) {
@@ -3816,7 +3799,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) {
@@ -3824,7 +3807,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) {
@@ -3832,7 +3815,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) {
@@ -3840,42 +3823,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) {
@@ -3883,7 +3866,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isFinite(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nan?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3891,7 +3874,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) {
@@ -3899,7 +3882,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) {
@@ -3907,21 +3890,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) {
@@ -3935,7 +3918,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) {
@@ -3949,7 +3932,7 @@ var predicatesNormalExpression = {
                 return coll.length > 0;
             return Object.keys(coll).length > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
 
@@ -3968,7 +3951,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) {
@@ -3982,7 +3965,7 @@ var regexpNormalExpression = {
                 return __spreadArray([], __read(match), false);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     replace: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3993,7 +3976,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) {
@@ -4004,7 +3987,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,
     },
 };
 
@@ -4020,7 +4003,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) {
@@ -4029,7 +4012,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) {
@@ -4044,6 +4027,7 @@ var stringNormalExpression = {
                 return result + paramStr;
             }, '');
         },
+        paramCount: {},
     },
     'number': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4054,7 +4038,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) {
@@ -4068,7 +4052,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'to_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4076,7 +4060,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) {
@@ -4084,7 +4068,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'upper_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4092,7 +4076,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toUpperCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4100,7 +4084,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.trim();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4108,7 +4092,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) {
@@ -4116,7 +4100,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/\s+$/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '++': {
         evaluate: function (params, sourceCodeInfo) {
@@ -4140,7 +4124,7 @@ var stringNormalExpression = {
                 return "".concat(acc).concat(str);
             }, first === null ? '' : "".concat(first));
         },
-        validate: function () { return undefined; },
+        paramCount: {},
     },
     'join': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4150,7 +4134,7 @@ var stringNormalExpression = {
             assertString(delimiter, sourceCodeInfo);
             return stringList.join(delimiter);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4164,7 +4148,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) {
@@ -4172,7 +4156,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) {
@@ -4183,7 +4167,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) {
@@ -4194,7 +4178,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) {
@@ -4225,7 +4209,7 @@ var stringNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+        paramCount: { min: 1, max: 10 },
     },
     'encode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4236,7 +4220,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) {
@@ -4254,7 +4238,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'encode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4262,7 +4246,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) {
@@ -4275,7 +4259,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'blank?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4286,7 +4270,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return blankRegexp.test(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'capitalize': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4294,7 +4278,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;
@@ -4325,14 +4309,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) {
@@ -4346,7 +4330,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     comp: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4364,6 +4348,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
+        paramCount: {},
     },
     constantly: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4376,7 +4361,7 @@ var functionalNormalExpression = {
                 _b.v = toAny(value),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     juxt: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4388,7 +4373,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     complement: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4401,7 +4386,7 @@ var functionalNormalExpression = {
                 _b.f = toAny(fn),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4413,7 +4398,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     some_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4425,7 +4410,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     fnil: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4439,7 +4424,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
 };
 
@@ -4458,7 +4443,7 @@ var andSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4502,14 +4487,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;
@@ -4539,7 +4524,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;
@@ -4570,7 +4555,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;
@@ -4618,7 +4603,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;
@@ -4643,7 +4628,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;
@@ -4715,7 +4700,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4754,7 +4739,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4979,7 +4964,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;
@@ -5003,7 +4988,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;
@@ -5040,7 +5025,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;
@@ -5095,7 +5080,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5361,7 +5346,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;
@@ -5383,7 +5368,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;
@@ -5396,7 +5381,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;
@@ -5426,7 +5411,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;
@@ -5458,7 +5443,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); });
@@ -5472,7 +5457,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;
@@ -5513,7 +5498,7 @@ var trySpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5950,8 +5935,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;
@@ -6157,6 +6143,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++]);
@@ -6346,7 +6346,6 @@ function getPrecedence(operatorSign) {
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    var _a;
     var node = {
         t: exports.AstNodeType.NormalExpression,
         n: name,
@@ -6355,7 +6354,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;
 }
@@ -6456,7 +6455,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;
             }
@@ -6464,9 +6463,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)) {
@@ -6502,6 +6502,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());
@@ -6539,7 +6542,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;
     };
@@ -6647,32 +6650,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: exports.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);
         }
@@ -6777,7 +6754,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':
@@ -6830,7 +6807,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();
@@ -6845,62 +6822,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: exports.AstNodeType.Binding,
-                    n: key.v,
-                    v: value,
-                    p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            }),
+            b: bindingNodess,
         };
         this.advance();
         return {
@@ -7350,6 +7319,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
+        assertA_OperatorToken(this.peek(), ';');
         var fnNode = {
             t: exports.AstNodeType.SpecialExpression,
             n: 'fn',
@@ -7512,7 +7482,7 @@ function parseObjectLitteral(tokenStream, parseState) {
         p: params,
         token: getTokenDebugData(firstToken) && firstToken,
     };
-    assertEvenNumberOfParams(node);
+    assertNumberOfParams({ even: true }, node);
     return node;
 }
 var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7618,7 +7588,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);
@@ -7642,7 +7612,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;
 }
@@ -7651,7 +7621,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,
@@ -7660,7 +7630,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
-    validateParameterCount(node);
+    assertNumberOfParams(paramCount, node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7690,47 +7660,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: exports.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: exports.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:
@@ -7740,49 +7675,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: exports.AstNodeType.SpecialExpression,
-            n: 'do',
-            p: nodes,
-            token: nodes[0].token,
-        };
-    }
     return parsePolishToken(tokenStream, parseState);
 }
 
@@ -7813,15 +7727,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;
@@ -7874,9 +7779,6 @@ function tokenizeSimpleToken(type, value, input, position) {
         return NO_MATCH;
 }
 var commonTokenizers = [
-    tokenizePolishNotation,
-    tokenizeAlgebraicNotation,
-    tokenizeEndNotation,
     tokenizeLParen,
     tokenizeRParen,
     tokenizeLBracket,
@@ -8386,7 +8288,6 @@ function getSugar() {
 
 function tokenize(input, params) {
     var debug = !!params.debug;
-    var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
     var position = 0;
     var tokenStream = {
         tokens: [],
@@ -8395,7 +8296,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
             ? {
@@ -8412,23 +8313,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;
 }
@@ -8513,9 +8399,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:
@@ -8640,7 +8523,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);