@mojir/lits 2.0.16 → 2.0.17

package/dist/index.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';
 }
@@ -769,11 +768,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);
@@ -1978,7 +1972,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]);
@@ -1990,7 +1984,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;
@@ -2005,7 +1999,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)
@@ -2015,7 +2009,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)
@@ -2025,7 +2019,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;
@@ -2047,7 +2041,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);
@@ -2058,7 +2052,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;
@@ -2077,7 +2071,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);
@@ -2096,7 +2090,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);
@@ -2110,7 +2123,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];
@@ -2171,7 +2184,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];
@@ -2218,7 +2231,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];
@@ -2266,7 +2279,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);
@@ -2279,7 +2292,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);
@@ -2291,7 +2304,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);
@@ -2306,7 +2319,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);
@@ -2320,7 +2333,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)
@@ -2332,7 +2345,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)
@@ -2342,7 +2355,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);
@@ -2354,7 +2367,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);
@@ -2368,7 +2381,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];
@@ -2385,7 +2398,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];
@@ -2423,7 +2436,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];
@@ -2474,7 +2487,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);
@@ -2484,7 +2497,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);
@@ -2495,7 +2508,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];
@@ -2523,7 +2536,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);
@@ -2533,7 +2546,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);
@@ -2544,7 +2557,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;
@@ -2560,7 +2573,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);
@@ -2574,7 +2587,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);
@@ -2584,9 +2597,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);
@@ -2599,9 +2612,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);
@@ -2616,9 +2629,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);
@@ -2626,9 +2639,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);
@@ -2641,7 +2654,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);
@@ -2657,9 +2670,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);
@@ -2675,34 +2688,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);
@@ -2719,7 +2728,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) {
@@ -3882,7 +3972,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;
@@ -3898,15 +3988,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) {
@@ -4064,6 +4166,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];
@@ -4167,6 +4277,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) {
@@ -4512,44 +4641,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: exports.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; },
@@ -4629,7 +4720,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 = {},
@@ -4650,53 +4741,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: exports.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 = exports.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);
@@ -4730,14 +4774,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 = [];
@@ -5515,8 +5551,6 @@ var specialExpressions = {
     'switch': switchSpecialExpression,
     'def': defSpecialExpression,
     'defn': defnSpecialExpression,
-    'defns': defnsSpecialExpression,
-    'defs': defsSpecialExpression,
     'do': doSpecialExpression,
     'doseq': doseqSpecialExpression,
     'for': forSpecialExpression,
@@ -5578,7 +5612,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) {
@@ -6242,6 +6275,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: exports.AstNodeType.String,
+        v: regexpString,
+        p: [],
+        n: undefined,
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    var optionsNode = {
+        t: exports.AstNodeType.String,
+        v: optionsString,
+        p: [],
+        n: undefined,
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    var node = {
+        t: exports.AstNodeType.NormalExpression,
+        n: 'regexp',
+        p: [stringNode, optionsNode],
+        token: getTokenDebugData(tkn) && tkn,
+    };
+    return node;
+}
 
 var exponentiationPrecedence = 10;
 var binaryFunctionalOperatorPrecedence = 1;
@@ -6383,6 +6443,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;
     };
