npm - @mojir/lits - Versions diffs - 2.0.19 → 2.0.21 - Mend

@mojir/lits 2.0.19 → 2.0.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/dist/cli/cli.js +339 -455
package/dist/cli/src/Lits/Lits.d.ts +3 -1
package/dist/cli/src/builtin/interface.d.ts +9 -5
package/dist/cli/src/parser/index.d.ts +1 -2
package/dist/cli/src/parser/interface.d.ts +0 -1
package/dist/cli/src/tokenizer/algebraic/algebraicTokenizers.d.ts +1 -1
package/dist/cli/src/tokenizer/algebraic/algebraicTokens.d.ts +2 -2
package/dist/cli/src/tokenizer/common/commonTokenizers.d.ts +2 -2
package/dist/cli/src/tokenizer/common/commonTokens.d.ts +2 -14
package/dist/cli/src/tokenizer/minifyTokenStream.d.ts +2 -0
package/dist/cli/src/tokenizer/polish/polishTokenizers.d.ts +1 -1
package/dist/cli/src/tokenizer/polish/polishTokens.d.ts +2 -2
package/dist/cli/src/tokenizer/tokens.d.ts +2 -2
package/dist/cli/src/typeGuards/index.d.ts +1 -7
package/dist/index.esm.js +338 -454
package/dist/index.esm.js.map +1 -1
package/dist/index.js +338 -454
package/dist/index.js.map +1 -1
package/dist/lits.iife.js +338 -454
package/dist/lits.iife.js.map +1 -1
package/dist/src/Lits/Lits.d.ts +3 -1
package/dist/src/builtin/interface.d.ts +9 -5
package/dist/src/parser/index.d.ts +1 -2
package/dist/src/parser/interface.d.ts +0 -1
package/dist/src/tokenizer/algebraic/algebraicTokenizers.d.ts +1 -1
package/dist/src/tokenizer/algebraic/algebraicTokens.d.ts +2 -2
package/dist/src/tokenizer/common/commonTokenizers.d.ts +2 -2
package/dist/src/tokenizer/common/commonTokens.d.ts +2 -14
package/dist/src/tokenizer/minifyTokenStream.d.ts +2 -0
package/dist/src/tokenizer/polish/polishTokenizers.d.ts +1 -1
package/dist/src/tokenizer/polish/polishTokens.d.ts +2 -2
package/dist/src/tokenizer/tokens.d.ts +2 -2
package/dist/src/typeGuards/index.d.ts +1 -7
package/dist/testFramework.esm.js +448 -564
package/dist/testFramework.esm.js.map +1 -1
package/dist/testFramework.js +448 -564
package/dist/testFramework.js.map +1 -1
package/package.json +1 -1

package/dist/testFramework.js CHANGED Viewed

@@ -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 = [
@@ -771,6 +754,128 @@ function asNumber(value, sourceCodeInfo, options) {
     return value;
 }
+var bitwiseNormalExpression = {
+    '<<': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num << count;
+        },
+        paramCount: 2,
+    },
+    '>>': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num >> count;
+        },
+        paramCount: 2,
+    },
+    '>>>': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], count = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            return num >>> count;
+        },
+        paramCount: 2,
+    },
+    '~': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), num = _b[0];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            return ~num;
+        },
+        paramCount: 1,
+    },
+    '&': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result & value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '&!': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result & ~value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '|': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result | value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    '^': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
+            assertNumber(first, sourceCodeInfo, { integer: true });
+            return rest.reduce(function (result, value) {
+                assertNumber(value, sourceCodeInfo, { integer: true });
+                return result ^ value;
+            }, first);
+        },
+        paramCount: { min: 2 },
+    },
+    'bit_flip': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num ^= mask);
+        },
+        paramCount: 2,
+    },
+    'bit_set': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num |= mask);
+        },
+        paramCount: 2,
+    },
+    'bit_clear': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return (num &= ~mask);
+        },
+        paramCount: 2,
+    },
+    'bit_test': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), num = _b[0], index = _b[1];
+            assertNumber(num, sourceCodeInfo, { integer: true });
+            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
+            var mask = 1 << index;
+            return !!(num & mask);
+        },
+        paramCount: 2,
+    },
+};
 function getAssertionError(typeName, value, sourceCodeInfo) {
     return new LitsError("Expected ".concat(typeName, ", got ").concat(valueToString(value), "."), getSourceCodeInfo(value, sourceCodeInfo));
 }
