@mojir/lits 2.0.13 → 2.0.15

package/dist/index.js

@@ -238,6 +238,12 @@ function isLitsError(error) {
     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
@@ -256,8 +262,12 @@ function addTokenDebugData(token, debugData) {
     }
     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 = [
@@ -279,7 +289,7 @@ function isLParenToken(token) {
 }
 function assertLParenToken(token) {
     if (!isLParenToken(token)) {
-        throwUnexpectedToken('LParen', token);
+        throwUnexpectedToken('LParen', undefined, token);
     }
 }
 function asLParenToken(token) {
@@ -291,7 +301,7 @@ function isRParenToken(token) {
 }
 function assertRParenToken(token) {
     if (!isRParenToken(token)) {
-        throwUnexpectedToken('RParen', token);
+        throwUnexpectedToken('RParen', undefined, token);
     }
 }
 function isLBracketToken(token) {
@@ -299,7 +309,7 @@ function isLBracketToken(token) {
 }
 function assertLBracketToken(token) {
     if (!isLBracketToken(token)) {
-        throwUnexpectedToken('LBracket', token);
+        throwUnexpectedToken('LBracket', undefined, token);
     }
 }
 function asLBracketToken(token) {
@@ -311,7 +321,7 @@ function isRBracketToken(token) {
 }
 function assertRBracketToken(token) {
     if (!isRBracketToken(token)) {
-        throwUnexpectedToken('RBracket', token);
+        throwUnexpectedToken('RBracket', undefined, token);
     }
 }
 function isLBraceToken(token) {
@@ -319,7 +329,7 @@ function isLBraceToken(token) {
 }
 function assertLBraceToken(token) {
     if (!isLBraceToken(token)) {
-        throwUnexpectedToken('LBrace', token);
+        throwUnexpectedToken('LBrace', undefined, token);
     }
 }
 function asLBraceToken(token) {
@@ -331,7 +341,7 @@ function isRBraceToken(token) {
 }
 function assertRBraceToken(token) {
     if (!isRBraceToken(token)) {
-        throwUnexpectedToken('RBrace', token);
+        throwUnexpectedToken('RBrace', undefined, token);
     }
 }
 function isStringToken(token) {
@@ -339,7 +349,7 @@ function isStringToken(token) {
 }
 function assertStringToken(token) {
     if (!isStringToken(token)) {
-        throwUnexpectedToken('String', token);
+        throwUnexpectedToken('String', undefined, token);
     }
 }
 function asStringToken(token) {
@@ -357,7 +367,7 @@ function isEndNotationToken(token) {
 }
 function assertEndNotationToken(token) {
     if (!isEndNotationToken(token)) {
-        throwUnexpectedToken('EndNotation', token);
+        throwUnexpectedToken('EndNotation', undefined, token);
     }
 }
 
@@ -410,28 +420,28 @@ var otherSymbolicOperators = [
     '.', // 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',
@@ -462,7 +472,7 @@ function isA_SymbolToken(token) {
 }
 function assertA_SymbolToken(token) {
     if (!isA_SymbolToken(token)) {
-        throwUnexpectedToken('A_Symbol', token);
+        throwUnexpectedToken('A_Symbol', undefined, token);
     }
 }
 function asA_SymbolToken(token) {
@@ -472,8 +482,19 @@ function asA_SymbolToken(token) {
 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';
@@ -492,10 +513,9 @@ function isA_OperatorToken(token, operatorName) {
 }
 function assertA_OperatorToken(token, operatorName) {
     if (!isA_OperatorToken(token, operatorName)) {
-        if (operatorName) {
+        {
             throw new LitsError("Unexpected token: ".concat(token, ", expected operator ").concat(operatorName), undefined);
         }
-        throwUnexpectedToken('A_Operator', token);
     }
 }
 function isA_WhitespaceToken(token) {
@@ -508,7 +528,7 @@ function isA_BasePrefixedNumberToken(token) {
     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',
 ];
@@ -531,7 +551,7 @@ function isP_StringShorthandToken(token) {
 }
 function assertP_StringShorthandToken(token) {
     if (!isP_StringShorthandToken(token)) {
-        throwUnexpectedToken('P_StringShorthand', token);
+        throwUnexpectedToken('P_StringShorthand', undefined, token);
     }
 }
 function asP_StringShorthandToken(token) {
@@ -543,7 +563,7 @@ function isP_SymbolToken(token) {
 }
 function assertP_SymbolToken(token) {
     if (!isP_SymbolToken(token)) {
-        throwUnexpectedToken('P_Symbol', token);
+        throwUnexpectedToken('P_Symbol', undefined, token);
     }
 }
 function asP_SymbolToken(token) {
@@ -561,7 +581,7 @@ function isP_RegexpShorthandToken(token) {
 }
 function assertP_RegexpShorthandToken(token) {
     if (!isP_RegexpShorthandToken(token)) {
-        throwUnexpectedToken('P_RegexpShorthand', token);
+        throwUnexpectedToken('P_RegexpShorthand', undefined, token);
     }
 }
 function asP_RegexpShorthandToken(token) {
@@ -576,7 +596,7 @@ function isP_CollectionAccessorToken(token) {
 }
 function assertP_CollectionAccessorToken(token) {
     if (!isP_CollectionAccessorToken(token)) {
-        throwUnexpectedToken('P_CollectionAccessor', token);
+        throwUnexpectedToken('P_CollectionAccessor', undefined, token);
     }
 }
 function asP_CollectionAccessorToken(token) {
@@ -588,7 +608,7 @@ function isP_CommentToken(token) {
 }
 function assertP_CommentToken(token) {
     if (!isP_CommentToken(token)) {
-        throwUnexpectedToken('P_Comment', token);
+        throwUnexpectedToken('P_Comment', undefined, token);
     }
 }
 function asP_CommentToken(token) {
@@ -603,7 +623,7 @@ function isP_NumberToken(token) {
 }
 function assertP_NumberToken(token) {
     if (!isP_NumberToken(token)) {
-        throwUnexpectedToken('P_Number', token);
+        throwUnexpectedToken('P_Number', undefined, token);
     }
 }
 
@@ -671,12 +691,6 @@ function valueToString(value) {
     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));
 }
@@ -729,7 +743,7 @@ function isExpressionNode(value) {
 }
 
 var specialExpressionCommentRemovers = {
-    'and': function (node, removeOptions) {
+    '&&': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -741,6 +755,10 @@ var specialExpressionCommentRemovers = {
         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);
@@ -762,12 +780,12 @@ var specialExpressionCommentRemovers = {
     '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);
     },
@@ -779,7 +797,7 @@ var specialExpressionCommentRemovers = {
         });
     },
     'loop': function (_node, _removeOptions) { },
-    'or': function (node, removeOptions) {
+    '||': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -791,19 +809,15 @@ var specialExpressionCommentRemovers = {
         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];
@@ -845,6 +859,13 @@ function assertEvenNumberOfParams(node) {
         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({
@@ -1008,7 +1029,7 @@ function asNumber(value, sourceCodeInfo, options) {
 }
 
 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 });
@@ -1017,7 +1038,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1026,7 +1047,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1035,7 +1056,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1043,7 +1064,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1054,7 +1075,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1065,7 +1086,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1076,7 +1097,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1087,7 +1108,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1097,7 +1118,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1107,7 +1128,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -1117,7 +1138,7 @@ var bitwiseNormalExpression = {
         },
         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 });
@@ -2816,7 +2837,7 @@ var mathNormalExpression = {
         },
         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);
@@ -2842,7 +2863,7 @@ var mathNormalExpression = {
         },
         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);
@@ -3119,10 +3140,6 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.13";
-
-var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-var xyRegexp = /[xy]/g;
 var miscNormalExpression = {
     '!=': {
         evaluate: function (params) {
@@ -3136,7 +3153,7 @@ var miscNormalExpression = {
         },
         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);
@@ -3261,20 +3278,14 @@ var miscNormalExpression = {
         },
         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);
@@ -3282,7 +3293,7 @@ var miscNormalExpression = {
         },
         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);
@@ -3315,23 +3326,7 @@ var miscNormalExpression = {
         },
         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);
@@ -3340,7 +3335,7 @@ var miscNormalExpression = {
         },
         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);
@@ -3553,7 +3548,7 @@ var assertNormalExpression = {
 };
 
 var objectNormalExpression = {
-    'object': {
+    object: {
         evaluate: function (params, sourceCodeInfo) {
             var result = {};
             for (var i = 0; i < params.length; i += 2) {
@@ -3566,7 +3561,7 @@ var objectNormalExpression = {
         },
         validate: function (node) { return assertEvenNumberOfParams(node); },
     },
-    'keys': {
+    keys: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), obj = _b[0];
             assertObj(obj, sourceCodeInfo);
@@ -3574,7 +3569,7 @@ var objectNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'vals': {
+    vals: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), obj = _b[0];
             assertObj(obj, sourceCodeInfo);
@@ -3582,7 +3577,7 @@ var objectNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'entries': {
+    entries: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), obj = _b[0];
             assertObj(obj, sourceCodeInfo);
@@ -3590,7 +3585,7 @@ var objectNormalExpression = {
         },
         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);
@@ -3601,7 +3596,7 @@ var objectNormalExpression = {
         },
         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);
@@ -3612,7 +3607,7 @@ var objectNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'merge': {
+    merge: {
         evaluate: function (params, sourceCodeInfo) {
             if (params.length === 0)
                 return null;
@@ -3625,7 +3620,7 @@ var objectNormalExpression = {
         },
         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];
@@ -3648,7 +3643,7 @@ var objectNormalExpression = {
         },
         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);
@@ -3663,7 +3658,7 @@ var objectNormalExpression = {
         },
         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);
@@ -3929,7 +3924,7 @@ var stringNormalExpression = {
         },
         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);
@@ -3963,27 +3958,7 @@ var stringNormalExpression = {
         },
         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 });
@@ -3997,7 +3972,7 @@ var stringNormalExpression = {
         },
         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 });
@@ -4005,7 +3980,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4013,7 +3988,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4029,7 +4004,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4037,7 +4012,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4045,6 +4020,30 @@ var stringNormalExpression = {
         },
         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];
@@ -4069,7 +4068,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4080,7 +4079,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4122,7 +4121,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4133,7 +4132,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4151,7 +4150,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4159,7 +4158,7 @@ var stringNormalExpression = {
         },
         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);
@@ -4328,7 +4327,7 @@ var andSpecialExpression = {
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: exports.AstNodeType.SpecialExpression,
-            n: 'and',
+            n: '&&',
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
@@ -4413,6 +4412,37 @@ var condSpecialExpression = {
     },
 };
 
+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); },
@@ -4885,7 +4915,7 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
             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';
@@ -4960,7 +4990,7 @@ var ifLetSpecialExpression = {
         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,
@@ -4997,7 +5027,7 @@ var ifLetSpecialExpression = {
 };
 
 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;
@@ -5207,7 +5237,7 @@ function parseLoopBinding(tokenStream, parseState, _a) {
                 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);
@@ -5407,7 +5437,7 @@ var doseqSpecialExpression = {
 };
 
 var orSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('or'),
+    polishParse: getCommonPolishSpecialExpressionParser('||'),
     validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -5499,25 +5529,6 @@ var throwSpecialExpression = {
     },
 };
 
-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;
@@ -5618,7 +5629,7 @@ var whenFirstSpecialExpression = {
         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,
@@ -5680,7 +5691,7 @@ var whenLetSpecialExpression = {
         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,
@@ -5726,7 +5737,7 @@ var whenLetSpecialExpression = {
 };
 
 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;
@@ -5759,9 +5770,10 @@ var whenNotSpecialExpression = {
 };
 
 var specialExpressions = {
-    'and': andSpecialExpression,
+    '&&': andSpecialExpression,
     'comment': commentSpecialExpression,
     'cond': condSpecialExpression,
+    'switch': switchSpecialExpression,
     'def': defSpecialExpression,
     'defn': defnSpecialExpression,
     'defns': defnsSpecialExpression,
@@ -5771,19 +5783,18 @@ var specialExpressions = {
     '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,
 };
@@ -6340,7 +6351,7 @@ var calculateAndOutcomes = function (_a) {
     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,
@@ -6462,7 +6473,7 @@ var calculateIfNotOutcomes = function (_a) {
     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,
@@ -6575,7 +6586,7 @@ var calculateOrOutcomes = function (_a) {
     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,
@@ -6595,12 +6606,6 @@ var calculateThrowOutcomes = function (_a) {
     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) {
@@ -6674,7 +6679,7 @@ var calculateWhenNotOutcomes = function (_a) {
     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,
@@ -6733,10 +6738,22 @@ var calculateLoopOutcomes = function (_a) {
         .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)); },
@@ -6746,27 +6763,22 @@ var specialExpressionCalculator = {
     '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.
@@ -6841,8 +6853,6 @@ function calculatePossibleAstNodes(contextStack, astNode, newIndentifiers) {
         : 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 })); });
     }
@@ -7069,13 +7079,10 @@ function fromUnaryAlgebraicToAstNode(operator, operand) {
     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));
@@ -7088,68 +7095,36 @@ function fromBinaryOperatorToAstNode(operator, left, right, token) {
         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 '=':
@@ -7170,14 +7145,52 @@ var AlgebraicParser = /** @class */ (function () {
         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);
@@ -7207,6 +7220,7 @@ var AlgebraicParser = /** @class */ (function () {
             else {
                 break;
             }
+            operator = this.peek();
         }
         if (!left) {
             throw new LitsError('Expected operand', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
@@ -7407,9 +7421,6 @@ var AlgebraicParser = /** @class */ (function () {
         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());
@@ -7430,17 +7441,14 @@ var AlgebraicParser = /** @class */ (function () {
                 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,
@@ -7453,13 +7461,11 @@ var AlgebraicParser = /** @class */ (function () {
                     }
                     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':
@@ -7482,8 +7488,32 @@ var AlgebraicParser = /** @class */ (function () {
         }
     };
     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;
@@ -7506,7 +7536,7 @@ var AlgebraicParser = /** @class */ (function () {
                 }
                 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];
@@ -7517,47 +7547,36 @@ var AlgebraicParser = /** @class */ (function () {
                 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 () {
@@ -7642,38 +7661,39 @@ var AlgebraicParser = /** @class */ (function () {
             }),
         };
     };
-    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: [],
@@ -7719,8 +7739,9 @@ var AlgebraicParser = /** @class */ (function () {
             }
             token = this.peek();
         }
-        assertA_OperatorToken(token, ',');
-        this.advance();
+        if (isA_OperatorToken(token, ',')) {
+            this.advance();
+        }
         return {
             b: bindingNode,
             m: modifiers,
@@ -7749,15 +7770,185 @@ var AlgebraicParser = /** @class */ (function () {
         };
         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;
 }());
 
@@ -8038,10 +8229,18 @@ function parsePolishToken(tokenStream, parseState) {
             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 = [];
@@ -8108,13 +8307,22 @@ function removeUnnecessaryTokens(tokenStream) {
 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_$]';
 
@@ -8194,25 +8402,28 @@ var commonTokenizers = [
     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);
@@ -8284,45 +8495,19 @@ var tokenizeA_BasePrefixedNumber = function (input, position) {
     }
     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;
@@ -8333,10 +8518,10 @@ var tokenizeA_Symbol = function (input, position) {
                 }
                 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;
@@ -8351,6 +8536,22 @@ var tokenizeA_Symbol = function (input, position) {
     }
     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);
@@ -8369,30 +8570,30 @@ var tokenizeA_Operator = function (input, position) {
 };
 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;
 };
@@ -8552,31 +8753,20 @@ var tokenizeP_FnShorthand = function (input, position) {
     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] !== ':')
@@ -8589,24 +8779,24 @@ var tokenizeP_StringShorthand = function (input, position) {
     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;
 };
@@ -8643,8 +8833,8 @@ var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_StringShorthand,
     tokenizeP_Number,
     tokenizeP_ReservedSymbol,
-    tokenizeP_Symbol,
     tokenizeP_Modifier,
+    tokenizeP_Symbol,
     tokenizeP_RegexpShorthand,
     tokenizeP_FnShorthand,
     tokenizeP_CollectionAccessor,
@@ -9052,7 +9242,7 @@ var collectionReference = {
         },
         args: {
             coll: {
-                type: ['collection', 'string', 'nil'],
+                type: ['collection', 'string', 'null'],
             },
         },
         variants: [
@@ -9141,7 +9331,7 @@ var collectionReference = {
         },
         args: {
             coll: {
-                type: ['collection', 'nil'],
+                type: ['collection', 'null'],
             },
             key: {
                 type: ['string', 'number'],
@@ -9169,7 +9359,7 @@ var collectionReference = {
         },
         args: {
             coll: {
-                type: ['collection', 'nil'],
+                type: ['collection', 'null'],
             },
             value: {
                 type: ['any'],
@@ -9372,7 +9562,7 @@ var collectionReference = {
         },
         args: {
             coll: {
-                type: ['collection', 'nil'],
+                type: ['collection', 'null'],
             },
         },
         variants: [
@@ -9973,7 +10163,7 @@ var sequenceReference = {
         },
         args: {
             'seq': {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             'n': {
                 type: 'integer',
@@ -10035,7 +10225,7 @@ var sequenceReference = {
         category: 'Sequence',
         linkName: 'pop',
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
             array: true,
         },
         args: {
@@ -10088,7 +10278,7 @@ var sequenceReference = {
         linkName: 'shift',
         clojureDocs: null,
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
             array: true,
         },
         args: {
@@ -10285,11 +10475,11 @@ var sequenceReference = {
         linkName: 'position',
         clojureDocs: null,
         returns: {
-            type: ['number', 'nil'],
+            type: ['number', 'null'],
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             fn: {
                 type: 'function',
@@ -10312,11 +10502,11 @@ var sequenceReference = {
         linkName: 'index_of',
         clojureDocs: null,
         returns: {
-            type: ['number', 'nil'],
+            type: ['number', 'null'],
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             x: {
                 type: 'any',
@@ -10342,7 +10532,7 @@ var sequenceReference = {
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
             fn: {
                 type: 'function',
@@ -10365,11 +10555,11 @@ var sequenceReference = {
         category: 'Sequence',
         linkName: 'reverse',
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
         },
         variants: [
@@ -10392,7 +10582,7 @@ var sequenceReference = {
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
         },
         variants: [
@@ -10414,7 +10604,7 @@ var sequenceReference = {
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
         },
         variants: [
@@ -10437,7 +10627,7 @@ var sequenceReference = {
         },
         args: {
             seq: {
-                type: ['sequence', 'nil'],
+                type: ['sequence', 'null'],
             },
         },
         variants: [
@@ -10457,7 +10647,7 @@ var sequenceReference = {
         category: 'Sequence',
         linkName: 'rest',
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
         },
         args: {
             seq: {
@@ -10510,7 +10700,7 @@ var sequenceReference = {
         category: 'Sequence',
         linkName: 'next',
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
         },
         args: {
             seq: {
@@ -10535,7 +10725,7 @@ var sequenceReference = {
         category: 'Sequence',
         linkName: 'nthnext',
         returns: {
-            type: ['sequence', 'nil'],
+            type: ['sequence', 'null'],
             array: true,
         },
         args: {
@@ -10759,7 +10949,7 @@ var sequenceReference = {
         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: {
@@ -11024,7 +11214,7 @@ var sequenceReference = {
         ],
         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)',
         ],
@@ -11130,10 +11320,11 @@ var mathReference = {
         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',
         },
@@ -11149,7 +11340,7 @@ var mathReference = {
             { 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',
@@ -11246,10 +11437,10 @@ var mathReference = {
         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',
@@ -11266,7 +11457,7 @@ var mathReference = {
             { 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',
@@ -11636,7 +11827,7 @@ var mathReference = {
             { 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',
@@ -11655,7 +11846,7 @@ var mathReference = {
             { 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',
@@ -11909,13 +12100,14 @@ var miscReference = {
             { 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',
         },
@@ -11933,7 +12125,7 @@ var miscReference = {
             { 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: '<',
@@ -12027,10 +12219,11 @@ var miscReference = {
         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',
         },
@@ -12043,7 +12236,7 @@ var miscReference = {
             { 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!',
@@ -12072,25 +12265,10 @@ var miscReference = {
             '(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',
         },
@@ -12104,14 +12282,14 @@ var miscReference = {
         ],
         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',
         },
@@ -12125,8 +12303,8 @@ var miscReference = {
         ],
         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': {
@@ -12182,34 +12360,6 @@ var miscReference = {
             '(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',
@@ -12235,14 +12385,14 @@ var miscReference = {
             '(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',
@@ -12257,13 +12407,13 @@ var miscReference = {
         ],
         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',
@@ -12283,8 +12433,8 @@ var miscReference = {
         ],
         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)',
         ],
     },
 };
@@ -12316,7 +12466,7 @@ var assertReference = { 'assert': {
         linkName: 'assert-equal',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12345,7 +12495,7 @@ var assertReference = { 'assert': {
         linkName: 'assert-exclamation-equal',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12374,7 +12524,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_equal',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12403,7 +12553,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_not_equal',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12432,7 +12582,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_gt',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12461,7 +12611,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_lt',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12490,7 +12640,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_gte',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12519,7 +12669,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_lte',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             a: {
@@ -12548,7 +12698,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_true',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             value: {
@@ -12574,7 +12724,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_false',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             value: {
@@ -12600,7 +12750,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_truthy',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             value: {
@@ -12633,7 +12783,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_falsy',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             value: {
@@ -12665,7 +12815,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_null',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             value: {
@@ -12697,7 +12847,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_throws',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             fn: {
@@ -12719,7 +12869,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_throws_error',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             'fn': {
@@ -12748,7 +12898,7 @@ var assertReference = { 'assert': {
         linkName: 'assert_not_throws',
         clojureDocs: null,
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             fn: {
@@ -12767,7 +12917,7 @@ var assertReference = { 'assert': {
     } };
 
 var objectReference = {
-    'dissoc': {
+    dissoc: {
         title: 'dissoc',
         category: 'Object',
         linkName: 'dissoc',
@@ -12792,7 +12942,7 @@ var objectReference = {
             "\n(def o { :a 5 }) (dissoc o :a)\no",
         ],
     },
-    'object': {
+    object: {
         title: 'object',
         category: 'Object',
         linkName: 'object',
@@ -12818,7 +12968,7 @@ var objectReference = {
             '{:a 1 :b 2}',
         ],
     },
-    'keys': {
+    keys: {
         title: 'keys',
         category: 'Object',
         linkName: 'keys',
@@ -12840,7 +12990,7 @@ var objectReference = {
             '(keys (object :x 10 :y true :z "A string"))',
         ],
     },
-    'vals': {
+    vals: {
         title: 'vals',
         category: 'Object',
         linkName: 'vals',
@@ -12862,7 +13012,7 @@ var objectReference = {
             '(vals (object :x 10 :y true :z "A string"))',
         ],
     },
-    'entries': {
+    entries: {
         title: 'entries',
         category: 'Object',
         linkName: 'entries',
@@ -12884,12 +13034,12 @@ var objectReference = {
             '(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: {
@@ -12908,7 +13058,7 @@ var objectReference = {
             '(find (object :a 1 :b 2) :c)',
         ],
     },
-    'merge': {
+    merge: {
         title: 'merge',
         category: 'Object',
         linkName: 'merge',
@@ -12930,10 +13080,10 @@ var objectReference = {
             '(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',
         },
@@ -12951,12 +13101,12 @@ var objectReference = {
         ],
         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',
@@ -12983,10 +13133,10 @@ var objectReference = {
             '(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',
         },
@@ -13004,8 +13154,8 @@ var objectReference = {
         ],
         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])',
         ],
     },
 };
@@ -13454,7 +13604,7 @@ var predicateReference = {
         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))',
@@ -13565,7 +13715,7 @@ var predicateReference = {
         },
         args: {
             x: {
-                type: ['collection', 'string', 'nil'],
+                type: ['collection', 'string', 'null'],
             },
         },
         variants: [
@@ -13592,7 +13742,7 @@ var predicateReference = {
         },
         args: {
             x: {
-                type: ['collection', 'string', 'nil'],
+                type: ['collection', 'string', 'null'],
             },
         },
         variants: [
@@ -13704,10 +13854,10 @@ var regularExpressionReference = {
 };
 
 var specialExpressionsReference = {
-    'and': {
-        title: 'and',
+    '&&': {
+        title: '&&',
         category: 'Special expression',
-        linkName: 'and',
+        linkName: '-and-and',
         returns: {
             type: 'boolean',
         },
@@ -13720,19 +13870,20 @@ var specialExpressionsReference = {
         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',
         },
@@ -13745,13 +13896,13 @@ var specialExpressionsReference = {
         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': {
@@ -13827,10 +13978,10 @@ var specialExpressionsReference = {
         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',
         },
@@ -13851,14 +14002,14 @@ var specialExpressionsReference = {
         ],
         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',
         },
@@ -13876,13 +14027,13 @@ var specialExpressionsReference = {
         ],
         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',
         },
@@ -13901,11 +14052,11 @@ var specialExpressionsReference = {
         ],
         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': {
@@ -14070,10 +14221,10 @@ var specialExpressionsReference = {
             '(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',
         },
@@ -14094,10 +14245,10 @@ var specialExpressionsReference = {
         ],
         description: 'Either $then-expr or $else-expr branch is taken. $then-expr is selected when $test is falsy. If $test is truthy $else-expr is executed, if no $else-expr exists, `nil` is returned.',
         examples: [
-            '(if-not true (write! "TRUE") (write! "FALSE"))',
-            '(if-not false (write! "TRUE") (write! "FALSE"))',
-            '(if-not true (write! "TRUE"))',
-            '(if-not false (write! "TRUE"))',
+            '(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': {
@@ -14122,6 +14273,31 @@ var specialExpressionsReference = {
             "\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',
@@ -14149,10 +14325,10 @@ var specialExpressionsReference = {
             '(when false)',
         ],
     },
-    'when-not': {
-        title: 'when-not',
+    'when_not': {
+        title: 'when_not',
         category: 'Special expression',
-        linkName: 'when-not',
+        linkName: 'when_not',
         returns: {
             type: 'any',
         },
@@ -14170,10 +14346,10 @@ var specialExpressionsReference = {
         ],
         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': {
@@ -14181,7 +14357,7 @@ var specialExpressionsReference = {
         category: 'Special expression',
         linkName: 'comment',
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             expressions: {
@@ -14222,7 +14398,7 @@ var specialExpressionsReference = {
         category: 'Special expression',
         linkName: 'recur',
         returns: {
-            type: 'nil',
+            type: 'null',
         },
         args: {
             expressions: {
@@ -14235,9 +14411,9 @@ var specialExpressionsReference = {
         ],
         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': {
@@ -14262,35 +14438,16 @@ var specialExpressionsReference = {
         ],
         description: 'Executes $expressions with initial $bindings. The $bindings will be replaced with the recur parameters for subsequent recursions.',
         examples: [
-            "\n(loop [n 3]\n  (write! n)\n  (when\n    (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: {
@@ -14430,10 +14587,10 @@ var stringReference = {
             '(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',
@@ -14451,8 +14608,8 @@ var stringReference = {
         ],
         description: 'Repeates $s $n times.',
         examples: [
-            '(string-repeat "*" 10)',
-            '(string-repeat "***" 0)',
+            '(string_repeat "*" 10)',
+            '(string_repeat "***" 0)',
         ],
     },
     'str': {
@@ -14502,41 +14659,10 @@ var stringReference = {
             '(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',
         },
@@ -14550,14 +14676,14 @@ var stringReference = {
         ],
         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',
@@ -14572,8 +14698,8 @@ var stringReference = {
         ],
         description: 'Returns $s converted to upper case.',
         examples: [
-            '(upper-case "Albert")',
-            '(upper-case "")',
+            '(upper_case "Albert")',
+            '(upper_case "")',
         ],
     },
     'trim': {
@@ -14599,10 +14725,10 @@ var stringReference = {
             '(trim "")',
         ],
     },
-    'trim-left': {
-        title: 'trim-left',
+    'trim_left': {
+        title: 'trim_left',
         category: 'String',
-        linkName: 'trim-left',
+        linkName: 'trim_left',
         clojureDocs: null,
         returns: {
             type: 'string',
@@ -14617,15 +14743,15 @@ var stringReference = {
         ],
         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',
@@ -14640,15 +14766,15 @@ var stringReference = {
         ],
         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',
@@ -14670,16 +14796,16 @@ var stringReference = {
         ],
         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',
@@ -14701,10 +14827,10 @@ var stringReference = {
         ],
         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': {
@@ -14775,10 +14901,10 @@ var stringReference = {
             '(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',
@@ -14793,14 +14919,14 @@ var stringReference = {
         ],
         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',
@@ -14815,14 +14941,14 @@ var stringReference = {
         ],
         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',
@@ -14837,13 +14963,13 @@ var stringReference = {
         ],
         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',
@@ -14858,13 +14984,13 @@ var stringReference = {
         ],
         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',
@@ -14879,13 +15005,13 @@ var stringReference = {
         ],
         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',
@@ -14900,7 +15026,7 @@ var stringReference = {
         ],
         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': {
@@ -14925,15 +15051,42 @@ var stringReference = {
         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',
         },
@@ -14949,11 +15102,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -14969,11 +15123,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -14989,11 +15144,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15006,11 +15162,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15032,13 +15189,14 @@ var bitwiseReference = { 'bit-shift-left': {
         ],
         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',
         },
@@ -15059,11 +15217,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15084,11 +15243,12 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15109,11 +15269,11 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15129,11 +15289,11 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15149,11 +15309,11 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15169,11 +15329,11 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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',
         },
@@ -15189,7 +15349,7 @@ var bitwiseReference = { 'bit-shift-left': {
             { 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 = {
@@ -15517,13 +15677,13 @@ var api = {
         '*',
         '/',
         'mod',
-        'rem',
+        '%',
         'quot',
         'inc',
         'dec',
         'sqrt',
         'cbrt',
-        'pow',
+        '**',
         'exp',
         'round',
         'trunc',
@@ -15573,23 +15733,20 @@ var api = {
     ],
     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',
@@ -15599,9 +15756,9 @@ var api = {
         'entries',
         'find',
         'merge',
-        'merge-with',
+        'merge_with',
         'zipmap',
-        'select-keys',
+        'select_keys',
     ],
     predicate: [
         'boolean?',
@@ -15635,29 +15792,29 @@ var api = {
         '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?',
@@ -15665,40 +15822,40 @@ var api = {
     ],
     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',
@@ -15785,7 +15942,7 @@ var dataTypes = [
     'function',
     'integer',
     'any',
-    'nil',
+    'null',
     'collection',
     'sequence',
     'regexp',