@mojir/lits 2.0.15 → 2.0.16

package/dist/lits.iife.js

@@ -429,20 +429,15 @@ var Lits = (function (exports) {
         '&&',
         'comment',
         'cond',
-        'declared?',
+        'defined?',
         'if',
-        'if_not',
+        'unless',
         '||',
-        'when',
-        'when_not',
         'do',
         'throw',
         'let',
         'def',
         'defs',
-        'if_let',
-        'when_let',
-        'when_first',
         'fn',
         'defn',
         'defns',
@@ -468,16 +463,22 @@ var Lits = (function (exports) {
     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) {
@@ -760,7 +761,7 @@ var Lits = (function (exports) {
             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);
         },
@@ -781,12 +782,11 @@ var Lits = (function (exports) {
         '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);
         },
@@ -815,10 +815,6 @@ var Lits = (function (exports) {
             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];
@@ -4445,7 +4441,7 @@ var Lits = (function (exports) {
     };
 
     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]);
@@ -4501,9 +4497,7 @@ var Lits = (function (exports) {
             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) {
@@ -4514,7 +4508,7 @@ var Lits = (function (exports) {
             var result = findUnresolvedIdentifiers([subNode], contextStack, builtin);
             var name = asSymbolNode(node.p[0]).v;
             assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-            contextStack.globalContext[name] = { value: true };
+            contextStack.exportValue(name, true);
             return result;
         },
     };
@@ -4540,9 +4534,7 @@ var Lits = (function (exports) {
             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),
-            };
+            contextStack.exportValue(name, evaluateAstNode(node.p[1], contextStack));
             return null;
         },
         findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4554,7 +4546,7 @@ var Lits = (function (exports) {
             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;
         },
     };
@@ -4585,7 +4577,7 @@ var Lits = (function (exports) {
         },
         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);
         },
     };
 
@@ -4614,11 +4606,6 @@ var Lits = (function (exports) {
     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) {
@@ -4653,13 +4640,13 @@ var Lits = (function (exports) {
                 _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);
         },
@@ -4695,7 +4682,7 @@ var Lits = (function (exports) {
                 _b.n = name,
                 _b.o = evaluatedFunctionOverloades,
                 _b);
-            contextStack.globalContext[name] = { value: litsFunction };
+            contextStack.exportValue(name, litsFunction);
             return null;
         },
         findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4706,7 +4693,7 @@ var Lits = (function (exports) {
             var name = evaluateAstNode(asAstNode(node.f, sourceCodeInfo), contextStack);
             assertString(name, sourceCodeInfo);
             assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-            contextStack.globalContext[name] = { value: true };
+            contextStack.exportValue(name, true);
             var newContext = (_b = {}, _b[name] = { value: true }, _b);
             return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin, newContext);
         },
@@ -4979,56 +4966,8 @@ var Lits = (function (exports) {
         },
     };
 
-    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: exports.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;
@@ -5053,55 +4992,39 @@ var Lits = (function (exports) {
 
     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: exports.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;
@@ -5111,11 +5034,10 @@ var Lits = (function (exports) {
                 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);
@@ -5566,9 +5488,10 @@ var Lits = (function (exports) {
                 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));
             }
         },
@@ -5577,199 +5500,15 @@ var Lits = (function (exports) {
             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: exports.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: exports.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,
@@ -5784,19 +5523,14 @@ var Lits = (function (exports) {
         '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) {
@@ -5818,8 +5552,8 @@ var Lits = (function (exports) {
     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;
@@ -5835,6 +5569,35 @@ var Lits = (function (exports) {
             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.addValue(name, value);
+            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({
@@ -5964,7 +5727,7 @@ var Lits = (function (exports) {
                     return acc;
                 }, {}),
         });
-        return contextStack;
+        return contextStack.create({});
     }
 
     var _a$1;
@@ -6276,7 +6039,14 @@ var Lits = (function (exports) {
 
     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: exports.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()) {
@@ -6337,548 +6107,20 @@ var Lits = (function (exports) {
             }
             case exports.AstNodeType.SpecialExpression: {
                 var specialExpression = asNonUndefined(builtin.specialExpressions[astNode.n], (_b = getTokenDebugData(astNode.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-                // eslint-disable-next-line ts/no-unsafe-argument
-                var unresolvedIdentifiers = specialExpression.findUnresolvedIdentifiers(astNode, contextStack, {
-                    findUnresolvedIdentifiers: findUnresolvedIdentifiers,
-                    builtin: builtin,
-                    evaluateAstNode: evaluateAstNode,
-                });
-                return unresolvedIdentifiers;
-            }
-        }
-    }
-
-    var calculateAndOutcomes = function (_a) {
-        var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: '&&',
-            t: exports.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: exports.AstNodeType.ReservedSymbol, v: 'true', token: undefined, p: [], n: undefined };
-    var falseNode = { t: exports.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: exports.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: exports.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: exports.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: exports.AstNodeType.SpecialExpression,
-                n: 'let',
-                bs: [{
-                        t: exports.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);
+                // eslint-disable-next-line ts/no-unsafe-argument
+                var unresolvedIdentifiers = specialExpression.findUnresolvedIdentifiers(astNode, contextStack, {
+                    findUnresolvedIdentifiers: findUnresolvedIdentifiers,
+                    builtin: builtin,
+                    evaluateAstNode: evaluateAstNode,
+                });
+                return unresolvedIdentifiers;
             }
-            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: exports.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 === exports.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 === exports.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),
         };
     }
 
@@ -7160,38 +6402,43 @@ var Lits = (function (exports) {
             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);
-            }
-            else if (isA_SymbolToken(firstToken) && firstToken[1] === 'for') {
-                left = this.parseFor(firstToken);
-            }
-            else {
-                left = this.parseOperand();
+            if (isA_SymbolToken(firstToken)) {
+                switch (firstToken[1]) {
+                    case 'def':
+                        return this.parseDef(firstToken);
+                    case 'defn':
+                        return this.parseDefn(firstToken);
+                    case 'let':
+                        return this.parseLet(firstToken);
+                    case 'if':
+                    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;
+                }
             }
+            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);
@@ -7444,12 +6691,9 @@ var Lits = (function (exports) {
                         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: exports.AstNodeType.SpecialExpression,
@@ -7460,17 +6704,10 @@ var Lits = (function (exports) {
                             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':
                             throw new Error("Special expression ".concat(name_2, " is not available in algebraic notation"));
                         default:
@@ -7633,36 +6870,142 @@ var Lits = (function (exports) {
             };
             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 !== exports.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);
-            }
-            var letBindings = arrayToPairs(letObject.p);
-            var expression = params[1];
+        AlgebraicParser.prototype.parseLet = function (token) {
+            this.advance();
+            var letSymbol = parseSymbol(this.tokenStream, this.parseState);
+            assertA_OperatorToken(this.peek(), '=');
+            this.advance();
+            var value = this.parseExpression();
             return {
                 t: exports.AstNodeType.SpecialExpression,
                 n: 'let',
-                p: [expression],
+                p: [],
                 token: getTokenDebugData(letSymbol.token) && letSymbol.token,
-                bs: letBindings.map(function (pair) {
-                    var key = pair[0];
-                    var value = pair[1];
-                    return {
+                bs: [{
                         t: exports.AstNodeType.Binding,
-                        n: key.v,
+                        n: letSymbol.v,
                         v: value,
                         p: [],
-                        token: getTokenDebugData(key.token) && key.token,
-                    };
-                }),
+                        token: getTokenDebugData(token) && 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: exports.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: exports.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: exports.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: exports.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: exports.AstNodeType.SpecialExpression,
+                    n: 'do',
+                    p: catchExpressions,
+                    token: getTokenDebugData(token) && token,
+                };
+            return {
+                t: exports.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();
@@ -7682,7 +7025,7 @@ var Lits = (function (exports) {
             this.advance();
             return {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'for',
+                n: isDoseq ? 'doseq' : 'for',
                 p: [expression],
                 token: getTokenDebugData(token) && token,
                 l: forLoopBindings,
@@ -7702,33 +7045,26 @@ var Lits = (function (exports) {
             }
             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: exports.AstNodeType.Binding,
-                        n: key.v,
-                        v: value,
-                        p: [],
-                        token: getTokenDebugData(key.token) && key.token,
-                    };
-                });
+                while (isA_SymbolToken(token, 'let')) {
+                    var letNode = this.parseLet(token);
+                    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');
@@ -7771,7 +7107,8 @@ var Lits = (function (exports) {
             };
             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');
@@ -7820,7 +7157,7 @@ var Lits = (function (exports) {
             }
             return {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'if',
+                n: isUnless ? 'unless' : 'if',
                 p: params,
                 token: getTokenDebugData(token) && token,
             };
@@ -7947,6 +7284,22 @@ var Lits = (function (exports) {
         AlgebraicParser.prototype.isAtEnd = function () {
             return this.parseState.position >= this.tokenStream.tokens.length;
         };
+        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.peek = function () {
             return this.tokenStream.tokens[this.parseState.position];
         };
@@ -8412,17 +7765,12 @@ var Lits = (function (exports) {
         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 },
     };
     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);
 
@@ -10121,7 +9469,7 @@ var Lits = (function (exports) {
             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)',
             ],
         },
@@ -13968,97 +13316,12 @@ var Lits = (function (exports) {
                     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',
@@ -14222,10 +13485,11 @@ var Lits = (function (exports) {
                 '(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',
             },
@@ -14246,10 +13510,10 @@ var Lits = (function (exports) {
             ],
             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': {
@@ -14299,60 +13563,6 @@ var Lits = (function (exports) {
                 "\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',
@@ -14412,9 +13622,9 @@ var Lits = (function (exports) {
             ],
             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': {
@@ -14439,7 +13649,7 @@ var Lits = (function (exports) {
             ],
             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))",
             ],
         },
@@ -14498,10 +13708,10 @@ var Lits = (function (exports) {
                 "\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',
             },
@@ -14515,11 +13725,11 @@ var Lits = (function (exports) {
             ],
             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)',
             ],
         },
         '??': {
@@ -15798,27 +15008,22 @@ var Lits = (function (exports) {
             '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: [