@mojir/lits 2.0.19 → 2.0.21

package/dist/lits.iife.js

@@ -278,9 +278,6 @@ var Lits = (function (exports) {
         'RBrace',
         'RBracket',
         'RParen',
-        'AlgNotation',
-        'PolNotation',
-        'EndNotation',
     ];
     var commomValueTokenTypes = [
         'String',
@@ -370,20 +367,6 @@ var Lits = (function (exports) {
         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 = [
@@ -843,20 +826,6 @@ var Lits = (function (exports) {
         return astNodes.filter(function (n) { return n.t !== exports.AstNodeType.Comment; });
     }
 
-    function assertEvenNumberOfParams(node) {
-        var _a;
-        var length = withoutCommentNodes(node.p).length;
-        if (length % 2 !== 0) {
-            throw new LitsError("Wrong number of arguments, expected an even number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-        }
-    }
-    function assertOddNumberOfParams(node) {
-        var _a;
-        var length = withoutCommentNodes(node.p).length;
-        if (length % 2 !== 1) {
-            throw new LitsError("Wrong number of arguments, expected an odd number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-        }
-    }
     function assertNumberOfParams(count, node) {
         var _a, _b;
         assertCount({
@@ -888,9 +857,17 @@ var Lits = (function (exports) {
             }
         }
         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);
             }
@@ -1027,7 +1004,7 @@ var Lits = (function (exports) {
                 assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
                 return num << count;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         '>>': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1036,7 +1013,7 @@ var Lits = (function (exports) {
                 assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
                 return num >> count;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         '>>>': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1045,7 +1022,7 @@ var Lits = (function (exports) {
                 assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
                 return num >>> count;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         '~': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1053,7 +1030,7 @@ var Lits = (function (exports) {
                 assertNumber(num, sourceCodeInfo, { integer: true });
                 return ~num;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         '&': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1064,7 +1041,7 @@ var Lits = (function (exports) {
                     return result & value;
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
         '&!': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1075,7 +1052,7 @@ var Lits = (function (exports) {
                     return result & ~value;
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
         '|': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1086,7 +1063,7 @@ var Lits = (function (exports) {
                     return result | value;
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
         '^': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1097,7 +1074,7 @@ var Lits = (function (exports) {
                     return result ^ value;
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
         'bit_flip': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1107,7 +1084,7 @@ var Lits = (function (exports) {
                 var mask = 1 << index;
                 return (num ^= mask);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'bit_set': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1117,7 +1094,7 @@ var Lits = (function (exports) {
                 var mask = 1 << index;
                 return (num |= mask);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'bit_clear': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1127,7 +1104,7 @@ var Lits = (function (exports) {
                 var mask = 1 << index;
                 return (num &= ~mask);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'bit_test': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1137,7 +1114,7 @@ var Lits = (function (exports) {
                 var mask = 1 << index;
                 return !!(num & mask);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
     };
 
@@ -1519,7 +1496,7 @@ var Lits = (function (exports) {
                 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) {
@@ -1554,7 +1531,7 @@ var Lits = (function (exports) {
                 }
                 return coll;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'count': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1568,7 +1545,7 @@ var Lits = (function (exports) {
                     return coll.length;
                 return Object.keys(coll).length;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'contains?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1585,7 +1562,7 @@ var Lits = (function (exports) {
                 }
                 return !!Object.getOwnPropertyDescriptor(coll, key);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'has?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1606,7 +1583,7 @@ var Lits = (function (exports) {
                 }
                 return Object.values(coll).includes(value);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'has_some?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1666,7 +1643,7 @@ var Lits = (function (exports) {
                 }
                 return false;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'has_every?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1728,7 +1705,7 @@ var Lits = (function (exports) {
                 }
                 return true;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'assoc': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1738,7 +1715,7 @@ var Lits = (function (exports) {
                 assertAny(value, sourceCodeInfo);
                 return assoc(coll, key, value, sourceCodeInfo);
             },
-            validate: function (node) { return assertNumberOfParams(3, node); },
+            paramCount: 3,
         },
         'assoc_in': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1763,7 +1740,7 @@ var Lits = (function (exports) {
                 }
                 return coll;
             },
-            validate: function (node) { return assertNumberOfParams(3, node); },
+            paramCount: 3,
         },
         'update': {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1774,7 +1751,7 @@ var Lits = (function (exports) {
                 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) {
@@ -1800,7 +1777,7 @@ var Lits = (function (exports) {
                 }
                 return coll;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
+            paramCount: { min: 3 },
         },
         'concat': {
             evaluate: function (params, sourceCodeInfo) {
@@ -1824,7 +1801,7 @@ var Lits = (function (exports) {
                     }, {});
                 }
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         'not_empty': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1838,7 +1815,7 @@ var Lits = (function (exports) {
                     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) {
@@ -1852,7 +1829,7 @@ var Lits = (function (exports) {
                     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) {
@@ -1866,7 +1843,7 @@ var Lits = (function (exports) {
                     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) {
@@ -1880,7 +1857,7 @@ var Lits = (function (exports) {
                     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) {
@@ -1894,13 +1871,14 @@ var Lits = (function (exports) {
                     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) {
@@ -1938,7 +1916,7 @@ var Lits = (function (exports) {
                     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) {
@@ -1949,7 +1927,7 @@ var Lits = (function (exports) {
                     result.push(value);
                 return result;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         flatten: {
             evaluate: function (_a) {
@@ -1958,7 +1936,7 @@ var Lits = (function (exports) {
                     return [];
                 return seq.flat(Number.POSITIVE_INFINITY);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         mapcat: {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1968,7 +1946,7 @@ var Lits = (function (exports) {
                 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,
         },
     };
 
@@ -1983,7 +1961,7 @@ var Lits = (function (exports) {
                 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) {
@@ -1998,7 +1976,7 @@ var Lits = (function (exports) {
                     .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
                     .join('');
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'first': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2008,7 +1986,7 @@ var Lits = (function (exports) {
                 assertSeq(array, sourceCodeInfo);
                 return toAny(array[0]);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'last': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2018,7 +1996,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2040,7 +2018,7 @@ var Lits = (function (exports) {
                         .join('');
                 }
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'pop': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2051,7 +2029,7 @@ var Lits = (function (exports) {
                 }
                 return seq.slice(0, seq.length - 1);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'position': {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2070,7 +2048,7 @@ var Lits = (function (exports) {
                     return index !== -1 ? index : null;
                 }
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'index_of': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2089,7 +2067,7 @@ var Lits = (function (exports) {
                     return index !== -1 ? index : null;
                 }
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'last_index_of': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2108,7 +2086,7 @@ var Lits = (function (exports) {
                     return index !== -1 ? index : null;
                 }
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'push': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2122,7 +2100,7 @@ var Lits = (function (exports) {
                     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) {
@@ -2183,7 +2161,7 @@ var Lits = (function (exports) {
                     }
                 }
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'reduce': {
             evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2230,7 +2208,7 @@ var Lits = (function (exports) {
                     }
                 }
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'reduce_right': {
             evaluate: function (params, sourceCodeInfo, contextStack, _a) {
@@ -2278,7 +2256,7 @@ var Lits = (function (exports) {
                     }
                 }
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'rest': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2291,7 +2269,7 @@ var Lits = (function (exports) {
                 }
                 return seq.substring(1);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'nthrest': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2303,7 +2281,7 @@ var Lits = (function (exports) {
                     return seq.slice(integerCount);
                 return seq.substring(integerCount);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'next': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2318,7 +2296,7 @@ var Lits = (function (exports) {
                     return null;
                 return seq.substring(1);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'nthnext': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2332,7 +2310,7 @@ var Lits = (function (exports) {
                     return seq.slice(integerCount);
                 return seq.substring(integerCount);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'reverse': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2344,7 +2322,7 @@ var Lits = (function (exports) {
                     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) {
@@ -2354,7 +2332,7 @@ var Lits = (function (exports) {
                 assertSeq(seq, sourceCodeInfo);
                 return toAny(seq[1]);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'shift': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2366,7 +2344,7 @@ var Lits = (function (exports) {
                 copy.shift();
                 return copy;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'slice': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2380,7 +2358,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2397,7 +2375,7 @@ var Lits = (function (exports) {
                     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) {
@@ -2435,7 +2413,7 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -2486,7 +2464,7 @@ var Lits = (function (exports) {
                 }
                 return result;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'take': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2496,7 +2474,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2507,7 +2485,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2535,7 +2513,7 @@ var Lits = (function (exports) {
                 }
                 return typeof seq === 'string' ? result.join('') : result;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'drop': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2545,7 +2523,7 @@ var Lits = (function (exports) {
                 assertSeq(input, sourceCodeInfo);
                 return input.slice(num);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'drop_last': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2556,7 +2534,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2572,7 +2550,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2586,7 +2564,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2596,7 +2574,7 @@ var Lits = (function (exports) {
                     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) {
@@ -2611,7 +2589,7 @@ var Lits = (function (exports) {
                     .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) {
@@ -2628,7 +2606,7 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -2638,7 +2616,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2653,7 +2631,7 @@ var Lits = (function (exports) {
                     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) {
@@ -2669,7 +2647,7 @@ var Lits = (function (exports) {
                     return result;
                 }, {});
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'group_by': {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -2687,7 +2665,7 @@ var Lits = (function (exports) {
                     return result;
                 }, {});
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'partition': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2699,7 +2677,7 @@ var Lits = (function (exports) {
                     : 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) {
@@ -2708,7 +2686,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2729,7 +2707,7 @@ var Lits = (function (exports) {
                 }, []);
                 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) {
@@ -2741,7 +2719,7 @@ var Lits = (function (exports) {
                 }
                 return str.at(-1) === search;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'starts_with?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2753,7 +2731,7 @@ var Lits = (function (exports) {
                 }
                 return str[0] === search;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'interleave': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2791,7 +2769,7 @@ var Lits = (function (exports) {
                 }
                 return isStringSeq ? result.join('') : result;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         'interpose': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2810,7 +2788,7 @@ var Lits = (function (exports) {
                 result.push(seq[seq.length - 1]);
                 return result;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
     };
     function partition(n, step, seq, pad, sourceCodeInfo) {
@@ -2848,7 +2826,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return first + 1;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'dec': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2856,7 +2834,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return first - 1;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         '+': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2865,6 +2843,7 @@ var Lits = (function (exports) {
                     return result + param;
                 }, 0);
             },
+            paramCount: {},
         },
         '*': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2873,6 +2852,7 @@ var Lits = (function (exports) {
                     return result * param;
                 }, 1);
             },
+            paramCount: {},
         },
         '/': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2889,6 +2869,7 @@ var Lits = (function (exports) {
                     return result / param;
                 }, first);
             },
+            paramCount: {},
         },
         '-': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2903,6 +2884,7 @@ var Lits = (function (exports) {
                     return result - param;
                 }, first);
             },
+            paramCount: {},
         },
         'quot': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2912,7 +2894,7 @@ var Lits = (function (exports) {
                 var quotient = Math.trunc(dividend / divisor);
                 return quotient;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'mod': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2922,7 +2904,7 @@ var Lits = (function (exports) {
                 var quotient = Math.floor(dividend / divisor);
                 return dividend - divisor * quotient;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         '%': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2932,7 +2914,7 @@ var Lits = (function (exports) {
                 var quotient = Math.trunc(dividend / divisor);
                 return dividend - divisor * quotient;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'sqrt': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2940,7 +2922,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return Math.sqrt(first);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'cbrt': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2948,7 +2930,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return Math.cbrt(first);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         '**': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2957,7 +2939,7 @@ var Lits = (function (exports) {
                 assertNumber(second, sourceCodeInfo);
                 return Math.pow(first, second);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'round': {
             evaluate: function (params, sourceCodeInfo) {
@@ -2969,7 +2951,7 @@ var Lits = (function (exports) {
                 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) {
@@ -2977,7 +2959,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return Math.trunc(first);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'floor': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2985,7 +2967,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return Math.floor(first);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'ceil': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -2993,7 +2975,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo);
                 return Math.ceil(first);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'min': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3006,7 +2988,7 @@ var Lits = (function (exports) {
                     return Math.min(min, value);
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         'max': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3019,7 +3001,7 @@ var Lits = (function (exports) {
                     return Math.max(min, value);
                 }, first);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         'abs': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3027,7 +3009,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.abs(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'sign': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3035,67 +3017,67 @@ var Lits = (function (exports) {
                 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) {
@@ -3103,7 +3085,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.exp(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'log': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3111,7 +3093,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.log(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'log2': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3119,7 +3101,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.log2(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'log10': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3127,7 +3109,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.log10(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'sin': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3135,7 +3117,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.sin(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'asin': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3143,7 +3125,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.asin(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'sinh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3151,7 +3133,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.sinh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'asinh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3159,7 +3141,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.asinh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'cos': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3167,7 +3149,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.cos(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'acos': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3175,7 +3157,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.acos(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'cosh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3183,7 +3165,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.cosh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'acosh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3191,7 +3173,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.acosh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'tan': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3199,7 +3181,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.tan(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'atan': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3207,7 +3189,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.atan(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'tanh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3215,7 +3197,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.tanh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'atanh': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3223,7 +3205,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Math.atanh(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
     };
 
@@ -3238,7 +3220,7 @@ var Lits = (function (exports) {
                 }
                 return true;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         '==': {
             evaluate: function (_a) {
@@ -3260,14 +3242,14 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -3291,7 +3273,7 @@ var Lits = (function (exports) {
                 }
                 return true;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         '<': {
             evaluate: function (_a) {
@@ -3315,7 +3297,7 @@ var Lits = (function (exports) {
                 }
                 return true;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         '>=': {
             evaluate: function (_a) {
@@ -3339,7 +3321,7 @@ var Lits = (function (exports) {
                 }
                 return true;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         '<=': {
             evaluate: function (_a) {
@@ -3363,14 +3345,14 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -3378,7 +3360,7 @@ var Lits = (function (exports) {
                 assertNumber(ms, sourceCodeInfo);
                 return new Date(ms).toISOString();
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'iso_date>epoch': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3388,7 +3370,7 @@ var Lits = (function (exports) {
                 assertNumber(ms, sourceCodeInfo, { finite: true });
                 return ms;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'write!': {
             evaluate: function (params, sourceCodeInfo) {
@@ -3398,20 +3380,21 @@ var Lits = (function (exports) {
                     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) {
@@ -3420,7 +3403,7 @@ var Lits = (function (exports) {
                 // 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) {
@@ -3431,7 +3414,7 @@ var Lits = (function (exports) {
                 assertNumber(second, sourceCodeInfo);
                 return JSON.stringify(first, null, second);
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+            paramCount: { min: 1, max: 2 },
         },
     };
 
@@ -3445,7 +3428,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3455,7 +3438,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3465,7 +3448,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3476,7 +3459,7 @@ var Lits = (function (exports) {
                 }
                 return null;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'assert_not_equal': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3487,7 +3470,7 @@ var Lits = (function (exports) {
                 }
                 return null;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+            paramCount: { min: 2, max: 3 },
         },
         'assert_gt': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3497,7 +3480,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3507,7 +3490,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3517,7 +3500,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3527,7 +3510,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3537,7 +3520,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3547,7 +3530,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3557,7 +3540,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3567,7 +3550,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3577,7 +3560,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3593,7 +3576,7 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -3614,7 +3597,7 @@ var Lits = (function (exports) {
                 }
                 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) {
@@ -3630,7 +3613,7 @@ var Lits = (function (exports) {
                 }
                 return null;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+            paramCount: { min: 1, max: 2 },
         },
     };
 
@@ -3646,7 +3629,7 @@ var Lits = (function (exports) {
                 }
                 return result;
             },
-            validate: function (node) { return assertEvenNumberOfParams(node); },
+            paramCount: { even: true },
         },
         keys: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3654,7 +3637,7 @@ var Lits = (function (exports) {
                 assertObj(obj, sourceCodeInfo);
                 return Object.keys(obj);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         vals: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3662,7 +3645,7 @@ var Lits = (function (exports) {
                 assertObj(obj, sourceCodeInfo);
                 return Object.values(obj);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         entries: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3670,7 +3653,7 @@ var Lits = (function (exports) {
                 assertObj(obj, sourceCodeInfo);
                 return Object.entries(obj);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         find: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3681,7 +3664,7 @@ var Lits = (function (exports) {
                     return [key, obj[key]];
                 return null;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         dissoc: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3692,7 +3675,7 @@ var Lits = (function (exports) {
                 delete newObj[key];
                 return newObj;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         merge: {
             evaluate: function (params, sourceCodeInfo) {
@@ -3705,7 +3688,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3728,7 +3711,7 @@ var Lits = (function (exports) {
                     return result;
                 }, __assign({}, first));
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
         zipmap: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3743,7 +3726,7 @@ var Lits = (function (exports) {
                 }
                 return result;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         select_keys: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3756,7 +3739,7 @@ var Lits = (function (exports) {
                     return result;
                 }, {});
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
     };
 
@@ -3766,42 +3749,42 @@ var Lits = (function (exports) {
                 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) {
@@ -3809,7 +3792,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo, { finite: true });
                 return first === 0;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'pos?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3817,7 +3800,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo, { finite: true });
                 return first > 0;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'neg?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3825,7 +3808,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo, { finite: true });
                 return first < 0;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'even?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3833,7 +3816,7 @@ var Lits = (function (exports) {
                 assertNumber(first, sourceCodeInfo, { finite: true });
                 return first % 2 === 0;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'odd?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3841,42 +3824,42 @@ var Lits = (function (exports) {
                 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) {
@@ -3884,7 +3867,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Number.isFinite(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'nan?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3892,7 +3875,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return Number.isNaN(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'positive_infinity?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3900,7 +3883,7 @@ var Lits = (function (exports) {
                 assertNumber(value, sourceCodeInfo);
                 return value === Number.POSITIVE_INFINITY;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'negative_infinity?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3908,21 +3891,21 @@ var Lits = (function (exports) {
                 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) {
@@ -3936,7 +3919,7 @@ var Lits = (function (exports) {
                     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) {
@@ -3950,7 +3933,7 @@ var Lits = (function (exports) {
                     return coll.length > 0;
                 return Object.keys(coll).length > 0;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
     };
 
@@ -3969,7 +3952,7 @@ var Lits = (function (exports) {
                     _b.f = flags,
                     _b;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
+            paramCount: { min: 1, max: 2 },
         },
         match: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3983,7 +3966,7 @@ var Lits = (function (exports) {
                     return __spreadArray([], __read(match), false);
                 return null;
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         replace: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -3994,7 +3977,7 @@ var Lits = (function (exports) {
                 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) {
@@ -4005,7 +3988,7 @@ var Lits = (function (exports) {
                 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,
         },
     };
 
@@ -4021,7 +4004,7 @@ var Lits = (function (exports) {
                 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) {
@@ -4030,7 +4013,7 @@ var Lits = (function (exports) {
                 assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
                 return str.repeat(count);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'str': {
             evaluate: function (params) {
@@ -4045,6 +4028,7 @@ var Lits = (function (exports) {
                     return result + paramStr;
                 }, '');
             },
+            paramCount: {},
         },
         'number': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4055,7 +4039,7 @@ var Lits = (function (exports) {
                     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) {
@@ -4069,7 +4053,7 @@ var Lits = (function (exports) {
                     throw new LitsError(error, sourceCodeInfo);
                 }
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'to_char_code': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4077,7 +4061,7 @@ var Lits = (function (exports) {
                 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) {
@@ -4085,7 +4069,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.toLowerCase();
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'upper_case': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4093,7 +4077,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.toUpperCase();
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'trim': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4101,7 +4085,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.trim();
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'trim_left': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4109,7 +4093,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.replace(/^\s+/, '');
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'trim_right': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4117,7 +4101,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.replace(/\s+$/, '');
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         '++': {
             evaluate: function (params, sourceCodeInfo) {
@@ -4141,7 +4125,7 @@ var Lits = (function (exports) {
                     return "".concat(acc).concat(str);
                 }, first === null ? '' : "".concat(first));
             },
-            validate: function () { return undefined; },
+            paramCount: {},
         },
         'join': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4151,7 +4135,7 @@ var Lits = (function (exports) {
                 assertString(delimiter, sourceCodeInfo);
                 return stringList.join(delimiter);
             },
-            validate: function (node) { return assertNumberOfParams(2, node); },
+            paramCount: 2,
         },
         'split': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4165,7 +4149,7 @@ var Lits = (function (exports) {
                     : 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) {
@@ -4173,7 +4157,7 @@ var Lits = (function (exports) {
                 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) {
@@ -4184,7 +4168,7 @@ var Lits = (function (exports) {
                     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) {
@@ -4195,7 +4179,7 @@ var Lits = (function (exports) {
                     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) {
@@ -4226,7 +4210,7 @@ var Lits = (function (exports) {
                     }
                 }
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
+            paramCount: { min: 1, max: 10 },
         },
         'encode_base64': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4237,7 +4221,7 @@ var Lits = (function (exports) {
                     return String.fromCharCode(Number.parseInt(p1, 16));
                 }));
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'decode_base64': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4255,7 +4239,7 @@ var Lits = (function (exports) {
                     throw new LitsError(error, sourceCodeInfo);
                 }
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'encode_uri_component': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4263,7 +4247,7 @@ var Lits = (function (exports) {
                 assertString(value, sourceCodeInfo);
                 return encodeURIComponent(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'decode_uri_component': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4276,7 +4260,7 @@ var Lits = (function (exports) {
                     throw new LitsError(error, sourceCodeInfo);
                 }
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'blank?': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4287,7 +4271,7 @@ var Lits = (function (exports) {
                 assertString(value, sourceCodeInfo);
                 return blankRegexp.test(value);
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         'capitalize': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4295,7 +4279,7 @@ var Lits = (function (exports) {
                 assertString(str, sourceCodeInfo);
                 return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
     };
     var doubleDollarRegexp = /\$\$/g;
@@ -4326,14 +4310,14 @@ var Lits = (function (exports) {
                 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) {
@@ -4347,7 +4331,7 @@ var Lits = (function (exports) {
                     _b.p = params,
                     _b;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         comp: {
             evaluate: function (fns, sourceCodeInfo) {
@@ -4365,6 +4349,7 @@ var Lits = (function (exports) {
                     _a.f = fns,
                     _a;
             },
+            paramCount: {},
         },
         constantly: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4377,7 +4362,7 @@ var Lits = (function (exports) {
                     _b.v = toAny(value),
                     _b;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         juxt: {
             evaluate: function (fns, sourceCodeInfo) {
@@ -4389,7 +4374,7 @@ var Lits = (function (exports) {
                     _a.f = fns,
                     _a;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         complement: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4402,7 +4387,7 @@ var Lits = (function (exports) {
                     _b.f = toAny(fn),
                     _b;
             },
-            validate: function (node) { return assertNumberOfParams(1, node); },
+            paramCount: 1,
         },
         every_pred: {
             evaluate: function (fns, sourceCodeInfo) {
@@ -4414,7 +4399,7 @@ var Lits = (function (exports) {
                     _a.f = fns,
                     _a;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         some_pred: {
             evaluate: function (fns, sourceCodeInfo) {
@@ -4426,7 +4411,7 @@ var Lits = (function (exports) {
                     _a.f = fns,
                     _a;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+            paramCount: { min: 1 },
         },
         fnil: {
             evaluate: function (_a, sourceCodeInfo) {
@@ -4440,7 +4425,7 @@ var Lits = (function (exports) {
                     _b.p = params,
                     _b;
             },
-            validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+            paramCount: { min: 2 },
         },
     };
 
@@ -4459,7 +4444,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -4503,14 +4488,14 @@ var Lits = (function (exports) {
 
     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;
@@ -4540,7 +4525,7 @@ var Lits = (function (exports) {
 
     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;
@@ -4571,7 +4556,7 @@ var Lits = (function (exports) {
 
     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;
@@ -4619,7 +4604,7 @@ var Lits = (function (exports) {
             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;
@@ -4644,7 +4629,7 @@ var Lits = (function (exports) {
 
     var doSpecialExpression = {
         polishParse: getCommonPolishSpecialExpressionParser('do'),
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -4716,7 +4701,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c, _d;
@@ -4755,7 +4740,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c;
@@ -4980,7 +4965,7 @@ var Lits = (function (exports) {
 
     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;
@@ -5004,7 +4989,7 @@ var Lits = (function (exports) {
 
     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;
@@ -5041,7 +5026,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function (node) { return assertNumberOfParams(0, node); },
+        paramCount: 0,
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5096,7 +5081,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5362,7 +5347,7 @@ var Lits = (function (exports) {
             };
             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;
@@ -5384,7 +5369,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
         evaluate: function (node, contextStack, helpers) {
             evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
             return null;
@@ -5397,7 +5382,7 @@ var Lits = (function (exports) {
 
     var orSpecialExpression = {
         polishParse: getCommonPolishSpecialExpressionParser('||'),
-        validateParameterCount: function () { return undefined; },
+        paramCount: {},
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5427,7 +5412,7 @@ var Lits = (function (exports) {
 
     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;
@@ -5459,7 +5444,7 @@ var Lits = (function (exports) {
             };
             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); });
@@ -5473,7 +5458,7 @@ var Lits = (function (exports) {
 
     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;
@@ -5514,7 +5499,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
-        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
+        paramCount: 1,
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c;
@@ -5951,8 +5936,9 @@ var Lits = (function (exports) {
         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;
@@ -6158,6 +6144,20 @@ var Lits = (function (exports) {
         };
     }
 
+    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++]);
@@ -6347,7 +6347,6 @@ var Lits = (function (exports) {
         }
     }
     function createNamedNormalExpressionNode(name, params, token) {
-        var _a;
         var node = {
             t: exports.AstNodeType.NormalExpression,
             n: name,
@@ -6356,7 +6355,7 @@ var Lits = (function (exports) {
         };
         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;
     }
@@ -6457,7 +6456,7 @@ var Lits = (function (exports) {
         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;
                 }
@@ -6465,9 +6464,10 @@ var Lits = (function (exports) {
             }
             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)) {
@@ -6503,6 +6503,9 @@ var Lits = (function (exports) {
                 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());
@@ -6540,7 +6543,7 @@ var Lits = (function (exports) {
                 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;
         };
@@ -6648,32 +6651,6 @@ var Lits = (function (exports) {
                     return parseReservedSymbol(this.tokenStream, this.parseState);
                 case 'RegexpShorthand':
                     return parseRegexpShorthand(this.tokenStream, this.parseState);
-                case 'PolNotation': {
-                    this.parseState.algebraic = false;
-                    var astNodes = [];
-                    this.advance();
-                    do {
-                        astNodes.push(this.parseState.parseToken(this.tokenStream, this.parseState));
-                    } while (!isEndNotationToken(this.peek()));
-                    this.advance();
-                    this.parseState.algebraic = true;
-                    if (astNodes.length === 1) {
-                        return astNodes[0];
-                    }
-                    return {
-                        t: exports.AstNodeType.SpecialExpression,
-                        n: 'do',
-                        p: astNodes,
-                        token: getTokenDebugData(token) && token,
-                    };
-                }
-                case 'AlgNotation': {
-                    this.advance();
-                    var node = this.parseOperand();
-                    assertEndNotationToken(this.peek());
-                    this.advance();
-                    return node;
-                }
                 default:
                     throw new LitsError("Unknown token type: ".concat(tokenType), (_b = getTokenDebugData(token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
             }
@@ -6778,7 +6755,7 @@ var Lits = (function (exports) {
                                 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':
@@ -6831,7 +6808,7 @@ var Lits = (function (exports) {
             }
         };
         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();
@@ -6846,62 +6823,54 @@ var Lits = (function (exports) {
             }
             this.advance();
             var rest = false;
-            var letBindingObject;
             var args = [];
             var restArg;
-            while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-                if (letBindingObject) {
-                    throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-                }
-                if (isLBraceToken(this.peek())) {
-                    letBindingObject = this.parseObject();
-                }
-                else {
-                    if (isA_OperatorToken(this.peek(), '...')) {
-                        if (rest) {
-                            throw new LitsError('Multiple spread operators in lambda function', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-                        }
-                        this.advance();
-                        rest = true;
-                    }
-                    var symbolToken = this.peek();
-                    if (!isA_SymbolToken(symbolToken)) {
-                        throw new LitsError('Expected symbol', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-                    }
+            while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+                if (isA_OperatorToken(this.peek(), '...')) {
                     if (rest) {
-                        restArg = symbolToken[1];
-                    }
-                    else {
-                        args.push(symbolToken[1]);
+                        throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
                     }
                     this.advance();
+                    rest = true;
+                }
+                var symbolToken = this.peek();
+                if (!isA_SymbolToken(symbolToken)) {
+                    throw new LitsError('Expected symbol', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
                 }
-                if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
-                    throw new LitsError('Expected comma or closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+                if (rest) {
+                    restArg = symbolToken[1];
+                }
+                else {
+                    args.push(symbolToken[1]);
+                }
+                this.advance();
+                if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isA_SymbolToken(this.peek(), 'let')) {
+                    throw new LitsError('Expected comma or closing parenthesis', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
                 }
                 if (isA_OperatorToken(this.peek(), ',')) {
                     this.advance();
                 }
             }
             var arity = restArg !== undefined ? { min: args.length } : args.length;
+            // let bindings, to be able to pass on values in the context down to the body
+            // This is needed since lits is dynamically scoped
+            // E.g.
+            // x => y => x + y // would not work, x is not available in the second lambda
+            // x => (y, let x = x) => x + y // would work, x is available in the second lambda
+            var bindingNodess = [];
+            var token = this.peek();
+            while (isA_SymbolToken(token, 'let')) {
+                var letNode = this.parseLet(token, true);
+                bindingNodess.push(letNode.bs[0]);
+                token = this.peek();
+            }
             if (!isRParenToken(this.peek())) {
-                throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
+                throw new LitsError('Expected closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
             }
-            var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
             var functionArguments = {
                 m: args,
                 r: restArg,
-                b: letBindings.map(function (pair) {
-                    var key = pair[0];
-                    var value = pair[1];
-                    return {
-                        t: exports.AstNodeType.Binding,
-                        n: key.v,
-                        v: value,
-                        p: [],
-                        token: getTokenDebugData(key.token) && key.token,
-                    };
-                }),
+                b: bindingNodess,
             };
             this.advance();
             return {
@@ -7351,6 +7320,7 @@ var Lits = (function (exports) {
             }
             assertA_ReservedSymbolToken(this.peek(), 'end');
             this.advance();
+            assertA_OperatorToken(this.peek(), ';');
             var fnNode = {
                 t: exports.AstNodeType.SpecialExpression,
                 n: 'fn',
@@ -7513,7 +7483,7 @@ var Lits = (function (exports) {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertEvenNumberOfParams(node);
+        assertNumberOfParams({ even: true }, node);
         return node;
     }
     var placeholderRegexp = /^%([1-9]\d?)?$/;
@@ -7619,7 +7589,7 @@ var Lits = (function (exports) {
         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);
@@ -7643,7 +7613,7 @@ var Lits = (function (exports) {
         };
         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;
     }
@@ -7652,7 +7622,7 @@ var Lits = (function (exports) {
         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,
@@ -7661,7 +7631,7 @@ var Lits = (function (exports) {
             parseBindings: parseBindings,
             parseArgument: parseArgument,
         });
-        validateParameterCount(node);
+        assertNumberOfParams(paramCount, node);
         return node;
     }
     function parsePolishToken(tokenStream, parseState) {
@@ -7691,47 +7661,12 @@ var Lits = (function (exports) {
                 return parseFnShorthand(tokenStream, parseState);
             case 'P_Comment':
                 return parseComment(tokenStream, parseState);
-            case 'AlgNotation': {
-                parseState.position += 1;
-                parseState.algebraic = true;
-                var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-                var nodes = algebraicParser.parse();
-                assertEndNotationToken(tokenStream.tokens[parseState.position++]);
-                parseState.algebraic = false;
-                if (nodes.length === 1) {
-                    return nodes[0];
-                }
-                return {
-                    t: exports.AstNodeType.SpecialExpression,
-                    n: 'do',
-                    p: nodes,
-                    token: nodes[0].token,
-                };
-            }
-            case 'PolNotation': {
-                var astNodes = [];
-                parseState.position += 1;
-                do {
-                    astNodes.push(parsePolishToken(tokenStream, parseState));
-                } while (!isEndNotationToken(asToken(tokenStream.tokens[parseState.position])));
-                parseState.position += 1;
-                if (astNodes.length === 1) {
-                    return astNodes[0];
-                }
-                return {
-                    t: exports.AstNodeType.SpecialExpression,
-                    n: 'do',
-                    p: astNodes,
-                    token: astNodes[0].token,
-                };
-            }
             case 'P_CollectionAccessor':
             case 'P_Modifier':
             case 'RParen':
             case 'RBracket':
             case 'RBrace':
             case 'P_Whitespace':
-            case 'EndNotation':
                 break;
             /* v8 ignore next 2 */
             default:
@@ -7741,49 +7676,28 @@ var Lits = (function (exports) {
     }
 
     function parse(tokenStream) {
-        var _a;
-        var safeTokenStream = removeUnnecessaryTokens(tokenStream);
+        tokenStream = minifyTokenStream(tokenStream);
+        var algebraic = tokenStream.algebraic;
         var ast = {
             b: [],
-            hasDebugData: safeTokenStream.hasDebugData,
+            hasDebugData: tokenStream.hasDebugData,
         };
         var parseState = {
             position: 0,
-            algebraic: (_a = safeTokenStream.algebraic) !== null && _a !== void 0 ? _a : false,
             parseToken: parseToken,
         };
-        while (parseState.position < safeTokenStream.tokens.length) {
-            ast.b.push(parseToken(safeTokenStream, parseState));
+        if (algebraic) {
+            var algebraicParser = new AlgebraicParser(tokenStream, parseState);
+            ast.b = algebraicParser.parse();
         }
-        return ast;
-    }
-    function removeUnnecessaryTokens(tokenStream) {
-        var tokens = tokenStream.tokens.filter(function (token) {
-            if (isP_CommentToken(token)
-                || isA_CommentToken(token)
-                || isA_MultiLineCommentToken(token)
-                || isA_WhitespaceToken(token)
-                || isP_WhitespaceToken(token)) {
-                return false;
+        else {
+            while (parseState.position < tokenStream.tokens.length) {
+                ast.b.push(parseToken(tokenStream, parseState));
             }
-            return true;
-        });
-        return __assign(__assign({}, tokenStream), { tokens: tokens });
+        }
+        return ast;
     }
     function parseToken(tokenStream, parseState) {
-        if (parseState.algebraic) {
-            var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-            var nodes = algebraicParser.parse();
-            if (nodes.length === 1) {
-                return nodes[0];
-            }
-            return {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'do',
-                p: nodes,
-                token: nodes[0].token,
-            };
-        }
         return parsePolishToken(tokenStream, parseState);
     }
 
@@ -7814,15 +7728,6 @@ var Lits = (function (exports) {
     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;
@@ -7875,9 +7780,6 @@ var Lits = (function (exports) {
             return NO_MATCH;
     }
     var commonTokenizers = [
-        tokenizePolishNotation,
-        tokenizeAlgebraicNotation,
-        tokenizeEndNotation,
         tokenizeLParen,
         tokenizeRParen,
         tokenizeLBracket,
@@ -8387,7 +8289,6 @@ var Lits = (function (exports) {
 
     function tokenize(input, params) {
         var debug = !!params.debug;
-        var notationStack = [params.algebraic ? 'algebraic' : 'polish'];
         var position = 0;
         var tokenStream = {
             tokens: [],
@@ -8396,7 +8297,7 @@ var Lits = (function (exports) {
             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
                 ? {
@@ -8413,23 +8314,8 @@ var Lits = (function (exports) {
                     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;
     }
@@ -8514,9 +8400,6 @@ var Lits = (function (exports) {
             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:
@@ -8641,7 +8524,8 @@ var Lits = (function (exports) {
             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);