@mojir/lits 2.0.16 → 2.0.18

package/dist/testFramework.js

@@ -283,6 +283,7 @@ var commonSimpleTokenTypes = [
 ];
 var commomValueTokenTypes = [
     'String',
+    'RegexpShorthand',
 ];
 function isLParenToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'LParen';
@@ -356,6 +357,18 @@ function asStringToken(token) {
     assertStringToken(token);
     return token;
 }
+function isRegexpShorthandToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'RegexpShorthand';
+}
+function assertRegexpShorthandToken(token) {
+    if (!isRegexpShorthandToken(token)) {
+        throwUnexpectedToken('RegexpShorthand', undefined, token);
+    }
+}
+function asRegexpShorthandToken(token) {
+    assertRegexpShorthandToken(token);
+    return token;
+}
 function isAlgebraicNotationToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'AlgNotation';
 }
@@ -426,24 +439,22 @@ var symbolicOperators = __spreadArray(__spreadArray(__spreadArray([], __read(sym
 var nonFunctionOperators = [
     '??',
     '&&',
+    '||',
     'comment',
     'cond',
+    'def',
     'defined?',
-    'if',
-    'unless',
-    '||',
+    'defn',
     'do',
-    'throw',
-    'let',
-    'def',
-    'defs',
+    'doseq',
     'fn',
-    'defn',
-    'defns',
-    'try',
-    'recur',
+    'if',
+    'let',
     'loop',
-    'doseq',
+    'recur',
+    'throw',
+    'try',
+    'unless',
     'while',
 ];
 var nonFunctionOperatorSet = new Set(nonFunctionOperators);
@@ -514,9 +525,10 @@ function isA_OperatorToken(token, operatorName) {
 }
 function assertA_OperatorToken(token, operatorName) {
     if (!isA_OperatorToken(token, operatorName)) {
-        {
+        if (operatorName) {
             throw new LitsError("Unexpected token: ".concat(token, ", expected operator ").concat(operatorName), undefined);
         }
+        throwUnexpectedToken('A_Operator', operatorName, token);
     }
 }
 function isA_WhitespaceToken(token) {
@@ -539,7 +551,6 @@ var polishOnlyValueTokenTypes = [
     'P_StringShorthand',
     'P_Symbol',
     'P_ReservedSymbol',
-    'P_RegexpShorthand',
     'P_CollectionAccessor',
     'P_Comment',
     'P_Whitespace',
@@ -577,18 +588,6 @@ function isP_ReservedSymbolToken(token) {
 function isP_ModifierToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'P_Modifier';
 }
-function isP_RegexpShorthandToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'P_RegexpShorthand';
-}
-function assertP_RegexpShorthandToken(token) {
-    if (!isP_RegexpShorthandToken(token)) {
-        throwUnexpectedToken('P_RegexpShorthand', undefined, token);
-    }
-}
-function asP_RegexpShorthandToken(token) {
-    assertP_RegexpShorthandToken(token);
-    return token;
-}
 function isP_FnShorthandToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'P_FnShorthand';
 }
@@ -849,11 +848,6 @@ var specialExpressionCommentRemovers = {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
-    'defns': function (_node, _removeOptions) { },
-    'defs': function (node, removeOptions) {
-        removeOptions.removeCommenNodesFromArray(node.p);
-        node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
-    },
     'do': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
@@ -1941,7 +1935,7 @@ var arrayNormalExpression = {
 };
 
 var sequenceNormalExpression = {
-    nth: {
+    'nth': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 2), seq = _a[0], i = _a[1];
             var defaultValue = toAny(params[2]);
@@ -1953,7 +1947,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    filter: {
+    'filter': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
@@ -1968,7 +1962,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    first: {
+    'first': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
             if (array === null)
@@ -1978,7 +1972,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    last: {
+    'last': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
             if (array === null)
@@ -1988,7 +1982,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    map: {
+    'map': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2010,7 +2004,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    pop: {
+    'pop': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2021,7 +2015,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    position: {
+    'position': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2040,7 +2034,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    index_of: {
+    'index_of': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], value = _b[1];
             assertAny(value, sourceCodeInfo);
@@ -2059,7 +2053,26 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    push: {
+    'last_index_of': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), seq = _b[0], value = _b[1];
+            assertAny(value, sourceCodeInfo);
+            if (seq === null)
+                return null;
+            assertSeq(seq, sourceCodeInfo);
+            if (typeof seq === 'string') {
+                assertString(value, sourceCodeInfo);
+                var index = seq.lastIndexOf(value);
+                return index !== -1 ? index : null;
+            }
+            else {
+                var index = seq.lastIndexOf(value);
+                return index !== -1 ? index : null;
+            }
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
+    },
+    'push': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a), seq = _b[0], values = _b.slice(1);
             assertSeq(seq, sourceCodeInfo);
@@ -2073,7 +2086,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
-    reductions: {
+    'reductions': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
             var _b = __read(params, 2), seq = _b[0], fn = _b[1];
@@ -2134,7 +2147,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    reduce: {
+    'reduce': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
             var _b = __read(params, 2), seq = _b[0], fn = _b[1];
@@ -2181,7 +2194,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    reduce_right: {
+    'reduce_right': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
             var _b = __read(params, 2), seq = _b[0], fn = _b[1];
@@ -2229,7 +2242,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    rest: {
+    'rest': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2242,7 +2255,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    nthrest: {
+    'nthrest': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], count = _b[1];
             assertSeq(seq, sourceCodeInfo);
@@ -2254,7 +2267,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    next: {
+    'next': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2269,7 +2282,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    nthnext: {
+    'nthnext': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], count = _b[1];
             assertSeq(seq, sourceCodeInfo);
@@ -2283,7 +2296,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    reverse: {
+    'reverse': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             if (seq === null)
@@ -2295,7 +2308,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    second: {
+    'second': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             if (seq === null)
@@ -2305,7 +2318,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    shift: {
+    'shift': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2317,7 +2330,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    slice: {
+    'slice': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 3), seq = _a[0], from = _a[1], to = _a[2];
             assertSeq(seq, sourceCodeInfo);
@@ -2331,7 +2344,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
     },
-    some: {
+    'some': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c;
             var _d = __read(_a, 2), seq = _d[0], fn = _d[1];
@@ -2348,7 +2361,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    sort: {
+    'sort': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
             var _b = __read(params, 1), seq = _b[0];
@@ -2386,7 +2399,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    sort_by: {
+    'sort_by': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
             var _b = __read(params, 2), seq = _b[0], keyfn = _b[1];
@@ -2437,7 +2450,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    take: {
+    'take': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), input = _b[0], n = _b[1];
             assertNumber(n, sourceCodeInfo);
@@ -2447,7 +2460,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    take_last: {
+    'take_last': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), array = _b[0], n = _b[1];
             assertSeq(array, sourceCodeInfo);
@@ -2458,7 +2471,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    take_while: {
+    'take_while': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var e_1, _c;
             var _d = __read(_a, 2), seq = _d[0], fn = _d[1];
@@ -2486,7 +2499,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    drop: {
+    'drop': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), input = _b[0], n = _b[1];
             assertNumber(n, sourceCodeInfo);
@@ -2496,7 +2509,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    drop_last: {
+    'drop_last': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), array = _b[0], n = _b[1];
             assertSeq(array, sourceCodeInfo);
@@ -2507,7 +2520,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    drop_while: {
+    'drop_while': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2523,7 +2536,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    unshift: {
+    'unshift': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a), seq = _b[0], values = _b.slice(1);
             assertSeq(seq, sourceCodeInfo);
@@ -2537,7 +2550,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
-    distinct: {
+    'distinct': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), input = _b[0];
             assertSeq(input, sourceCodeInfo);
@@ -2547,9 +2560,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    remove: {
+    'remove': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], input = _c[1];
+            var _c = __read(_a, 2), input = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertSeq(input, sourceCodeInfo);
@@ -2562,9 +2575,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    remove_at: {
+    'remove_at': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), index = _b[0], input = _b[1];
+            var _b = __read(_a, 2), input = _b[0], index = _b[1];
             assertNumber(index, sourceCodeInfo);
             assertSeq(input, sourceCodeInfo);
             var intIndex = Math.ceil(index);
@@ -2579,9 +2592,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    split_at: {
+    'split_at': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), pos = _b[0], seq = _b[1];
+            var _b = __read(_a, 2), seq = _b[0], pos = _b[1];
             assertNumber(pos, sourceCodeInfo, { finite: true });
             var intPos = toNonNegativeInteger(pos);
             assertSeq(seq, sourceCodeInfo);
@@ -2589,9 +2602,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    split_with: {
+    'split_with': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
@@ -2604,7 +2617,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    frequencies: {
+    'frequencies': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2620,9 +2633,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    group_by: {
+    'group_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertAny(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
@@ -2638,34 +2651,30 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    partition: {
+    'partition': {
         evaluate: function (params, sourceCodeInfo) {
-            var len = params.length;
-            var n = toNonNegativeInteger(asNumber(params[0], sourceCodeInfo));
-            var seq = len === 2
-                ? asSeq(params[1], sourceCodeInfo)
-                : len === 3
-                    ? asSeq(params[2], sourceCodeInfo)
-                    : asSeq(params[3], sourceCodeInfo);
-            var step = len >= 3 ? toNonNegativeInteger(asNumber(params[1], sourceCodeInfo)) : n;
-            var pad = len === 4 ? (params[2] === null ? [] : asArray(params[2], sourceCodeInfo)) : undefined;
+            var seq = asSeq(params[0], sourceCodeInfo);
+            var n = toNonNegativeInteger(asNumber(params[1], sourceCodeInfo));
+            var step = params.length >= 3 ? toNonNegativeInteger(asNumber(params[2], sourceCodeInfo)) : n;
+            var pad = params.length === 4
+                ? params[3] === null ? [] : asArray(params[3], sourceCodeInfo)
+                : undefined;
             return partition(n, step, seq, pad, sourceCodeInfo);
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 4 }, node); },
     },
-    partition_all: {
+    'partition_all': {
         evaluate: function (params, sourceCodeInfo) {
-            var len = params.length;
-            var n = toNonNegativeInteger(asNumber(params[0], sourceCodeInfo));
-            var seq = len === 2 ? asSeq(params[1], sourceCodeInfo) : asSeq(params[2], sourceCodeInfo);
-            var step = len >= 3 ? toNonNegativeInteger(asNumber(params[1], sourceCodeInfo)) : n;
+            var seq = asSeq(params[0], sourceCodeInfo);
+            var n = toNonNegativeInteger(asNumber(params[1], sourceCodeInfo));
+            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); },
     },
-    partition_by: {
+    'partition_by': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
@@ -2682,7 +2691,88 @@ var sequenceNormalExpression = {
             }, []);
             return isStringSeq ? result.map(function (elem) { return elem.join(''); }) : result;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
+        validate: function (node) { return assertNumberOfParams(2, node); },
+    },
+    'ends_with?': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), str = _b[0], search = _b[1];
+            assertSeq(str, sourceCodeInfo);
+            if (typeof str === 'string') {
+                assertString(search, sourceCodeInfo);
+                return str.endsWith(search);
+            }
+            return str.at(-1) === search;
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
+    },
+    'starts_with?': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), str = _b[0], search = _b[1];
+            assertSeq(str, sourceCodeInfo);
+            if (typeof str === 'string') {
+                assertString(search, sourceCodeInfo);
+                return str.startsWith(search);
+            }
+            return str[0] === search;
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
+    },
+    'interleave': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var e_2, _b;
+            var _c = __read(_a), seqs = _c.slice(0);
+            var isStringSeq = typeof seqs[0] === 'string';
+            var seqsArr = isStringSeq
+                ? seqs.map(function (seq) {
+                    assertString(seq, sourceCodeInfo);
+                    if (typeof seq === 'string')
+                        return seq.split('');
+                    return seq;
+                })
+                : seqs.map(function (seq) {
+                    assertArray(seq, sourceCodeInfo);
+                    return seq;
+                });
+            var maxLength = Math.min.apply(Math, __spreadArray([], __read(seqsArr.map(function (seq) { return seq.length; })), false));
+            var result = [];
+            for (var i = 0; i < maxLength; i += 1) {
+                try {
+                    for (var seqsArr_1 = (e_2 = void 0, __values(seqsArr)), seqsArr_1_1 = seqsArr_1.next(); !seqsArr_1_1.done; seqsArr_1_1 = seqsArr_1.next()) {
+                        var seq = seqsArr_1_1.value;
+                        if (i < seq.length)
+                            result.push(seq[i]);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (seqsArr_1_1 && !seqsArr_1_1.done && (_b = seqsArr_1.return)) _b.call(seqsArr_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            return isStringSeq ? result.join('') : result;
+        },
+        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+    },
+    'interpose': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), seq = _b[0], separator = _b[1];
+            assertSeq(seq, sourceCodeInfo);
+            if (typeof seq === 'string') {
+                assertString(separator, sourceCodeInfo);
+                return seq.split('').join(separator);
+            }
+            if (seq.length === 0)
+                return [];
+            var result = [];
+            for (var i = 0; i < seq.length - 1; i += 1) {
+                result.push(seq[i], separator);
+            }
+            result.push(seq[seq.length - 1]);
+            return result;
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
     },
 };
 function partition(n, step, seq, pad, sourceCodeInfo) {
@@ -3845,7 +3935,7 @@ var regexpNormalExpression = {
     },
     match: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), regexp = _b[0], text = _b[1];
+            var _b = __read(_a, 2), text = _b[0], regexp = _b[1];
             assertRegularExpression(regexp, sourceCodeInfo);
             if (!isString(text))
                 return null;
@@ -3861,15 +3951,27 @@ var regexpNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), str = _b[0], regexp = _b[1], value = _b[2];
             assertString(str, sourceCodeInfo);
-            assertRegularExpression(regexp, sourceCodeInfo);
+            assertStringOrRegularExpression(regexp, sourceCodeInfo);
             assertString(value, sourceCodeInfo);
-            var regExp = new RegExp(regexp.s, regexp.f);
-            return str.replace(regExp, value);
+            var matcher = isRegularExpression(regexp) ? new RegExp(regexp.s, "".concat(regexp.f)) : regexp;
+            return str.replace(matcher, value);
+        },
+        validate: function (node) { return assertNumberOfParams(3, node); },
+    },
+    replace_all: {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), str = _b[0], regexp = _b[1], value = _b[2];
+            assertString(str, sourceCodeInfo);
+            assertStringOrRegularExpression(regexp, sourceCodeInfo);
+            assertString(value, sourceCodeInfo);
+            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); },
     },
 };
 
+var blankRegexp = /^\s*$/;
 var stringNormalExpression = {
     'subs': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -4027,6 +4129,14 @@ var stringNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
+    'split_lines': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), str = _b[0];
+            assertString(str, sourceCodeInfo);
+            return str.split((/\r\n|\n|\r/)).filter(function (line) { return line !== ''; });
+        },
+        validate: function (node) { return assertNumberOfParams(1, node); },
+    },
     'pad_left': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), str = _b[0], length = _b[1], padString = _b[2];
@@ -4130,6 +4240,25 @@ var stringNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
+    'blank?': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), value = _b[0];
+            if (value === null) {
+                return true;
+            }
+            assertString(value, sourceCodeInfo);
+            return blankRegexp.test(value);
+        },
+        validate: function (node) { return assertNumberOfParams(1, node); },
+    },
+    'capitalize': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), str = _b[0];
+            assertString(str, sourceCodeInfo);
+            return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+        },
+        validate: function (node) { return assertNumberOfParams(1, node); },
+    },
 };
 var doubleDollarRegexp = /\$\$/g;
 function applyPlaceholders(templateString, placeholders, sourceCodeInfo) {
@@ -4474,44 +4603,6 @@ var defSpecialExpression = {
     },
 };
 
-var defsSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'defs',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
-    evaluate: function (node, contextStack, _a) {
-        var _b, _c;
-        var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
-        var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
-        var name = evaluateAstNode(node.p[0], contextStack);
-        assertString(name, sourceCodeInfo);
-        assertNameNotDefined(name, contextStack, builtin, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        contextStack.exportValue(name, evaluateAstNode(node.p[1], contextStack));
-        return null;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-        var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
-        var subNode = node.p[1];
-        var result = findUnresolvedIdentifiers([subNode], contextStack, builtin);
-        var name = evaluateAstNode(node.p[0], contextStack);
-        assertString(name, sourceCodeInfo);
-        assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.exportValue(name, true);
-        return result;
-    },
-};
-
 var doSpecialExpression = {
     polishParse: getCommonPolishSpecialExpressionParser('do'),
     validateParameterCount: function () { return undefined; },
@@ -4591,7 +4682,7 @@ var defnSpecialExpression = {
         var _b;
         var _c, _d;
         var builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-        var name = getFunctionName('defn', node, contextStack, evaluateAstNode);
+        var name = node.f.v;
         assertNameNotDefined(name, contextStack, builtin, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
         var evaluatedFunctionOverloades = evaluateFunctionOverloades(node, contextStack, evaluateAstNode);
         var litsFunction = (_b = {},
@@ -4612,53 +4703,6 @@ var defnSpecialExpression = {
         return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin, newContext);
     },
 };
-var defnsSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, parsers) {
-        var parseToken = parsers.parseToken;
-        var functionName = parseToken(tokenStream, parseState);
-        var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'defns',
-            p: [],
-            f: functionName,
-            o: functionOverloades,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function () { return undefined; },
-    evaluate: function (node, contextStack, _a) {
-        var _b;
-        var _c, _d;
-        var builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-        var name = getFunctionName('defns', node, contextStack, evaluateAstNode);
-        assertNameNotDefined(name, contextStack, builtin, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        var evaluatedFunctionOverloades = evaluateFunctionOverloades(node, contextStack, evaluateAstNode);
-        var litsFunction = (_b = {},
-            _b[FUNCTION_SYMBOL] = true,
-            _b.sourceCodeInfo = (_d = getTokenDebugData(node.token)) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo,
-            _b.t = FunctionType.UserDefined,
-            _b.n = name,
-            _b.o = evaluatedFunctionOverloades,
-            _b);
-        contextStack.exportValue(name, litsFunction);
-        return null;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var _c;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin, evaluateAstNode = _a.evaluateAstNode;
-        var sourceCodeInfo = (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo;
-        var name = evaluateAstNode(asAstNode(node.f, sourceCodeInfo), contextStack);
-        assertString(name, sourceCodeInfo);
-        assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.exportValue(name, true);
-        var newContext = (_b = {}, _b[name] = { value: true }, _b);
-        return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin, newContext);
-    },
-};
 var fnSpecialExpression = {
     polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
@@ -4692,14 +4736,6 @@ var fnSpecialExpression = {
         return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin);
     },
 };
-function getFunctionName(expressionName, node, contextStack, evaluateAstNode) {
-    var _a;
-    var sourceCodeInfo = (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo;
-    if (expressionName === 'defn')
-        return (node.f).v;
-    var name = evaluateAstNode(node.f, contextStack);
-    return asString(name, sourceCodeInfo);
-}
 function evaluateFunctionOverloades(node, contextStack, evaluateAstNode) {
     var e_1, _a, e_2, _b;
     var evaluatedFunctionOverloades = [];
@@ -5477,8 +5513,6 @@ var specialExpressions = {
     'switch': switchSpecialExpression,
     'def': defSpecialExpression,
     'defn': defnSpecialExpression,
-    'defns': defnsSpecialExpression,
-    'defs': defsSpecialExpression,
     'do': doSpecialExpression,
     'doseq': doseqSpecialExpression,
     'for': forSpecialExpression,
@@ -5540,7 +5574,6 @@ var ContextStackImpl = /** @class */ (function () {
         if (normalExpressionKeys.includes(name)) {
             throw new Error("Cannot shadow builtin function \"".concat(name, "\""));
         }
-        this.addValue(name, value);
         this.globalContext[name] = { value: value };
     };
     ContextStackImpl.prototype.addValue = function (name, value) {
@@ -6204,6 +6237,33 @@ function parseString(tokenStream, parseState) {
         token: getTokenDebugData(tkn) && tkn,
     };
 }
+function parseRegexpShorthand(tokenStream, parseState) {
+    var tkn = asRegexpShorthandToken(tokenStream.tokens[parseState.position++]);
+    var endStringPosition = tkn[1].lastIndexOf('"');
+    var regexpString = tkn[1].substring(2, endStringPosition);
+    var optionsString = tkn[1].substring(endStringPosition + 1);
+    var stringNode = {
+        t: AstNodeType.String,
+        v: regexpString,
+        p: [],
+        n: undefined,
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    var optionsNode = {
+        t: AstNodeType.String,
+        v: optionsString,
+        p: [],
+        n: undefined,
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    var node = {
+        t: AstNodeType.NormalExpression,
+        n: 'regexp',
+        p: [stringNode, optionsNode],
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    return node;
+}
 
 var exponentiationPrecedence = 10;
 var binaryFunctionalOperatorPrecedence = 1;
@@ -6345,6 +6405,12 @@ var AlgebraicParser = /** @class */ (function () {
         this.tokenStream = tokenStream;
         this.parseState = parseState;
     }
+    AlgebraicParser.prototype.peek = function () {
+        return this.tokenStream.tokens[this.parseState.position];
+    };
+    AlgebraicParser.prototype.peekAhead = function (count) {
+        return this.tokenStream.tokens[this.parseState.position + count];
+    };
     AlgebraicParser.prototype.advance = function () {
         this.parseState.position += 1;
     };
@@ -6366,10 +6432,6 @@ var AlgebraicParser = /** @class */ (function () {
         var left;
         if (isA_SymbolToken(firstToken)) {
             switch (firstToken[1]) {
-                case 'def':
-                    return this.parseDef(firstToken);
-                case 'defn':
-                    return this.parseDefn(firstToken);
                 case 'let':
                     return this.parseLet(firstToken);
                 case 'if':
@@ -6397,6 +6459,12 @@ var AlgebraicParser = /** @class */ (function () {
                     break;
             }
         }
+        else if (isA_ReservedSymbolToken(firstToken, 'function')) {
+            return this.parseFunction(firstToken);
+        }
+        else if (isA_ReservedSymbolToken(firstToken, 'export')) {
+            return this.parseExport(firstToken);
+        }
         left || (left = this.parseOperand());
         var operator = this.peek();
         while (!this.isAtExpressionEnd()) {
@@ -6528,10 +6596,18 @@ var AlgebraicParser = /** @class */ (function () {
             case 'String':
                 return parseString(this.tokenStream, this.parseState);
             case 'A_Symbol': {
+                var positionBefore = this.parseState.position;
+                var lamdaFunction = this.parseLambdaFunction();
+                if (lamdaFunction) {
+                    return lamdaFunction;
+                }
+                this.parseState.position = positionBefore;
                 return parseSymbol(this.tokenStream, this.parseState);
             }
             case 'A_ReservedSymbol':
                 return parseReservedSymbol(this.tokenStream, this.parseState);
+            case 'RegexpShorthand':
+                return parseRegexpShorthand(this.tokenStream, this.parseState);
             case 'PolNotation': {
                 this.parseState.algebraic = false;
                 var astNodes = [];
@@ -6665,11 +6741,9 @@ var AlgebraicParser = /** @class */ (function () {
                         builtin.specialExpressions[node.n].validateParameterCount(node);
                         return node;
                     }
-                    case 'defs':
                     case 'fn':
-                    case 'defns':
-                    case 'try':
-                    case 'doseq':
+                    case 'def':
+                    case 'defn':
                         throw new Error("Special expression ".concat(name_2, " is not available in algebraic notation"));
                     default:
                         throw new Error("Unknown special expression: ".concat(name_2));
@@ -6688,6 +6762,11 @@ var AlgebraicParser = /** @class */ (function () {
     };
     AlgebraicParser.prototype.parseLambdaFunction = function () {
         var firstToken = this.peek();
+        if (isLParenToken(firstToken)
+            && isA_SymbolToken(this.peekAhead(1))
+            && isA_OperatorToken(this.peekAhead(2), '=>')) {
+            return null;
+        }
         try {
             var _a = this.parseFunctionArguments(), functionArguments = _a.functionArguments, arity = _a.arity;
             if (!isA_OperatorToken(this.peek(), '=>')) {
@@ -6713,6 +6792,18 @@ var AlgebraicParser = /** @class */ (function () {
     };
     AlgebraicParser.prototype.parseFunctionArguments = function () {
         var _a, _b, _c, _d, _e;
+        var firstToken = this.peek();
+        if (isA_SymbolToken(firstToken)) {
+            this.advance();
+            return {
+                functionArguments: {
+                    m: [firstToken[1]],
+                    b: [],
+                    r: undefined,
+                },
+                arity: 1,
+            };
+        }
         this.advance();
         var rest = false;
         var letBindingObject;
@@ -6831,17 +6922,20 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseLet = function (token) {
+    AlgebraicParser.prototype.parseLet = function (token, optionalSemicolon) {
+        if (optionalSemicolon === void 0) { optionalSemicolon = false; }
         this.advance();
         var letSymbol = parseSymbol(this.tokenStream, this.parseState);
         assertA_OperatorToken(this.peek(), '=');
         this.advance();
         var value = this.parseExpression();
+        if (!optionalSemicolon) {
+            assertA_OperatorToken(this.peek(), ';');
+        }
         return {
             t: AstNodeType.SpecialExpression,
             n: 'let',
             p: [],
-            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
             bs: [{
                     t: AstNodeType.Binding,
                     n: letSymbol.v,
@@ -6849,6 +6943,7 @@ var AlgebraicParser = /** @class */ (function () {
                     p: [],
                     token: getTokenDebugData(token) && token,
                 }],
+            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
         };
     };
     AlgebraicParser.prototype.parseDo = function (token) {
@@ -7016,7 +7111,7 @@ var AlgebraicParser = /** @class */ (function () {
             modifiers.push('&let');
             letBindings = [];
             while (isA_SymbolToken(token, 'let')) {
-                var letNode = this.parseLet(token);
+                var letNode = this.parseLet(token, true);
                 letBindings.push(letNode.bs[0]);
                 token = this.peek();
             }
@@ -7203,20 +7298,7 @@ var AlgebraicParser = /** @class */ (function () {
             token: getTokenDebugData(token) && token,
         };
     };
-    AlgebraicParser.prototype.parseDef = function (token) {
-        this.advance();
-        var symbol = parseSymbol(this.tokenStream, this.parseState);
-        assertA_OperatorToken(this.peek(), '=');
-        this.advance();
-        var value = this.parseExpression();
-        return {
-            t: AstNodeType.SpecialExpression,
-            n: 'def',
-            p: [symbol, value],
-            token: getTokenDebugData(token) && token,
-        };
-    };
-    AlgebraicParser.prototype.parseDefn = function (token) {
+    AlgebraicParser.prototype.parseFunction = function (token) {
         this.advance();
         var symbol = parseSymbol(this.tokenStream, this.parseState);
         var _a = this.parseFunctionArguments(), functionArguments = _a.functionArguments, arity = _a.arity;
@@ -7229,10 +7311,9 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
-        return {
+        var fnNode = {
             t: AstNodeType.SpecialExpression,
-            n: 'defn',
-            f: symbol,
+            n: 'fn',
             p: [],
             o: [{
                     as: functionArguments,
@@ -7241,6 +7322,19 @@ var AlgebraicParser = /** @class */ (function () {
                 }],
             token: getTokenDebugData(token) && token,
         };
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'let',
+            p: [],
+            bs: [{
+                    t: AstNodeType.Binding,
+                    n: symbol.v,
+                    v: fnNode,
+                    p: [],
+                    token: getTokenDebugData(symbol.token) && symbol.token,
+                }],
+            token: getTokenDebugData(token) && token,
+        };
     };
     AlgebraicParser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
@@ -7261,8 +7355,30 @@ var AlgebraicParser = /** @class */ (function () {
         }
         return false;
     };
-    AlgebraicParser.prototype.peek = function () {
-        return this.tokenStream.tokens[this.parseState.position];
+    AlgebraicParser.prototype.parseExport = function (token) {
+        var _a;
+        this.advance();
+        var symbol = parseSymbol(this.tokenStream, this.parseState);
+        if (isA_OperatorToken(this.peek(), ';')) {
+            return {
+                t: AstNodeType.SpecialExpression,
+                n: 'def',
+                p: [symbol, symbol],
+                token: getTokenDebugData(token) && token,
+            };
+        }
+        if (!isA_OperatorToken(this.peek(), '=')) {
+            throw new LitsError('Expected = or ;', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        this.advance();
+        var value = this.parseExpression();
+        assertA_OperatorToken(this.peek(), ';');
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'def',
+            p: [symbol, value],
+            token: getTokenDebugData(token) && token,
+        };
     };
     return AlgebraicParser;
 }());
@@ -7338,33 +7454,6 @@ function parseObjectLitteral(tokenStream, parseState) {
     assertEvenNumberOfParams(node);
     return node;
 }
-function parseRegexpShorthand(tokenStream, parseState) {
-    var tkn = asP_RegexpShorthandToken(tokenStream.tokens[parseState.position++]);
-    var endStringPosition = tkn[1].lastIndexOf('"');
-    var regexpString = tkn[1].substring(2, endStringPosition);
-    var optionsString = tkn[1].substring(endStringPosition + 1);
-    var stringNode = {
-        t: AstNodeType.String,
-        v: regexpString,
-        p: [],
-        n: undefined,
-        token: getTokenDebugData(tkn) && tkn,
-    };
-    var optionsNode = {
-        t: AstNodeType.String,
-        v: optionsString,
-        p: [],
-        n: undefined,
-        token: getTokenDebugData(tkn) && tkn,
-    };
-    var node = {
-        t: AstNodeType.NormalExpression,
-        n: 'regexp',
-        p: [stringNode, optionsNode],
-        token: getTokenDebugData(tkn) && tkn,
-    };
-    return node;
-}
 var placeholderRegexp = /^%([1-9]\d?)?$/;
 function parseFnShorthand(tokenStream, parseState) {
     var _a, _b, _c, _d;
@@ -7534,7 +7623,7 @@ function parsePolishToken(tokenStream, parseState) {
             return parseArrayLitteral(tokenStream, parseState);
         case 'LBrace':
             return parseObjectLitteral(tokenStream, parseState);
-        case 'P_RegexpShorthand':
+        case 'RegexpShorthand':
             return parseRegexpShorthand(tokenStream, parseState);
         case 'P_FnShorthand':
             return parseFnShorthand(tokenStream, parseState);
@@ -7697,6 +7786,25 @@ var tokenizeString = function (input, position) {
     value += '"'; // closing quote
     return [length + 1, ['String', value]];
 };
+var tokenizeRegexpShorthand = function (input, position) {
+    if (input[position] !== '#')
+        return NO_MATCH;
+    var _a = __read(tokenizeString(input, position + 1), 2), stringLength = _a[0], token = _a[1];
+    if (!token)
+        return NO_MATCH;
+    position += stringLength + 1;
+    var length = stringLength + 1;
+    var options = '';
+    while (input[position] === 'g' || input[position] === 'i') {
+        if (options.includes(input[position])) {
+            throw new LitsError("Duplicated regexp option \"".concat(input[position], "\" at position ").concat(position, "."), undefined);
+        }
+        options += input[position];
+        length += 1;
+        position += 1;
+    }
+    return [length, ['RegexpShorthand', "#".concat(token[1]).concat(options)]];
+};
 function tokenizeSimpleToken(type, value, input, position) {
     if (value === input.slice(position, position + value.length))
         return [value.length, [type]];
@@ -7714,6 +7822,7 @@ var commonTokenizers = [
     tokenizeLBrace,
     tokenizeRBrace,
     tokenizeString,
+    tokenizeRegexpShorthand,
 ];
 
 var validAlgebraicReservedNamesRecord = {
@@ -7727,10 +7836,11 @@ var validAlgebraicReservedNamesRecord = {
     case: { value: null, forbidden: false },
     when: { value: null, forbidden: false },
     while: { value: null, forbidden: false },
+    function: { value: null, forbidden: false },
+    export: { value: null, forbidden: false },
 };
 var forbiddenAlgebraicReservedNamesRecord = {
     fn: { value: null, forbidden: true },
-    defns: { value: null, forbidden: true },
 };
 var algebraicReservedNamesRecord = __assign(__assign({}, validAlgebraicReservedNamesRecord), forbiddenAlgebraicReservedNamesRecord);
 
@@ -8115,25 +8225,6 @@ var tokenizeP_CollectionAccessor = function (input, position) {
         return NO_MATCH;
     return [1, ['P_CollectionAccessor', char]];
 };
-var tokenizeP_RegexpShorthand = function (input, position) {
-    if (input[position] !== '#')
-        return NO_MATCH;
-    var _a = __read(tokenizeString(input, position + 1), 2), stringLength = _a[0], token = _a[1];
-    if (!token)
-        return NO_MATCH;
-    position += stringLength + 1;
-    var length = stringLength + 1;
-    var options = '';
-    while (input[position] === 'g' || input[position] === 'i') {
-        if (options.includes(input[position])) {
-            throw new LitsError("Duplicated regexp option \"".concat(input[position], "\" at position ").concat(position, "."), undefined);
-        }
-        options += input[position];
-        length += 1;
-        position += 1;
-    }
-    return [length, ['P_RegexpShorthand', "#".concat(token[1]).concat(options)]];
-};
 // All tokenizers, order matters!
 var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_Whitespace,
@@ -8144,7 +8235,6 @@ var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_ReservedSymbol,
     tokenizeP_Modifier,
     tokenizeP_Symbol,
-    tokenizeP_RegexpShorthand,
     tokenizeP_FnShorthand,
     tokenizeP_CollectionAccessor,
 ], false);