@mojir/lits 2.0.13 → 2.0.15

package/dist/lits.iife.js

@@ -239,6 +239,12 @@ var Lits = (function (exports) {
         return error instanceof LitsError;
     }
 
+    function getSourceCodeInfo(anyValue, sourceCodeInfo) {
+        var _a;
+        // eslint-disable-next-line ts/no-unsafe-return, ts/no-unsafe-member-access
+        return (_a = anyValue === null || anyValue === void 0 ? void 0 : anyValue.sourceCodeInfo) !== null && _a !== void 0 ? _a : sourceCodeInfo;
+    }
+
     function isTokenDebugData(tokenDebugData) {
         return (typeof tokenDebugData === 'object'
             && tokenDebugData !== null
@@ -257,8 +263,12 @@ var Lits = (function (exports) {
         }
         token.push(debugData);
     }
-    function throwUnexpectedToken(expected, actual) {
-        throw new LitsError("Unexpected token: ".concat(actual, ", expected ").concat(expected), undefined);
+    function throwUnexpectedToken(expected, expectedValue, actual) {
+        if (actual === undefined) {
+            throw new LitsError("Unexpected end of input, expected ".concat(expected).concat(expectedValue ? " '".concat(expectedValue, "'") : ''), undefined);
+        }
+        var actualOutput = "".concat(actual[0]).concat(actual[1] ? " '".concat(actual[1], "'") : '');
+        throw new LitsError("Unexpected token: ".concat(actualOutput, ", expected ").concat(expected).concat(expectedValue ? " '".concat(expectedValue, "'") : ''), getSourceCodeInfo(actual));
     }
 
     var commonSimpleTokenTypes = [
@@ -280,7 +290,7 @@ var Lits = (function (exports) {
     }
     function assertLParenToken(token) {
         if (!isLParenToken(token)) {
-            throwUnexpectedToken('LParen', token);
+            throwUnexpectedToken('LParen', undefined, token);
         }
     }
     function asLParenToken(token) {
@@ -292,7 +302,7 @@ var Lits = (function (exports) {
     }
     function assertRParenToken(token) {
         if (!isRParenToken(token)) {
-            throwUnexpectedToken('RParen', token);
+            throwUnexpectedToken('RParen', undefined, token);
         }
     }
     function isLBracketToken(token) {
@@ -300,7 +310,7 @@ var Lits = (function (exports) {
     }
     function assertLBracketToken(token) {
         if (!isLBracketToken(token)) {
-            throwUnexpectedToken('LBracket', token);
+            throwUnexpectedToken('LBracket', undefined, token);
         }
     }
     function asLBracketToken(token) {
@@ -312,7 +322,7 @@ var Lits = (function (exports) {
     }
     function assertRBracketToken(token) {
         if (!isRBracketToken(token)) {
-            throwUnexpectedToken('RBracket', token);
+            throwUnexpectedToken('RBracket', undefined, token);
         }
     }
     function isLBraceToken(token) {
@@ -320,7 +330,7 @@ var Lits = (function (exports) {
     }
     function assertLBraceToken(token) {
         if (!isLBraceToken(token)) {
-            throwUnexpectedToken('LBrace', token);
+            throwUnexpectedToken('LBrace', undefined, token);
         }
     }
     function asLBraceToken(token) {
@@ -332,7 +342,7 @@ var Lits = (function (exports) {
     }
     function assertRBraceToken(token) {
         if (!isRBraceToken(token)) {
-            throwUnexpectedToken('RBrace', token);
+            throwUnexpectedToken('RBrace', undefined, token);
         }
     }
     function isStringToken(token) {
@@ -340,7 +350,7 @@ var Lits = (function (exports) {
     }
     function assertStringToken(token) {
         if (!isStringToken(token)) {
-            throwUnexpectedToken('String', token);
+            throwUnexpectedToken('String', undefined, token);
         }
     }
     function asStringToken(token) {
@@ -358,7 +368,7 @@ var Lits = (function (exports) {
     }
     function assertEndNotationToken(token) {
         if (!isEndNotationToken(token)) {
-            throwUnexpectedToken('EndNotation', token);
+            throwUnexpectedToken('EndNotation', undefined, token);
         }
     }
 
@@ -411,28 +421,28 @@ var Lits = (function (exports) {
         '.', // property accessor
         ',', // item separator
         '=', // property assignment
+        ';', // statement terminator
     ];
     var symbolicOperators = __spreadArray(__spreadArray(__spreadArray([], __read(symbolicUnaryOperators), false), __read(symbolicBinaryOperators), false), __read(otherSymbolicOperators), false);
     var nonFunctionOperators = [
         '??',
-        'and',
+        '&&',
         'comment',
         'cond',
         'declared?',
         'if',
-        'if-not',
-        'or',
+        'if_not',
+        '||',
         'when',
-        'when-not',
+        'when_not',
         'do',
-        'time!',
         'throw',
         'let',
         'def',
         'defs',
-        'if-let',
-        'when-let',
-        'when-first',
+        'if_let',
+        'when_let',
+        'when_first',
         'fn',
         'defn',
         'defns',
@@ -463,7 +473,7 @@ var Lits = (function (exports) {
     }
     function assertA_SymbolToken(token) {
         if (!isA_SymbolToken(token)) {
-            throwUnexpectedToken('A_Symbol', token);
+            throwUnexpectedToken('A_Symbol', undefined, token);
         }
     }
     function asA_SymbolToken(token) {
@@ -473,8 +483,19 @@ var Lits = (function (exports) {
     function isA_BinaryOperatorToken(token) {
         return (token === null || token === void 0 ? void 0 : token[0]) === 'A_Operator' && isSymbolicBinaryOperator(token[1]);
     }
-    function isA_ReservedSymbolToken(token) {
-        return (token === null || token === void 0 ? void 0 : token[0]) === 'A_ReservedSymbol';
+    function isA_ReservedSymbolToken(token, symbolName) {
+        if ((token === null || token === void 0 ? void 0 : token[0]) !== 'A_ReservedSymbol') {
+            return false;
+        }
+        if (symbolName && token[1] !== symbolName) {
+            return false;
+        }
+        return true;
+    }
+    function assertA_ReservedSymbolToken(token, symbolName) {
+        if (!isA_ReservedSymbolToken(token, symbolName)) {
+            throwUnexpectedToken('A_ReservedSymbol', symbolName, token);
+        }
     }
     function isA_CommentToken(token) {
         return (token === null || token === void 0 ? void 0 : token[0]) === 'A_SingleLineComment';
@@ -493,10 +514,9 @@ var Lits = (function (exports) {
     }
     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', token);
         }
     }
     function isA_WhitespaceToken(token) {
@@ -509,7 +529,7 @@ var Lits = (function (exports) {
         return (token === null || token === void 0 ? void 0 : token[0]) === 'A_BasePrefixedNumber';
     }
 
-    var modifierNames = ['&', '&let', '&when', '&while'];
+    var modifierNames = ['&rest', '&let', '&when', '&while'];
     var polishOnlySimpleTokenTypes = [
         'P_FnShorthand',
     ];
@@ -532,7 +552,7 @@ var Lits = (function (exports) {
     }
     function assertP_StringShorthandToken(token) {
         if (!isP_StringShorthandToken(token)) {
-            throwUnexpectedToken('P_StringShorthand', token);
+            throwUnexpectedToken('P_StringShorthand', undefined, token);
         }
     }
     function asP_StringShorthandToken(token) {
@@ -544,7 +564,7 @@ var Lits = (function (exports) {
     }
     function assertP_SymbolToken(token) {
         if (!isP_SymbolToken(token)) {
-            throwUnexpectedToken('P_Symbol', token);
+            throwUnexpectedToken('P_Symbol', undefined, token);
         }
     }
     function asP_SymbolToken(token) {
@@ -562,7 +582,7 @@ var Lits = (function (exports) {
     }
     function assertP_RegexpShorthandToken(token) {
         if (!isP_RegexpShorthandToken(token)) {
-            throwUnexpectedToken('P_RegexpShorthand', token);
+            throwUnexpectedToken('P_RegexpShorthand', undefined, token);
         }
     }
     function asP_RegexpShorthandToken(token) {
@@ -577,7 +597,7 @@ var Lits = (function (exports) {
     }
     function assertP_CollectionAccessorToken(token) {
         if (!isP_CollectionAccessorToken(token)) {
-            throwUnexpectedToken('P_CollectionAccessor', token);
+            throwUnexpectedToken('P_CollectionAccessor', undefined, token);
         }
     }
     function asP_CollectionAccessorToken(token) {
@@ -589,7 +609,7 @@ var Lits = (function (exports) {
     }
     function assertP_CommentToken(token) {
         if (!isP_CommentToken(token)) {
-            throwUnexpectedToken('P_Comment', token);
+            throwUnexpectedToken('P_Comment', undefined, token);
         }
     }
     function asP_CommentToken(token) {
@@ -604,7 +624,7 @@ var Lits = (function (exports) {
     }
     function assertP_NumberToken(token) {
         if (!isP_NumberToken(token)) {
-            throwUnexpectedToken('P_Number', token);
+            throwUnexpectedToken('P_Number', undefined, token);
         }
     }
 
@@ -672,12 +692,6 @@ var Lits = (function (exports) {
         return JSON.stringify(value);
     }
 
-    function getSourceCodeInfo(anyValue, sourceCodeInfo) {
-        var _a;
-        // eslint-disable-next-line ts/no-unsafe-return, ts/no-unsafe-member-access
-        return (_a = anyValue === null || anyValue === void 0 ? void 0 : anyValue.sourceCodeInfo) !== null && _a !== void 0 ? _a : sourceCodeInfo;
-    }
-
     function getAssertionError(typeName, value, sourceCodeInfo) {
         return new LitsError("Expected ".concat(typeName, ", got ").concat(valueToString(value), "."), getSourceCodeInfo(value, sourceCodeInfo));
     }
@@ -730,7 +744,7 @@ var Lits = (function (exports) {
     }
 
     var specialExpressionCommentRemovers = {
-        'and': function (node, removeOptions) {
+        '&&': function (node, removeOptions) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
@@ -742,6 +756,10 @@ var Lits = (function (exports) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
+        'switch': function (node, removeOptions) {
+            removeOptions.removeCommenNodesFromArray(node.p);
+            node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
+        },
         'declared?': function (node, removeOptions) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
@@ -763,12 +781,12 @@ var Lits = (function (exports) {
         'doseq': function (_node, _removeOptions) { },
         'fn': function (_node, _removeOptions) { },
         'for': function (_node, _removeOptions) { },
-        'if-let': 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) {
+        'if_not': function (node, removeOptions) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
@@ -780,7 +798,7 @@ var Lits = (function (exports) {
             });
         },
         'loop': function (_node, _removeOptions) { },
-        'or': function (node, removeOptions) {
+        '||': function (node, removeOptions) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
@@ -792,19 +810,15 @@ var Lits = (function (exports) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
-        'time!': function (node, removeOptions) {
-            removeOptions.removeCommenNodesFromArray(node.p);
-            node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
-        },
         'throw': function (node, removeOptions) {
             removeOptions.removeCommenNodesFromArray(node.p);
             node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
         },
         'try': function (_node, _removeOptions) { },
-        'when-first': function (_node, _removeOptions) { },
-        'when-let': function (_node, _removeOptions) { },
+        'when_first': function (_node, _removeOptions) { },
+        'when_let': function (_node, _removeOptions) { },
         'when': function (_node, _removeOptions) { },
-        'when-not': function (_node, _removeOptions) { },
+        'when_not': function (_node, _removeOptions) { },
     };
     function removeCommentNodesFromSpecialExpression(node, removeOptions) {
         var uncommenter = specialExpressionCommentRemovers[node.n];
@@ -846,6 +860,13 @@ var Lits = (function (exports) {
             throw new LitsError("Wrong number of arguments, expected an even number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
         }
     }
+    function assertOddNumberOfParams(node) {
+        var _a;
+        var length = withoutCommentNodes(node.p).length;
+        if (length % 2 !== 1) {
+            throw new LitsError("Wrong number of arguments, expected an odd number, got ".concat(valueToString(length), "."), (_a = getTokenDebugData(node.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+    }
     function assertNumberOfParams(count, node) {
         var _a, _b;
         assertCount({
@@ -1009,7 +1030,7 @@ var Lits = (function (exports) {
     }
 
     var bitwiseNormalExpression = {
-        'bit-shift-left': {
+        '<<': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], count = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1018,7 +1039,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'bit-shift-right': {
+        '>>': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], count = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1027,7 +1048,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'unsigned-bit-shift-right': {
+        '>>>': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], count = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1036,7 +1057,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'bit-not': {
+        '~': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), num = _b[0];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1044,7 +1065,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'bit-and': {
+        '&': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a), first = _b[0], rest = _b.slice(1);
                 assertNumber(first, sourceCodeInfo, { integer: true });
@@ -1055,7 +1076,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
         },
-        'bit-and-not': {
+        '&!': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a), first = _b[0], rest = _b.slice(1);
                 assertNumber(first, sourceCodeInfo, { integer: true });
@@ -1066,7 +1087,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
         },
-        'bit-or': {
+        '|': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a), first = _b[0], rest = _b.slice(1);
                 assertNumber(first, sourceCodeInfo, { integer: true });
@@ -1077,7 +1098,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
         },
-        'bit-xor': {
+        '^': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a), first = _b[0], rest = _b.slice(1);
                 assertNumber(first, sourceCodeInfo, { integer: true });
@@ -1088,7 +1109,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
         },
-        'bit-flip': {
+        'bit_flip': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], index = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1098,7 +1119,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'bit-set': {
+        'bit_set': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], index = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1108,7 +1129,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'bit-clear': {
+        'bit_clear': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], index = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -1118,7 +1139,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'bit-test': {
+        'bit_test': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), num = _b[0], index = _b[1];
                 assertNumber(num, sourceCodeInfo, { integer: true });
@@ -2817,7 +2838,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'rem': {
+        '%': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), dividend = _b[0], divisor = _b[1];
                 assertNumber(dividend, sourceCodeInfo);
@@ -2843,7 +2864,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'pow': {
+        '**': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), first = _b[0], second = _b[1];
                 assertNumber(first, sourceCodeInfo);
@@ -3120,10 +3141,6 @@ var Lits = (function (exports) {
         },
     };
 
-    var version = "2.0.13";
-
-    var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-    var xyRegexp = /[xy]/g;
     var miscNormalExpression = {
         '!=': {
             evaluate: function (params) {
@@ -3137,7 +3154,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
         },
-        '=': {
+        '==': {
             evaluate: function (_a) {
                 var e_1, _b;
                 var _c = __read(_a), first = _c[0], rest = _c.slice(1);
@@ -3262,20 +3279,14 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
         },
-        'not': {
+        '!': {
             evaluate: function (_a) {
                 var _b = __read(_a, 1), first = _b[0];
                 return !first;
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'inst-ms!': {
-            evaluate: function () {
-                return Date.now();
-            },
-            validate: function (node) { return assertNumberOfParams(0, node); },
-        },
-        'inst-ms->iso-date-time': {
+        'epoch>iso_date': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), ms = _b[0];
                 assertNumber(ms, sourceCodeInfo);
@@ -3283,7 +3294,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'iso-date-time->inst-ms': {
+        'iso_date>epoch': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), dateTime = _b[0];
                 assertString(dateTime, sourceCodeInfo);
@@ -3316,23 +3327,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'uuid!': {
-            evaluate: function () {
-                return uuidTemplate.replace(xyRegexp, function (character) {
-                    var randomNbr = Math.floor(Math.random() * 16);
-                    var newValue = character === 'x' ? randomNbr : (randomNbr & 0x3) | 0x8;
-                    return newValue.toString(16);
-                });
-            },
-            validate: function (node) { return assertNumberOfParams(0, node); },
-        },
-        'lits-version!': {
-            evaluate: function () {
-                return version;
-            },
-            validate: function (node) { return assertNumberOfParams(0, node); },
-        },
-        'json-parse': {
+        'json_parse': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), first = _b[0];
                 assertString(first, sourceCodeInfo);
@@ -3341,7 +3336,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'json-stringify': {
+        'json_stringify': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), first = _b[0], second = _b[1];
                 assertAny(first, sourceCodeInfo);
@@ -3554,7 +3549,7 @@ var Lits = (function (exports) {
     };
 
     var objectNormalExpression = {
-        'object': {
+        object: {
             evaluate: function (params, sourceCodeInfo) {
                 var result = {};
                 for (var i = 0; i < params.length; i += 2) {
@@ -3567,7 +3562,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertEvenNumberOfParams(node); },
         },
-        'keys': {
+        keys: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), obj = _b[0];
                 assertObj(obj, sourceCodeInfo);
@@ -3575,7 +3570,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'vals': {
+        vals: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), obj = _b[0];
                 assertObj(obj, sourceCodeInfo);
@@ -3583,7 +3578,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'entries': {
+        entries: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), obj = _b[0];
                 assertObj(obj, sourceCodeInfo);
@@ -3591,7 +3586,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'find': {
+        find: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), obj = _b[0], key = _b[1];
                 assertObj(obj, sourceCodeInfo);
@@ -3602,7 +3597,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'dissoc': {
+        dissoc: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), obj = _b[0], key = _b[1];
                 assertObj(obj, sourceCodeInfo);
@@ -3613,7 +3608,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'merge': {
+        merge: {
             evaluate: function (params, sourceCodeInfo) {
                 if (params.length === 0)
                     return null;
@@ -3626,7 +3621,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 0 }, node); },
         },
-        'merge-with': {
+        merge_with: {
             evaluate: function (params, sourceCodeInfo, contextStack, _a) {
                 var executeFunction = _a.executeFunction;
                 var first = params[0];
@@ -3649,7 +3644,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
         },
-        'zipmap': {
+        zipmap: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), keys = _b[0], values = _b[1];
                 assertStringArray(keys, sourceCodeInfo);
@@ -3664,7 +3659,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(2, node); },
         },
-        'select-keys': {
+        select_keys: {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), obj = _b[0], keys = _b[1];
                 assertStringArray(keys, sourceCodeInfo);
@@ -3930,7 +3925,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         },
-        'string-repeat': {
+        'string_repeat': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), str = _b[0], count = _b[1];
                 assertString(str, sourceCodeInfo);
@@ -3964,27 +3959,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'number-to-string': {
-            evaluate: function (params, sourceCodeInfo) {
-                var _a = __read(params, 2), num = _a[0], base = _a[1];
-                assertNumber(num, sourceCodeInfo, { finite: true });
-                if (params.length === 1) {
-                    return "".concat(num);
-                }
-                else {
-                    assertNumber(base, sourceCodeInfo, { finite: true });
-                    if (base !== 2 && base !== 8 && base !== 10 && base !== 16) {
-                        throw new LitsError("Expected \"number-to-string\" base argument to be 2, 8, 10 or 16, got: ".concat(base), sourceCodeInfo);
-                    }
-                    if (base === 10)
-                        return "".concat(num);
-                    assertNumber(num, sourceCodeInfo, { integer: true, nonNegative: true });
-                    return Number(num).toString(base);
-                }
-            },
-            validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
-        },
-        'from-char-code': {
+        'from_char_code': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), num = _b[0];
                 assertNumber(num, sourceCodeInfo, { finite: true });
@@ -3998,7 +3973,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'to-char-code': {
+        'to_char_code': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), str = _b[0];
                 assertString(str, sourceCodeInfo, { nonEmpty: true });
@@ -4006,7 +3981,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'lower-case': {
+        'lower_case': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), str = _b[0];
                 assertString(str, sourceCodeInfo);
@@ -4014,7 +3989,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'upper-case': {
+        'upper_case': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), str = _b[0];
                 assertString(str, sourceCodeInfo);
@@ -4030,7 +4005,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'trim-left': {
+        'trim_left': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), str = _b[0];
                 assertString(str, sourceCodeInfo);
@@ -4038,7 +4013,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'trim-right': {
+        'trim_right': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), str = _b[0];
                 assertString(str, sourceCodeInfo);
@@ -4046,6 +4021,30 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
+        '++': {
+            evaluate: function (params, sourceCodeInfo) {
+                if (params.length === 0) {
+                    return '';
+                }
+                var first = params[0];
+                if (first !== null) {
+                    assertStringOrNumber(first, sourceCodeInfo);
+                }
+                if (params.length === 1) {
+                    return first === null ? '' : "".concat(first);
+                }
+                return params.slice(1).reduce(function (acc, str) {
+                    if (str !== null) {
+                        assertStringOrNumber(str, sourceCodeInfo);
+                    }
+                    if (str === null) {
+                        return acc;
+                    }
+                    return "".concat(acc).concat(str);
+                }, first === null ? '' : "".concat(first));
+            },
+            validate: function () { return undefined; },
+        },
         'join': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), stringList = _b[0], delimiter = _b[1];
@@ -4070,7 +4069,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         },
-        'pad-left': {
+        'pad_left': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 3), str = _b[0], length = _b[1], padString = _b[2];
                 assertString(str, sourceCodeInfo);
@@ -4081,7 +4080,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         },
-        'pad-right': {
+        'pad_right': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 3), str = _b[0], length = _b[1], padString = _b[2];
                 assertString(str, sourceCodeInfo);
@@ -4123,7 +4122,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams({ min: 1, max: 10 }, node); },
         },
-        'encode-base64': {
+        'encode_base64': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), value = _b[0];
                 assertString(value, sourceCodeInfo);
@@ -4134,7 +4133,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'decode-base64': {
+        'decode_base64': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), value = _b[0];
                 assertString(value, sourceCodeInfo);
@@ -4152,7 +4151,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'encode-uri-component': {
+        'encode_uri_component': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), value = _b[0];
                 assertString(value, sourceCodeInfo);
@@ -4160,7 +4159,7 @@ var Lits = (function (exports) {
             },
             validate: function (node) { return assertNumberOfParams(1, node); },
         },
-        'decode-uri-component': {
+        'decode_uri_component': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), value = _b[0];
                 assertString(value, sourceCodeInfo);
@@ -4329,7 +4328,7 @@ var Lits = (function (exports) {
             assertRParenToken(tokenStream.tokens[parseState.position++]);
             var node = {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'and',
+                n: '&&',
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
@@ -4414,6 +4413,37 @@ var Lits = (function (exports) {
         },
     };
 
+    var switchSpecialExpression = {
+        polishParse: getCommonPolishSpecialExpressionParser('switch'),
+        validateParameterCount: function (node) { return assertOddNumberOfParams(node); },
+        evaluate: function (node, contextStack, _a) {
+            var e_1, _b;
+            var evaluateAstNode = _a.evaluateAstNode;
+            var switchValue = evaluateAstNode(node.p[0], contextStack);
+            try {
+                for (var _c = __values(arrayToPairs(node.p.slice(1))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), test = _e[0], form = _e[1];
+                    var value = evaluateAstNode(test, contextStack);
+                    if (value === switchValue) {
+                        return evaluateAstNode(form, contextStack);
+                    }
+                }
+            }
+            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 null;
+        },
+        findUnresolvedIdentifiers: function (node, contextStack, _a) {
+            var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
+            return findUnresolvedIdentifiers(node.p, contextStack, builtin);
+        },
+    };
+
     var declaredSpecialExpression = {
         polishParse: getCommonPolishSpecialExpressionParser('declared?'),
         validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
@@ -4886,7 +4916,7 @@ var Lits = (function (exports) {
                 tkn = asToken(tokenStream.tokens[parseState.position]);
                 if (node.t === exports.AstNodeType.Modifier) {
                     switch (node.v) {
-                        case '&':
+                        case '&rest':
                             if (state === 'rest')
                                 throw new LitsError('& can only appear once', (_a = getTokenDebugData(tkn)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
                             state = 'rest';
@@ -4961,7 +4991,7 @@ var Lits = (function (exports) {
             assertRParenToken(tokenStream.tokens[parseState.position++]);
             var node = {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'if-let',
+                n: 'if_let',
                 b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
@@ -4998,7 +5028,7 @@ var Lits = (function (exports) {
     };
 
     var ifNotSpecialExpression = {
-        polishParse: getCommonPolishSpecialExpressionParser('if-not'),
+        polishParse: getCommonPolishSpecialExpressionParser('if_not'),
         validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
@@ -5208,7 +5238,7 @@ var Lits = (function (exports) {
                     loopBinding.we = parseToken(tokenStream, parseState);
                     loopBinding.m.push('&while');
                     break;
-                case '&':
+                case '&rest':
                     throw new LitsError("Illegal modifier: ".concat(modifier), (_e = getTokenDebugData(tkn)) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
                 default:
                     throw new LitsError("Illegal modifier: ".concat(modifier), (_f = getTokenDebugData(tkn)) === null || _f === void 0 ? void 0 : _f.sourceCodeInfo);
@@ -5408,7 +5438,7 @@ var Lits = (function (exports) {
     };
 
     var orSpecialExpression = {
-        polishParse: getCommonPolishSpecialExpressionParser('or'),
+        polishParse: getCommonPolishSpecialExpressionParser('||'),
         validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
@@ -5500,25 +5530,6 @@ var Lits = (function (exports) {
         },
     };
 
-    var timeSpecialExpression = {
-        polishParse: getCommonPolishSpecialExpressionParser('time!'),
-        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
-        evaluate: function (node, contextStack, _a) {
-            var evaluateAstNode = _a.evaluateAstNode;
-            var param = node.p[0];
-            var startTime = Date.now();
-            var result = evaluateAstNode(param, contextStack);
-            var totalTime = Date.now() - startTime;
-            // eslint-disable-next-line no-console
-            console.log("Elapsed time: ".concat(totalTime, " ms"));
-            return result;
-        },
-        findUnresolvedIdentifiers: function (node, contextStack, _a) {
-            var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-            return findUnresolvedIdentifiers(node.p, contextStack, builtin);
-        },
-    };
-
     var trySpecialExpression = {
         polishParse: function (tokenStream, parseState, firstToken, _a) {
             var _b, _c, _d;
@@ -5619,7 +5630,7 @@ var Lits = (function (exports) {
             assertRParenToken(tokenStream.tokens[parseState.position++]);
             var node = {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'when-first',
+                n: 'when_first',
                 b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
@@ -5681,7 +5692,7 @@ var Lits = (function (exports) {
             assertRParenToken(tokenStream.tokens[parseState.position++]);
             var node = {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'when-let',
+                n: 'when_let',
                 b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
@@ -5727,7 +5738,7 @@ var Lits = (function (exports) {
     };
 
     var whenNotSpecialExpression = {
-        polishParse: getCommonPolishSpecialExpressionParser('when-not'),
+        polishParse: getCommonPolishSpecialExpressionParser('when_not'),
         validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
@@ -5760,9 +5771,10 @@ var Lits = (function (exports) {
     };
 
     var specialExpressions = {
-        'and': andSpecialExpression,
+        '&&': andSpecialExpression,
         'comment': commentSpecialExpression,
         'cond': condSpecialExpression,
+        'switch': switchSpecialExpression,
         'def': defSpecialExpression,
         'defn': defnSpecialExpression,
         'defns': defnsSpecialExpression,
@@ -5772,19 +5784,18 @@ var Lits = (function (exports) {
         'for': forSpecialExpression,
         'fn': fnSpecialExpression,
         'if': ifSpecialExpression,
-        'if-let': ifLetSpecialExpression,
-        'if-not': ifNotSpecialExpression,
+        'if_let': ifLetSpecialExpression,
+        'if_not': ifNotSpecialExpression,
         'let': letSpecialExpression,
         'loop': loopSpecialExpression,
-        'or': orSpecialExpression,
+        '||': orSpecialExpression,
         'recur': recurSpecialExpression,
         'throw': throwSpecialExpression,
-        'time!': timeSpecialExpression,
         'try': trySpecialExpression,
         'when': whenSpecialExpression,
-        'when-first': whenFirstSpecialExpression,
-        'when-let': whenLetSpecialExpression,
-        'when-not': whenNotSpecialExpression,
+        'when_first': whenFirstSpecialExpression,
+        'when_let': whenLetSpecialExpression,
+        'when_not': whenNotSpecialExpression,
         'declared?': declaredSpecialExpression,
         '??': qqSpecialExpression,
     };
@@ -6341,7 +6352,7 @@ var Lits = (function (exports) {
         var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
         return combinateAstNodes(astNode.p)
             .map(function (p) { return ({
-            n: 'and',
+            n: '&&',
             t: exports.AstNodeType.SpecialExpression,
             p: p,
             token: astNode.token,
@@ -6463,7 +6474,7 @@ var Lits = (function (exports) {
         if (isAstComputable(condition)) {
             return combinateAstNodes(astNode.p)
                 .map(function (p) { return ({
-                n: 'if-not',
+                n: 'if_not',
                 t: astNode.t,
                 p: p,
                 token: astNode.token,
@@ -6576,7 +6587,7 @@ var Lits = (function (exports) {
         var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
         return combinateAstNodes(astNode.p)
             .map(function (p) { return ({
-            n: 'or',
+            n: '||',
             t: exports.AstNodeType.SpecialExpression,
             p: p,
             token: astNode.token,
@@ -6596,12 +6607,6 @@ var Lits = (function (exports) {
         return calculatePossibleAstNodes(astNode.p[0]).map(function (m) { return (__assign(__assign({}, astNode), { p: [m] })); });
     };
 
-    var calculateTimeOutcomes = function (_a) {
-        var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-        return calculatePossibleAstNodes(astNode.p[0])
-            .map(function (p) { return (__assign(__assign({}, astNode), { n: 'do', p: [p] })); });
-    };
-
     var calculateTryOutcomes = function (_a) {
         var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
         var _b = calculatePossibleAstNodes(astNode.p[0]).reduce(function (acc, node) {
@@ -6675,7 +6680,7 @@ var Lits = (function (exports) {
         if (isAstComputable(condition)) {
             return combinateAstNodes(astNode.p)
                 .map(function (p) { return ({
-                n: 'when-not',
+                n: 'when_not',
                 t: astNode.t,
                 p: p,
                 token: astNode.token,
@@ -6734,10 +6739,22 @@ var Lits = (function (exports) {
             .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 = {
-        'and': function (astNode, helperOptions) { return calculateAndOutcomes(__assign({ astNode: astNode }, helperOptions)); },
+        '&&': 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)); },
@@ -6747,27 +6764,22 @@ var Lits = (function (exports) {
         '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_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)); },
+        '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)); },
-        'or': function (astNode, helperOptions) { return calculateOrOutcomes(__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)); },
-        'time!': function (astNode, helperOptions) { return calculateTimeOutcomes(__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_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)); },
+        'when_not': function (astNode, helperOptions) { return calculateWhenNotOutcomes(__assign({ astNode: astNode }, helperOptions)); },
     };
 
-    function isIdempotent(normalExpressionName) {
-        return !normalExpressionName.endsWith('!')
-            || normalExpressionName === 'write!';
-    }
     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.
@@ -6842,8 +6854,6 @@ var Lits = (function (exports) {
             : undefined;
         var newContextStack = newContext ? contextStack.create(newContext) : contextStack;
         if (astNode.t === exports.AstNodeType.NormalExpression) {
-            if (astNode.n && !isIdempotent(astNode.n))
-                throw new Error("NormalExpressionNode with name ".concat(astNode.n, " is not idempotent. Cannot calculate possible ASTs."));
             return combinate(astNode.p.map(function (n) { return calculatePossibleAstNodes(newContextStack, n); }))
                 .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
         }
@@ -7070,13 +7080,10 @@ var Lits = (function (exports) {
         var operatorName = operator[1];
         switch (operatorName) {
             case '+':
-                return createNamedNormalExpressionNode('+', [operand], token);
             case '-':
-                return createNamedNormalExpressionNode('-', [operand], token);
             case '!':
-                return createNamedNormalExpressionNode('not', [operand], token);
             case '~':
-                return createNamedNormalExpressionNode('bit-not', [operand], token);
+                return createNamedNormalExpressionNode(operatorName, [operand], token);
             /* v8 ignore next 2 */
             default:
                 throw new Error("Unknown operator: ".concat(operatorName));
@@ -7089,68 +7096,36 @@ var Lits = (function (exports) {
             case '.':
                 return createAccessorNode(left, fromSymbolToStringNode(asSymbolNode(right, (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo)), token);
             case '**': // exponentiation
-                return createNamedNormalExpressionNode('pow', [left, right], token);
             case '*':
-                return createNamedNormalExpressionNode('*', [left, right], token);
             case '/':
-                return createNamedNormalExpressionNode('/', [left, right], token);
             case '%':
-                return createNamedNormalExpressionNode('rem', [left, right], token);
             case '+':
-                return createNamedNormalExpressionNode('+', [left, right], token);
             case '-':
-                return createNamedNormalExpressionNode('-', [left, right], token);
             case '<<':
-                return createNamedNormalExpressionNode('bit-shift-left', [left, right], token);
             case '>>':
-                return createNamedNormalExpressionNode('bit-shift-right', [left, right], token);
             case '>>>':
-                return createNamedNormalExpressionNode('unsigned-bit-shift-right', [left, right], token);
-            case '++': {
-                var leftString = createNamedNormalExpressionNode('str', [left], token);
-                var rightString = createNamedNormalExpressionNode('str', [right], token);
-                return createNamedNormalExpressionNode('str', [leftString, rightString], token);
-            }
+            case '++':
             case '<':
-                return createNamedNormalExpressionNode('<', [left, right], token);
             case '<=':
-                return createNamedNormalExpressionNode('<=', [left, right], token);
             case '>':
-                return createNamedNormalExpressionNode('>', [left, right], token);
             case '>=':
-                return createNamedNormalExpressionNode('>=', [left, right], token);
             case '==':
-                return createNamedNormalExpressionNode('=', [left, right], token);
             case '!=':
-                return createNamedNormalExpressionNode('!=', [left, right], token);
             case '&':
-                return createNamedNormalExpressionNode('bit-and', [left, right], token);
             case '^':
-                return createNamedNormalExpressionNode('bit-xor', [left, right], token);
             case '|':
-                return createNamedNormalExpressionNode('bit-or', [left, right], token);
+                return createNamedNormalExpressionNode(operatorName, [left, right], token);
             case '&&':
-                return {
-                    t: exports.AstNodeType.SpecialExpression,
-                    n: 'and',
-                    p: [left, right],
-                    token: getTokenDebugData(token) && token,
-                };
             case '||':
-                return {
-                    t: exports.AstNodeType.SpecialExpression,
-                    n: 'or',
-                    p: [left, right],
-                    token: getTokenDebugData(token) && token,
-                };
             case '??':
                 return {
                     t: exports.AstNodeType.SpecialExpression,
-                    n: '??',
+                    n: operatorName,
                     p: [left, right],
                     token: getTokenDebugData(token) && token,
                 };
             /* v8 ignore next 8 */
+            case ';':
             case '!':
             case '~':
             case '=':
@@ -7171,14 +7146,52 @@ var Lits = (function (exports) {
             this.parseState.position += 1;
         };
         AlgebraicParser.prototype.parse = function () {
-            return this.parseExpression();
+            var nodes = [];
+            while (!this.isAtEnd()) {
+                nodes.push(this.parseExpression());
+                if (!isA_OperatorToken(this.peek(), ';')) {
+                    break;
+                }
+                this.advance();
+            }
+            return nodes;
         };
         AlgebraicParser.prototype.parseExpression = function (precedence) {
             var _a;
             if (precedence === void 0) { precedence = 0; }
-            var left = this.parseOperand();
-            while (!this.isAtEnd() && !isA_OperatorToken(this.peek(), ',') && !isRBracketToken(this.peek()) && !isRParenToken(this.peek())) {
-                var operator = this.peek();
+            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();
+            }
+            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)) {
                 if (isA_BinaryOperatorToken(operator)) {
                     var name_1 = operator[1];
                     var newPrecedece = getPrecedence(name_1);
@@ -7208,6 +7221,7 @@ var Lits = (function (exports) {
                 else {
                     break;
                 }
+                operator = this.peek();
             }
             if (!left) {
                 throw new LitsError('Expected operand', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
@@ -7408,9 +7422,6 @@ var Lits = (function (exports) {
             var _a, _b;
             var isNamedFunction = symbol.t === exports.AstNodeType.Symbol;
             this.advance();
-            if (isNamedFunction && symbol.v === 'for') {
-                return this.parseFor(symbol);
-            }
             var params = [];
             while (!this.isAtEnd() && !isRParenToken(this.peek())) {
                 params.push(this.parseExpression());
@@ -7431,17 +7442,14 @@ var Lits = (function (exports) {
                     var name_2 = symbol.v;
                     switch (name_2) {
                         case '??':
-                        case 'and':
+                        case '&&':
                         case 'comment':
-                        case 'cond':
                         case 'declared?':
-                        case 'if':
-                        case 'if-not':
-                        case 'or':
+                        case 'if_not':
+                        case '||':
                         case 'when':
-                        case 'when-not':
+                        case 'when_not':
                         case 'do':
-                        case 'time!':
                         case 'throw': {
                             var node = {
                                 t: exports.AstNodeType.SpecialExpression,
@@ -7454,13 +7462,11 @@ var Lits = (function (exports) {
                         }
                         case 'let':
                             return this.parseLet(symbol, params);
-                        case 'def':
                         case 'defs':
-                        case 'if-let':
-                        case 'when-let':
-                        case 'when-first':
+                        case 'if_let':
+                        case 'when_let':
+                        case 'when_first':
                         case 'fn':
-                        case 'defn':
                         case 'defns':
                         case 'try':
                         case 'recur':
@@ -7483,8 +7489,32 @@ var Lits = (function (exports) {
             }
         };
         AlgebraicParser.prototype.parseLambdaFunction = function () {
-            var _a, _b;
             var firstToken = this.peek();
+            try {
+                var _a = this.parseFunctionArguments(), functionArguments = _a.functionArguments, arity = _a.arity;
+                if (!isA_OperatorToken(this.peek(), '=>')) {
+                    return null;
+                }
+                this.advance();
+                var body = this.parseExpression();
+                return {
+                    t: exports.AstNodeType.SpecialExpression,
+                    n: 'fn',
+                    p: [],
+                    o: [{
+                            as: functionArguments,
+                            b: [body],
+                            a: arity,
+                        }],
+                    token: getTokenDebugData(firstToken) && firstToken,
+                };
+            }
+            catch (_b) {
+                return null;
+            }
+        };
+        AlgebraicParser.prototype.parseFunctionArguments = function () {
+            var _a, _b, _c, _d, _e;
             this.advance();
             var rest = false;
             var letBindingObject;
@@ -7507,7 +7537,7 @@ var Lits = (function (exports) {
                     }
                     var symbolToken = this.peek();
                     if (!isA_SymbolToken(symbolToken)) {
-                        return null;
+                        throw new LitsError('Expected symbol', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
                     }
                     if (rest) {
                         restArg = symbolToken[1];
@@ -7518,47 +7548,36 @@ var Lits = (function (exports) {
                     this.advance();
                 }
                 if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
-                    return null;
+                    throw new LitsError('Expected comma or closing parenthesis', (_d = getTokenDebugData(this.peek())) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
                 }
                 if (isA_OperatorToken(this.peek(), ',')) {
                     this.advance();
                 }
             }
+            var arity = restArg !== undefined ? { min: args.length } : args.length;
             if (!isRParenToken(this.peek())) {
-                return null;
+                throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
             }
-            this.advance();
-            if (!isA_OperatorToken(this.peek(), '=>')) {
-                return null;
-            }
-            this.advance();
             var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
-            var body = this.parseExpression();
-            var arity = restArg !== undefined ? { min: args.length } : args.length;
+            var functionArguments = {
+                m: args,
+                r: restArg,
+                b: letBindings.map(function (pair) {
+                    var key = pair[0];
+                    var value = pair[1];
+                    return {
+                        t: exports.AstNodeType.Binding,
+                        n: key.v,
+                        v: value,
+                        p: [],
+                        token: getTokenDebugData(key.token) && key.token,
+                    };
+                }),
+            };
+            this.advance();
             return {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'fn',
-                p: [],
-                o: [{
-                        as: {
-                            m: args,
-                            r: restArg,
-                            b: letBindings.map(function (pair) {
-                                var key = pair[0];
-                                var value = pair[1];
-                                return {
-                                    t: exports.AstNodeType.Binding,
-                                    n: key.v,
-                                    v: value,
-                                    p: [],
-                                    token: getTokenDebugData(key.token) && key.token,
-                                };
-                            }),
-                        },
-                        b: [body],
-                        a: arity,
-                    }],
-                token: getTokenDebugData(firstToken) && firstToken,
+                functionArguments: functionArguments,
+                arity: arity,
             };
         };
         AlgebraicParser.prototype.parseShorthandLamdaFunction = function () {
@@ -7643,38 +7662,39 @@ var Lits = (function (exports) {
                 }),
             };
         };
-        AlgebraicParser.prototype.parseFor = function (forSymbol) {
+        AlgebraicParser.prototype.parseFor = function (token) {
+            this.advance();
+            assertLParenToken(this.peek());
+            this.advance();
             var forLoopBindings = [
                 this.parseForLoopBinding(),
             ];
-            var nextToken = this.peekAhead();
-            while (isA_SymbolToken(nextToken) && nextToken[1] === 'of') {
+            while (!this.isAtEnd() && !isRParenToken(this.peek())) {
                 forLoopBindings.push(this.parseForLoopBinding());
-                nextToken = this.peekAhead();
+                if (isA_OperatorToken(this.peek(), ',')) {
+                    this.advance();
+                }
             }
-            var expression = this.parseExpression();
             assertRParenToken(this.peek());
             this.advance();
+            var expression = this.parseExpression();
+            assertA_ReservedSymbolToken(this.peek(), 'end');
+            this.advance();
             return {
                 t: exports.AstNodeType.SpecialExpression,
                 n: 'for',
                 p: [expression],
-                token: getTokenDebugData(forSymbol.token) && forSymbol.token,
+                token: getTokenDebugData(token) && token,
                 l: forLoopBindings,
             };
         };
-        // export interface LoopBindingNode {
-        //   b: BindingNode // Binding
-        //   m: Array<'&let' | '&when' | '&while'> // Modifiers
-        //   l?: BindingNode[] // Let-Bindings
-        //   wn?: AstNode // When Node
-        //   we?: AstNode // While Node
-        // }
         AlgebraicParser.prototype.parseForLoopBinding = function () {
             var _a;
             var bindingNode = this.parseBinding();
-            if (isA_OperatorToken(this.peek(), ',')) {
-                this.advance();
+            if (isRParenToken(this.peek()) || isA_OperatorToken(this.peek(), ',')) {
+                if (isA_OperatorToken(this.peek(), ',')) {
+                    this.advance();
+                }
                 return {
                     b: bindingNode,
                     m: [],
@@ -7720,8 +7740,9 @@ var Lits = (function (exports) {
                 }
                 token = this.peek();
             }
-            assertA_OperatorToken(token, ',');
-            this.advance();
+            if (isA_OperatorToken(token, ',')) {
+                this.advance();
+            }
             return {
                 b: bindingNode,
                 m: modifiers,
@@ -7750,15 +7771,185 @@ var Lits = (function (exports) {
             };
             return node;
         };
+        AlgebraicParser.prototype.parseIf = function (token) {
+            this.advance();
+            var condition = this.parseExpression();
+            assertA_ReservedSymbolToken(this.peek(), 'then');
+            this.advance();
+            var thenExpressions = [];
+            while (!this.isAtEnd()
+                && !isA_ReservedSymbolToken(this.peek(), 'else')
+                && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                thenExpressions.push(this.parseExpression());
+                if (isA_OperatorToken(this.peek(), ';')) {
+                    this.advance();
+                }
+            }
+            var thenExpression = thenExpressions.length === 1
+                ? thenExpressions[0]
+                : {
+                    t: exports.AstNodeType.SpecialExpression,
+                    n: 'do',
+                    p: thenExpressions,
+                    token: getTokenDebugData(token) && token,
+                };
+            var elseExpression;
+            if (isA_ReservedSymbolToken(this.peek(), 'else')) {
+                this.advance();
+                var elseExpressions = [];
+                while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                    elseExpressions.push(this.parseExpression());
+                    if (isA_OperatorToken(this.peek(), ';')) {
+                        this.advance();
+                    }
+                }
+                elseExpression = elseExpressions.length === 1
+                    ? elseExpressions[0]
+                    : {
+                        t: exports.AstNodeType.SpecialExpression,
+                        n: 'do',
+                        p: elseExpressions,
+                        token: getTokenDebugData(token) && token,
+                    };
+            }
+            assertA_ReservedSymbolToken(this.peek(), 'end');
+            this.advance();
+            var params = [condition, thenExpression];
+            if (elseExpression) {
+                params.push(elseExpression);
+            }
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'if',
+                p: params,
+                token: getTokenDebugData(token) && token,
+            };
+        };
+        AlgebraicParser.prototype.parseCond = function (token) {
+            this.advance();
+            var params = [];
+            while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                assertA_ReservedSymbolToken(this.peek(), 'case');
+                this.advance();
+                params.push(this.parseExpression());
+                assertA_ReservedSymbolToken(this.peek(), 'then');
+                this.advance();
+                var expressions = [];
+                while (!this.isAtEnd()
+                    && !isA_ReservedSymbolToken(this.peek(), 'case')
+                    && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                    expressions.push(this.parseExpression());
+                    if (isA_OperatorToken(this.peek(), ';')) {
+                        this.advance();
+                    }
+                }
+                params.push(expressions.length === 1
+                    ? expressions[0]
+                    : {
+                        t: exports.AstNodeType.SpecialExpression,
+                        n: 'do',
+                        p: expressions,
+                        token: getTokenDebugData(token) && token,
+                    });
+                if (isA_ReservedSymbolToken(this.peek(), 'end')) {
+                    break;
+                }
+                assertA_ReservedSymbolToken(this.peek(), 'case');
+            }
+            assertA_ReservedSymbolToken(this.peek(), 'end');
+            this.advance();
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'cond',
+                p: params,
+                token: getTokenDebugData(token) && token,
+            };
+        };
+        AlgebraicParser.prototype.parseSwitch = function (token) {
+            this.advance();
+            var params = [this.parseExpression()];
+            while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                assertA_ReservedSymbolToken(this.peek(), 'case');
+                this.advance();
+                params.push(this.parseExpression());
+                assertA_ReservedSymbolToken(this.peek(), 'then');
+                this.advance();
+                var expressions = [];
+                while (!this.isAtEnd()
+                    && !isA_ReservedSymbolToken(this.peek(), 'case')
+                    && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                    expressions.push(this.parseExpression());
+                    if (isA_OperatorToken(this.peek(), ';')) {
+                        this.advance();
+                    }
+                }
+                params.push(expressions.length === 1
+                    ? expressions[0]
+                    : {
+                        t: exports.AstNodeType.SpecialExpression,
+                        n: 'do',
+                        p: expressions,
+                        token: getTokenDebugData(token) && token,
+                    });
+                if (isA_ReservedSymbolToken(this.peek(), 'end')) {
+                    break;
+                }
+                assertA_ReservedSymbolToken(this.peek(), 'case');
+            }
+            assertA_ReservedSymbolToken(this.peek(), 'end');
+            this.advance();
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'switch',
+                p: params,
+                token: getTokenDebugData(token) && token,
+            };
+        };
+        AlgebraicParser.prototype.parseDef = function (token) {
+            this.advance();
+            var symbol = parseSymbol(this.tokenStream, this.parseState);
+            assertA_OperatorToken(this.peek(), '=');
+            this.advance();
+            var value = this.parseExpression();
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'def',
+                p: [symbol, value],
+                token: getTokenDebugData(token) && token,
+            };
+        };
+        AlgebraicParser.prototype.parseDefn = function (token) {
+            this.advance();
+            var symbol = parseSymbol(this.tokenStream, this.parseState);
+            var _a = this.parseFunctionArguments(), functionArguments = _a.functionArguments, arity = _a.arity;
+            var body = [];
+            while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+                body.push(this.parseExpression());
+                if (isA_OperatorToken(this.peek(), ';')) {
+                    this.advance();
+                }
+            }
+            assertA_ReservedSymbolToken(this.peek(), 'end');
+            this.advance();
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'defn',
+                f: symbol,
+                p: [],
+                o: [{
+                        as: functionArguments,
+                        b: body,
+                        a: arity,
+                    }],
+                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.peekAhead = function () {
-            return this.tokenStream.tokens[this.parseState.position + 1];
-        };
         return AlgebraicParser;
     }());
 
@@ -8039,10 +8230,18 @@ var Lits = (function (exports) {
                 parseState.position += 1;
                 parseState.algebraic = true;
                 var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-                var node = algebraicParser.parse();
+                var nodes = algebraicParser.parse();
                 assertEndNotationToken(tokenStream.tokens[parseState.position++]);
                 parseState.algebraic = false;
-                return node;
+                if (nodes.length === 1) {
+                    return nodes[0];
+                }
+                return {
+                    t: exports.AstNodeType.SpecialExpression,
+                    n: 'do',
+                    p: nodes,
+                    token: nodes[0].token,
+                };
             }
             case 'PolNotation': {
                 var astNodes = [];
@@ -8109,13 +8308,22 @@ var Lits = (function (exports) {
     function parseToken(tokenStream, parseState) {
         if (parseState.algebraic) {
             var algebraicParser = new AlgebraicParser(tokenStream, parseState);
-            return algebraicParser.parse();
+            var nodes = algebraicParser.parse();
+            if (nodes.length === 1) {
+                return nodes[0];
+            }
+            return {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'do',
+                p: nodes,
+                token: nodes[0].token,
+            };
         }
         return parsePolishToken(tokenStream, parseState);
     }
 
-    var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:-]';
-    var polishIdentifierFirstCharacterClass = '[a-zA-Z_@%^?=!$<>+*/-]';
+    var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:&\|~-]';
+    var polishIdentifierFirstCharacterClass = '[a-zA-Z_@%^?=!$<>+*/&\|~-]';
     var algebraicIdentifierCharacterClass = '[\\w$:!?]';
     var algebraicIdentifierFirstCharacterClass = '[a-zA-Z_$]';
 
@@ -8195,25 +8403,28 @@ var Lits = (function (exports) {
         tokenizeString,
     ];
 
-    var algebraicReservedNamesRecord = {
-        'true': { value: true },
-        'false': { value: false },
-        'nil': { value: null },
-        'null': { value: null },
-        'def': { value: null, forbidden: true },
-        'defs': { value: null, forbidden: true },
-        'if-let': { value: null, forbidden: true },
-        'when-let': { value: null, forbidden: true },
-        'when-first': { value: null, forbidden: true },
-        'fn': { value: null, forbidden: true },
-        'defn': { value: null, forbidden: true },
-        'defns': { value: null, forbidden: true },
-        'try': { value: null, forbidden: true },
-        'recur': { value: null, forbidden: true },
-        'loop': { value: null, forbidden: true },
-        'time!': { value: null, forbidden: true },
-        'doseq': { value: null, forbidden: true },
+    var validAlgebraicReservedNamesRecord = {
+        true: { value: true, forbidden: false },
+        false: { value: false, forbidden: false },
+        nil: { value: null, forbidden: false },
+        null: { value: null, forbidden: false },
+        then: { value: null, forbidden: false },
+        else: { value: null, forbidden: false },
+        end: { value: null, forbidden: false },
+        case: { 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);
 
     var identifierRegExp = new RegExp(algebraicIdentifierCharacterClass);
     var identifierFirstCharacterRegExp = new RegExp(algebraicIdentifierFirstCharacterClass);
@@ -8285,45 +8496,19 @@ var Lits = (function (exports) {
         }
         return [length, ['A_BasePrefixedNumber', input.substring(position, i)]];
     };
-    var tokenizeA_ReservedSymbolToken = function (input, position) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(Object.entries(algebraicReservedNamesRecord)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), reservedName = _d[0], forbidden = _d[1].forbidden;
-                var length_1 = reservedName.length;
-                var nextChar = input[position + length_1];
-                if (nextChar && identifierRegExp.test(nextChar))
-                    continue;
-                var name_1 = input.substring(position, position + length_1);
-                if (name_1 === reservedName) {
-                    if (forbidden)
-                        throw new LitsError("".concat(name_1, " is forbidden!"), undefined);
-                    return [length_1, ['A_ReservedSymbol', reservedName]];
-                }
-            }
-        }
-        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; }
-        }
-        return NO_MATCH;
-    };
     var tokenizeA_Symbol = function (input, position) {
         var value = input[position];
         if (!value) {
             return NO_MATCH;
         }
         if (value === '\'') {
-            var length_2 = 1;
-            var char = input[position + length_2];
+            var length_1 = 1;
+            var char = input[position + length_1];
             var escaping = false;
             while (char !== '\'' || escaping) {
                 if (char === undefined)
                     throw new LitsError("Unclosed string at position ".concat(position, "."), undefined);
-                length_2 += 1;
+                length_1 += 1;
                 if (escaping) {
                     escaping = false;
                     value += char;
@@ -8334,10 +8519,10 @@ var Lits = (function (exports) {
                     }
                     value += char;
                 }
-                char = input[position + length_2];
+                char = input[position + length_1];
             }
             value += '\''; // closing quote
-            return [length_2 + 1, ['A_Symbol', value]];
+            return [length_1 + 1, ['A_Symbol', value]];
         }
         if (identifierFirstCharacterRegExp.test(value)) {
             var initialPosition = position;
@@ -8352,6 +8537,22 @@ var Lits = (function (exports) {
         }
         return NO_MATCH;
     };
+    var tokenizeA_ReservedSymbolToken = function (input, position) {
+        var symbolMeta = tokenizeA_Symbol(input, position);
+        if (symbolMeta[0] === 0 || !symbolMeta[1]) {
+            return NO_MATCH;
+        }
+        var symbolName = symbolMeta[1][1];
+        symbolName = symbolName.startsWith('\'') ? symbolName.slice(1, symbolName.length - 1) : symbolName;
+        var info = algebraicReservedNamesRecord[symbolName];
+        if (!info) {
+            return NO_MATCH;
+        }
+        if (info.forbidden) {
+            throw new LitsError("".concat(symbolName, " is forbidden!"), undefined);
+        }
+        return [symbolMeta[0], ['A_ReservedSymbol', symbolName]];
+    };
     var tokenizeA_Operator = function (input, position) {
         var _a;
         var threeChars = input.slice(position, position + 3);
@@ -8370,30 +8571,30 @@ var Lits = (function (exports) {
     };
     var tokenizeA_MultiLineComment = function (input, position) {
         if (input[position] === '/' && input[position + 1] === '*') {
-            var length_3 = 2;
+            var length_2 = 2;
             var value = '/*';
-            while (input[position + length_3] !== '*' && input[position + length_3 + 1] !== '/' && position + length_3 + 1 < input.length) {
-                value += input[position + length_3];
-                length_3 += 1;
+            while (input[position + length_2] !== '*' && input[position + length_2 + 1] !== '/' && position + length_2 + 1 < input.length) {
+                value += input[position + length_2];
+                length_2 += 1;
             }
-            if (position + length_3 + 1 >= input.length) {
+            if (position + length_2 + 1 >= input.length) {
                 throw new LitsError('Comment not closed', undefined);
             }
             value += '*/';
-            length_3 += 2;
-            return [length_3, ['A_MultiLineComment', value]];
+            length_2 += 2;
+            return [length_2, ['A_MultiLineComment', value]];
         }
         return NO_MATCH;
     };
     var tokenizeA_SingleLineComment = function (input, position) {
         if (input[position] === '/' && input[position + 1] === '/') {
-            var length_4 = 2;
+            var length_3 = 2;
             var value = '//';
-            while (input[position + length_4] !== '\n' && position + length_4 < input.length) {
-                value += input[position + length_4];
-                length_4 += 1;
+            while (input[position + length_3] !== '\n' && position + length_3 < input.length) {
+                value += input[position + length_3];
+                length_3 += 1;
             }
-            return [length_4, ['A_SingleLineComment', value]];
+            return [length_3, ['A_SingleLineComment', value]];
         }
         return NO_MATCH;
     };
@@ -8553,31 +8754,20 @@ var Lits = (function (exports) {
         return [1, ['P_FnShorthand']];
     };
     var tokenizeP_ReservedSymbol = function (input, position) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(Object.entries(polishReservedNamesRecord)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), reservedName = _d[0], forbidden = _d[1].forbidden;
-                var length_3 = reservedName.length;
-                var nextChar = input[position + length_3];
-                if (nextChar && P_symbolRegExp.test(nextChar)) {
-                    continue;
-                }
-                var symbol = input.substring(position, position + length_3);
-                if (symbol === reservedName) {
-                    if (forbidden)
-                        throw new LitsError("".concat(symbol, " is forbidden!"), undefined);
-                    return [length_3, ['P_ReservedSymbol', reservedName]];
-                }
-            }
+        var symbolMeta = tokenizeP_Symbol(input, position);
+        if (symbolMeta[0] === 0 || !symbolMeta[1]) {
+            return NO_MATCH;
         }
-        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; }
+        var symbolName = symbolMeta[1][1];
+        symbolName = symbolName.startsWith('\'') ? symbolName.slice(1, symbolName.length - 1) : symbolName;
+        var info = polishReservedNamesRecord[symbolName];
+        if (!info) {
+            return NO_MATCH;
         }
-        return NO_MATCH;
+        if (info.forbidden) {
+            throw new LitsError("".concat(symbolName, " is forbidden!"), undefined);
+        }
+        return [symbolMeta[0], ['P_ReservedSymbol', symbolName]];
     };
     var tokenizeP_StringShorthand = function (input, position) {
         if (input[position] !== ':')
@@ -8590,24 +8780,24 @@ var Lits = (function (exports) {
         return [symbolDescription[0] + 1, ['P_StringShorthand', ":".concat(symbolToken[1])]];
     };
     var tokenizeP_Modifier = function (input, position) {
-        var e_2, _a;
+        var e_1, _a;
         try {
             for (var modifierNames_1 = __values(modifierNames), modifierNames_1_1 = modifierNames_1.next(); !modifierNames_1_1.done; modifierNames_1_1 = modifierNames_1.next()) {
                 var modifierName = modifierNames_1_1.value;
-                var length_4 = modifierName.length;
-                var charAfterModifier = input[position + length_4];
-                if (input.substring(position, position + length_4) === modifierName && (!charAfterModifier || !P_symbolRegExp.test(charAfterModifier))) {
+                var length_3 = modifierName.length;
+                var charAfterModifier = input[position + length_3];
+                if (input.substring(position, position + length_3) === modifierName && (!charAfterModifier || !P_symbolRegExp.test(charAfterModifier))) {
                     var value = modifierName;
-                    return [length_4, ['P_Modifier', value]];
+                    return [length_3, ['P_Modifier', value]];
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (modifierNames_1_1 && !modifierNames_1_1.done && (_a = modifierNames_1.return)) _a.call(modifierNames_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_1) throw e_1.error; }
         }
         return NO_MATCH;
     };
@@ -8644,8 +8834,8 @@ var Lits = (function (exports) {
         tokenizeP_StringShorthand,
         tokenizeP_Number,
         tokenizeP_ReservedSymbol,
-        tokenizeP_Symbol,
         tokenizeP_Modifier,
+        tokenizeP_Symbol,
         tokenizeP_RegexpShorthand,
         tokenizeP_FnShorthand,
         tokenizeP_CollectionAccessor,
@@ -9053,7 +9243,7 @@ var Lits = (function (exports) {
             },
             args: {
                 coll: {
-                    type: ['collection', 'string', 'nil'],
+                    type: ['collection', 'string', 'null'],
                 },
             },
             variants: [
@@ -9142,7 +9332,7 @@ var Lits = (function (exports) {
             },
             args: {
                 coll: {
-                    type: ['collection', 'nil'],
+                    type: ['collection', 'null'],
                 },
                 key: {
                     type: ['string', 'number'],
@@ -9170,7 +9360,7 @@ var Lits = (function (exports) {
             },
             args: {
                 coll: {
-                    type: ['collection', 'nil'],
+                    type: ['collection', 'null'],
                 },
                 value: {
                     type: ['any'],
@@ -9373,7 +9563,7 @@ var Lits = (function (exports) {
             },
             args: {
                 coll: {
-                    type: ['collection', 'nil'],
+                    type: ['collection', 'null'],
                 },
             },
             variants: [
@@ -9974,7 +10164,7 @@ var Lits = (function (exports) {
             },
             args: {
                 'seq': {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
                 'n': {
                     type: 'integer',
@@ -10036,7 +10226,7 @@ var Lits = (function (exports) {
             category: 'Sequence',
             linkName: 'pop',
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
                 array: true,
             },
             args: {
@@ -10089,7 +10279,7 @@ var Lits = (function (exports) {
             linkName: 'shift',
             clojureDocs: null,
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
                 array: true,
             },
             args: {
@@ -10286,11 +10476,11 @@ var Lits = (function (exports) {
             linkName: 'position',
             clojureDocs: null,
             returns: {
-                type: ['number', 'nil'],
+                type: ['number', 'null'],
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
                 fn: {
                     type: 'function',
@@ -10313,11 +10503,11 @@ var Lits = (function (exports) {
             linkName: 'index_of',
             clojureDocs: null,
             returns: {
-                type: ['number', 'nil'],
+                type: ['number', 'null'],
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
                 x: {
                     type: 'any',
@@ -10343,7 +10533,7 @@ var Lits = (function (exports) {
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
                 fn: {
                     type: 'function',
@@ -10366,11 +10556,11 @@ var Lits = (function (exports) {
             category: 'Sequence',
             linkName: 'reverse',
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
             },
             variants: [
@@ -10393,7 +10583,7 @@ var Lits = (function (exports) {
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
             },
             variants: [
@@ -10415,7 +10605,7 @@ var Lits = (function (exports) {
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
             },
             variants: [
@@ -10438,7 +10628,7 @@ var Lits = (function (exports) {
             },
             args: {
                 seq: {
-                    type: ['sequence', 'nil'],
+                    type: ['sequence', 'null'],
                 },
             },
             variants: [
@@ -10458,7 +10648,7 @@ var Lits = (function (exports) {
             category: 'Sequence',
             linkName: 'rest',
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             args: {
                 seq: {
@@ -10511,7 +10701,7 @@ var Lits = (function (exports) {
             category: 'Sequence',
             linkName: 'next',
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             args: {
                 seq: {
@@ -10536,7 +10726,7 @@ var Lits = (function (exports) {
             category: 'Sequence',
             linkName: 'nthnext',
             returns: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
                 array: true,
             },
             args: {
@@ -10760,7 +10950,7 @@ var Lits = (function (exports) {
             description: 'Returns a sorted sequence of the items in $seq, where the sort order is determined by comparing `(keyfn item)`. If no $comp is supplied, uses builtin `compare`.',
             examples: [
                 '(sort_by ["Albert" "Mojir" "Nina"] count)',
-                '(sort_by "Albert" lower-case #(compare %2 %1))',
+                '(sort_by "Albert" lower_case #(compare %2 %1))',
             ],
         },
         distinct: {
@@ -11025,7 +11215,7 @@ var Lits = (function (exports) {
             ],
             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 2 3 4 5] #(== 3 %1))',
                 '(partition_by [1 1 1 2 2 3 3] odd?)',
                 '(partition_by "Leeeeeerrroyyy" identity)',
             ],
@@ -11131,10 +11321,11 @@ var Lits = (function (exports) {
             description: 'Modulus of `dividend` and `divisor`. Truncates toward negative infinity.',
             examples: ['(mod 5 3)', '(mod 5.2 3.1)', '(mod -5 3)', '(mod 5 -3)', '(mod -5 -3)'],
         },
-        'rem': {
-            title: 'rem',
+        '%': {
+            title: '%',
             category: 'Math',
-            linkName: 'rem',
+            linkName: '-percent',
+            clojureDocs: 'rem',
             returns: {
                 type: 'number',
             },
@@ -11150,7 +11341,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['a', 'b'] },
             ],
             description: 'Remainder of dividing `dividend` and `divisor`.',
-            examples: ['(rem 5 3)', '(rem 5.2 3.1)', '(rem -5 3)', '(rem 5 -3)', '(rem -5 -3)'],
+            examples: ['(% 5 3)', '(% 5.2 3.1)', '(% -5 3)', '(% 5 -3)', '(% -5 -3)'],
         },
         'quot': {
             title: 'quot',
@@ -11247,10 +11438,10 @@ var Lits = (function (exports) {
             description: 'Computes cube root of $x.',
             examples: ['(cbrt 0)', '(cbrt 27)', '(cbrt 2)', '(cbrt 1)'],
         },
-        'pow': {
-            title: 'pow',
+        '**': {
+            title: '**',
             category: 'Math',
-            linkName: 'pow',
+            linkName: '-star-star',
             clojureDocs: null,
             returns: {
                 type: 'number',
@@ -11267,7 +11458,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['a', 'b'] },
             ],
             description: 'Computes returns $a raised to the power of $b.',
-            examples: ['(pow 2 3)', '(pow 2 0)', '(pow 2 -3)', '(pow -2 3)', '(pow -2 -3)'],
+            examples: ['(** 2 3)', '(** 2 0)', '(** 2 -3)', '(** -2 3)', '(** -2 -3)'],
         },
         'exp': {
             title: 'exp',
@@ -11637,7 +11828,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['x'] },
             ],
             description: 'Returns the base `2` logarithm of a number.',
-            examples: ['(log2 0.01)', '(log2 (pow 2 12))', '(log2 2.5)'],
+            examples: ['(log2 0.01)', '(log2 (** 2 12))', '(log2 2.5)'],
         },
         'log10': {
             title: 'log10',
@@ -11656,7 +11847,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['x'] },
             ],
             description: 'Returns the `10` logarithm of a number.',
-            examples: ['(log10 0.01)', '(log10 (pow 10 12))', '(log10 2.5)'],
+            examples: ['(log10 0.01)', '(log10 (** 10 12))', '(log10 2.5)'],
         },
         'sin': {
             title: 'sin',
@@ -11910,13 +12101,14 @@ var Lits = (function (exports) {
                 { argumentNames: ['x'] },
                 { argumentNames: ['x', 'ys'] },
             ],
-            description: 'Result is `true` if no two `values` are equal to each other, otherwise result is `false`. Note that only two argument version result is negation of `=` function, that is `(!= a b)` is same as `(not (= a b))`.',
+            description: 'Result is `true` if no two `values` are equal to each other, otherwise result is `false`. Note that only two argument version result is negation of `=` function, that is `(!= a b)` is same as `(! (== a b))`.',
             examples: ['(!= 3)', '(!= 3 2)', '(!= :3 3)', '(!= 3 3 2)', '(!= :3 :2 :1 :0)', '(!= 0 -0)'],
         },
-        '=': {
-            title: '=',
+        '==': {
+            title: '==',
             category: 'Misc',
-            linkName: '-equal',
+            linkName: '-equal-equal',
+            clojureDocs: '=',
             returns: {
                 type: 'boolean',
             },
@@ -11934,7 +12126,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'ys'] },
             ],
             description: 'Compares `values` according to \'equal\' predicate. Result is `true` if every specified value is equal to each other, otherwise result is `false`.',
-            examples: ['(= 1 1)', '(= 1.01 1)', '(= :1 1)', '(= :2 :2 :2 :2)', '(= 2 2 1 2)'],
+            examples: ['(== 1 1)', '(== 1.01 1)', '(== :1 1)', '(== :2 :2 :2 :2)', '(== 2 2 1 2)'],
         },
         '<': {
             title: '<',
@@ -12028,10 +12220,11 @@ var Lits = (function (exports) {
             description: 'Returns `true` if the number $x and $ys are in non increasing order, `false` otherwise.',
             examples: ['(>= 1 0)', '(>= 1.01 1)', '(>= 1 1)', '(>= 4 3 2 1)', '(>= 3 2 2 1)'],
         },
-        'not': {
-            title: 'not',
+        '!': {
+            title: '!',
             category: 'Misc',
-            linkName: 'not',
+            linkName: '-exclamation',
+            clojureDocs: 'not',
             returns: {
                 type: 'boolean',
             },
@@ -12044,7 +12237,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['x'] },
             ],
             description: 'Computes logical negation. Note that any other $x than `false`, `0`, `nil` and `\'\'` is truthy.',
-            examples: ['(not 3)', '(not true)', '(not "A string")', '(not 0)', '(not false)', '(not nil)', '(not "")'],
+            examples: ['(! 3)', '(! true)', '(! "A string")', '(! 0)', '(! false)', '(! nil)', '(! "")'],
         },
         'write!': {
             title: 'write!',
@@ -12073,25 +12266,10 @@ var Lits = (function (exports) {
                 '(write! nil true false)',
             ],
         },
-        'inst-ms!': {
-            title: 'inst-ms!',
+        'iso_date>epoch': {
+            title: 'iso_date>epoch',
             category: 'Misc',
-            linkName: 'inst-ms-exclamation',
-            clojureDocs: 'inst-ms',
-            returns: {
-                type: 'number',
-            },
-            args: {},
-            variants: [
-                { argumentNames: [] },
-            ],
-            description: 'Returns milliseconds elapsed since the UNIX epoch.',
-            examples: ['(inst-ms!)'],
-        },
-        'iso-date-time->inst-ms': {
-            title: 'iso-date-time->inst-ms',
-            category: 'Misc',
-            linkName: 'iso-date-time--gtinst-ms',
+            linkName: 'iso_date-gtepoch',
             returns: {
                 type: 'number',
             },
@@ -12105,14 +12283,14 @@ var Lits = (function (exports) {
             ],
             description: 'Returns milliseconds elapsed since the UNIX epoch to `iso`.',
             examples: [
-                '(iso-date-time->inst-ms "2022-04-12T09:37:10.899Z")',
-                '(iso-date-time->inst-ms "1980-01-01")',
+                '(iso_date>epoch "2022-04-12T09:37:10.899Z")',
+                '(iso_date>epoch "1980-01-01")',
             ],
         },
-        'inst-ms->iso-date-time': {
-            title: 'inst-ms->iso-date-time',
+        'epoch>iso_date': {
+            title: 'epoch>iso_date',
             category: 'Misc',
-            linkName: 'inst-ms--gtiso-date-time',
+            linkName: 'epoch-gtiso_date',
             returns: {
                 type: 'string',
             },
@@ -12126,8 +12304,8 @@ var Lits = (function (exports) {
             ],
             description: 'Returns IOS date time string from `ms` (milliseconds elapsed since the UNIX epoch).',
             examples: [
-                '(inst-ms->iso-date-time 1649756230899)',
-                '(inst-ms->iso-date-time 0)',
+                '(epoch>iso_date 1649756230899)',
+                '(epoch>iso_date 0)',
             ],
         },
         'boolean': {
@@ -12183,34 +12361,6 @@ var Lits = (function (exports) {
                 '(compare + -)',
             ],
         },
-        'lits-version!': {
-            title: 'lits-version!',
-            category: 'Misc',
-            linkName: 'lits-version-exclamation',
-            returns: {
-                type: 'string',
-            },
-            args: {},
-            variants: [
-                { argumentNames: [] },
-            ],
-            description: 'Returns the lits version.',
-            examples: ['(lits-version!)'],
-        },
-        'uuid!': {
-            title: 'uuid!',
-            category: 'Misc',
-            linkName: 'uuid-exclamation',
-            returns: {
-                type: 'string',
-            },
-            args: {},
-            variants: [
-                { argumentNames: [] },
-            ],
-            description: 'Returns random UUID string.',
-            examples: ['(uuid!)'],
-        },
         'equal?': {
             title: 'equal?',
             category: 'Misc',
@@ -12236,14 +12386,14 @@ var Lits = (function (exports) {
                 '(equal? [1 true nil] [1 true nil])',
                 '(equal? {:a 10 :b [1 2 {:b 20}]} {:b [1 2 {:b 20}] :a 10})',
                 '(equal? {:a 10 :b [1 2 {:b 20}]} {:b [1 2 {:b 21}] :a 10})',
-                '(= 0.3 (+ 0.1 0.2))',
+                '(== 0.3 (+ 0.1 0.2))',
                 '(equal? 0.3 (+ 0.1 0.2))',
             ],
         },
-        'json-parse': {
-            title: 'json-parse',
+        'json_parse': {
+            title: 'json_parse',
             category: 'Misc',
-            linkName: 'json-parse',
+            linkName: 'json_parse',
             clojureDocs: null,
             returns: {
                 type: 'any',
@@ -12258,13 +12408,13 @@ var Lits = (function (exports) {
             ],
             description: 'Returns `JSON.parse(`$x`)`.',
             examples: [
-                '(json-parse "[1, 2, 3]")',
+                '(json_parse "[1, 2, 3]")',
             ],
         },
-        'json-stringify': {
-            title: 'json-stringify',
+        'json_stringify': {
+            title: 'json_stringify',
             category: 'Misc',
-            linkName: 'json-stringify',
+            linkName: 'json_stringify',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -12284,8 +12434,8 @@ var Lits = (function (exports) {
             ],
             description: 'Returns `JSON.stringify(`$x`)`. If second argument is provided, returns `JSON.stringify(`$x`, null, `$indent`)`.',
             examples: [
-                '(json-stringify [1, 2, 3])',
-                '(json-stringify {:a {:b 10}} 2)',
+                '(json_stringify [1, 2, 3])',
+                '(json_stringify {:a {:b 10}} 2)',
             ],
         },
     };
@@ -12317,7 +12467,7 @@ var Lits = (function (exports) {
             linkName: 'assert-equal',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12346,7 +12496,7 @@ var Lits = (function (exports) {
             linkName: 'assert-exclamation-equal',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12375,7 +12525,7 @@ var Lits = (function (exports) {
             linkName: 'assert_equal',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12404,7 +12554,7 @@ var Lits = (function (exports) {
             linkName: 'assert_not_equal',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12433,7 +12583,7 @@ var Lits = (function (exports) {
             linkName: 'assert_gt',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12462,7 +12612,7 @@ var Lits = (function (exports) {
             linkName: 'assert_lt',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12491,7 +12641,7 @@ var Lits = (function (exports) {
             linkName: 'assert_gte',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12520,7 +12670,7 @@ var Lits = (function (exports) {
             linkName: 'assert_lte',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 a: {
@@ -12549,7 +12699,7 @@ var Lits = (function (exports) {
             linkName: 'assert_true',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 value: {
@@ -12575,7 +12725,7 @@ var Lits = (function (exports) {
             linkName: 'assert_false',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 value: {
@@ -12601,7 +12751,7 @@ var Lits = (function (exports) {
             linkName: 'assert_truthy',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 value: {
@@ -12634,7 +12784,7 @@ var Lits = (function (exports) {
             linkName: 'assert_falsy',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 value: {
@@ -12666,7 +12816,7 @@ var Lits = (function (exports) {
             linkName: 'assert_null',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 value: {
@@ -12698,7 +12848,7 @@ var Lits = (function (exports) {
             linkName: 'assert_throws',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 fn: {
@@ -12720,7 +12870,7 @@ var Lits = (function (exports) {
             linkName: 'assert_throws_error',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 'fn': {
@@ -12749,7 +12899,7 @@ var Lits = (function (exports) {
             linkName: 'assert_not_throws',
             clojureDocs: null,
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 fn: {
@@ -12768,7 +12918,7 @@ var Lits = (function (exports) {
         } };
 
     var objectReference = {
-        'dissoc': {
+        dissoc: {
             title: 'dissoc',
             category: 'Object',
             linkName: 'dissoc',
@@ -12793,7 +12943,7 @@ var Lits = (function (exports) {
                 "\n(def o { :a 5 }) (dissoc o :a)\no",
             ],
         },
-        'object': {
+        object: {
             title: 'object',
             category: 'Object',
             linkName: 'object',
@@ -12819,7 +12969,7 @@ var Lits = (function (exports) {
                 '{:a 1 :b 2}',
             ],
         },
-        'keys': {
+        keys: {
             title: 'keys',
             category: 'Object',
             linkName: 'keys',
@@ -12841,7 +12991,7 @@ var Lits = (function (exports) {
                 '(keys (object :x 10 :y true :z "A string"))',
             ],
         },
-        'vals': {
+        vals: {
             title: 'vals',
             category: 'Object',
             linkName: 'vals',
@@ -12863,7 +13013,7 @@ var Lits = (function (exports) {
                 '(vals (object :x 10 :y true :z "A string"))',
             ],
         },
-        'entries': {
+        entries: {
             title: 'entries',
             category: 'Object',
             linkName: 'entries',
@@ -12885,12 +13035,12 @@ var Lits = (function (exports) {
                 '(entries (object :x 10 :y true :z "A string"))',
             ],
         },
-        'find': {
+        find: {
             title: 'find',
             category: 'Object',
             linkName: 'find',
             returns: {
-                type: ['array', 'nil'],
+                type: ['array', 'null'],
             },
             args: {
                 obj: {
@@ -12909,7 +13059,7 @@ var Lits = (function (exports) {
                 '(find (object :a 1 :b 2) :c)',
             ],
         },
-        'merge': {
+        merge: {
             title: 'merge',
             category: 'Object',
             linkName: 'merge',
@@ -12931,10 +13081,10 @@ var Lits = (function (exports) {
                 '(merge (object :x 10) (object :x 15 :y 20))',
             ],
         },
-        'merge-with': {
-            title: 'merge-with',
+        merge_with: {
+            title: 'merge_with',
             category: 'Object',
-            linkName: 'merge-with',
+            linkName: 'merge_with',
             returns: {
                 type: 'object',
             },
@@ -12952,12 +13102,12 @@ var Lits = (function (exports) {
             ],
             description: "\nReturns a new object created by merging together all arguments.\nIf two keys appears in more than one object $fn is used to calculate the new value.\n\nIf no arguments are provided `nil` is returned.",
             examples: [
-                '(merge-with (object :x 10) (object :y 20) +)',
-                '(merge-with (object :x 10) (object :x 15 :y 20) +)',
-                '(merge-with (object :x 10) (object :x 20) (object :x 30) (object :x 40) -)',
+                '(merge_with (object :x 10) (object :y 20) +)',
+                '(merge_with (object :x 10) (object :x 15 :y 20) +)',
+                '(merge_with (object :x 10) (object :x 20) (object :x 30) (object :x 40) -)',
             ],
         },
-        'zipmap': {
+        zipmap: {
             title: 'zipmap',
             category: 'Object',
             linkName: 'zipmap',
@@ -12984,10 +13134,10 @@ var Lits = (function (exports) {
                 '(zipmap [] [10 nil [1 2 3]])',
             ],
         },
-        'select-keys': {
-            title: 'select-keys',
+        select_keys: {
+            title: 'select_keys',
             category: 'Object',
-            linkName: 'select-keys',
+            linkName: 'select_keys',
             returns: {
                 type: 'object',
             },
@@ -13005,8 +13155,8 @@ var Lits = (function (exports) {
             ],
             description: 'Returns an object containing only those entries in $obj whose key is in $keys.',
             examples: [
-                '(select-keys {:a 1 :b 2 :c 3} [:a :b])',
-                '(select-keys {:a 1} [:a :b])',
+                '(select_keys {:a 1 :b 2 :c 3} [:a :b])',
+                '(select_keys {:a 1} [:a :b])',
             ],
         },
     };
@@ -13455,7 +13605,7 @@ var Lits = (function (exports) {
             variants: [
                 { argumentNames: ['x'] },
             ],
-            description: 'Returns `true` if $x is NaN (not a number), otherwise `false`.',
+            description: 'Returns `true` if $x is NaN (! a number), otherwise `false`.',
             examples: [
                 '(nan? 1.0)',
                 '(nan? (/ 1 0))',
@@ -13566,7 +13716,7 @@ var Lits = (function (exports) {
             },
             args: {
                 x: {
-                    type: ['collection', 'string', 'nil'],
+                    type: ['collection', 'string', 'null'],
                 },
             },
             variants: [
@@ -13593,7 +13743,7 @@ var Lits = (function (exports) {
             },
             args: {
                 x: {
-                    type: ['collection', 'string', 'nil'],
+                    type: ['collection', 'string', 'null'],
                 },
             },
             variants: [
@@ -13705,10 +13855,10 @@ var Lits = (function (exports) {
     };
 
     var specialExpressionsReference = {
-        'and': {
-            title: 'and',
+        '&&': {
+            title: '&&',
             category: 'Special expression',
-            linkName: 'and',
+            linkName: '-and-and',
             returns: {
                 type: 'boolean',
             },
@@ -13721,19 +13871,20 @@ var Lits = (function (exports) {
             variants: [
                 { argumentNames: ['expressions'] },
             ],
-            description: "\nComputes logical `and` function. Evaluation of $expressions starts from left.\nAs soon as a `expression` evaluates to a falsy value, the result is returned.\n\nIf all expressions evaluate to truthy values, the value of the last expression is returned.",
+            description: "\nComputes logical `and`. Evaluation of $expressions starts from left.\nAs soon as a `expression` evaluates to a falsy value, the result is returned.\n\nIf all expressions evaluate to truthy values, the value of the last expression is returned.",
             examples: [
-                '(and 1 1)',
-                '(and (> 3 2) "string")',
-                '(and (< 3 2) "string")',
-                '(and true true true true)',
-                '(and true true 0 true)',
+                '(&& 1 1)',
+                '(&& (> 3 2) "string")',
+                '(&& (< 3 2) "string")',
+                '(&& true true true true)',
+                '(&& true true 0 true)',
             ],
         },
-        'or': {
-            title: 'or',
+        '||': {
+            title: '||',
             category: 'Special expression',
-            linkName: 'or',
+            linkName: '-or-or',
+            clojureDocs: 'or',
             returns: {
                 type: 'boolean',
             },
@@ -13746,13 +13897,13 @@ var Lits = (function (exports) {
             variants: [
                 { argumentNames: ['expressions'] },
             ],
-            description: "\nComputes logical `or` function. Evaluation of $expressions evaluation starts from left.\nAs soon as a `expression` evaluates to a truthy value, the result is returned.\n\nIf all expressions evaluate to falsy values, the value of the last expression is returned.",
+            description: "\nComputes logical `or`. Evaluation of $expressions evaluation starts from left.\nAs soon as a `expression` evaluates to a truthy value, the result is returned.\n\nIf all expressions evaluate to falsy values, the value of the last expression is returned.",
             examples: [
-                '(or 1 1)',
-                '(or (> 3 2) "string")',
-                '(or (< 3 2) "string")',
-                '(or true true true true)',
-                '(or 1 2 3 4)',
+                '(|| 1 1)',
+                '(|| (> 3 2) "string")',
+                '(|| (< 3 2) "string")',
+                '(|| true true true true)',
+                '(|| 1 2 3 4)',
             ],
         },
         'def': {
@@ -13828,10 +13979,10 @@ var Lits = (function (exports) {
             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',
+        'if_let': {
+            title: 'if_let',
             category: 'Special expression',
-            linkName: 'if-let',
+            linkName: 'if_let',
             returns: {
                 type: 'any',
             },
@@ -13852,14 +14003,14 @@ var Lits = (function (exports) {
             ],
             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.\"))",
+                "\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',
+        'when_let': {
+            title: 'when_let',
             category: 'Special expression',
-            linkName: 'when-let',
+            linkName: 'when_let',
             returns: {
                 type: 'any',
             },
@@ -13877,13 +14028,13 @@ var Lits = (function (exports) {
             ],
             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))",
+                "\n(when_let [a (> (count \"Albert\") 4)]\n  (write! a))",
             ],
         },
-        'when-first': {
-            title: 'when-first',
+        'when_first': {
+            title: 'when_first',
             category: 'Special expression',
-            linkName: 'when-first',
+            linkName: 'when_first',
             returns: {
                 type: 'any',
             },
@@ -13902,11 +14053,11 @@ var Lits = (function (exports) {
             ],
             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)",
+                "\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)",
             ],
         },
         'fn': {
@@ -14071,10 +14222,10 @@ var Lits = (function (exports) {
                 '(if false (write! "TRUE"))',
             ],
         },
-        'if-not': {
-            title: 'if-not',
+        'if_not': {
+            title: 'if_not',
             category: 'Special expression',
-            linkName: 'if-not',
+            linkName: 'if_not',
             returns: {
                 type: 'any',
             },
@@ -14095,10 +14246,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"))',
+                '(if_not true (write! "TRUE") (write! "FALSE"))',
+                '(if_not false (write! "TRUE") (write! "FALSE"))',
+                '(if_not true (write! "TRUE"))',
+                '(if_not false (write! "TRUE"))',
             ],
         },
         'cond': {
@@ -14123,6 +14274,31 @@ var Lits = (function (exports) {
                 "\n(cond\n  false (write! \"FALSE\")\n  nil (write! \"nil\"))",
             ],
         },
+        'switch': {
+            title: 'switch',
+            category: 'Special expression',
+            linkName: 'switch',
+            returns: {
+                type: 'any',
+            },
+            args: {
+                value: {
+                    type: 'any',
+                },
+                conds: {
+                    type: '*conditions',
+                },
+            },
+            variants: [
+                { argumentNames: ['value', 'conds'] },
+            ],
+            description: 'Used for branching. $conds are tested sequentially from the top against $value. If no branch is tested truthy, `nil` is returned.',
+            examples: [
+                "\n(switch 1\n  1 (write! \"FALSE\")\n  2 (write! \"nil\"))",
+                "\n(switch 2\n  1 (write! \"FALSE\")\n  2 (write! \"nil\"))",
+                "\n(switch 3\n  1 (write! \"FALSE\")\n  2 (write! \"nil\"))",
+            ],
+        },
         'when': {
             title: 'when',
             category: 'Special expression',
@@ -14150,10 +14326,10 @@ var Lits = (function (exports) {
                 '(when false)',
             ],
         },
-        'when-not': {
-            title: 'when-not',
+        'when_not': {
+            title: 'when_not',
             category: 'Special expression',
-            linkName: 'when-not',
+            linkName: 'when_not',
             returns: {
                 type: 'any',
             },
@@ -14171,10 +14347,10 @@ var Lits = (function (exports) {
             ],
             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)',
+                '(when_not true (write! "Hi") (write! "There"))',
+                '(when_not false (write! "Hi") (write! "There"))',
+                '(when_not true)',
+                '(when_not false)',
             ],
         },
         'comment': {
@@ -14182,7 +14358,7 @@ var Lits = (function (exports) {
             category: 'Special expression',
             linkName: 'comment',
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 expressions: {
@@ -14223,7 +14399,7 @@ var Lits = (function (exports) {
             category: 'Special expression',
             linkName: 'recur',
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 expressions: {
@@ -14236,9 +14412,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 (not (zero? n))\n    (recur\n      (dec n))))\n(foo 3)",
-                "\n(\n  (fn [n]\n    (write! n)\n    (when (not (zero? n))\n      (recur\n        (dec n))))\n  3)",
-                "\n(\n  loop [n 3]\n    (write! n)\n    (when\n      (not (zero? n))\n      (recur (dec n))))",
+                "\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))))",
             ],
         },
         'loop': {
@@ -14263,35 +14439,16 @@ 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    (not (zero? n))\n    (recur (dec n))))",
-                "\n(loop [n 3]\n  (write! n)\n  (if\n    (not (zero? n))\n    (recur (dec n))\n    n))",
+                "\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    n))",
             ],
         },
-        'time!': {
-            title: 'time!',
-            category: 'Special expression',
-            linkName: 'time-exclamation',
-            clojureDocs: 'time',
-            returns: {
-                type: 'any',
-            },
-            args: {
-                expression: {
-                    type: '*expression',
-                },
-            },
-            variants: [
-                { argumentNames: ['expression'] },
-            ],
-            description: 'Prints the time it took to evaluate $expression. Returns $expression evaluated.',
-            examples: ["\n(defn fib [x]\n  (if\n    (<= x 2)\n    1\n    (+ \n      (fib (dec x))\n      (fib (- x 2)))))\n(time! (fib 20))"],
-        },
         'doseq': {
             title: 'doseq',
             category: 'Special expression',
             linkName: 'doseq',
             returns: {
-                type: 'nil',
+                type: 'null',
             },
             args: {
                 bindings: {
@@ -14431,10 +14588,10 @@ var Lits = (function (exports) {
                 '(subs "A string" 100)',
             ],
         },
-        'string-repeat': {
-            title: 'string-repeat',
+        'string_repeat': {
+            title: 'string_repeat',
             category: 'String',
-            linkName: 'string-repeat',
+            linkName: 'string_repeat',
             clojureDocs: null,
             returns: {
                 type: 'number',
@@ -14452,8 +14609,8 @@ var Lits = (function (exports) {
             ],
             description: 'Repeates $s $n times.',
             examples: [
-                '(string-repeat "*" 10)',
-                '(string-repeat "***" 0)',
+                '(string_repeat "*" 10)',
+                '(string_repeat "***" 0)',
             ],
         },
         'str': {
@@ -14503,41 +14660,10 @@ var Lits = (function (exports) {
                 '(number "-1.01")',
             ],
         },
-        'number-to-string': {
-            title: 'number-to-string',
-            category: 'String',
-            linkName: 'number-to-string',
-            clojureDocs: null,
-            returns: {
-                type: 'string',
-            },
-            args: {
-                n: {
-                    type: 'number',
-                },
-                base: {
-                    type: 'number',
-                    description: '2, 8, 10 or 16',
-                },
-            },
-            variants: [
-                { argumentNames: ['n'] },
-                { argumentNames: ['n', 'base'] },
-            ],
-            description: 'Converts $n to a string. If $base is not equal to `10`, $n must be a non negative integer.',
-            examples: [
-                '(number-to-string 10)',
-                '(number-to-string -1.01)',
-                '(number-to-string -.01)',
-                '(number-to-string 15 2)',
-                '(number-to-string 15 8)',
-                '(number-to-string 15 16)',
-            ],
-        },
-        'lower-case': {
-            title: 'lower-case',
+        'lower_case': {
+            title: 'lower_case',
             category: 'String',
-            linkName: 'lower-case',
+            linkName: 'lower_case',
             returns: {
                 type: 'string',
             },
@@ -14551,14 +14677,14 @@ var Lits = (function (exports) {
             ],
             description: 'Returns $s converted to lower case.',
             examples: [
-                '(lower-case "Albert")',
-                '(lower-case "")',
+                '(lower_case "Albert")',
+                '(lower_case "")',
             ],
         },
-        'upper-case': {
-            title: 'upper-case',
+        'upper_case': {
+            title: 'upper_case',
             category: 'String',
-            linkName: 'upper-case',
+            linkName: 'upper_case',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14573,8 +14699,8 @@ var Lits = (function (exports) {
             ],
             description: 'Returns $s converted to upper case.',
             examples: [
-                '(upper-case "Albert")',
-                '(upper-case "")',
+                '(upper_case "Albert")',
+                '(upper_case "")',
             ],
         },
         'trim': {
@@ -14600,10 +14726,10 @@ var Lits = (function (exports) {
                 '(trim "")',
             ],
         },
-        'trim-left': {
-            title: 'trim-left',
+        'trim_left': {
+            title: 'trim_left',
             category: 'String',
-            linkName: 'trim-left',
+            linkName: 'trim_left',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14618,15 +14744,15 @@ var Lits = (function (exports) {
             ],
             description: 'Returns a new string with leading whitespaces removed.',
             examples: [
-                '(trim-left "  Albert  ")',
-                '(trim-left "   ")',
-                '(trim-left "")',
+                '(trim_left "  Albert  ")',
+                '(trim_left "   ")',
+                '(trim_left "")',
             ],
         },
-        'trim-right': {
-            title: 'trim-right',
+        'trim_right': {
+            title: 'trim_right',
             category: 'String',
-            linkName: 'trim-right',
+            linkName: 'trim_right',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14641,15 +14767,15 @@ var Lits = (function (exports) {
             ],
             description: 'Returns a new string with trailing whitespaces removed.',
             examples: [
-                '(trim-right "  Albert  ")',
-                '(trim-right "   ")',
-                '(trim-right "")',
+                '(trim_right "  Albert  ")',
+                '(trim_right "   ")',
+                '(trim_right "")',
             ],
         },
-        'pad-left': {
-            title: 'pad-left',
+        'pad_left': {
+            title: 'pad_left',
             category: 'String',
-            linkName: 'pad-left',
+            linkName: 'pad_left',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14671,16 +14797,16 @@ var Lits = (function (exports) {
             ],
             description: 'Pads from the start of $s with `padString` (multiple times, if needed) until the resulting string reaches the given $length.',
             examples: [
-                '(pad-left "Albert" 20)',
-                '(pad-left "Albert" 20 "-*-")',
-                '(pad-left "Albert" 5)',
-                '(pad-left "Albert" -1)',
+                '(pad_left "Albert" 20)',
+                '(pad_left "Albert" 20 "-*-")',
+                '(pad_left "Albert" 5)',
+                '(pad_left "Albert" -1)',
             ],
         },
-        'pad-right': {
-            title: 'pad-right',
+        'pad_right': {
+            title: 'pad_right',
             category: 'String',
-            linkName: 'pad-right',
+            linkName: 'pad_right',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14702,10 +14828,10 @@ var Lits = (function (exports) {
             ],
             description: 'Pads from the start of $s with `padString` (multiple times, if needed) until the resulting string reaches the given `length`.',
             examples: [
-                '(pad-right "Albert" 20)',
-                '(pad-right "Albert" 20 "-*-")',
-                '(pad-right "Albert" 5)',
-                '(pad-right "Albert" -1)',
+                '(pad_right "Albert" 20)',
+                '(pad_right "Albert" 20 "-*-")',
+                '(pad_right "Albert" 5)',
+                '(pad_right "Albert" -1)',
             ],
         },
         'split': {
@@ -14776,10 +14902,10 @@ var Lits = (function (exports) {
                 '(template "No book||||One book||||Two books||||Three books||||$1 books" 4)',
             ],
         },
-        'to-char-code': {
-            title: 'to-char-code',
+        'to_char_code': {
+            title: 'to_char_code',
             category: 'String',
-            linkName: 'to-char-code',
+            linkName: 'to_char_code',
             clojureDocs: null,
             returns: {
                 type: 'number',
@@ -14794,14 +14920,14 @@ var Lits = (function (exports) {
             ],
             description: 'Return code point for first character in $c.',
             examples: [
-                '(to-char-code :A)',
-                '(to-char-code "Albert")',
+                '(to_char_code :A)',
+                '(to_char_code "Albert")',
             ],
         },
-        'from-char-code': {
-            title: 'from-char-code',
+        'from_char_code': {
+            title: 'from_char_code',
             category: 'String',
-            linkName: 'from-char-code',
+            linkName: 'from_char_code',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14816,14 +14942,14 @@ var Lits = (function (exports) {
             ],
             description: 'Return character for code point $code.',
             examples: [
-                '(from-char-code 65)',
-                '(from-char-code 0)',
+                '(from_char_code 65)',
+                '(from_char_code 0)',
             ],
         },
-        'encode-base64': {
-            title: 'encode-base64',
+        'encode_base64': {
+            title: 'encode_base64',
             category: 'String',
-            linkName: 'encode-base64',
+            linkName: 'encode_base64',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14838,13 +14964,13 @@ var Lits = (function (exports) {
             ],
             description: 'Returns a Base64 encoded string from $s.',
             examples: [
-                '(encode-base64 "Albert")',
+                '(encode_base64 "Albert")',
             ],
         },
-        'decode-base64': {
-            title: 'decode-base64',
+        'decode_base64': {
+            title: 'decode_base64',
             category: 'String',
-            linkName: 'decode-base64',
+            linkName: 'decode_base64',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14859,13 +14985,13 @@ var Lits = (function (exports) {
             ],
             description: 'Returns a Base64 decoded string from $base64string.',
             examples: [
-                '(decode-base64 "QWxiZXJ0IPCfkLs=")',
+                '(decode_base64 "QWxiZXJ0IPCfkLs=")',
             ],
         },
-        'encode-uri-component': {
-            title: 'encode-uri-component',
+        'encode_uri_component': {
+            title: 'encode_uri_component',
             category: 'String',
-            linkName: 'encode-uri-component',
+            linkName: 'encode_uri_component',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14880,13 +15006,13 @@ var Lits = (function (exports) {
             ],
             description: 'Returns an escaped `URI` string.',
             examples: [
-                '(encode-uri-component "Hi everyone!?")',
+                '(encode_uri_component "Hi everyone!?")',
             ],
         },
-        'decode-uri-component': {
-            title: 'decode-uri-component',
+        'decode_uri_component': {
+            title: 'decode_uri_component',
             category: 'String',
-            linkName: 'decode-uri-component',
+            linkName: 'decode_uri_component',
             clojureDocs: null,
             returns: {
                 type: 'string',
@@ -14901,7 +15027,7 @@ var Lits = (function (exports) {
             ],
             description: 'Returns an un-escaped `URI` string.',
             examples: [
-                '(decode-uri-component "Hi%20everyone!%3F%20%F0%9F%91%8D")',
+                '(decode_uri_component "Hi%20everyone!%3F%20%F0%9F%91%8D")',
             ],
         },
         'join': {
@@ -14926,15 +15052,42 @@ var Lits = (function (exports) {
             description: 'Returns a new string by concatenating all of the elements in $arr, separated by $delimiter.',
             examples: [
                 '(join ["Albert" "Mojir"] " ")',
-                '(join (map number-to-string [0 1 2 3 4 5 6 7 8 9]) ", ")',
+                '(join (map [0 1 2 3 4 5 6 7 8 9] str) ", ")',
+            ],
+        },
+        '++': {
+            title: '++',
+            category: 'String',
+            linkName: '-plus-plus',
+            clojureDocs: null,
+            returns: {
+                type: 'string',
+            },
+            args: {
+                strings: {
+                    type: ['string', 'number', 'null'],
+                    rest: true,
+                },
+            },
+            variants: [{
+                    argumentNames: ['strings'],
+                }],
+            description: 'Concatenats $strings into one string.',
+            examples: [
+                '(++ "Albert" " " "Mojir")',
+                '(++ "Albert" "Mojir")',
+                '(++ "Albert" null "Mojir")',
+                '(++ "Albert")',
+                '(++)',
             ],
         },
     };
 
-    var bitwiseReference = { 'bit-shift-left': {
-            title: 'bit-shift-left',
+    var bitwiseReference = { '<<': {
+            title: '<<',
             category: 'Bitwise',
-            linkName: 'bit-shift-left',
+            linkName: '-lt-lt',
+            clojureDocs: 'bit-shift-left',
             returns: {
                 type: 'integer',
             },
@@ -14950,11 +15103,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Shifts $x arithmetically left by $n bit positions.',
-            examples: ['(bit-shift-left 1 10)', '(bit-shift-left -4 2)'],
-        }, 'bit-shift-right': {
-            title: 'bit-shift-right',
+            examples: ['(<< 1 10)', '(<< -4 2)'],
+        }, '>>': {
+            title: '>>',
             category: 'Bitwise',
-            linkName: 'bit-shift-right',
+            linkName: '-gt-gt',
+            clojureDocs: 'bit-shift-right',
             returns: {
                 type: 'integer',
             },
@@ -14970,11 +15124,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Shifts $x arithmetically right by $n bit positions.',
-            examples: ['(bit-shift-right 2048 10)', '(bit-shift-right 4 10)'],
-        }, 'unsigned-bit-shift-right': {
-            title: 'unsigned-bit-shift-right',
+            examples: ['(>> 2048 10)', '(>> 4 10)'],
+        }, '>>>': {
+            title: '>>>',
             category: 'Bitwise',
-            linkName: 'unsigned-bit-shift-right',
+            linkName: '-gt-gt-gt',
+            clojureDocs: 'unsigned-bit-shift-right',
             returns: {
                 type: 'integer',
             },
@@ -14990,11 +15145,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Shifts $x arithmetically right by $n bit positions without sign extension.',
-            examples: ['(unsigned-bit-shift-right 2048 10)', '(unsigned-bit-shift-right 4 10)', '(unsigned-bit-shift-right -1 10)'],
-        }, 'bit-not': {
-            title: 'bit-not',
+            examples: ['(>>> 2048 10)', '(>>> 4 10)', '(>>> -1 10)'],
+        }, '~': {
+            title: '~',
             category: 'Bitwise',
-            linkName: 'bit-not',
+            linkName: '-tilde',
+            clojureDocs: 'bit-not',
             returns: {
                 type: 'integer',
             },
@@ -15007,11 +15163,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x'] },
             ],
             description: 'Returns bitwise `not` of $x.',
-            examples: ['(bit-not 0)', '(bit-not 255)'],
-        }, 'bit-and': {
-            title: 'bit-and',
+            examples: ['(~ 0)', '(~ 255)'],
+        }, '&': {
+            title: '&',
             category: 'Bitwise',
-            linkName: 'bit-and',
+            linkName: '-and',
+            clojureDocs: 'bit-and',
             returns: {
                 type: 'integer',
             },
@@ -15033,13 +15190,14 @@ var Lits = (function (exports) {
             ],
             description: 'Returns bitwise `and` of all arguments.',
             examples: [
-                '(bit-and 0b0011 0b0110)',
-                '(bit-and 0b0011 0b0110 0b1001)',
+                '(& 0b0011 0b0110)',
+                '(& 0b0011 0b0110 0b1001)',
             ],
-        }, 'bit-and-not': {
-            title: 'bit-and-not',
+        }, '&!': {
+            title: '&!',
             category: 'Bitwise',
-            linkName: 'bit-and-not',
+            linkName: '-and-exclamation',
+            clojureDocs: 'bit-and-not',
             returns: {
                 type: 'integer',
             },
@@ -15060,11 +15218,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'y', 'rest'] },
             ],
             description: 'Returns bitwise `and` with complement.',
-            examples: ['(bit-and-not 0b0011 0b0110)', '(bit-and-not 0b0011 0b0110 0b1001)'],
-        }, 'bit-or': {
-            title: 'bit-or',
+            examples: ['(&! 0b0011 0b0110)', '(&! 0b0011 0b0110 0b1001)'],
+        }, '|': {
+            title: '|',
             category: 'Bitwise',
-            linkName: 'bit-or',
+            linkName: '-or',
+            clojureDocs: 'bit-or',
             returns: {
                 type: 'integer',
             },
@@ -15085,11 +15244,12 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'y', 'rest'] },
             ],
             description: 'Returns bitwise `or` of all arguments.',
-            examples: ['(bit-or 0b0011 0b0110)', '(bit-or 0b1000 0b0100 0b0010)'],
-        }, 'bit-xor': {
-            title: 'bit-xor',
+            examples: ['(| 0b0011 0b0110)', '(| 0b1000 0b0100 0b0010)'],
+        }, '^': {
+            title: '^',
             category: 'Bitwise',
-            linkName: 'bit-xor',
+            linkName: '-caret',
+            clojureDocs: 'bit-xor',
             returns: {
                 type: 'integer',
             },
@@ -15110,11 +15270,11 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'y', 'rest'] },
             ],
             description: 'Returns bitwise `xor` of all arguments.',
-            examples: ['(bit-xor 0b0011 0b0110)', '(bit-xor 0b11110000 0b00111100 0b10101010)'],
-        }, 'bit-flip': {
-            title: 'bit-flip',
+            examples: ['(^ 0b0011 0b0110)', '(^ 0b11110000 0b00111100 0b10101010)'],
+        }, 'bit_flip': {
+            title: 'bit_flip',
             category: 'Bitwise',
-            linkName: 'bit-flip',
+            linkName: 'bit_flip',
             returns: {
                 type: 'integer',
             },
@@ -15130,11 +15290,11 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Flips bit number $n.',
-            examples: ['(bit-flip 0b0011 1)', '(bit-flip 0b1100 1)'],
-        }, 'bit-clear': {
-            title: 'bit-clear',
+            examples: ['(bit_flip 0b0011 1)', '(bit_flip 0b1100 1)'],
+        }, 'bit_clear': {
+            title: 'bit_clear',
             category: 'Bitwise',
-            linkName: 'bit-clear',
+            linkName: 'bit_clear',
             returns: {
                 type: 'integer',
             },
@@ -15150,11 +15310,11 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Clears bit number $n.',
-            examples: ['(bit-clear 0b0011 1)', '(bit-clear 0b1100 1)'],
-        }, 'bit-set': {
-            title: 'bit-set',
+            examples: ['(bit_clear 0b0011 1)', '(bit_clear 0b1100 1)'],
+        }, 'bit_set': {
+            title: 'bit_set',
             category: 'Bitwise',
-            linkName: 'bit-set',
+            linkName: 'bit_set',
             returns: {
                 type: 'integer',
             },
@@ -15170,11 +15330,11 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Sets bit number $n.',
-            examples: ['(bit-set 0b0011 1)', '(bit-set 0b1100 1)'],
-        }, 'bit-test': {
-            title: 'bit-test',
+            examples: ['(bit_set 0b0011 1)', '(bit_set 0b1100 1)'],
+        }, 'bit_test': {
+            title: 'bit_test',
             category: 'Bitwise',
-            linkName: 'bit-test',
+            linkName: 'bit_test',
             returns: {
                 type: 'boolean',
             },
@@ -15190,7 +15350,7 @@ var Lits = (function (exports) {
                 { argumentNames: ['x', 'n'] },
             ],
             description: 'Checks if bit number $n is set.',
-            examples: ['(bit-test 0b0011 1)', '(bit-test 0b1100 1)'],
+            examples: ['(bit_test 0b0011 1)', '(bit_test 0b1100 1)'],
         } };
 
     var shorthand = {
@@ -15518,13 +15678,13 @@ var Lits = (function (exports) {
             '*',
             '/',
             'mod',
-            'rem',
+            '%',
             'quot',
             'inc',
             'dec',
             'sqrt',
             'cbrt',
-            'pow',
+            '**',
             'exp',
             'round',
             'trunc',
@@ -15574,23 +15734,20 @@ var Lits = (function (exports) {
         ],
         misc: [
             '!=',
-            '=',
+            '==',
             '<',
             '>',
             '<=',
             '>=',
-            'not',
+            '!',
             'write!',
-            'inst-ms!',
-            'iso-date-time->inst-ms',
-            'inst-ms->iso-date-time',
+            'iso_date>epoch',
+            'epoch>iso_date',
             'boolean',
             'compare',
-            'lits-version!',
-            'uuid!',
             'equal?',
-            'json-parse',
-            'json-stringify',
+            'json_parse',
+            'json_stringify',
         ],
         object: [
             'dissoc',
@@ -15600,9 +15757,9 @@ var Lits = (function (exports) {
             'entries',
             'find',
             'merge',
-            'merge-with',
+            'merge_with',
             'zipmap',
-            'select-keys',
+            'select_keys',
         ],
         predicate: [
             'boolean?',
@@ -15636,29 +15793,29 @@ var Lits = (function (exports) {
             'replace',
         ],
         specialExpressions: [
-            'and',
-            'or',
+            '&&',
+            '||',
             'def',
             'defs',
             'let',
-            'if-let',
-            'when-let',
-            'when-first',
+            'if_let',
+            'when_let',
+            'when_first',
             'fn',
             'defn',
             'defns',
             'try',
             'throw',
             'if',
-            'if-not',
+            'if_not',
             'cond',
+            'switch',
             'when',
-            'when-not',
+            'when_not',
             'comment',
             'do',
             'recur',
             'loop',
-            'time!',
             'doseq',
             'for',
             'declared?',
@@ -15666,40 +15823,40 @@ var Lits = (function (exports) {
         ],
         string: [
             'subs',
-            'string-repeat',
+            'string_repeat',
             'str',
             'number',
-            'number-to-string',
-            'lower-case',
-            'upper-case',
+            'lower_case',
+            'upper_case',
             'trim',
-            'trim-left',
-            'trim-right',
-            'pad-left',
-            'pad-right',
+            'trim_left',
+            'trim_right',
+            'pad_left',
+            'pad_right',
             'split',
             'template',
-            'to-char-code',
-            'from-char-code',
-            'encode-base64',
-            'decode-base64',
-            'encode-uri-component',
-            'decode-uri-component',
+            'to_char_code',
+            'from_char_code',
+            'encode_base64',
+            'decode_base64',
+            'encode_uri_component',
+            'decode_uri_component',
             'join',
+            '++',
         ],
         bitwise: [
-            'bit-shift-left',
-            'bit-shift-right',
-            'unsigned-bit-shift-right',
-            'bit-not',
-            'bit-and',
-            'bit-and-not',
-            'bit-or',
-            'bit-xor',
-            'bit-flip',
-            'bit-clear',
-            'bit-set',
-            'bit-test',
+            '<<',
+            '>>',
+            '>>>',
+            '~',
+            '&',
+            '&!',
+            '|',
+            '^',
+            'bit_flip',
+            'bit_clear',
+            'bit_set',
+            'bit_test',
         ],
         assert: [
             'assert',
@@ -15786,7 +15943,7 @@ var Lits = (function (exports) {
         'function',
         'integer',
         'any',
-        'nil',
+        'null',
         'collection',
         'sequence',
         'regexp',