@@ -922,20 +1027,6 @@ function withoutCommentNodes(astNodes) {
     return astNodes.filter(function (n) { return n.t !== AstNodeType.Comment; });
 }
-function assertEvenNumberOfParams(node) {
-    var _a;
-    var length = withoutCommentNodes(node.p).length;
-    if (length % 2 !== 0) {
-        throw new LitsError("Wrong number of arguments, expected an even number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-    }
-}
-function assertOddNumberOfParams(node) {
-    var _a;
-    var length = withoutCommentNodes(node.p).length;
-    if (length % 2 !== 1) {
-        throw new LitsError("Wrong number of arguments, expected an odd number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-    }
-}
 function assertNumberOfParams(count, node) {
     var _a, _b;
     assertCount({
@@ -967,9 +1058,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);
         }
@@ -979,128 +1078,6 @@ function assertCount(_a) {
     }
 }
-var bitwiseNormalExpression = {
-    '<<': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num << count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '>>': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num >> count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '>>>': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], count = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            return num >>> count;
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    '~': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), num = _b[0];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            return ~num;
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    '&': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result & value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '&!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result & ~value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '|': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result | value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    '^': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a), first = _b[0], rest = _b.slice(1);
-            assertNumber(first, sourceCodeInfo, { integer: true });
-            return rest.reduce(function (result, value) {
-                assertNumber(value, sourceCodeInfo, { integer: true });
-                return result ^ value;
-            }, first);
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
-    },
-    'bit_flip': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num ^= mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_set': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num |= mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_clear': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return (num &= ~mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'bit_test': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), num = _b[0], index = _b[1];
-            assertNumber(num, sourceCodeInfo, { integer: true });
-            assertNumber(index, sourceCodeInfo, { integer: true, nonNegative: true });
-            var mask = 1 << index;
-            return !!(num & mask);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-};
 function isLitsFunction(value) {
     if (value === null || typeof value !== 'object')
         return false;
@@ -1481,7 +1458,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) {
@@ -1516,7 +1493,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) {
@@ -1530,7 +1507,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) {
@@ -1547,7 +1524,7 @@ var collectionNormalExpression = {
             }
             return !!Object.getOwnPropertyDescriptor(coll, key);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1568,7 +1545,7 @@ var collectionNormalExpression = {
             }
             return Object.values(coll).includes(value);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1628,7 +1605,7 @@ var collectionNormalExpression = {
             }
             return false;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1690,7 +1667,7 @@ var collectionNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'assoc': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1700,7 +1677,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) {
@@ -1725,7 +1702,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams(3, node); },
+        paramCount: 3,
     },
     'update': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1736,7 +1713,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) {
@@ -1762,7 +1739,7 @@ var collectionNormalExpression = {
             }
             return coll;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+        paramCount: { min: 3 },
     },
     'concat': {
         evaluate: function (params, sourceCodeInfo) {
@@ -1786,7 +1763,7 @@ var collectionNormalExpression = {
                 }, {});
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1800,7 +1777,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) {
@@ -1814,7 +1791,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) {
@@ -1828,7 +1805,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) {
@@ -1842,7 +1819,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) {
@@ -1856,13 +1833,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) {
@@ -1900,7 +1878,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) {
@@ -1911,7 +1889,7 @@ var arrayNormalExpression = {
                 result.push(value);
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     flatten: {
         evaluate: function (_a) {
@@ -1920,7 +1898,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) {
@@ -1930,7 +1908,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,
     },
 };
@@ -1945,7 +1923,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) {
@@ -1960,7 +1938,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) {
@@ -1970,7 +1948,7 @@ var sequenceNormalExpression = {
             assertSeq(array, sourceCodeInfo);
             return toAny(array[0]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'last': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1980,7 +1958,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) {
@@ -2002,7 +1980,7 @@ var sequenceNormalExpression = {
                     .join('');
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2013,7 +1991,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) {
@@ -2032,7 +2010,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2051,7 +2029,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'last_index_of': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2070,7 +2048,7 @@ var sequenceNormalExpression = {
                 return index !== -1 ? index : null;
             }
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'push': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2084,7 +2062,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) {
@@ -2145,7 +2123,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) {
@@ -2192,7 +2170,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) {
@@ -2240,7 +2218,7 @@ var sequenceNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        paramCount: { min: 2, max: 3 },
     },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2253,7 +2231,7 @@ var sequenceNormalExpression = {
             }
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2265,7 +2243,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) {
@@ -2280,7 +2258,7 @@ var sequenceNormalExpression = {
                 return null;
             return seq.substring(1);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2294,7 +2272,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) {
@@ -2306,7 +2284,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) {
@@ -2316,7 +2294,7 @@ var sequenceNormalExpression = {
             assertSeq(seq, sourceCodeInfo);
             return toAny(seq[1]);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'shift': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2328,7 +2306,7 @@ var sequenceNormalExpression = {
             copy.shift();
             return copy;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'slice': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2342,7 +2320,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) {
@@ -2359,7 +2337,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) {
@@ -2397,7 +2375,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) {
@@ -2448,7 +2426,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) {
@@ -2458,7 +2436,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) {
@@ -2469,7 +2447,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) {
@@ -2497,7 +2475,7 @@ var sequenceNormalExpression = {
             }
             return typeof seq === 'string' ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'drop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2507,7 +2485,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) {
@@ -2518,7 +2496,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) {
@@ -2534,7 +2512,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) {
@@ -2548,7 +2526,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) {
@@ -2558,7 +2536,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) {
@@ -2573,7 +2551,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) {
@@ -2590,7 +2568,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) {
@@ -2600,7 +2578,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) {
@@ -2615,7 +2593,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) {
@@ -2631,7 +2609,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2649,7 +2627,7 @@ var sequenceNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'partition': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2661,7 +2639,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) {
@@ -2670,7 +2648,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) {
@@ -2691,7 +2669,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) {
@@ -2703,7 +2681,7 @@ var sequenceNormalExpression = {
             }
             return str.at(-1) === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'starts_with?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2715,7 +2693,7 @@ var sequenceNormalExpression = {
             }
             return str[0] === search;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'interleave': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2753,7 +2731,7 @@ var sequenceNormalExpression = {
             }
             return isStringSeq ? result.join('') : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     'interpose': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2772,7 +2750,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) {
@@ -2810,7 +2788,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'dec': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2818,7 +2796,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2827,6 +2805,7 @@ var mathNormalExpression = {
                 return result + param;
             }, 0);
         },
+        paramCount: {},
     },
     '*': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2835,6 +2814,7 @@ var mathNormalExpression = {
                 return result * param;
             }, 1);
         },
+        paramCount: {},
     },
     '/': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2851,6 +2831,7 @@ var mathNormalExpression = {
                 return result / param;
             }, first);
         },
