@mojir/lits 2.0.15 → 2.0.17

package/dist/index.esm.js

@@ -281,6 +281,7 @@ var commonSimpleTokenTypes = [
 ];
 var commomValueTokenTypes = [
     'String',
+    'RegexpShorthand',
 ];
 function isLParenToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'LParen';
@@ -354,6 +355,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';
 }
@@ -424,29 +437,22 @@ var symbolicOperators = __spreadArray(__spreadArray(__spreadArray([], __read(sym
 var nonFunctionOperators = [
     '??',
     '&&',
+    '||',
     'comment',
     'cond',
-    'declared?',
-    'if',
-    'if_not',
-    '||',
-    'when',
-    'when_not',
-    'do',
-    'throw',
-    'let',
     'def',
-    'defs',
-    'if_let',
-    'when_let',
-    'when_first',
-    'fn',
+    'defined?',
     'defn',
-    'defns',
-    'try',
-    'recur',
-    'loop',
+    'do',
     'doseq',
+    'fn',
+    'if',
+    'let',
+    'loop',
+    'recur',
+    'throw',
+    'try',
+    'unless',
     'while',
 ];
 var nonFunctionOperatorSet = new Set(nonFunctionOperators);
@@ -465,16 +471,22 @@ var symbolicOperatorSet = new Set(symbolicOperators);
 function isSymbolicOperator(operator) {
     return symbolicOperatorSet.has(operator);
 }
-function isA_SymbolToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_Symbol';
+function isA_SymbolToken(token, symbolName) {
+    if ((token === null || token === void 0 ? void 0 : token[0]) !== 'A_Symbol') {
+        return false;
+    }
+    if (symbolName && token[1] !== symbolName) {
+        return false;
+    }
+    return true;
 }
-function assertA_SymbolToken(token) {
-    if (!isA_SymbolToken(token)) {
+function assertA_SymbolToken(token, symbolName) {
+    if (!isA_SymbolToken(token, symbolName)) {
         throwUnexpectedToken('A_Symbol', undefined, token);
     }
 }
-function asA_SymbolToken(token) {
-    assertA_SymbolToken(token);
+function asA_SymbolToken(token, symbolName) {
+    assertA_SymbolToken(token, symbolName);
     return token;
 }
 function isA_BinaryOperatorToken(token) {
@@ -511,9 +523,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) {
@@ -536,7 +549,6 @@ var polishOnlyValueTokenTypes = [
     'P_StringShorthand',
     'P_Symbol',
     'P_ReservedSymbol',
-    'P_RegexpShorthand',
     'P_CollectionAccessor',
     'P_Comment',
     'P_Whitespace',
@@ -574,18 +586,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';
 }
@@ -757,7 +757,7 @@ var specialExpressionCommentRemovers = {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
-    'declared?': function (node, removeOptions) {
+    'defined?': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -766,11 +766,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);
@@ -778,12 +773,11 @@ var specialExpressionCommentRemovers = {
     'doseq': function (_node, _removeOptions) { },
     'fn': function (_node, _removeOptions) { },
     'for': function (_node, _removeOptions) { },
-    'if_let': function (_node, _removeOptions) { },
     'if': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
-    'if_not': function (node, removeOptions) {
+    'unless': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -812,10 +806,6 @@ var specialExpressionCommentRemovers = {
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
     'try': function (_node, _removeOptions) { },
-    'when_first': function (_node, _removeOptions) { },
-    'when_let': function (_node, _removeOptions) { },
-    'when': function (_node, _removeOptions) { },
-    'when_not': function (_node, _removeOptions) { },
 };
 function removeCommentNodesFromSpecialExpression(node, removeOptions) {
     var uncommenter = specialExpressionCommentRemovers[node.n];
@@ -1980,7 +1970,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]);
@@ -1992,7 +1982,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;
@@ -2007,7 +1997,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)
@@ -2017,7 +2007,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)
@@ -2027,7 +2017,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;
@@ -2049,7 +2039,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);
@@ -2060,7 +2050,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;
@@ -2079,7 +2069,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);
@@ -2098,7 +2088,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);
@@ -2112,7 +2121,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];
@@ -2173,7 +2182,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];
@@ -2220,7 +2229,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];
@@ -2268,7 +2277,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);
@@ -2281,7 +2290,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);
@@ -2293,7 +2302,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);
@@ -2308,7 +2317,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);
@@ -2322,7 +2331,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)
@@ -2334,7 +2343,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)
@@ -2344,7 +2353,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);
@@ -2356,7 +2365,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);
@@ -2370,7 +2379,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];
@@ -2387,7 +2396,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];
@@ -2425,7 +2434,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];
@@ -2476,7 +2485,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);
@@ -2486,7 +2495,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);
@@ -2497,7 +2506,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];
@@ -2525,7 +2534,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);
@@ -2535,7 +2544,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);
@@ -2546,7 +2555,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;
@@ -2562,7 +2571,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);
@@ -2576,7 +2585,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);
@@ -2586,9 +2595,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);
@@ -2601,9 +2610,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);
@@ -2618,9 +2627,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);
@@ -2628,9 +2637,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);
@@ -2643,7 +2652,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);
@@ -2659,9 +2668,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);
@@ -2677,34 +2686,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);
@@ -2721,7 +2726,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) {
@@ -3884,7 +3970,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;
@@ -3900,15 +3986,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) {
@@ -4066,6 +4164,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];
@@ -4169,6 +4275,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) {
@@ -4442,7 +4567,7 @@ var switchSpecialExpression = {
 };
 
 var declaredSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('declared?'),
+    polishParse: getCommonPolishSpecialExpressionParser('defined?'),
     validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
@@ -4498,9 +4623,7 @@ var defSpecialExpression = {
         var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
         var name = node.p[0].v;
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = {
-            value: evaluateAstNode(node.p[1], contextStack),
-        };
+        contextStack.exportValue(name, evaluateAstNode(node.p[1], contextStack));
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4511,47 +4634,7 @@ var defSpecialExpression = {
         var result = findUnresolvedIdentifiers([subNode], contextStack, builtin);
         var name = asSymbolNode(node.p[0]).v;
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = { value: true };
-        return result;
-    },
-};
-
-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.globalContext[name] = {
-            value: 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.globalContext[name] = { value: true };
+        contextStack.exportValue(name, true);
         return result;
     },
 };
@@ -4582,7 +4665,7 @@ var doSpecialExpression = {
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
+        return findUnresolvedIdentifiers(node.p, contextStack.create({}), builtin);
     },
 };
 