@@ -6404,10 +6470,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':
@@ -6435,6 +6497,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()) {
@@ -6566,10 +6634,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 = [];
@@ -6703,11 +6779,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));
@@ -6726,6 +6800,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(), '=>')) {
@@ -6751,6 +6830,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;
@@ -6869,17 +6960,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: exports.AstNodeType.SpecialExpression,
             n: 'let',
             p: [],
-            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
             bs: [{
                     t: exports.AstNodeType.Binding,
                     n: letSymbol.v,
@@ -6887,6 +6981,7 @@ var AlgebraicParser = /** @class */ (function () {
                     p: [],
                     token: getTokenDebugData(token) && token,
                 }],
+            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
         };
     };
     AlgebraicParser.prototype.parseDo = function (token) {
@@ -7054,7 +7149,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();
             }
@@ -7241,20 +7336,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: exports.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;
@@ -7267,10 +7349,9 @@ var AlgebraicParser = /** @class */ (function () {
         }
         assertA_ReservedSymbolToken(this.peek(), 'end');
         this.advance();
-        return {
+        var fnNode = {
             t: exports.AstNodeType.SpecialExpression,
-            n: 'defn',
-            f: symbol,
+            n: 'fn',
             p: [],
             o: [{
                     as: functionArguments,
@@ -7279,6 +7360,19 @@ var AlgebraicParser = /** @class */ (function () {
                 }],
             token: getTokenDebugData(token) && token,
         };
+        return {
+            t: exports.AstNodeType.SpecialExpression,
+            n: 'let',
+            p: [],
+            bs: [{
+                    t: exports.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;
@@ -7299,8 +7393,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: exports.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: exports.AstNodeType.SpecialExpression,
+            n: 'def',
+            p: [symbol, value],
+            token: getTokenDebugData(token) && token,
+        };
     };
     return AlgebraicParser;
 }());
@@ -7376,33 +7492,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: exports.AstNodeType.String,
-        v: regexpString,
-        p: [],
-        n: undefined,
-        token: getTokenDebugData(tkn) && tkn,
-    };
-    var optionsNode = {
-        t: exports.AstNodeType.String,
-        v: optionsString,
-        p: [],
-        n: undefined,
-        token: getTokenDebugData(tkn) && tkn,
-    };
-    var node = {
-        t: exports.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;
@@ -7572,7 +7661,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);
@@ -7736,6 +7825,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]];
@@ -7753,6 +7861,7 @@ var commonTokenizers = [
     tokenizeLBrace,
     tokenizeRBrace,
     tokenizeString,
+    tokenizeRegexpShorthand,
 ];
 
 var validAlgebraicReservedNamesRecord = {
@@ -7766,10 +7875,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);
 
@@ -8154,25 +8264,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,
@@ -8183,7 +8274,6 @@ var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_ReservedSymbol,
     tokenizeP_Modifier,
     tokenizeP_Symbol,
-    tokenizeP_RegexpShorthand,
     tokenizeP_FnShorthand,
     tokenizeP_CollectionAccessor,
 ], false);