+        paramCount: {},
     },
     '-': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2865,6 +2846,7 @@ var mathNormalExpression = {
                 return result - param;
             }, first);
         },
+        paramCount: {},
     },
     'quot': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2874,7 +2856,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) {
@@ -2884,7 +2866,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) {
@@ -2894,7 +2876,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) {
@@ -2902,7 +2884,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.sqrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cbrt': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2910,7 +2892,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.cbrt(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '**': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2919,7 +2901,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) {
@@ -2931,7 +2913,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) {
@@ -2939,7 +2921,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.trunc(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'floor': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2947,7 +2929,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.floor(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'ceil': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2955,7 +2937,7 @@ var mathNormalExpression = {
             assertNumber(first, sourceCodeInfo);
             return Math.ceil(first);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2968,7 +2950,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) {
@@ -2981,7 +2963,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) {
@@ -2989,7 +2971,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.abs(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sign': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -2997,67 +2979,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) {
@@ -3065,7 +3047,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.exp(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3073,7 +3055,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log2': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3081,7 +3063,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log2(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'log10': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3089,7 +3071,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.log10(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3097,7 +3079,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asin': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3105,7 +3087,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asin(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'sinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3113,7 +3095,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.sinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'asinh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3121,7 +3103,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.asinh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3129,7 +3111,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acos': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3137,7 +3119,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acos(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'cosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3145,7 +3127,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.cosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'acosh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3153,7 +3135,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.acosh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3161,7 +3143,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atan': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3169,7 +3151,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atan(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'tanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3177,7 +3159,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.tanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'atanh': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3185,7 +3167,7 @@ var mathNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Math.atanh(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
@@ -3200,7 +3182,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '==': {
         evaluate: function (_a) {
@@ -3222,14 +3204,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) {
@@ -3253,7 +3235,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<': {
         evaluate: function (_a) {
@@ -3277,7 +3259,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '>=': {
         evaluate: function (_a) {
@@ -3301,7 +3283,7 @@ var miscNormalExpression = {
             }
             return true;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     '<=': {
         evaluate: function (_a) {
@@ -3325,14 +3307,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) {
@@ -3340,7 +3322,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) {
@@ -3350,7 +3332,7 @@ var miscNormalExpression = {
             assertNumber(ms, sourceCodeInfo, { finite: true });
             return ms;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'write!': {
         evaluate: function (params, sourceCodeInfo) {
@@ -3360,20 +3342,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) {
@@ -3382,7 +3365,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) {
@@ -3393,7 +3376,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 },
     },
 };
@@ -3407,7 +3390,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) {
@@ -3417,7 +3400,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) {
@@ -3427,7 +3410,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) {
@@ -3438,7 +3421,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) {
@@ -3449,7 +3432,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) {
@@ -3459,7 +3442,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) {
@@ -3469,7 +3452,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) {
@@ -3479,7 +3462,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) {
@@ -3489,7 +3472,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) {
@@ -3499,7 +3482,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) {
@@ -3509,7 +3492,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) {
@@ -3519,7 +3502,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) {
@@ -3529,7 +3512,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) {
@@ -3539,7 +3522,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) {
@@ -3555,7 +3538,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) {
@@ -3576,7 +3559,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) {
@@ -3592,7 +3575,7 @@ var assertNormalExpression = {
             }
             return null;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+        paramCount: { min: 1, max: 2 },
     },
 };
@@ -3608,7 +3591,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertEvenNumberOfParams(node); },
+        paramCount: { even: true },
     },
     keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3616,7 +3599,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.keys(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     vals: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3624,7 +3607,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.values(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     entries: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3632,7 +3615,7 @@ var objectNormalExpression = {
             assertObj(obj, sourceCodeInfo);
             return Object.entries(obj);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     find: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3643,7 +3626,7 @@ var objectNormalExpression = {
                 return [key, obj[key]];
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     dissoc: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3654,7 +3637,7 @@ var objectNormalExpression = {
             delete newObj[key];
             return newObj;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     merge: {
         evaluate: function (params, sourceCodeInfo) {
@@ -3667,7 +3650,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) {
@@ -3690,7 +3673,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
     zipmap: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3705,7 +3688,7 @@ var objectNormalExpression = {
             }
             return result;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     select_keys: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3718,7 +3701,7 @@ var objectNormalExpression = {
                 return result;
             }, {});
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
 };
@@ -3728,42 +3711,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) {
@@ -3771,7 +3754,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) {
@@ -3779,7 +3762,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) {
@@ -3787,7 +3770,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) {
@@ -3795,7 +3778,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) {
@@ -3803,42 +3786,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) {
@@ -3846,7 +3829,7 @@ var predicatesNormalExpression = {
             assertNumber(value, sourceCodeInfo);
             return Number.isFinite(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'nan?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3854,7 +3837,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) {
@@ -3862,7 +3845,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) {
@@ -3870,21 +3853,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) {
@@ -3898,7 +3881,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) {
@@ -3912,7 +3895,7 @@ var predicatesNormalExpression = {
                 return coll.length > 0;
             return Object.keys(coll).length > 0;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
 };
@@ -3931,7 +3914,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) {
@@ -3945,7 +3928,7 @@ var regexpNormalExpression = {
                 return __spreadArray([], __read(match), false);
             return null;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     replace: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3956,7 +3939,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) {
@@ -3967,7 +3950,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,
     },
 };
@@ -3983,7 +3966,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) {
@@ -3992,7 +3975,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) {
@@ -4007,6 +3990,7 @@ var stringNormalExpression = {
                 return result + paramStr;
             }, '');
         },
+        paramCount: {},
     },
     'number': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4017,7 +4001,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) {
@@ -4031,7 +4015,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'to_char_code': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4039,7 +4023,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) {
@@ -4047,7 +4031,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toLowerCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'upper_case': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4055,7 +4039,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.toUpperCase();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4063,7 +4047,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.trim();
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'trim_left': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4071,7 +4055,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) {
@@ -4079,7 +4063,7 @@ var stringNormalExpression = {
             assertString(str, sourceCodeInfo);
             return str.replace(/\s+$/, '');
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     '++': {
         evaluate: function (params, sourceCodeInfo) {
@@ -4103,7 +4087,7 @@ var stringNormalExpression = {
                 return "".concat(acc).concat(str);
             }, first === null ? '' : "".concat(first));
         },
-        validate: function () { return undefined; },
+        paramCount: {},
     },
     'join': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4113,7 +4097,7 @@ var stringNormalExpression = {
             assertString(delimiter, sourceCodeInfo);
             return stringList.join(delimiter);
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
+        paramCount: 2,
     },
     'split': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4127,7 +4111,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) {
@@ -4135,7 +4119,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) {
@@ -4146,7 +4130,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) {
@@ -4157,7 +4141,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) {
@@ -4188,7 +4172,7 @@ var stringNormalExpression = {
                 }
             }
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+        paramCount: { min: 1, max: 10 },
     },
     'encode_base64': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4199,7 +4183,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) {
@@ -4217,7 +4201,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'encode_uri_component': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4225,7 +4209,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) {
@@ -4238,7 +4222,7 @@ var stringNormalExpression = {
                 throw new LitsError(error, sourceCodeInfo);
             }
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'blank?': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4249,7 +4233,7 @@ var stringNormalExpression = {
             assertString(value, sourceCodeInfo);
             return blankRegexp.test(value);
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     'capitalize': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4257,7 +4241,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;
@@ -4288,14 +4272,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) {
@@ -4309,7 +4293,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     comp: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4327,6 +4311,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
+        paramCount: {},
     },
     constantly: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4339,7 +4324,7 @@ var functionalNormalExpression = {
                 _b.v = toAny(value),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     juxt: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4351,7 +4336,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     complement: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4364,7 +4349,7 @@ var functionalNormalExpression = {
                 _b.f = toAny(fn),
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
     },
     every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
@@ -4376,7 +4361,7 @@ var functionalNormalExpression = {
                 _a.f = fns,
                 _a;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        paramCount: { min: 1 },
     },
     some_pred: {
         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 },
     },
     fnil: {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4402,7 +4387,7 @@ var functionalNormalExpression = {
                 _b.p = params,
                 _b;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+        paramCount: { min: 2 },
     },
 };
@@ -4421,7 +4406,7 @@ var andSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4465,14 +4450,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;
@@ -4502,7 +4487,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;
@@ -4533,7 +4518,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;
@@ -4580,7 +4565,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;
@@ -4605,7 +4590,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;
@@ -4677,7 +4662,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4716,7 +4701,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4941,7 +4926,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;
@@ -4965,7 +4950,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;
@@ -5002,7 +4987,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;
@@ -5057,7 +5042,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    paramCount: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5323,7 +5308,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;
@@ -5345,7 +5330,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;
@@ -5358,7 +5343,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;
@@ -5388,7 +5373,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;
@@ -5420,7 +5405,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); });
@@ -5434,7 +5419,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;
@@ -5475,7 +5460,7 @@ var trySpecialExpression = {
         };
         return node;
     },
-    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+    paramCount: 1,
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5912,8 +5897,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;
@@ -6119,6 +6105,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++]);
@@ -6308,7 +6308,6 @@ function getPrecedence(operatorSign) {
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    var _a;
     var node = {
         t: AstNodeType.NormalExpression,
         n: name,
@@ -6317,7 +6316,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;
 }
@@ -6418,7 +6417,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;
             }
@@ -6426,9 +6425,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)) {
@@ -6464,6 +6464,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());
@@ -6501,7 +6504,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;
     };
@@ -6609,32 +6612,6 @@ var AlgebraicParser = /** @class */ (function () {
                 return parseReservedSymbol(this.tokenStream, this.parseState);
             case 'RegexpShorthand':
                 return parseRegexpShorthand(this.tokenStream, this.parseState);
-            case 'PolNotation': {
-                this.parseState.algebraic = false;
-                var astNodes = [];
-                this.advance();
-                do {
-                    astNodes.push(this.parseState.parseToken(this.tokenStream, this.parseState));
-                } while (!isEndNotationToken(this.peek()));
-                this.advance();
-                this.parseState.algebraic = true;
-                if (astNodes.length === 1) {
-                    return astNodes[0];
-                }
-                return {
-                    t: AstNodeType.SpecialExpression,
-                    n: 'do',
-                    p: astNodes,
-                    token: getTokenDebugData(token) && token,
-                };
-            }
-            case 'AlgNotation': {
-                this.advance();
-                var node = this.parseOperand();
-                assertEndNotationToken(this.peek());
-                this.advance();
-                return node;
-            }
             default:
                 throw new LitsError("Unknown token type: ".concat(tokenType), (_b = getTokenDebugData(token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         }
@@ -6739,7 +6716,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':
@@ -6792,7 +6769,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();
@@ -6807,62 +6784,54 @@ var AlgebraicParser = /** @class */ (function () {
         }
         this.advance();
         var rest = false;
-        var letBindingObject;
         var args = [];
         var restArg;
-        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (letBindingObject) {
-                throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-            }
-            if (isLBraceToken(this.peek())) {
-                letBindingObject = this.parseObject();
-            }
-            else {
-                if (isA_OperatorToken(this.peek(), '...')) {
-                    if (rest) {
-                        throw new LitsError('Multiple spread operators in lambda function', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-                    }
-                    this.advance();
-                    rest = true;
-                }
-                var symbolToken = this.peek();
-                if (!isA_SymbolToken(symbolToken)) {
-                    throw new LitsError('Expected symbol', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-                }
+        while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+            if (isA_OperatorToken(this.peek(), '...')) {
                 if (rest) {
-                    restArg = symbolToken[1];
-                }
-                else {
-                    args.push(symbolToken[1]);
+                    throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
                 }
                 this.advance();
+                rest = true;
+            }
+            var symbolToken = this.peek();
+            if (!isA_SymbolToken(symbolToken)) {
+                throw new LitsError('Expected symbol', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
             }
-            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
-                throw new LitsError('Expected comma or closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+            if (rest) {
+                restArg = symbolToken[1];
+            }
+            else {
+                args.push(symbolToken[1]);
+            }
+            this.advance();
+            if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+                throw new LitsError('Expected comma or closing parenthesis', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
             }
             if (isA_OperatorToken(this.peek(), ',')) {
                 this.advance();
             }
         }
         var arity = restArg !== undefined ? { min: args.length } : args.length;
+        // let bindings, to be able to pass on values in the context down to the body
+        // This is needed since lits is dynamically scoped
+        // E.g.
+        // x => y => x + y // would not work, x is not available in the second lambda
+        // x => (y, let x = x) => x + y // would work, x is available in the second lambda
+        var bindingNodess = [];
+        var token = this.peek();
+        while (isA_SymbolToken(token, 'let')) {
+            var letNode = this.parseLet(token, true);
+            bindingNodess.push(letNode.bs[0]);
+            token = this.peek();
+        }
         if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
+            throw new LitsError('Expected closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
         }
-        var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
         var functionArguments = {
             m: args,
             r: restArg,
-            b: letBindings.map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
-                    t: AstNodeType.Binding,
-                    n: key.v,
-                    v: value,
-                    p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            }),
+            b: bindingNodess,
         };
         this.advance();
         return {
@@ -7312,6 +7281,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
+        assertA_OperatorToken(this.peek(), ';');
         var fnNode = {
             t: AstNodeType.SpecialExpression,
             n: 'fn',
@@ -7474,7 +7444,7 @@ function parseObjectLitteral(tokenStream, parseState) {
         p: params,
         token: getTokenDebugData(firstToken) && firstToken,
     };
-    assertEvenNumberOfParams(node);
+    assertNumberOfParams({ even: true }, node);
     return node;
 }
 var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7580,7 +7550,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);
@@ -7604,7 +7574,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;
 }
@@ -7613,7 +7583,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,
@@ -7622,7 +7592,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
-    validateParameterCount(node);
+    assertNumberOfParams(paramCount, node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {
@@ -7652,47 +7622,12 @@ function parsePolishToken(tokenStream, parseState) {
             return parseFnShorthand(tokenStream, parseState);
         case 'P_Comment':
             return parseComment(tokenStream, parseState);
-        case 'AlgNotation': {
-            parseState.position += 1;
-            parseState.algebraic = true;
-            var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-            var nodes = algebraicParser.parse();
-            assertEndNotationToken(tokenStream.tokens[parseState.position++]);
-            parseState.algebraic = false;
-            if (nodes.length === 1) {
-                return nodes[0];
-            }
-            return {
-                t: AstNodeType.SpecialExpression,
-                n: 'do',
-                p: nodes,
-                token: nodes[0].token,
-            };
-        }
-        case 'PolNotation': {
-            var astNodes = [];
-            parseState.position += 1;
-            do {
-                astNodes.push(parsePolishToken(tokenStream, parseState));
-            } while (!isEndNotationToken(asToken(tokenStream.tokens[parseState.position])));
-            parseState.position += 1;
-            if (astNodes.length === 1) {
-                return astNodes[0];
-            }
-            return {
-                t: AstNodeType.SpecialExpression,
-                n: 'do',
-                p: astNodes,
-                token: astNodes[0].token,
-            };
-        }
         case 'P_CollectionAccessor':
         case 'P_Modifier':
         case 'RParen':
         case 'RBracket':
         case 'RBrace':
         case 'P_Whitespace':
-        case 'EndNotation':
             break;
         /* v8 ignore next 2 */
         default:
@@ -7702,49 +7637,28 @@ function parsePolishToken(tokenStream, parseState) {
 }
 function parse(tokenStream) {
-    var _a;
-    var safeTokenStream = removeUnnecessaryTokens(tokenStream);
+    tokenStream = minifyTokenStream(tokenStream);
+    var algebraic = tokenStream.algebraic;
     var ast = {
         b: [],
-        hasDebugData: safeTokenStream.hasDebugData,
+        hasDebugData: tokenStream.hasDebugData,
     };
     var parseState = {
         position: 0,
-        algebraic: (_a = safeTokenStream.algebraic) !== null && _a !== void 0 ? _a : false,
         parseToken: parseToken,
     };
-    while (parseState.position < safeTokenStream.tokens.length) {
-        ast.b.push(parseToken(safeTokenStream, parseState));
+    if (algebraic) {
+        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
+        ast.b = algebraicParser.parse();
     }
-    return ast;
-}
-function removeUnnecessaryTokens(tokenStream) {
-    var tokens = tokenStream.tokens.filter(function (token) {
-        if (isP_CommentToken(token)
-            || isA_CommentToken(token)
-            || isA_MultiLineCommentToken(token)
-            || isA_WhitespaceToken(token)
-            || isP_WhitespaceToken(token)) {
-            return false;
+    else {
+        while (parseState.position < tokenStream.tokens.length) {
+            ast.b.push(parseToken(tokenStream, parseState));
         }
-        return true;
-    });
-    return __assign(__assign({}, tokenStream), { tokens: tokens });
+    }
+    return ast;
 }
 function parseToken(tokenStream, parseState) {
-    if (parseState.algebraic) {
-        var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-        var nodes = algebraicParser.parse();
-        if (nodes.length === 1) {
-            return nodes[0];
-        }
-        return {
-            t: AstNodeType.SpecialExpression,
-            n: 'do',
-            p: nodes,
-            token: nodes[0].token,
-        };
-    }
     return parsePolishToken(tokenStream, parseState);
 }
@@ -7774,15 +7688,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;
@@ -7835,9 +7740,6 @@ function tokenizeSimpleToken(type, value, input, position) {
         return NO_MATCH;
 }
 var commonTokenizers = [
-    tokenizePolishNotation,
-    tokenizeAlgebraicNotation,
-    tokenizeEndNotation,
     tokenizeLParen,
     tokenizeRParen,
     tokenizeLBracket,
@@ -8347,7 +8249,6 @@ function getSugar() {
 function tokenize(input, params) {
     var debug = !!params.debug;
-    var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
     var position = 0;
     var tokenStream = {
         tokens: [],
@@ -8356,7 +8257,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
             ? {
@@ -8373,23 +8274,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;
 }
@@ -8474,9 +8360,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:
@@ -8601,7 +8484,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);