@@ -4611,11 +4694,6 @@ function joinAnalyzeResults() {
 function addAnalyzeResults(target, source) {
     source.forEach(function (symbol) { return target.add(symbol); });
 }
-function combinate(arrays) {
-    return arrays.reduce(function (acc, curr) {
-        return acc.flatMap(function (a) { return curr.map(function (c) { return __spreadArray(__spreadArray([], __read(a), false), [c], false); }); });
-    }, [[]]);
-}
 
 var defnSpecialExpression = {
     polishParse: function (tokenStream, parseState, firstToken, parsers) {
@@ -4640,7 +4718,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,64 +4728,17 @@ var defnSpecialExpression = {
             _b.n = name,
             _b.o = evaluatedFunctionOverloades,
             _b);
-        contextStack.globalContext[name] = { value: litsFunction };
+        contextStack.exportValue(name, litsFunction);
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var _b;
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        contextStack.globalContext[node.f.v] = { value: true };
+        contextStack.exportValue(node.f.v, true);
         var newContext = (_b = {}, _b[node.f.v] = { value: true }, _b);
         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.globalContext[name] = { value: 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.globalContext[name] = { value: 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);
@@ -4741,14 +4772,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 = [];
@@ -4976,56 +4999,8 @@ var ifSpecialExpression = {
     },
 };
 
-var ifLetSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if_let',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var _b;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
-        var locals = {};
-        var bindingValue = evaluateAstNode(node.b.v, contextStack);
-        if (bindingValue) {
-            locals[node.b.n] = { value: bindingValue };
-            var newContextStack = contextStack.create(locals);
-            var thenForm = asAstNode(node.p[0], sourceCodeInfo);
-            return evaluateAstNode(thenForm, newContextStack);
-        }
-        if (node.p.length === 2) {
-            var elseForm = asAstNode(node.p[1], sourceCodeInfo);
-            return evaluateAstNode(elseForm, contextStack);
-        }
-        return null;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var newContext = (_b = {}, _b[node.b.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([node.b.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var ifNotSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('if_not'),
+var unlessSpecialExpression = {
+    polishParse: getCommonPolishSpecialExpressionParser('unless'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
@@ -5050,55 +5025,39 @@ var ifNotSpecialExpression = {
 
 var letSpecialExpression = {
     polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
+        var parseBindings = _a.parseBindings;
         var bindings = parseBindings(tokenStream, parseState);
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
+        // const params = parseTokensUntilClosingBracket(tokenStream, parseState)
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: AstNodeType.SpecialExpression,
             n: 'let',
-            p: params,
+            p: [],
             bs: bindings,
             token: getTokenDebugData(firstToken) && firstToken,
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    validateParameterCount: function (node) { return assertNumberOfParams(0, node); },
     evaluate: function (node, contextStack, _a) {
-        var e_1, _b, e_2, _c;
+        var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
-        var locals = {};
-        var newContextStack = contextStack.create(locals);
         try {
-            for (var _d = __values(node.bs), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var binding = _e.value;
+            for (var _c = __values(node.bs), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var binding = _d.value;
                 var bindingValueNode = binding.v;
-                var bindingValue = evaluateAstNode(bindingValueNode, newContextStack);
-                locals[binding.n] = { value: bindingValue };
+                var bindingValue = evaluateAstNode(bindingValueNode, contextStack);
+                contextStack.addValue(binding.n, bindingValue);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
             finally { if (e_1) throw e_1.error; }
         }
-        var result = null;
-        try {
-            for (var _f = __values(node.p), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var astNode = _g.value;
-                result = evaluateAstNode(astNode, newContextStack);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return result;
+        return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5108,11 +5067,10 @@ var letSpecialExpression = {
             context[name] = { value: true };
             return context;
         }, {});
-        var bindingContext = {};
         var bindingResults = node.bs.map(function (bindingNode) {
             var valueNode = bindingNode.v;
-            var bindingsResult = findUnresolvedIdentifiers([valueNode], contextStack.create(bindingContext), builtin);
-            bindingContext[bindingNode.n] = { value: true };
+            var bindingsResult = findUnresolvedIdentifiers([valueNode], contextStack, builtin);
+            contextStack.addValue(bindingNode.n, { value: true });
             return bindingsResult;
         });
         var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
@@ -5563,9 +5521,10 @@ var trySpecialExpression = {
             return evaluateAstNode(tryExpressions[0], contextStack);
         }
         catch (error) {
-            var newContext = (_b = {},
-                _b[errorNode.v] = { value: asAny(error, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo) },
-                _b);
+            var newContext = errorNode
+                ? (_b = {},
+                    _b[errorNode.v] = { value: asAny(error, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo) },
+                    _b) : {};
             return evaluateAstNode(catchExpression, contextStack.create(newContext));
         }
     },
@@ -5574,199 +5533,15 @@ var trySpecialExpression = {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
         var tryExpressions = node.p, catchExpression = node.ce, errorNode = node.e;
         var tryResult = findUnresolvedIdentifiers(tryExpressions, contextStack, builtin);
-        var newContext = (_b = {},
-            _b[errorNode.v] = { value: true },
-            _b);
+        var newContext = errorNode
+            ? (_b = {},
+                _b[errorNode.v] = { value: true },
+                _b) : {};
         var catchResult = findUnresolvedIdentifiers([catchExpression], contextStack.create(newContext), builtin);
         return joinAnalyzeResults(tryResult, catchResult);
     },
 };
 
-var whenSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('when'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var _d = __read(node.p), whenExpression = _d[0], body = _d.slice(1);
-        assertAstNode(whenExpression, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        if (!evaluateAstNode(whenExpression, contextStack))
-            return null;
-        var result = null;
-        try {
-            for (var body_1 = __values(body), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
-                var form = body_1_1.value;
-                result = evaluateAstNode(form, contextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
-    },
-};
-
-var whenFirstSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when_first',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function () { return undefined; },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var locals = {};
-        var binding = node.b;
-        var evaluatedBindingForm = evaluateAstNode(binding.v, contextStack);
-        if (!isSeq(evaluatedBindingForm)) {
-            throw new LitsError("Expected undefined or a sequence, got ".concat(valueToString(evaluatedBindingForm)), (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        }
-        if (evaluatedBindingForm.length === 0)
-            return null;
-        var bindingValue = toAny(evaluatedBindingForm[0]);
-        locals[binding.n] = { value: bindingValue };
-        var newContextStack = contextStack.create(locals);
-        var result = null;
-        try {
-            for (var _d = __values(node.p), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var form = _e.value;
-                result = evaluateAstNode(form, newContextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var binding = node.b;
-        var newContext = (_b = {}, _b[binding.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([binding.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var whenLetSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when_let',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function () { return undefined; },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var binding = node.b;
-        var locals = {};
-        var bindingValue = evaluateAstNode(binding.v, contextStack);
-        if (!bindingValue)
-            return null;
-        locals[binding.n] = { value: bindingValue };
-        var newContextStack = contextStack.create(locals);
-        var result = null;
-        try {
-            for (var _c = __values(node.p), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var form = _d.value;
-                result = evaluateAstNode(form, newContextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var binding = node.b;
-        var newContext = (_b = {}, _b[binding.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([binding.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var whenNotSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('when_not'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var _d = __read(node.p), whenExpression = _d[0], body = _d.slice(1);
-        assertAstNode(whenExpression, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        if (evaluateAstNode(whenExpression, contextStack))
-            return null;
-        var result = null;
-        try {
-            for (var body_1 = __values(body), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
-                var form = body_1_1.value;
-                result = evaluateAstNode(form, contextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
-    },
-};
-
 var specialExpressions = {
     '&&': andSpecialExpression,
     'comment': commentSpecialExpression,
@@ -5774,26 +5549,19 @@ var specialExpressions = {
     'switch': switchSpecialExpression,
     'def': defSpecialExpression,
     'defn': defnSpecialExpression,
-    'defns': defnsSpecialExpression,
-    'defs': defsSpecialExpression,
     'do': doSpecialExpression,
     'doseq': doseqSpecialExpression,
     'for': forSpecialExpression,
     'fn': fnSpecialExpression,
     'if': ifSpecialExpression,
-    'if_let': ifLetSpecialExpression,
-    'if_not': ifNotSpecialExpression,
+    'unless': unlessSpecialExpression,
     'let': letSpecialExpression,
     'loop': loopSpecialExpression,
     '||': orSpecialExpression,
     'recur': recurSpecialExpression,
     'throw': throwSpecialExpression,
     'try': trySpecialExpression,
-    'when': whenSpecialExpression,
-    'when_first': whenFirstSpecialExpression,
-    'when_let': whenLetSpecialExpression,
-    'when_not': whenNotSpecialExpression,
-    'declared?': declaredSpecialExpression,
+    'defined?': declaredSpecialExpression,
     '??': qqSpecialExpression,
 };
 Object.keys(specialExpressions).forEach(function (key) {
@@ -5815,8 +5583,8 @@ function isContextEntry(value) {
 var ContextStackImpl = /** @class */ (function () {
     function ContextStackImpl(_a) {
         var contexts = _a.contexts, hostValues = _a.values, lazyHostValues = _a.lazyValues, nativeJsFunctions = _a.nativeJsFunctions;
-        this.contexts = contexts;
         this.globalContext = asNonUndefined(contexts[0]);
+        this.contexts = contexts;
         this.values = hostValues;
         this.lazyValues = lazyHostValues;
         this.nativeJsFunctions = nativeJsFunctions;
@@ -5832,6 +5600,34 @@ var ContextStackImpl = /** @class */ (function () {
         contextStack.globalContext = globalContext;
         return contextStack;
     };
+    ContextStackImpl.prototype.exportValue = function (name, value) {
+        if (this.globalContext[name]) {
+            throw new Error("Cannot redefine exported value \"".concat(name, "\""));
+        }
+        if (specialExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow special expression \"".concat(name, "\""));
+        }
+        if (normalExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow builtin function \"".concat(name, "\""));
+        }
+        this.globalContext[name] = { value: value };
+    };
+    ContextStackImpl.prototype.addValue = function (name, value) {
+        var currentContext = this.contexts[0];
+        if (!currentContext) {
+            throw new Error('No context to add value to');
+        }
+        if (currentContext[name]) {
+            throw new Error("Cannot redefine value \"".concat(name, "\""));
+        }
+        if (specialExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow special expression \"".concat(name, "\""));
+        }
+        if (normalExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow builtin function \"".concat(name, "\""));
+        }
+        currentContext[name] = { value: toAny(value) };
+    };
     ContextStackImpl.prototype.clone = function () {
         // eslint-disable-next-line ts/no-unsafe-argument
         return new ContextStackImpl(JSON.parse(JSON.stringify({
@@ -5961,7 +5757,7 @@ function createContextStack(params) {
                 return acc;
             }, {}),
     });
-    return contextStack;
+    return contextStack.create({});
 }
 
 var _a$1;
@@ -6273,7 +6069,14 @@ function evaluateNumberAsFunction(fn, params, sourceCodeInfo) {
 
 var findUnresolvedIdentifiers = function (ast, contextStack, builtin) {
     var e_1, _a;
-    var astNodes = Array.isArray(ast) ? ast : ast.b;
+    var astNodes = Array.isArray(ast)
+        ? ast
+        : [{
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: ast.b,
+                token: undefined,
+            }];
     var unresolvedIdentifiers = new Set();
     try {
         for (var astNodes_1 = __values(astNodes), astNodes_1_1 = astNodes_1.next(); !astNodes_1_1.done; astNodes_1_1 = astNodes_1.next()) {
@@ -6345,537 +6148,9 @@ function findUnresolvedIdentifiersInAstNode(astNode, contextStack, builtin) {
     }
 }
 
-var calculateAndOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return ({
-        n: '&&',
-        t: AstNodeType.SpecialExpression,
-        p: p,
-        token: astNode.token,
-    }); });
-};
-
-var calculateCondOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, isAstComputable = _a.isAstComputable;
-    var testNodes = arrayToPairs(astNode.p).map(function (_a) {
-        var _b = __read(_a, 1), t = _b[0];
-        return t;
-    });
-    if (isAstComputable(testNodes)) {
-        return combinate(arrayToPairs(astNode.p)
-            // Create a list of ast nodes from the test and form of each condition
-            .reduce(function (acc, _a) {
-            var _b = __read(_a, 2), test = _b[0], form = _b[1];
-            acc.push(calculatePossibleAstNodes(test), calculatePossibleAstNodes(form));
-            return acc;
-        }, []))
-            // Create a new CondNode for each combination of test and form outcomes
-            .map(function (conditionAsts) { return (__assign(__assign({}, astNode), { c: arrayToPairs(conditionAsts).map(function (_a) {
-                var _b = __read(_a, 2), t = _b[0], f = _b[1];
-                return ({ t: t, f: f });
-            }) })); });
-    }
-    return __spreadArray(__spreadArray([], __read(arrayToPairs(astNode.p).flatMap(function (_a) {
-        var _b = __read(_a, 2); _b[0]; var form = _b[1];
-        return calculatePossibleAstNodes(form);
-    })), false), [
-        nilNode,
-    ], false);
-};
-
-var trueNode = { t: AstNodeType.ReservedSymbol, v: 'true', token: undefined, p: [], n: undefined };
-var falseNode = { t: AstNodeType.ReservedSymbol, v: 'false', token: undefined, p: [], n: undefined };
-var calculateDeclaredOutcomes = function (_a) {
-    var astNode = _a.astNode, isAstComputable = _a.isAstComputable;
-    if (isAstComputable(astNode.p))
-        return [trueNode];
-    return [trueNode, falseNode];
-};
-
-var calculateDefOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, addGlobalIdentifier = _a.addGlobalIdentifier;
-    var nameNode = asSymbolNode(astNode.p[0]);
-    var valueNode = astNode.p[1];
-    addGlobalIdentifier(nameNode.v);
-    return calculatePossibleAstNodes(valueNode)
-        .map(function (node) { return (__assign(__assign({}, astNode), { p: [nameNode, node] })); });
-};
-
-var calculateDefsOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateDoOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p).map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-function calculateFunctionOverloadOutcomes(combinateAstNodes, functionOverloads) {
-    return combinate(functionOverloads
-        // For each overload, calculate the possible outcomes for each parameter
-        .map(function (functionOverload) {
-        var _a;
-        return combinateAstNodes(functionOverload.b, [
-            functionOverload.as.m,
-            functionOverload.as.b.map(function (bindingNode) { return bindingNode.n; }),
-            (_a = functionOverload.as.r) !== null && _a !== void 0 ? _a : [],
-        ].flat())
-            // For each combination of parameter outcomes, create a new overload
-            .map(function (body) { return (__assign(__assign({}, functionOverload), { b: body })); });
-    }));
-}
-var calculateDefnOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, addGlobalIdentifier = _a.addGlobalIdentifier;
-    addGlobalIdentifier(astNode.f.v);
-    // astNode.o is an array of overloads
-    return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { o: functionOverloads })); });
-};
-var calculateDefnsOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes;
-    // astNode.o is an array of overloads
-    return calculatePossibleAstNodes(astNode.f).flatMap(function (functionName) {
-        return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { f: functionName, o: functionOverloads })); });
-    });
-};
-var calculateFnOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    // astNode.o is an array of overloads
-    return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { o: functionOverloads })); });
-};
-
-var calculateIfLetOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    var thenBranch = astNode.p[0];
-    var elseBranch = (_b = astNode.p[1]) !== null && _b !== void 0 ? _b : nilNode;
-    if (!isAstComputable(bindingNode.v)) {
-        return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-    }
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) { return combinateAstNodes(astNode.p, [newIdentifier])
-        .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); }); });
-};
-
-var calculateIfNotOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    var thenBranch = astNode.p[1];
-    var elseBranch = (_b = astNode.p[2]) !== null && _b !== void 0 ? _b : nilNode;
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'if_not',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-};
-
-var calculateIfOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    var thenBranch = astNode.p[1];
-    var elseBranch = (_b = astNode.p[2]) !== null && _b !== void 0 ? _b : nilNode;
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'if',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-};
-
-var calculateLetOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    try {
-        // check bindings, if any binding value cannot be calculated, convert the whole let to a do-expression
-        if (!isAstComputable(astNode.bs.map(function (b) { return calculatePossibleAstNodes(b.v); })))
-            throw new Error('Could not calculate binding value');
-    }
-    catch (_b) {
-        var doNodes = combinateAstNodes(astNode.p)
-            .map(function (p) {
-            return {
-                n: 'do',
-                t: AstNodeType.SpecialExpression,
-                p: p,
-                token: astNode.token,
-            };
-        });
-        return doNodes;
-    }
-    var newIdentifiers = astNode.bs.map(function (bindingNode) { return bindingNode.n; });
-    var letNodes = combinate(astNode.bs.map(function (bindingNode) {
-        return calculatePossibleAstNodes(bindingNode.v)
-            .map(function (bindingValues) { return (__assign(__assign({}, bindingNode), { v: bindingValues })); });
-    }))
-        .flatMap(function (bindingNodes) { return combinate(astNode.p.map(function (p) { return calculatePossibleAstNodes(p, newIdentifiers); }))
-        .map(function (p) {
-        return {
-            n: 'let',
-            bs: bindingNodes,
-            t: AstNodeType.SpecialExpression,
-            p: p,
-            token: astNode.token,
-        };
-    }); });
-    return letNodes;
-};
-
-var calculateForOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    if (!isDeterministic(calculatePossibleAstNodes, astNode))
-        throw new Error('Could not calculate for loop, not deterministic');
-    return [astNode];
-};
-var calculateDoSeqOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    if (!isDeterministic(calculatePossibleAstNodes, astNode))
-        throw new Error('Could not calculate doSeq node, not deterministic');
-    return [astNode];
-};
-function isDeterministic(calculatePossibleAstNodes, astNode) {
-    var e_1, _a;
-    try {
-        for (var _b = __values(astNode.l), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var _d = _c.value, b = _d.b, l = _d.l, wn = _d.wn, we = _d.we;
-            if (l && l.some(function (_a) {
-                var v = _a.v;
-                return !astIsDeterministic(calculatePossibleAstNodes, v);
-            }))
-                return false;
-            if (!astIsDeterministic(calculatePossibleAstNodes, b.v))
-                return false;
-            if (wn && !astIsDeterministic(calculatePossibleAstNodes, wn))
-                return false;
-            if (we && !astIsDeterministic(calculatePossibleAstNodes, we))
-                return false;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    if (!astIsDeterministic(calculatePossibleAstNodes, astNode.p[0]))
-        return false;
-    return true;
-}
-function astIsDeterministic(calculatePossibleAstNodes, astNode) {
-    return calculatePossibleAstNodes(astNode).length === 1;
-}
-
-var calculateOrOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return ({
-        n: '||',
-        t: AstNodeType.SpecialExpression,
-        p: p,
-        token: astNode.token,
-    }); });
-};
-
-var calculateQqOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    if (!isAstComputable(astNode.p[0]))
-        throw new Error('First argument of ?? not computable');
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateThrowOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    return calculatePossibleAstNodes(astNode.p[0]).map(function (m) { return (__assign(__assign({}, astNode), { p: [m] })); });
-};
-
-var calculateTryOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    var _b = calculatePossibleAstNodes(astNode.p[0]).reduce(function (acc, node) {
-        if (node.n === 'throw') {
-            acc.throws.push(node.p[0]);
-        }
-        else {
-            acc.vals.push(node);
-        }
-        return acc;
-    }, { vals: [], throws: [] }), vals = _b.vals, throws = _b.throws;
-    var catches = throws.flatMap(function (throwNode) {
-        var letNode = {
-            t: AstNodeType.SpecialExpression,
-            n: 'let',
-            bs: [{
-                    t: AstNodeType.Binding,
-                    n: astNode.e.v,
-                    v: throwNode,
-                    token: undefined,
-                    p: [],
-                }],
-            p: [astNode.ce],
-            token: undefined,
-        };
-        return calculatePossibleAstNodes(letNode);
-    });
-    return __spreadArray(__spreadArray([], __read(vals), false), __read(catches), false);
-};
-
-var calculateWhenFirstOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    if (!isAstComputable(bindingNode.v))
-        throw new Error('Could not calculate binding value');
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) {
-        return combinateAstNodes(astNode.p, [newIdentifier])
-            .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); });
-    });
-};
-
-var calculateWhenLetOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    if (!isAstComputable(bindingNode.v)) {
-        return __spreadArray(__spreadArray([], __read(combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'do',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); })), false), [
-            nilNode,
-        ], false);
-    }
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) {
-        return combinateAstNodes(astNode.p, [newIdentifier])
-            .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); });
-    });
-};
-
-var calculateWhenNotOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, nilNode = _a.nilNode, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'when_not',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    var body = astNode.p.slice(1);
-    return __spreadArray(__spreadArray([], __read(combinateAstNodes(body)
-        .map(function (p) { return ({
-        n: 'do',
-        t: astNode.t,
-        p: p,
-        token: astNode.token,
-    }); })), false), [
-        nilNode,
-    ], false);
-};
-
-var calculateWhenOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, nilNode = _a.nilNode, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'when',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    var body = astNode.p.slice(1);
-    return __spreadArray(__spreadArray([], __read(combinateAstNodes(body)
-        .map(function (p) { return ({
-        n: 'do',
-        t: astNode.t,
-        p: p,
-        token: astNode.token,
-    }); })), false), [
-        nilNode,
-    ], false);
-};
-
-var calculateRecurOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateCommentOutcomes = function (_a) {
-    var nilNode = _a.nilNode;
-    return [nilNode];
-};
-
-var calculateLoopOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p, astNode.bs.map(function (bindingNode) { return bindingNode.n; }))
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateSwitchOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    // TODO be smarter about this
-    return __spreadArray(__spreadArray([], __read(arrayToPairs(astNode.p.slice(1)).flatMap(function (_a) {
-        var _b = __read(_a, 2); _b[0]; var form = _b[1];
-        return calculatePossibleAstNodes(form);
-    })), false), [
-        nilNode,
-    ], false);
-};
-
-var specialExpressionCalculator = {
-    '&&': function (astNode, helperOptions) { return calculateAndOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'comment': function (astNode, helperOptions) { return calculateCommentOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'cond': function (astNode, helperOptions) { return calculateCondOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'switch': function (astNode, helperOptions) { return calculateSwitchOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'declared?': function (astNode, helperOptions) { return calculateDeclaredOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defn': function (astNode, helperOptions) { return calculateDefnOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'def': function (astNode, helperOptions) { return calculateDefOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defns': function (astNode, helperOptions) { return calculateDefnsOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defs': function (astNode, helperOptions) { return calculateDefsOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'do': function (astNode, helperOptions) { return calculateDoOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'doseq': function (astNode, helperOptions) { return calculateDoSeqOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'fn': function (astNode, helperOptions) { return calculateFnOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'for': function (astNode, helperOptions) { return calculateForOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if_let': function (astNode, helperOptions) { return calculateIfLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if': function (astNode, helperOptions) { return calculateIfOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if_not': function (astNode, helperOptions) { return calculateIfNotOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'let': function (astNode, helperOptions) { return calculateLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'loop': function (astNode, helperOptions) { return calculateLoopOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    '||': function (astNode, helperOptions) { return calculateOrOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    '??': function (astNode, helperOptions) { return calculateQqOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'recur': function (astNode, helperOptions) { return calculateRecurOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'throw': function (astNode, helperOptions) { return calculateThrowOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'try': function (astNode, helperOptions) { return calculateTryOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_first': function (astNode, helperOptions) { return calculateWhenFirstOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_let': function (astNode, helperOptions) { return calculateWhenLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when': function (astNode, helperOptions) { return calculateWhenOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_not': function (astNode, helperOptions) { return calculateWhenNotOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-};
-
-function calculateOutcomes(contextStack, astNodes) {
-    // First, we try to calculate outcomes for the whole astNodes array.
-    // If that fails, we try to calculate outcomes for the array without the first element.
-    // If that fails, we try to calculate outcomes for the array without the first two elements.
-    // And so on.
-    // This makes it possible to calculate outcomes for e.g.
-    // (write! x) x
-    // Problems occur for e.g.
-    // (def x 1) (write! x) x
-    // This should output [1], but since (write! x) fails to calculate outcomes, we get null.
-    // Ok, but not optimal
-    // The contract is that when an array is returned, it must be correct.
-    // But returning null (indicating that the calculation failed) is always a way out.
-    for (var i = 0; i < astNodes.length; i++) {
-        var usingAstNode = astNodes.slice(i);
-        var outcomes = calculateOutcomesInner(contextStack, usingAstNode);
-        if (outcomes !== null)
-            return outcomes;
-    }
-    return null;
-}
-function calculateOutcomesInner(contextStack, astNodes) {
-    var e_1, _a;
-    var possibleAsts = calculatePossibleAsts(contextStack.clone(), astNodes);
-    if (possibleAsts === null)
-        return null;
-    var outcomes = [];
-    try {
-        for (var possibleAsts_1 = __values(possibleAsts), possibleAsts_1_1 = possibleAsts_1.next(); !possibleAsts_1_1.done; possibleAsts_1_1 = possibleAsts_1.next()) {
-            var possibleAst = possibleAsts_1_1.value;
-            var unresolvedIdentifiers = findUnresolvedIdentifiers(possibleAst, contextStack.clone(), builtin);
-            if (unresolvedIdentifiers.size !== 0)
-                return null;
-            var ast = {
-                b: possibleAst,
-                hasDebugData: true,
-            };
-            try {
-                outcomes.push(evaluate(ast, contextStack.clone()));
-            }
-            catch (e) {
-                outcomes.push(e);
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (possibleAsts_1_1 && !possibleAsts_1_1.done && (_a = possibleAsts_1.return)) _a.call(possibleAsts_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return outcomes;
-}
-function calculatePossibleAsts(contextStack, astNodes) {
-    var possibleAsts;
-    try {
-        possibleAsts = combinate(astNodes.map(function (astNode) { return calculatePossibleAstNodes(contextStack, astNode); }));
-    }
-    catch (e) {
-        return null;
-    }
-    return possibleAsts;
-}
-var nilNode = { t: AstNodeType.ReservedSymbol, v: 'nil', token: undefined, p: [], n: undefined };
-function calculatePossibleAstNodes(contextStack, astNode, newIndentifiers) {
-    var newContext = newIndentifiers
-        ? newIndentifiers.reduce(function (acc, identity) {
-            acc[identity] = { value: null };
-            return acc;
-        }, {})
-        : undefined;
-    var newContextStack = newContext ? contextStack.create(newContext) : contextStack;
-    if (astNode.t === AstNodeType.NormalExpression) {
-        return combinate(astNode.p.map(function (n) { return calculatePossibleAstNodes(newContextStack, n); }))
-            .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-    }
-    else if (astNode.t === AstNodeType.SpecialExpression) {
-        var helperOptions = {
-            nilNode: nilNode,
-            calculatePossibleAstNodes: function (node, identifiers) { return calculatePossibleAstNodes(newContextStack.clone(), node, identifiers); },
-            combinateAstNodes: function (nodes, identifiers) {
-                return combinate(nodes.map(function (node) { return calculatePossibleAstNodes(newContextStack.clone(), node, identifiers); }));
-            },
-            isAstComputable: function (node) {
-                return calculateOutcomesInner(newContextStack, Array.isArray(node) ? node.flat() : [node]) !== null;
-            },
-            addGlobalIdentifier: function (name) { return newContextStack.globalContext[name] = { value: null }; },
-        };
-        // eslint-disable-next-line ts/no-unsafe-argument
-        return specialExpressionCalculator[astNode.n](astNode, helperOptions);
-    }
-    return [astNode];
-}
-
 function analyze(ast, params) {
     return {
         unresolvedIdentifiers: findUnresolvedIdentifiers(ast, createContextStack(params), builtin),
-        outcomes: calculateOutcomes(createContextStack(params), ast.b),
     };
 }
 
@@ -6998,6 +6273,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;
@@ -7139,6 +6441,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;
     };
@@ -7157,38 +6465,45 @@ var AlgebraicParser = /** @class */ (function () {
         var _a;
         if (precedence === void 0) { precedence = 0; }
         var firstToken = this.peek();
-        if (isA_SymbolToken(firstToken) && firstToken[1] === 'def') {
-            return this.parseDef(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'defn') {
-            return this.parseDefn(firstToken);
-        }
         var left;
-        if (isA_SymbolToken(firstToken) && firstToken[1] === 'if') {
-            left = this.parseIf(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'cond') {
-            left = this.parseCond(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'switch') {
-            left = this.parseSwitch(firstToken);
+        if (isA_SymbolToken(firstToken)) {
+            switch (firstToken[1]) {
+                case 'let':
+                    return this.parseLet(firstToken);
+                case 'if':
+                case 'unless':
+                    left = this.parseIfOrUnless(firstToken);
+                    break;
+                case 'cond':
+                    left = this.parseCond(firstToken);
+                    break;
+                case 'switch':
+                    left = this.parseSwitch(firstToken);
+                    break;
+                case 'for':
+                case 'doseq':
+                    left = this.parseForOrDoseq(firstToken);
+                    break;
+                case 'do':
+                    left = this.parseDo(firstToken);
+                    break;
+                case 'loop':
+                    left = this.parseLoop(firstToken);
+                    break;
+                case 'try':
+                    left = this.parseTry(firstToken);
+                    break;
+            }
         }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'for') {
-            left = this.parseFor(firstToken);
+        else if (isA_ReservedSymbolToken(firstToken, 'function')) {
+            return this.parseFunction(firstToken);
         }
-        else {
-            left = this.parseOperand();
+        else if (isA_ReservedSymbolToken(firstToken, 'export')) {
+            return this.parseExport(firstToken);
         }
+        left || (left = this.parseOperand());
         var operator = this.peek();
-        while (!this.isAtEnd()
-            && !isA_OperatorToken(operator, ',')
-            && !isA_OperatorToken(operator, ';')
-            && !isRBracketToken(operator)
-            && !isA_ReservedSymbolToken(operator, 'else')
-            && !isA_ReservedSymbolToken(operator, 'then')
-            && !isA_ReservedSymbolToken(operator, 'end')
-            && !isA_ReservedSymbolToken(operator, 'case')
-            && !isRParenToken(operator)) {
+        while (!this.isAtExpressionEnd()) {
             if (isA_BinaryOperatorToken(operator)) {
                 var name_1 = operator[1];
                 var newPrecedece = getPrecedence(name_1);
@@ -7317,10 +6632,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 = [];
@@ -7441,12 +6764,9 @@ var AlgebraicParser = /** @class */ (function () {
                     case '??':
                     case '&&':
                     case 'comment':
-                    case 'declared?':
-                    case 'if_not':
+                    case 'defined?':
                     case '||':
-                    case 'when':
-                    case 'when_not':
-                    case 'do':
+                    case 'recur':
                     case 'throw': {
                         var node = {
                             t: AstNodeType.SpecialExpression,
@@ -7457,18 +6777,9 @@ var AlgebraicParser = /** @class */ (function () {
                         builtin.specialExpressions[node.n].validateParameterCount(node);
                         return node;
                     }
-                    case 'let':
-                        return this.parseLet(symbol, params);
-                    case 'defs':
-                    case 'if_let':
-                    case 'when_let':
-                    case 'when_first':
                     case 'fn':
-                    case 'defns':
-                    case 'try':
-                    case 'recur':
-                    case 'loop':
-                    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));
@@ -7487,6 +6798,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(), '=>')) {
@@ -7512,6 +6828,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;
@@ -7630,36 +6958,146 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseLet = function (letSymbol, params) {
-        var _a, _b;
-        if (params.length !== 2) {
-            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(letSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-        }
-        var letObject = params[0];
-        if (letObject.t !== AstNodeType.NormalExpression || letObject.n !== 'object') {
-            throw new LitsError('let expects an object as first argument', (_b = getTokenDebugData(letObject.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+    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(), ';');
         }
-        var letBindings = arrayToPairs(letObject.p);
-        var expression = params[1];
         return {
             t: AstNodeType.SpecialExpression,
             n: 'let',
-            p: [expression],
-            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
-            bs: letBindings.map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
+            p: [],
+            bs: [{
                     t: AstNodeType.Binding,
-                    n: key.v,
+                    n: letSymbol.v,
                     v: value,
                     p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            }),
+                    token: getTokenDebugData(token) && token,
+                }],
+            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
+        };
+    };
+    AlgebraicParser.prototype.parseDo = function (token) {
+        this.advance();
+        var expressions = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            expressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'do',
+            p: expressions,
+            token: getTokenDebugData(token) && token,
+        };
+    };
+    AlgebraicParser.prototype.parseLoop = function (token) {
+        var _a;
+        this.advance();
+        assertLParenToken(this.peek());
+        this.advance();
+        var bindingNodes = [];
+        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
+            var symbol = parseSymbol(this.tokenStream, this.parseState);
+            assertA_OperatorToken(this.peek(), '=');
+            this.advance();
+            var value = this.parseExpression();
+            bindingNodes.push({
+                t: AstNodeType.Binding,
+                n: symbol.v,
+                v: value,
+                p: [],
+                token: getTokenDebugData(symbol.token) && symbol.token,
+            });
+            if (isA_OperatorToken(this.peek(), ',')) {
+                this.advance();
+            }
+        }
+        if (bindingNodes.length === 0) {
+            throw new LitsError('Expected binding', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        assertRParenToken(this.peek());
+        this.advance();
+        var params = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            params.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'loop',
+            p: params,
+            bs: bindingNodes,
+            token: getTokenDebugData(token) && token,
+        };
+    };
+    AlgebraicParser.prototype.parseTry = function (token) {
+        this.advance();
+        var tryExpressions = [];
+        while (!this.isAtEnd() && !isA_SymbolToken(this.peek(), 'catch')) {
+            tryExpressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        var tryExpression = tryExpressions.length === 1
+            ? tryExpressions[0]
+            : {
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: tryExpressions,
+                token: getTokenDebugData(token) && token,
+            };
+        assertA_SymbolToken(this.peek(), 'catch');
+        this.advance();
+        var errorSymbol;
+        if (isLParenToken(this.peek())) {
+            this.advance();
+            errorSymbol = parseSymbol(this.tokenStream, this.parseState);
+            assertRParenToken(this.peek());
+            this.advance();
+        }
+        var catchExpressions = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            catchExpressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        var catchExpression = catchExpressions.length === 1
+            ? catchExpressions[0]
+            : {
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: catchExpressions,
+                token: getTokenDebugData(token) && token,
+            };
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'try',
+            p: [tryExpression],
+            ce: catchExpression,
+            e: errorSymbol,
+            token: getTokenDebugData(token) && token,
         };
     };
-    AlgebraicParser.prototype.parseFor = function (token) {
+    AlgebraicParser.prototype.parseForOrDoseq = function (token) {
+        var isDoseq = token[1] === 'doseq';
         this.advance();
         assertLParenToken(this.peek());
         this.advance();
@@ -7679,7 +7117,7 @@ var AlgebraicParser = /** @class */ (function () {
         this.advance();
         return {
             t: AstNodeType.SpecialExpression,
-            n: 'for',
+            n: isDoseq ? 'doseq' : 'for',
             p: [expression],
             token: getTokenDebugData(token) && token,
             l: forLoopBindings,
@@ -7699,33 +7137,26 @@ var AlgebraicParser = /** @class */ (function () {
         }
         var modifiers = [];
         var token = this.peek();
-        if (!isA_SymbolToken(token)) {
+        if (!isA_SymbolToken(token, 'let')
+            && !isA_ReservedSymbolToken(token, 'when')
+            && !isA_ReservedSymbolToken(token, 'while')) {
             throw new LitsError('Expected symbol let, when or while', (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
         }
         var letBindings;
         if (token[1] === 'let') {
             modifiers.push('&let');
             letBindings = [];
-            this.advance();
-            var letObject = this.parseObject();
-            letBindings = arrayToPairs(letObject.p).map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
-                    t: AstNodeType.Binding,
-                    n: key.v,
-                    v: value,
-                    p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            });
+            while (isA_SymbolToken(token, 'let')) {
+                var letNode = this.parseLet(token, true);
+                letBindings.push(letNode.bs[0]);
+                token = this.peek();
+            }
         }
         token = this.peek();
         var whenNode;
         var whileNode;
-        while (isA_SymbolToken(token)
-            && ((token[1] === 'when' && !modifiers.includes('&when'))
-                || (token[1] === 'while' && !modifiers.includes('&while')))) {
+        while (isA_ReservedSymbolToken(token, 'when')
+            || isA_ReservedSymbolToken(token, 'while')) {
             this.advance();
             if (token[1] === 'when') {
                 modifiers.push('&when');
@@ -7768,7 +7199,8 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseIf = function (token) {
+    AlgebraicParser.prototype.parseIfOrUnless = function (token) {
+        var isUnless = token[1] === 'unless';
         this.advance();
         var condition = this.parseExpression();
         assertA_ReservedSymbolToken(this.peek(), 'then');
@@ -7817,7 +7249,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         return {
             t: AstNodeType.SpecialExpression,
-            n: 'if',
+            n: isUnless ? 'unless' : 'if',
             p: params,
             token: getTokenDebugData(token) && token,
         };
@@ -7902,20 +7334,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;
@@ -7928,10 +7347,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,
@@ -7940,12 +7358,63 @@ 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;
     };
-    AlgebraicParser.prototype.peek = function () {
-        return this.tokenStream.tokens[this.parseState.position];
+    AlgebraicParser.prototype.isAtExpressionEnd = function () {
+        if (this.isAtEnd()) {
+            return true;
+        }
+        var token = this.peek();
+        if (isA_OperatorToken(token)) {
+            return [';', ','].includes(token[1]);
+        }
+        if (isA_SymbolToken(token)) {
+            return ['catch'].includes(token[1]);
+        }
+        if (isA_ReservedSymbolToken(token)) {
+            return ['else', 'when', 'while', 'then', 'end', 'case'].includes(token[1]);
+        }
+        return false;
+    };
+    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;
 }());
@@ -8021,33 +7490,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;
@@ -8217,7 +7659,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);
@@ -8381,6 +7823,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]];
@@ -8398,6 +7859,7 @@ var commonTokenizers = [
     tokenizeLBrace,
     tokenizeRBrace,
     tokenizeString,
+    tokenizeRegexpShorthand,
 ];
 
 var validAlgebraicReservedNamesRecord = {
@@ -8409,17 +7871,13 @@ var validAlgebraicReservedNamesRecord = {
     else: { value: null, forbidden: false },
     end: { value: null, forbidden: false },
     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 = {
-    if_let: { value: null, forbidden: true },
-    when_let: { value: null, forbidden: true },
-    when_first: { value: null, forbidden: true },
     fn: { value: null, forbidden: true },
-    defns: { value: null, forbidden: true },
-    try: { value: null, forbidden: true },
-    recur: { value: null, forbidden: true },
-    loop: { value: null, forbidden: true },
-    doseq: { value: null, forbidden: true },
 };
 var algebraicReservedNamesRecord = __assign(__assign({}, validAlgebraicReservedNamesRecord), forbiddenAlgebraicReservedNamesRecord);
 
@@ -8804,25 +8262,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,
@@ -8833,7 +8272,6 @@ var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_ReservedSymbol,
     tokenizeP_Modifier,
     tokenizeP_Symbol,
-    tokenizeP_RegexpShorthand,
     tokenizeP_FnShorthand,
     tokenizeP_CollectionAccessor,
 ], false);
@@ -10118,7 +9556,7 @@ var arrayReference = {
         description: 'Takes a nested array $x and flattens it.',
         examples: [
             '(flatten [1 2 [3 4] 5])',
-            "\n(let [foo :bar]\n  (flatten\n    [1\n     \" 2 A \"\n     [foo [4 [:ABC]]] 6]))",
+            "\n(let [foo :bar])\n(flatten\n  [1\n    \" 2 A \"\n    [foo [4 [:ABC]]] 6])",
             '(flatten 12)',
         ],
     },
@@ -10152,7 +9590,7 @@ var arrayReference = {
 };
 
 var sequenceReference = {
-    nth: {
+    'nth': {
         title: 'nth',
         category: 'Sequence',
         linkName: 'nth',
@@ -10188,7 +9626,7 @@ var sequenceReference = {
             '(nth nil 1 "Default value")',
         ],
     },
-    push: {
+    'push': {
         title: 'push',
         category: 'Sequence',
         linkName: 'push',
@@ -10218,7 +9656,7 @@ var sequenceReference = {
             '(def l [1 2 3]) (push l 4) l',
         ],
     },
-    pop: {
+    'pop': {
         title: 'pop',
         category: 'Sequence',
         linkName: 'pop',
@@ -10241,7 +9679,7 @@ var sequenceReference = {
             '(pop [])',
         ],
     },
-    unshift: {
+    'unshift': {
         title: 'unshift',
         category: 'Sequence',
         linkName: 'unshift',
@@ -10270,7 +9708,7 @@ var sequenceReference = {
             "\n(def l [1 2 3])\n(unshift l 4)\nl",
         ],
     },
-    shift: {
+    'shift': {
         title: 'shift',
         category: 'Sequence',
         linkName: 'shift',
@@ -10294,7 +9732,7 @@ var sequenceReference = {
             '(shift [])',
         ],
     },
-    slice: {
+    'slice': {
         title: 'slice',
         category: 'Sequence',
         linkName: 'slice',
@@ -10328,7 +9766,7 @@ var sequenceReference = {
             '(slice [1 2 3 4 5] 2)',
         ],
     },
-    reductions: {
+    'reductions': {
         title: 'reductions',
         category: 'Sequence',
         linkName: 'reductions',
@@ -10360,7 +9798,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',
@@ -10390,7 +9828,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',
@@ -10418,7 +9856,7 @@ var sequenceReference = {
             '(reduce_right str [:A :B :C] "")',
         ],
     },
-    map: {
+    'map': {
         title: 'map',
         category: 'Sequence',
         linkName: 'map',
@@ -10443,7 +9881,7 @@ var sequenceReference = {
             '(map [1 2 3] inc)',
         ],
     },
-    filter: {
+    'filter': {
         title: 'filter',
         category: 'Sequence',
         linkName: 'filter',
@@ -10467,7 +9905,7 @@ var sequenceReference = {
             "\n(filter\n[5 10 15 20]\n  (fn [x] (> x 10)))",
         ],
     },
-    position: {
+    'position': {
         title: 'position',
         category: 'Sequence',
         linkName: 'position',
@@ -10494,7 +9932,7 @@ var sequenceReference = {
             "\n(position\n  (fn [x] (> x 100))\n  nil)",
         ],
     },
-    index_of: {
+    'index_of': {
         title: 'index_of',
         category: 'Sequence',
         linkName: 'index_of',
@@ -10521,7 +9959,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',
@@ -10548,7 +10013,7 @@ var sequenceReference = {
             "\n(some\n  nil\n  (fn [x] (> x 10)))",
         ],
     },
-    reverse: {
+    'reverse': {
         title: 'reverse',
         category: 'Sequence',
         linkName: 'reverse',
@@ -10571,7 +10036,7 @@ var sequenceReference = {
             '(reverse nil)',
         ],
     },
-    first: {
+    'first': {
         title: 'first',
         category: 'Sequence',
         linkName: 'first',
@@ -10593,7 +10058,7 @@ var sequenceReference = {
             '(first nil)',
         ],
     },
-    second: {
+    'second': {
         title: 'second',
         category: 'Sequence',
         linkName: 'second',
@@ -10616,7 +10081,7 @@ var sequenceReference = {
             '(second nil)',
         ],
     },
-    last: {
+    'last': {
         title: 'last',
         category: 'Sequence',
         linkName: 'last',
@@ -10640,7 +10105,7 @@ var sequenceReference = {
             '(last nil)',
         ],
     },
-    rest: {
+    'rest': {
         title: 'rest',
         category: 'Sequence',
         linkName: 'rest',
@@ -10665,7 +10130,7 @@ var sequenceReference = {
             '(rest "")',
         ],
     },
-    nthrest: {
+    'nthrest': {
         title: 'nthrest',
         category: 'Sequence',
         linkName: 'nthrest',
@@ -10693,7 +10158,7 @@ var sequenceReference = {
             '(nthrest "" 0)',
         ],
     },
-    next: {
+    'next': {
         title: 'next',
         category: 'Sequence',
         linkName: 'next',
@@ -10718,7 +10183,7 @@ var sequenceReference = {
             '(next "")',
         ],
     },
-    nthnext: {
+    'nthnext': {
         title: 'nthnext',
         category: 'Sequence',
         linkName: 'nthnext',
@@ -10746,7 +10211,7 @@ var sequenceReference = {
             '(nthnext "" 0)',
         ],
     },
-    take: {
+    'take': {
         title: 'take',
         category: 'Sequence',
         linkName: 'take',
@@ -10772,7 +10237,7 @@ var sequenceReference = {
             '(take 50 "Albert")',
         ],
     },
-    take_last: {
+    'take_last': {
         title: 'take_last',
         category: 'Sequence',
         linkName: 'take_last',
@@ -10796,7 +10261,7 @@ var sequenceReference = {
             '(take_last 0 [1 2 3 4 5])',
         ],
     },
-    take_while: {
+    'take_while': {
         title: 'take_while',
         category: 'Sequence',
         linkName: 'take_while',
@@ -10820,7 +10285,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',
@@ -10846,7 +10311,7 @@ var sequenceReference = {
             '(drop "Albert" 50)',
         ],
     },
-    drop_last: {
+    'drop_last': {
         title: 'drop_last',
         category: 'Sequence',
         linkName: 'drop_last',
@@ -10870,7 +10335,7 @@ var sequenceReference = {
             '(drop_last [1 2 3 4 5] 0)',
         ],
     },
-    drop_while: {
+    'drop_while': {
         title: 'drop_while',
         category: 'Sequence',
         linkName: 'drop_while',
@@ -10894,7 +10359,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',
@@ -10921,7 +10386,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',
@@ -10950,7 +10415,7 @@ var sequenceReference = {
             '(sort_by "Albert" lower_case #(compare %2 %1))',
         ],
     },
-    distinct: {
+    'distinct': {
         title: 'distinct',
         category: 'Sequence',
         linkName: 'distinct',
@@ -10973,7 +10438,7 @@ var sequenceReference = {
             '(distinct "")',
         ],
     },
-    remove: {
+    'remove': {
         title: 'remove',
         category: 'Sequence',
         linkName: 'remove',
@@ -10997,7 +10462,7 @@ var sequenceReference = {
             '(remove "Albert Mojir" #(has? "aoueiyAOUEIY" %1))',
         ],
     },
-    remove_at: {
+    'remove_at': {
         title: 'remove_at',
         category: 'Sequence',
         linkName: 'remove_at',
@@ -11023,7 +10488,7 @@ var sequenceReference = {
             '(remove_at "Albert Mojir" 6)',
         ],
     },
-    split_at: {
+    'split_at': {
         title: 'split_at',
         category: 'Sequence',
         linkName: 'split_at',
@@ -11048,7 +10513,7 @@ var sequenceReference = {
             '(split_at "Albert" 2)',
         ],
     },
-    split_with: {
+    'split_with': {
         title: 'split_with',
         category: 'Sequence',
         linkName: 'split_with',
@@ -11073,7 +10538,7 @@ var sequenceReference = {
             '(split_with "Albert" #(<= %1 :Z))',
         ],
     },
-    frequencies: {
+    'frequencies': {
         title: 'frequencies',
         category: 'Sequence',
         linkName: 'frequencies',
@@ -11094,7 +10559,7 @@ var sequenceReference = {
             '(frequencies "Pneumonoultramicroscopicsilicovolcanoconiosis")',
         ],
     },
-    group_by: {
+    'group_by': {
         title: 'group_by',
         category: 'Sequence',
         linkName: 'group_by',
@@ -11118,7 +10583,7 @@ var sequenceReference = {
             '(group_by "Albert Mojir" (fn [char] (if (has? "aoueiAOUEI" char) "vowel" "other")))',
         ],
     },
-    partition: {
+    'partition': {
         title: 'partition',
         category: 'Sequence',
         linkName: 'partition',
@@ -11135,67 +10600,175 @@ var sequenceReference = {
             step: {
                 type: 'number',
             },
-            pad: {
-                type: 'array',
+            pad: {
+                type: 'array',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'n'] },
+            { argumentNames: ['seq', 'n', 'step'] },
+            { argumentNames: ['seq', 'n', 'step', 'pad'] },
+        ],
+        description: 'Returns an array of sequences of $n items each, at offsets $step apart. If $step is not supplied, defaults to $n. If a $pad array is supplied, use its elements as necessary to complete last partition upto $n items. In case there are not enough padding elements, return a partition with less than $n items.',
+        examples: [
+            '(partition (range 20) 4)',
+            '(partition (range 22) 4)',
+            '(partition (range 20) 4 6)',
+            '(partition (range 20) 4 3)',
+            '(partition (range 20) 3 6 [:a])',
+            '(partition (range 20) 4 6 [:a])',
+            '(partition (range 20) 4 6 [:a :b :c :d])',
+            '(partition [:a :b :c :d :e :f] 3 1)',
+            '(partition [1 2 3 4] 10)',
+            '(partition [1 2 3 4] 10 10)',
+            '(partition [1 2 3 4] 10 10 [])',
+            '(partition [1 2 3 4] 10 10 nil)',
+            '(partition "superfragilistic" 5)',
+            '(partition "superfragilistic" 5 5 nil)',
+            '(def foo [5 6 7 8]) (partition foo 2 1 foo)',
+        ],
+    },
+    'partition_all': {
+        title: 'partition_all',
+        category: 'Sequence',
+        linkName: 'partition_all',
+        returns: {
+            type: 'sequence',
+        },
+        args: {
+            seq: {
+                type: 'sequence',
+            },
+            n: {
+                type: 'number',
+            },
+            step: {
+                type: 'number',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'n'] },
+            { argumentNames: ['seq', 'n', 'step'] },
+        ],
+        description: 'Returns an array of sequences like partition, but may include partitions with fewer than n items at the end.',
+        examples: [
+            '(partition_all [0 1 2 3 4 5 6 7 8 9] 4)',
+            '(partition [0 1 2 3 4 5 6 7 8 9] 4)',
+            '(partition_all [0 1 2 3 4 5 6 7 8 9] 2 4)',
+        ],
+    },
+    'partition_by': {
+        title: 'partition_by',
+        category: 'Sequence',
+        linkName: 'partition_by',
+        returns: {
+            type: 'sequence',
+        },
+        args: {
+            seq: {
+                type: 'sequence',
+            },
+            fn: {
+                type: 'function',
+            },
+        },
+        variants: [
+            { argumentNames: ['seq', 'fn'] },
+        ],
+        description: 'Applies $fn to each value in $seq, splitting it each time $fn returns a new value. Returns an array of sequences.',
+        examples: [
+            '(partition_by [1 2 3 4 5] #(== 3 %1))',
+            '(partition_by [1 1 1 2 2 3 3] odd?)',
+            '(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', 'n'] },
-            { argumentNames: ['seq', 'n', 'step'] },
-            { argumentNames: ['seq', 'n', 'step', 'pad'] },
+            { argumentNames: ['seq', 'suffix'] },
         ],
-        description: 'Returns an array of sequences of $n items each, at offsets $step apart. If $step is not supplied, defaults to $n. If a $pad array is supplied, use its elements as necessary to complete last partition upto $n items. In case there are not enough padding elements, return a partition with less than $n items.',
+        description: 'Returns `true` if $seq ends with $suffix, otherwise `false`.',
         examples: [
-            '(partition (range 20) 4)',
-            '(partition (range 22) 4)',
-            '(partition (range 20) 4 6)',
-            '(partition (range 20) 4 3)',
-            '(partition (range 20) 3 6 [:a])',
-            '(partition (range 20) 4 6 [:a])',
-            '(partition (range 20) 4 6 [:a :b :c :d])',
-            '(partition [:a :b :c :d :e :f] 3 1)',
-            '(partition [1 2 3 4] 10)',
-            '(partition [1 2 3 4] 10 10)',
-            '(partition [1 2 3 4] 10 10 [])',
-            '(partition [1 2 3 4] 10 10 nil)',
-            '(partition "superfragilistic" 5)',
-            '(partition "superfragilistic" 5 5 nil)',
-            '(def foo [5 6 7 8]) (partition foo 2 1 foo)',
+            '(ends_with? [1 2 3 4 5] 5)',
+            '(ends_with? [1 2 3 4 5] [5])',
+            '(ends_with? "Albert" "rt")',
+            '(ends_with? "Albert" "RT")',
         ],
     },
-    partition_all: {
-        title: 'partition_all',
+    'interleave': {
+        title: 'interleave',
         category: 'Sequence',
-        linkName: 'partition_all',
+        linkName: 'interleave',
+        clojureDocs: null,
         returns: {
             type: 'sequence',
         },
         args: {
-            seq: {
+            seqs: {
                 type: 'sequence',
-            },
-            n: {
-                type: 'number',
-            },
-            step: {
-                type: 'number',
+                array: true,
             },
         },
         variants: [
-            { argumentNames: ['seq', 'n'] },
-            { argumentNames: ['seq', 'n', 'step'] },
+            { argumentNames: ['seqs'] },
         ],
-        description: 'Returns an array of sequences like partition, but may include partitions with fewer than n items at the end.',
+        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: [
-            '(partition_all [0 1 2 3 4 5 6 7 8 9] 4)',
-            '(partition [0 1 2 3 4 5 6 7 8 9] 4)',
-            '(partition_all [0 1 2 3 4 5 6 7 8 9] 2 4)',
+            '(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 [])',
         ],
     },
-    partition_by: {
-        title: 'partition_by',
+    'interpose': {
+        title: 'interpose',
         category: 'Sequence',
-        linkName: 'partition_by',
+        linkName: 'interpose',
+        clojureDocs: null,
         returns: {
             type: 'sequence',
         },
@@ -11203,18 +10776,18 @@ var sequenceReference = {
             seq: {
                 type: 'sequence',
             },
-            fn: {
-                type: 'function',
+            separator: {
+                type: 'any',
             },
         },
         variants: [
-            { argumentNames: ['seq', 'fn'] },
+            { argumentNames: ['seq', 'separator'] },
         ],
-        description: 'Applies $fn to each value in $seq, splitting it each time $fn returns a new value. Returns an array of sequences.',
+        description: 'Returns a sequence of the elements of $seq separated by $separator. If $seq is a string, the separator must be a string.',
         examples: [
-            '(partition_by [1 2 3 4 5] #(== 3 %1))',
-            '(partition_by [1 1 1 2 2 3 3] odd?)',
-            '(partition_by "Leeeeeerrroyyy" identity)',
+            '(interpose :a [1 2 3 4 5])',
+            '(interpose " " ["Albert" "Mojir" "Nina"])',
+            '(interpose "." "Albert")',
         ],
     },
 };
@@ -13811,12 +13384,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: {
@@ -13833,7 +13406,7 @@ var regularExpressionReference = {
                 type: 'string',
             },
             r: {
-                type: 'regexp',
+                type: ['regexp', 'string'],
             },
             x: {
                 type: 'string',
@@ -13842,13 +13415,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 = {
@@ -13927,32 +13536,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',
@@ -13965,97 +13548,12 @@ var specialExpressionsReference = {
                 type: '*binding',
                 rest: true,
             },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['bindings', 'expressions'] },
-        ],
-        description: "\nBinds local variables. The variables lives only within $expressions.\nIt returns evaluation of the last expression in $expressions.",
-        examples: ["\n  (let [a (+ 1 2 3 4) \n        b (* 1 2 3 4)]\n    (write! a b))"],
-    },
-    'if_let': {
-        title: 'if_let',
-        category: 'Special expression',
-        linkName: 'if_let',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            'binding': {
-                type: '*binding',
-            },
-            'then-expr': {
-                type: '*expression',
-            },
-            'else-expr': {
-                type: '*expression',
-            },
-        },
-        variants: [
-            { argumentNames: ['binding', 'then-expr'] },
-            { argumentNames: ['binding', 'then-expr', 'else-expr'] },
-        ],
-        description: "\nBinds one local variable. If it evaluates to a truthy value\n$then-expr is executed with the variable accessable.\nIf the bound variable evaluates to false, the $else-expr is evaluated\n(without variable accessable).",
-        examples: [
-            "\n(if_let [a (> (count \"Albert\") 4)]\n  (write! (str a \", is big enough\"))\n  (write! \"Sorry, not big enough.\"))",
-            "\n(if_let [a (> (count \"Albert\") 10)]\n  (write! (str a \", is big enough\"))\n  (write! \"Sorry, not big enough.\"))",
-        ],
-    },
-    'when_let': {
-        title: 'when_let',
-        category: 'Special expression',
-        linkName: 'when_let',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            binding: {
-                type: '*binding',
-            },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['binding', 'expressions'] },
-        ],
-        description: "\nBinds one local variable. If it evaluates to a truthy value\n$expressions is executed with the variable accessable.\nIf the bound variable evaluates to a falsy value, `nil` is returned.",
-        examples: [
-            "\n(when_let [a (> (count \"Albert\") 4)]\n  (write! a))",
-        ],
-    },
-    'when_first': {
-        title: 'when_first',
-        category: 'Special expression',
-        linkName: 'when_first',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            binding: {
-                type: '*binding',
-                rest: true,
-            },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
         },
         variants: [
-            { argumentNames: ['binding', 'expressions'] },
-        ],
-        description: 'When the binding value in $binding is a non empty sequence, the first element of that sequence (instead of the sequence itself) is bound to the variable.',
-        examples: [
-            "\n(when_first [x [1 2 3]]\n  (write! x)\n  x)",
-            "\n(when_first [x \"Albert\"]\n  (write! x)\n  x)",
-            "\n(when_first [x [0]]\n  (write! x)\n  x)",
-            "\n(when_first [x [nil]]\n  (write! x)\n  x)",
-            "\n(when_first [x []]\n  (write! x)\n  x)",
+            { argumentNames: ['bindings'] },
         ],
+        description: "\nBinds local variables.",
+        examples: ["\n(let [a (+ 1 2 3 4) \n      b (* 1 2 3 4)])\n(write! a b)"],
     },
     'fn': {
         title: 'fn',
@@ -14111,36 +13609,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',
@@ -14219,10 +13687,11 @@ var specialExpressionsReference = {
             '(if false (write! "TRUE"))',
         ],
     },
-    'if_not': {
-        title: 'if_not',
+    'unless': {
+        title: 'unless',
         category: 'Special expression',
-        linkName: 'if_not',
+        linkName: 'unless',
+        clojureDocs: 'if-not',
         returns: {
             type: 'any',
         },
@@ -14243,10 +13712,10 @@ var specialExpressionsReference = {
         ],
         description: 'Either $then-expr or $else-expr branch is taken. $then-expr is selected when $test is falsy. If $test is truthy $else-expr is executed, if no $else-expr exists, `nil` is returned.',
         examples: [
-            '(if_not true (write! "TRUE") (write! "FALSE"))',
-            '(if_not false (write! "TRUE") (write! "FALSE"))',
-            '(if_not true (write! "TRUE"))',
-            '(if_not false (write! "TRUE"))',
+            '(unless true (write! "TRUE") (write! "FALSE"))',
+            '(unless false (write! "TRUE") (write! "FALSE"))',
+            '(unless true (write! "TRUE"))',
+            '(unless false (write! "TRUE"))',
         ],
     },
     'cond': {
@@ -14296,60 +13765,6 @@ var specialExpressionsReference = {
             "\n(switch 3\n  1 (write! \"FALSE\")\n  2 (write! \"nil\"))",
         ],
     },
-    'when': {
-        title: 'when',
-        category: 'Special expression',
-        linkName: 'when',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            test: {
-                type: '*expression',
-            },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['test', 'expressions'] },
-        ],
-        description: "If $test yields a thruthy value, the expressions are evaluated\nand the value returned by the last expression is returned.\nOtherwise, if $test yields a falsy value, the expressions are not evaluated,\nand `nil` is returned. If no $expressions are provided, `nil` is returned.",
-        examples: [
-            "(when true\n      (write! \"Hi\")\n      (write! \"There\"))",
-            "(when false\n      (write! \"Hi\")\n      (write! \"There\"))",
-            '(when true)',
-            '(when false)',
-        ],
-    },
-    'when_not': {
-        title: 'when_not',
-        category: 'Special expression',
-        linkName: 'when_not',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            test: {
-                type: '*expression',
-            },
-            expressions: {
-                type: '*expression',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['test', 'expressions'] },
-        ],
-        description: "If $test yields a falsy value, the expressions are evaluated\nand the value returned by the last `expression` is returned.\nOtherwise, if $test yields a truthy value, the $expressions are not evaluated,\nand `nil` is returned. If no `expression` is provided, `nil` is returned.",
-        examples: [
-            '(when_not true (write! "Hi") (write! "There"))',
-            '(when_not false (write! "Hi") (write! "There"))',
-            '(when_not true)',
-            '(when_not false)',
-        ],
-    },
     'comment': {
         title: 'comment',
         category: 'Special expression',
@@ -14409,9 +13824,9 @@ var specialExpressionsReference = {
         ],
         description: 'Recursevly calls enclosing function or loop with its evaluated $expressions.',
         examples: [
-            "\n(defn foo [n]\n  (write! n)\n  (when (! (zero? n))\n    (recur\n      (dec n))))\n(foo 3)",
-            "\n(\n  (fn [n]\n    (write! n)\n    (when (! (zero? n))\n      (recur\n        (dec n))))\n  3)",
-            "\n(\n  loop [n 3]\n    (write! n)\n    (when\n      (! (zero? n))\n      (recur (dec n))))",
+            "\n(defn foo [n]\n  (write! n)\n  (if (! (zero? n))\n    (recur\n      (dec n))))\n(foo 3)",
+            "\n(\n  (fn [n]\n    (write! n)\n    (if (! (zero? n))\n      (recur\n        (dec n))))\n  3)",
+            "\n(\n  loop [n 3]\n    (write! n)\n    (if\n      (! (zero? n))\n      (recur (dec n))))",
         ],
     },
     'loop': {
@@ -14436,7 +13851,7 @@ var specialExpressionsReference = {
         ],
         description: 'Executes $expressions with initial $bindings. The $bindings will be replaced with the recur parameters for subsequent recursions.',
         examples: [
-            "\n(loop [n 3]\n  (write! n)\n  (when\n    (! (zero? n))\n    (recur (dec n))))",
+            "\n(loop [n 3]\n  (write! n)\n  (if\n    (! (zero? n))\n    (recur (dec n))))",
             "\n(loop [n 3]\n  (write! n)\n  (if\n    (! (zero? n))\n    (recur (dec n))\n    n))",
         ],
     },
@@ -14495,10 +13910,10 @@ var specialExpressionsReference = {
             "\n(for\n  [x [1 2 3] y [1 2 3] z [1 2 3]\n  &while (<= x y)]\n  \n  [x y z])",
         ],
     },
-    'declared?': {
-        title: 'declared?',
+    'defined?': {
+        title: 'defined?',
         category: 'Special expression',
-        linkName: 'declared-question',
+        linkName: 'defined-question',
         returns: {
             type: 'boolean',
         },
@@ -14512,11 +13927,11 @@ var specialExpressionsReference = {
         ],
         description: 'Returns `true` if $n is a declared variable or a builtin function, otherwise `false`.',
         examples: [
-            '(declared? foo)',
-            "\n(def foo :foo)\n(declared? foo)",
-            '(declared? +)',
-            "\n(def foo nil)\n(declared? foo)",
-            '(declared? if)',
+            '(defined? foo)',
+            "\n(def foo :foo)\n(defined? foo)",
+            '(defined? +)',
+            "\n(def foo nil)\n(defined? foo)",
+            '(defined? if)',
         ],
     },
     '??': {
@@ -14862,6 +14277,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',
@@ -15078,6 +14517,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 = { '<<': {
@@ -15641,6 +15129,7 @@ var api = {
         'filter',
         'position',
         'index_of',
+        'last_index_of',
         'some',
         'reverse',
         'first',
@@ -15668,6 +15157,10 @@ var api = {
         'partition',
         'partition_all',
         'partition_by',
+        'starts_with?',
+        'ends_with?',
+        'interleave',
+        'interpose',
     ],
     math: [
         '+',
@@ -15788,34 +15281,28 @@ var api = {
         'regexp',
         'match',
         'replace',
+        'replace_all',
     ],
     specialExpressions: [
         '&&',
         '||',
         'def',
-        'defs',
         'let',
-        'if_let',
-        'when_let',
-        'when_first',
         'fn',
         'defn',
-        'defns',
         'try',
         'throw',
         'if',
-        'if_not',
+        'unless',
         'cond',
         'switch',
-        'when',
-        'when_not',
         'comment',
         'do',
         'recur',
         'loop',
         'doseq',
         'for',
-        'declared?',
+        'defined?',
         '??',
     ],
     string: [
@@ -15831,6 +15318,7 @@ var api = {
         'pad_left',
         'pad_right',
         'split',
+        'split_lines',
         'template',
         'to_char_code',
         'from_char_code',
@@ -15840,6 +15328,8 @@ var api = {
         'decode_uri_component',
         'join',
         '++',
+        'capitalize',
+        'blank?',
     ],
     bitwise: [
         '<<',