@@ -9502,7 +9592,7 @@ var arrayReference = {
 };
 
 var sequenceReference = {
-    nth: {
+    'nth': {
         title: 'nth',
         category: 'Sequence',
         linkName: 'nth',
@@ -9538,7 +9628,7 @@ var sequenceReference = {
             '(nth nil 1 "Default value")',
         ],
     },
-    push: {
+    'push': {
         title: 'push',
         category: 'Sequence',
         linkName: 'push',
@@ -9568,7 +9658,7 @@ var sequenceReference = {
             '(def l [1 2 3]) (push l 4) l',
         ],
     },
-    pop: {
+    'pop': {
         title: 'pop',
         category: 'Sequence',
         linkName: 'pop',
@@ -9591,7 +9681,7 @@ var sequenceReference = {
             '(pop [])',
         ],
     },
-    unshift: {
+    'unshift': {
         title: 'unshift',
         category: 'Sequence',
         linkName: 'unshift',
@@ -9620,7 +9710,7 @@ var sequenceReference = {
             "\n(def l [1 2 3])\n(unshift l 4)\nl",
         ],
     },
-    shift: {
+    'shift': {
         title: 'shift',
         category: 'Sequence',
         linkName: 'shift',
@@ -9644,7 +9734,7 @@ var sequenceReference = {
             '(shift [])',
         ],
     },
-    slice: {
+    'slice': {
         title: 'slice',
         category: 'Sequence',
         linkName: 'slice',
@@ -9678,7 +9768,7 @@ var sequenceReference = {
             '(slice [1 2 3 4 5] 2)',
         ],
     },
-    reductions: {
+    'reductions': {
         title: 'reductions',
         category: 'Sequence',
         linkName: 'reductions',
@@ -9710,7 +9800,7 @@ var sequenceReference = {
             "\n(reductions\n  (fn [result value] (+ result (if (even? value) value 0)))\n  0\n  [1 2 3 4 5 6 7 8 9])",
         ],
     },
-    reduce: {
+    'reduce': {
         title: 'reduce',
         category: 'Sequence',
         linkName: 'reduce',
@@ -9740,7 +9830,7 @@ var sequenceReference = {
             "\n(reduce\n  (fn [result value] (+ result (if (even? value) value 0)))\n  0\n  [1 2 3 4 5 6 7 8 9])",
         ],
     },
-    reduce_right: {
+    'reduce_right': {
         title: 'reduce_right',
         category: 'Sequence',
         linkName: 'reduce_right',
@@ -9768,7 +9858,7 @@ var sequenceReference = {
             '(reduce_right str [:A :B :C] "")',
         ],
     },
-    map: {
+    'map': {
         title: 'map',
         category: 'Sequence',
         linkName: 'map',
@@ -9793,7 +9883,7 @@ var sequenceReference = {
             '(map [1 2 3] inc)',
         ],
     },
-    filter: {
+    'filter': {
         title: 'filter',
         category: 'Sequence',
         linkName: 'filter',
@@ -9817,7 +9907,7 @@ var sequenceReference = {
             "\n(filter\n[5 10 15 20]\n  (fn [x] (> x 10)))",
         ],
     },
-    position: {
+    'position': {
         title: 'position',
         category: 'Sequence',
         linkName: 'position',
@@ -9844,7 +9934,7 @@ var sequenceReference = {
             "\n(position\n  (fn [x] (> x 100))\n  nil)",
         ],
     },
-    index_of: {
+    'index_of': {
         title: 'index_of',
         category: 'Sequence',
         linkName: 'index_of',
@@ -9871,7 +9961,34 @@ var sequenceReference = {
             '(index_of nil 1)',
         ],
     },
-    some: {
+    'last_index_of': {
+        title: 'last_index_of',
+        category: 'Sequence',
+        linkName: 'last_index_of',
+        clojureDocs: null,
+        returns: {
+            type: ['number', 'null'],
+        },
+        args: {
+            seq: {
+                type: ['sequence', 'null'],
+            },
+            x: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'x'] },
+        ],
+        description: 'Returns the last index of $x in $seq. If element is not present in $seq `nil` is returned.',
+        examples: [
+            '(last_index_of ["Albert" "Mojir" 160 [1 2]] "Mojir")',
+            '(last_index_of [5 10 15 20] 15)',
+            '(last_index_of [5 10 15 20] 1)',
+            '(last_index_of nil 1)',
+        ],
+    },
+    'some': {
         title: 'some',
         category: 'Sequence',
         linkName: 'some',
@@ -9898,7 +10015,7 @@ var sequenceReference = {
             "\n(some\n  nil\n  (fn [x] (> x 10)))",
         ],
     },
-    reverse: {
+    'reverse': {
         title: 'reverse',
         category: 'Sequence',
         linkName: 'reverse',
@@ -9921,7 +10038,7 @@ var sequenceReference = {
             '(reverse nil)',
         ],
     },
-    first: {
+    'first': {
         title: 'first',
         category: 'Sequence',
         linkName: 'first',
@@ -9943,7 +10060,7 @@ var sequenceReference = {
             '(first nil)',
         ],
     },
-    second: {
+    'second': {
         title: 'second',
         category: 'Sequence',
         linkName: 'second',
@@ -9966,7 +10083,7 @@ var sequenceReference = {
             '(second nil)',
         ],
     },
-    last: {
+    'last': {
         title: 'last',
         category: 'Sequence',
         linkName: 'last',
@@ -9990,7 +10107,7 @@ var sequenceReference = {
             '(last nil)',
         ],
     },
-    rest: {
+    'rest': {
         title: 'rest',
         category: 'Sequence',
         linkName: 'rest',
@@ -10015,7 +10132,7 @@ var sequenceReference = {
             '(rest "")',
         ],
     },
-    nthrest: {
+    'nthrest': {
         title: 'nthrest',
         category: 'Sequence',
         linkName: 'nthrest',
@@ -10043,7 +10160,7 @@ var sequenceReference = {
             '(nthrest "" 0)',
         ],
     },
-    next: {
+    'next': {
         title: 'next',
         category: 'Sequence',
         linkName: 'next',
@@ -10068,7 +10185,7 @@ var sequenceReference = {
             '(next "")',
         ],
     },
-    nthnext: {
+    'nthnext': {
         title: 'nthnext',
         category: 'Sequence',
         linkName: 'nthnext',
@@ -10096,7 +10213,7 @@ var sequenceReference = {
             '(nthnext "" 0)',
         ],
     },
-    take: {
+    'take': {
         title: 'take',
         category: 'Sequence',
         linkName: 'take',
@@ -10122,7 +10239,7 @@ var sequenceReference = {
             '(take 50 "Albert")',
         ],
     },
-    take_last: {
+    'take_last': {
         title: 'take_last',
         category: 'Sequence',
         linkName: 'take_last',
@@ -10146,7 +10263,7 @@ var sequenceReference = {
             '(take_last 0 [1 2 3 4 5])',
         ],
     },
-    take_while: {
+    'take_while': {
         title: 'take_while',
         category: 'Sequence',
         linkName: 'take_while',
@@ -10170,7 +10287,7 @@ var sequenceReference = {
             "\n(take_while\n  [1 2 3 2 1]\n  (fn [x] (> x 3)))",
         ],
     },
-    drop: {
+    'drop': {
         title: 'drop',
         category: 'Sequence',
         linkName: 'drop',
@@ -10196,7 +10313,7 @@ var sequenceReference = {
             '(drop "Albert" 50)',
         ],
     },
-    drop_last: {
+    'drop_last': {
         title: 'drop_last',
         category: 'Sequence',
         linkName: 'drop_last',
@@ -10220,7 +10337,7 @@ var sequenceReference = {
             '(drop_last [1 2 3 4 5] 0)',
         ],
     },
-    drop_while: {
+    'drop_while': {
         title: 'drop_while',
         category: 'Sequence',
         linkName: 'drop_while',
@@ -10244,7 +10361,7 @@ var sequenceReference = {
             "\n(drop_while\n  [1 2 3 2 1]\n  (fn [x] (> x 3)))",
         ],
     },
-    sort: {
+    'sort': {
         title: 'sort',
         category: 'Sequence',
         linkName: 'sort',
@@ -10271,7 +10388,7 @@ var sequenceReference = {
             "\n(sort\n  [3 1 2]\n  (fn [a b] (cond (> a b) -1 (< a b) 1 true -1)))",
         ],
     },
-    sort_by: {
+    'sort_by': {
         title: 'sort_by',
         category: 'Sequence',
         linkName: 'sort_by',
@@ -10300,7 +10417,7 @@ var sequenceReference = {
             '(sort_by "Albert" lower_case #(compare %2 %1))',
         ],
     },
-    distinct: {
+    'distinct': {
         title: 'distinct',
         category: 'Sequence',
         linkName: 'distinct',
@@ -10323,7 +10440,7 @@ var sequenceReference = {
             '(distinct "")',
         ],
     },
-    remove: {
+    'remove': {
         title: 'remove',
         category: 'Sequence',
         linkName: 'remove',
@@ -10347,7 +10464,7 @@ var sequenceReference = {
             '(remove "Albert Mojir" #(has? "aoueiyAOUEIY" %1))',
         ],
     },
-    remove_at: {
+    'remove_at': {
         title: 'remove_at',
         category: 'Sequence',
         linkName: 'remove_at',
@@ -10373,7 +10490,7 @@ var sequenceReference = {
             '(remove_at "Albert Mojir" 6)',
         ],
     },
-    split_at: {
+    'split_at': {
         title: 'split_at',
         category: 'Sequence',
         linkName: 'split_at',
@@ -10398,7 +10515,7 @@ var sequenceReference = {
             '(split_at "Albert" 2)',
         ],
     },
-    split_with: {
+    'split_with': {
         title: 'split_with',
         category: 'Sequence',
         linkName: 'split_with',
@@ -10423,7 +10540,7 @@ var sequenceReference = {
             '(split_with "Albert" #(<= %1 :Z))',
         ],
     },
-    frequencies: {
+    'frequencies': {
         title: 'frequencies',
         category: 'Sequence',
         linkName: 'frequencies',
@@ -10444,7 +10561,7 @@ var sequenceReference = {
             '(frequencies "Pneumonoultramicroscopicsilicovolcanoconiosis")',
         ],
     },
-    group_by: {
+    'group_by': {
         title: 'group_by',
         category: 'Sequence',
         linkName: 'group_by',
@@ -10468,7 +10585,7 @@ var sequenceReference = {
             '(group_by "Albert Mojir" (fn [char] (if (has? "aoueiAOUEI" char) "vowel" "other")))',
         ],
     },
-    partition: {
+    'partition': {
         title: 'partition',
         category: 'Sequence',
         linkName: 'partition',
@@ -10513,7 +10630,7 @@ var sequenceReference = {
             '(def foo [5 6 7 8]) (partition foo 2 1 foo)',
         ],
     },
-    partition_all: {
+    'partition_all': {
         title: 'partition_all',
         category: 'Sequence',
         linkName: 'partition_all',
@@ -10542,7 +10659,7 @@ var sequenceReference = {
             '(partition_all [0 1 2 3 4 5 6 7 8 9] 2 4)',
         ],
     },
-    partition_by: {
+    'partition_by': {
         title: 'partition_by',
         category: 'Sequence',
         linkName: 'partition_by',
@@ -10567,6 +10684,114 @@ var sequenceReference = {
             '(partition_by "Leeeeeerrroyyy" identity)',
         ],
     },
+    'starts_with?': {
+        title: 'starts_with?',
+        category: 'Sequence',
+        linkName: 'starts_with-question',
+        clojureDocs: null,
+        returns: {
+            type: 'boolean',
+        },
+        args: {
+            seq: {
+                type: 'sequence',
+            },
+            prefix: {
+                type: 'sequence',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'prefix'] },
+        ],
+        description: 'Returns `true` if $seq starts with $prefix, otherwise `false`.',
+        examples: [
+            '(starts_with? [1 2 3 4 5] 1)',
+            '(starts_with? [1 2 3 4 5] [1])',
+            '(starts_with? "Albert" "Al")',
+            '(starts_with? "Albert" "al")',
+        ],
+    },
+    'ends_with?': {
+        title: 'ends_with?',
+        category: 'Sequence',
+        linkName: 'ends_with-question',
+        clojureDocs: null,
+        returns: {
+            type: 'boolean',
+        },
+        args: {
+            seq: {
+                type: 'sequence',
+            },
+            suffix: {
+                type: 'sequence',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'suffix'] },
+        ],
+        description: 'Returns `true` if $seq ends with $suffix, otherwise `false`.',
+        examples: [
+            '(ends_with? [1 2 3 4 5] 5)',
+            '(ends_with? [1 2 3 4 5] [5])',
+            '(ends_with? "Albert" "rt")',
+            '(ends_with? "Albert" "RT")',
+        ],
+    },
+    'interleave': {
+        title: 'interleave',
+        category: 'Sequence',
+        linkName: 'interleave',
+        clojureDocs: null,
+        returns: {
+            type: 'sequence',
+        },
+        args: {
+            seqs: {
+                type: 'sequence',
+                array: true,
+            },
+        },
+        variants: [
+            { argumentNames: ['seqs'] },
+        ],
+        description: 'Returns a sequence of the first item from each of the $seqs, then the second item from each of the $seqs, until all items from the shortest seq are exhausted.',
+        examples: [
+            '(interleave [1 2 3] [4 5 6])',
+            '(interleave [1 2 3] [4 5 6] [7 8 9])',
+            '(interleave [1 2 3] [4 5 6] [7 8])',
+            '(interleave [1 2 3] [4 5 6] [7])',
+            '(interleave [1 2 3] [4 5 6] [])',
+            '(interleave [1 2 3] [])',
+            '(interleave [])',
+        ],
+    },
+    'interpose': {
+        title: 'interpose',
+        category: 'Sequence',
+        linkName: 'interpose',
+        clojureDocs: null,
+        returns: {
+            type: 'sequence',
+        },
+        args: {
+            seq: {
+                type: 'sequence',
+            },
+            separator: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'separator'] },
+        ],
+        description: 'Returns a sequence of the elements of $seq separated by $separator. If $seq is a string, the separator must be a string.',
+        examples: [
+            '(interpose :a [1 2 3 4 5])',
+            '(interpose " " ["Albert" "Mojir" "Nina"])',
+            '(interpose "." "Albert")',
+        ],
+    },
 };
 
 var mathReference = {
@@ -13161,12 +13386,12 @@ var regularExpressionReference = {
         ],
         description: "Matches $s against regular expression $r.\nIf $s is a string and matches the regular expression, a `match`-array is returned, otherwise `nil` is returned.",
         examples: [
-            '(match (regexp "^\\s*(.*)$") "  A string")',
-            '(match #"albert"i "My name is Albert")',
-            '(match #"albert"i "My name is Ben")',
-            '(match #"albert"i nil)',
-            '(match #"albert"i 1)',
-            '(match #"albert"i {})',
+            '(match "  A string" (regexp "^\\s*(.*)$"))',
+            '(match "My name is Albert" #"albert"i)',
+            '(match "My name is Ben" #"albert"i)',
+            '(match nil #"albert"i)',
+            '(match 1 #"albert"i)',
+            '(match {} #"albert"i)',
         ],
     },
     replace: {
@@ -13183,7 +13408,7 @@ var regularExpressionReference = {
                 type: 'string',
             },
             r: {
-                type: 'regexp',
+                type: ['regexp', 'string'],
             },
             x: {
                 type: 'string',
@@ -13192,13 +13417,49 @@ var regularExpressionReference = {
         variants: [
             { argumentNames: ['s', 'r', 'x'] },
         ],
-        description: 'Returns a new string with some or all matches of regular expression $r replaced by $x.',
+        description: 'Returns a new string with first match of regular expression $r replaced by $x.',
         examples: [
-            '(replace "Duck" (regexp :u) :i)',
+            '(replace "Duck duck" "u" :i)',
+            '(replace "Duck duck" (regexp :u) :i)',
+            '(replace "abcABC" (regexp :a "i") "-")',
             '(replace "abcABC" (regexp :a "gi") "-")',
+            '(replace "abcABC" #"a"i "-")',
             '(replace "abcABC" #"a"gi "-")',
         ],
     },
+    replace_all: {
+        title: 'replace_all',
+        category: 'Regular expression',
+        linkName: 'replace_all',
+        clojureDocs: null,
+        returns: {
+            type: 'any',
+            array: true,
+        },
+        args: {
+            s: {
+                type: 'string',
+            },
+            r: {
+                type: ['regexp', 'string'],
+            },
+            x: {
+                type: 'string',
+            },
+        },
+        variants: [
+            { argumentNames: ['s', 'r', 'x'] },
+        ],
+        description: 'Returns a new string with all matches of regular expression $r replaced by $x.',
+        examples: [
+            '(replace_all "Duck duck" "u" :i)',
+            '(replace_all "Duck duck" (regexp :u) :i)',
+            '(replace_all "abcABC" (regexp :a "i") "-")',
+            '(replace_all "abcABC" (regexp :a "gi") "-")',
+            '(replace_all "abcABC" #"a"i "-")',
+            '(replace_all "abcABC" #"a"gi "-")',
+        ],
+    },
 };
 
 var specialExpressionsReference = {
@@ -13277,32 +13538,6 @@ var specialExpressionsReference = {
             '(def a (object :x 10 :y true :z "A string"))',
         ],
     },
-    'defs': {
-        title: 'defs',
-        category: 'Special expression',
-        linkName: 'defs',
-        clojureDocs: null,
-        returns: {
-            type: 'any',
-        },
-        args: {
-            name: {
-                type: '*expression',
-            },
-            value: {
-                type: '*expression',
-            },
-        },
-        variants: [
-            { argumentNames: ['name', 'value'] },
-        ],
-        description: "\nCreates a variable with name set to $name evaluated and value set to $value.\n\nIf a variable with name $name is already defined, an error is thrown.",
-        examples: [
-            '(defs :a :b)',
-            "\n(defs (str :a :1) (object :x 10 :y true :z \"A string\"))\na1",
-            "\n(defs :a :b)\n(defs a :c)\nb",
-        ],
-    },
     'let': {
         title: 'let',
         category: 'Special expression',
@@ -13376,36 +13611,6 @@ var specialExpressionsReference = {
             "\n(defn sumOfSquares [& s]\n  (apply\n    +\n    (map\n      (fn [x] (* x x))\n      s)))\n(sumOfSquares 1 2 3 4 5)",
         ],
     },
-    'defns': {
-        title: 'defns',
-        category: 'Special expression',
-        linkName: 'defns',
-        clojureDocs: null,
-        returns: {
-            type: 'function',
-        },
-        args: {
-            name: {
-                type: '*expression',
-            },
-            args: {
-                type: '*arguments',
-            },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['name', 'args', 'expressions'] },
-        ],
-        description: 'Creates a named global function with its name set to $name evaluated. When called, evaluation of the last expression in the body is returned.',
-        examples: [
-            "\n(defns \"hyp\" [a b]\n  (sqrt\n    (+\n      (* a a)\n      (* b b))))\nhyp",
-            "\n(defns\n  (str :h :y :p)\n  [a b]\n  (sqrt\n    (+\n      (* a a)\n      (* b b))))\n(hyp 3 4)",
-            "\n(defns \"sumOfSquares\" [& s]\n  (apply\n    +\n    (map\n      (fn [x] (* x x))\n      s)))\n(sumOfSquares 1 2 3 4 5)",
-        ],
-    },
     'try': {
         title: 'try',
         category: 'Special expression',
@@ -14074,6 +14279,30 @@ var stringReference = {
             '(map number (split "0123456789" "" 5))',
         ],
     },
+    'split_lines': {
+        title: 'split_lines',
+        category: 'String',
+        linkName: 'split_lines',
+        clojureDocs: null,
+        returns: {
+            type: 'string',
+        },
+        args: {
+            s: {
+                type: 'string',
+            },
+        },
+        variants: [
+            { argumentNames: ['s'] },
+        ],
+        description: 'Divides $s into an array of substrings, each representing a line.',
+        examples: [
+            '(split_lines "Albert\nMojir\n")',
+            '(split_lines "Albert\n\nMojir")',
+            '(split_lines "Albert\nMojir\n\n")',
+            '(split_lines "")',
+        ],
+    },
     'template': {
         title: 'template',
         category: 'String',
@@ -14290,6 +14519,55 @@ var stringReference = {
             '(++)',
         ],
     },
+    'capitalize': {
+        title: 'capitalize',
+        category: 'String',
+        linkName: 'capitalize',
+        clojureDocs: 'clojure.string/capitalize',
+        returns: {
+            type: 'string',
+        },
+        args: {
+            s: {
+                type: 'string',
+            },
+        },
+        variants: [
+            { argumentNames: ['s'] },
+        ],
+        description: 'Returns $s with the first character converted to uppercase and the rest to lowercase.',
+        examples: [
+            '(capitalize "albert")',
+            '(capitalize "ALBERT")',
+            '(capitalize "aLBERT")',
+            '(capitalize "")',
+        ],
+    },
+    'blank?': {
+        title: 'blank?',
+        category: 'String',
+        linkName: 'blank-question',
+        clojureDocs: 'clojure.string/blank_q',
+        returns: {
+            type: 'boolean',
+        },
+        args: {
+            s: {
+                type: ['string', 'null'],
+            },
+        },
+        variants: [
+            { argumentNames: ['s'] },
+        ],
+        description: 'Returns true if $s is null or only contains whitespace characters.',
+        examples: [
+            '(blank? "")',
+            '(blank? null)',
+            '(blank? "\n")',
+            '(blank? " ")',
+            '(blank? ".")',
+        ],
+    },
 };
 
 var bitwiseReference = { '<<': {
@@ -14853,6 +15131,7 @@ var api = {
         'filter',
         'position',
         'index_of',
+        'last_index_of',
         'some',
         'reverse',
         'first',
@@ -14880,6 +15159,10 @@ var api = {
         'partition',
         'partition_all',
         'partition_by',
+        'starts_with?',
+        'ends_with?',
+        'interleave',
+        'interpose',
     ],
     math: [
         '+',
@@ -15000,16 +15283,15 @@ var api = {
         'regexp',
         'match',
         'replace',
+        'replace_all',
     ],
     specialExpressions: [
         '&&',
         '||',
         'def',
-        'defs',
         'let',
         'fn',
         'defn',
-        'defns',
         'try',
         'throw',
         'if',
@@ -15038,6 +15320,7 @@ var api = {
         'pad_left',
         'pad_right',
         'split',
+        'split_lines',
         'template',
         'to_char_code',
         'from_char_code',
@@ -15047,6 +15330,8 @@ var api = {
         'decode_uri_component',
         'join',
         '++',
+        'capitalize',
+        'blank?',
     ],
     bitwise: [
         '<<',