@mojir/lits 2.0.13 → 2.0.15

package/dist/testFramework.esm.js

@@ -236,6 +236,12 @@ function isFunctionType(type) {
     return typeof type === 'number' && functionTypeName.has(type);
 }
 
+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
@@ -254,8 +260,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 = [
@@ -277,7 +287,7 @@ function isLParenToken(token) {
 }
 function assertLParenToken(token) {
     if (!isLParenToken(token)) {
-        throwUnexpectedToken('LParen', token);
+        throwUnexpectedToken('LParen', undefined, token);
     }
 }
 function asLParenToken(token) {
@@ -289,7 +299,7 @@ function isRParenToken(token) {
 }
 function assertRParenToken(token) {
     if (!isRParenToken(token)) {
-        throwUnexpectedToken('RParen', token);
+        throwUnexpectedToken('RParen', undefined, token);
     }
 }
 function isLBracketToken(token) {
@@ -297,7 +307,7 @@ function isLBracketToken(token) {
 }
 function assertLBracketToken(token) {
     if (!isLBracketToken(token)) {
-        throwUnexpectedToken('LBracket', token);
+        throwUnexpectedToken('LBracket', undefined, token);
     }
 }
 function asLBracketToken(token) {
@@ -309,7 +319,7 @@ function isRBracketToken(token) {
 }
 function assertRBracketToken(token) {
     if (!isRBracketToken(token)) {
-        throwUnexpectedToken('RBracket', token);
+        throwUnexpectedToken('RBracket', undefined, token);
     }
 }
 function isLBraceToken(token) {
@@ -317,7 +327,7 @@ function isLBraceToken(token) {
 }
 function assertLBraceToken(token) {
     if (!isLBraceToken(token)) {
-        throwUnexpectedToken('LBrace', token);
+        throwUnexpectedToken('LBrace', undefined, token);
     }
 }
 function asLBraceToken(token) {
@@ -329,7 +339,7 @@ function isRBraceToken(token) {
 }
 function assertRBraceToken(token) {
     if (!isRBraceToken(token)) {
-        throwUnexpectedToken('RBrace', token);
+        throwUnexpectedToken('RBrace', undefined, token);
     }
 }
 function isStringToken(token) {
@@ -337,7 +347,7 @@ function isStringToken(token) {
 }
 function assertStringToken(token) {
     if (!isStringToken(token)) {
-        throwUnexpectedToken('String', token);
+        throwUnexpectedToken('String', undefined, token);
     }
 }
 function asStringToken(token) {
@@ -355,7 +365,7 @@ function isEndNotationToken(token) {
 }
 function assertEndNotationToken(token) {
     if (!isEndNotationToken(token)) {
-        throwUnexpectedToken('EndNotation', token);
+        throwUnexpectedToken('EndNotation', undefined, token);
     }
 }
 
@@ -408,28 +418,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',
@@ -460,7 +470,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) {
@@ -470,8 +480,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';
@@ -490,10 +511,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) {
@@ -506,7 +526,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',
 ];
@@ -529,7 +549,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) {
@@ -541,7 +561,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) {
@@ -559,7 +579,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) {
@@ -574,7 +594,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) {
@@ -586,7 +606,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) {
@@ -601,7 +621,7 @@ function isP_NumberToken(token) {
 }
 function assertP_NumberToken(token) {
     if (!isP_NumberToken(token)) {
-        throwUnexpectedToken('P_Number', token);
+        throwUnexpectedToken('P_Number', undefined, token);
     }
 }
 
@@ -669,12 +689,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 getRangeString(options) {
     var hasUpperAndLowerBound = (typeof options.gt === 'number' || typeof options.gte === 'number')
         && (typeof options.lt === 'number' || typeof options.lte === 'number');
@@ -807,7 +821,7 @@ function isExpressionNode(value) {
 }
 
 var specialExpressionCommentRemovers = {
-    'and': function (node, removeOptions) {
+    '&&': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -819,6 +833,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);
@@ -840,12 +858,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);
     },
@@ -857,7 +875,7 @@ var specialExpressionCommentRemovers = {
         });
     },
     'loop': function (_node, _removeOptions) { },
-    'or': function (node, removeOptions) {
+    '||': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -869,19 +887,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];
@@ -923,6 +937,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({
@@ -967,7 +988,7 @@ function assertCount(_a) {
 }
 
 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 });
@@ -976,7 +997,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 });
@@ -985,7 +1006,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 });
@@ -994,7 +1015,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 });
@@ -1002,7 +1023,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 });
@@ -1013,7 +1034,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 });
@@ -1024,7 +1045,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 });
@@ -1035,7 +1056,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 });
@@ -1046,7 +1067,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 });
@@ -1056,7 +1077,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 });
@@ -1066,7 +1087,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 });
@@ -1076,7 +1097,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 });
@@ -2777,7 +2798,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);
@@ -2803,7 +2824,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);
@@ -3080,10 +3101,6 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.13";
-
-var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-var xyRegexp = /[xy]/g;
 var miscNormalExpression = {
     '!=': {
         evaluate: function (params) {
@@ -3097,7 +3114,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);
@@ -3222,20 +3239,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);
@@ -3243,7 +3254,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);
@@ -3276,23 +3287,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);
@@ -3301,7 +3296,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);
@@ -3514,7 +3509,7 @@ var assertNormalExpression = {
 };
 
 var objectNormalExpression = {
-    'object': {
+    object: {
         evaluate: function (params, sourceCodeInfo) {
             var result = {};
             for (var i = 0; i < params.length; i += 2) {
@@ -3527,7 +3522,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);
@@ -3535,7 +3530,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);
@@ -3543,7 +3538,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);
@@ -3551,7 +3546,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);
@@ -3562,7 +3557,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);
@@ -3573,7 +3568,7 @@ var objectNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'merge': {
+    merge: {
         evaluate: function (params, sourceCodeInfo) {
             if (params.length === 0)
                 return null;
@@ -3586,7 +3581,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];
@@ -3609,7 +3604,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);
@@ -3624,7 +3619,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);
@@ -3890,7 +3885,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);
@@ -3924,27 +3919,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 });
@@ -3958,7 +3933,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 });
@@ -3966,7 +3941,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);
@@ -3974,7 +3949,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);
@@ -3990,7 +3965,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);
@@ -3998,7 +3973,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);
@@ -4006,6 +3981,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];
@@ -4030,7 +4029,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);
@@ -4041,7 +4040,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);
@@ -4083,7 +4082,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);
@@ -4094,7 +4093,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);
@@ -4112,7 +4111,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);
@@ -4120,7 +4119,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);
@@ -4289,7 +4288,7 @@ var andSpecialExpression = {
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: AstNodeType.SpecialExpression,
-            n: 'and',
+            n: '&&',
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
@@ -4374,6 +4373,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); },
@@ -4845,7 +4875,7 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
             tkn = asToken(tokenStream.tokens[parseState.position]);
             if (node.t === 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';
@@ -4920,7 +4950,7 @@ var ifLetSpecialExpression = {
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: 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,
@@ -4957,7 +4987,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;
@@ -5167,7 +5197,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);
@@ -5367,7 +5397,7 @@ var doseqSpecialExpression = {
 };
 
 var orSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('or'),
+    polishParse: getCommonPolishSpecialExpressionParser('||'),
     validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -5459,25 +5489,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;
@@ -5578,7 +5589,7 @@ var whenFirstSpecialExpression = {
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: 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,
@@ -5640,7 +5651,7 @@ var whenLetSpecialExpression = {
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: 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,
@@ -5686,7 +5697,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;
@@ -5719,9 +5730,10 @@ var whenNotSpecialExpression = {
 };
 
 var specialExpressions = {
-    'and': andSpecialExpression,
+    '&&': andSpecialExpression,
     'comment': commentSpecialExpression,
     'cond': condSpecialExpression,
+    'switch': switchSpecialExpression,
     'def': defSpecialExpression,
     'defn': defnSpecialExpression,
     'defns': defnsSpecialExpression,
@@ -5731,19 +5743,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,
 };
@@ -6300,7 +6311,7 @@ var calculateAndOutcomes = function (_a) {
     var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
     return combinateAstNodes(astNode.p)
         .map(function (p) { return ({
-        n: 'and',
+        n: '&&',
         t: AstNodeType.SpecialExpression,
         p: p,
         token: astNode.token,
@@ -6422,7 +6433,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,
@@ -6535,7 +6546,7 @@ var calculateOrOutcomes = function (_a) {
     var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
     return combinateAstNodes(astNode.p)
         .map(function (p) { return ({
-        n: 'or',
+        n: '||',
         t: AstNodeType.SpecialExpression,
         p: p,
         token: astNode.token,
@@ -6555,12 +6566,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) {
@@ -6634,7 +6639,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,
@@ -6693,10 +6698,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)); },
@@ -6706,27 +6723,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.
@@ -6801,8 +6813,6 @@ function calculatePossibleAstNodes(contextStack, astNode, newIndentifiers) {
         : undefined;
     var newContextStack = newContext ? contextStack.create(newContext) : contextStack;
     if (astNode.t === 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 })); });
     }
@@ -7029,13 +7039,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));
@@ -7048,68 +7055,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: AstNodeType.SpecialExpression,
-                n: 'and',
-                p: [left, right],
-                token: getTokenDebugData(token) && token,
-            };
         case '||':
-            return {
-                t: AstNodeType.SpecialExpression,
-                n: 'or',
-                p: [left, right],
-                token: getTokenDebugData(token) && token,
-            };
         case '??':
             return {
                 t: AstNodeType.SpecialExpression,
-                n: '??',
+                n: operatorName,
                 p: [left, right],
                 token: getTokenDebugData(token) && token,
             };
         /* v8 ignore next 8 */
+        case ';':
         case '!':
         case '~':
         case '=':
@@ -7130,14 +7105,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);
@@ -7167,6 +7180,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);
@@ -7367,9 +7381,6 @@ var AlgebraicParser = /** @class */ (function () {
         var _a, _b;
         var isNamedFunction = symbol.t === 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());
@@ -7390,17 +7401,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: AstNodeType.SpecialExpression,
@@ -7413,13 +7421,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':
@@ -7442,8 +7448,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: 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;
@@ -7466,7 +7496,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];
@@ -7477,47 +7507,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;
-        }
-        this.advance();
-        if (!isA_OperatorToken(this.peek(), '=>')) {
-            return null;
+            throw new LitsError('Expected closing parenthesis', (_e = getTokenDebugData(this.peek())) === null || _e === void 0 ? void 0 : _e.sourceCodeInfo);
         }
-        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: AstNodeType.Binding,
+                    n: key.v,
+                    v: value,
+                    p: [],
+                    token: getTokenDebugData(key.token) && key.token,
+                };
+            }),
+        };
+        this.advance();
         return {
-            t: 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: 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 () {
@@ -7602,38 +7621,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: 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: [],
@@ -7679,8 +7699,9 @@ var AlgebraicParser = /** @class */ (function () {
             }
             token = this.peek();
         }
-        assertA_OperatorToken(token, ',');
-        this.advance();
+        if (isA_OperatorToken(token, ',')) {
+            this.advance();
+        }
         return {
             b: bindingNode,
             m: modifiers,
@@ -7709,15 +7730,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: 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: 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: 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: 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: 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: 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: 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: 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: 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;
 }());
 
@@ -7998,10 +8189,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: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: nodes,
+                token: nodes[0].token,
+            };
         }
         case 'PolNotation': {
             var astNodes = [];
@@ -8068,12 +8267,21 @@ 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: AstNodeType.SpecialExpression,
+            n: 'do',
+            p: nodes,
+            token: nodes[0].token,
+        };
     }
     return parsePolishToken(tokenStream, parseState);
 }
 
-var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:-]';
+var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:&\|~-]';
 var algebraicIdentifierCharacterClass = '[\\w$:!?]';
 var algebraicIdentifierFirstCharacterClass = '[a-zA-Z_$]';
 
@@ -8153,25 +8361,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);
@@ -8243,45 +8454,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;
@@ -8292,10 +8477,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;
@@ -8310,6 +8495,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);
@@ -8328,30 +8529,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;
 };
@@ -8511,31 +8712,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] !== ':')
@@ -8548,24 +8738,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;
 };
@@ -8602,8 +8792,8 @@ var polishTokenizers = __spreadArray(__spreadArray([
     tokenizeP_StringShorthand,
     tokenizeP_Number,
     tokenizeP_ReservedSymbol,
-    tokenizeP_Symbol,
     tokenizeP_Modifier,
+    tokenizeP_Symbol,
     tokenizeP_RegexpShorthand,
     tokenizeP_FnShorthand,
     tokenizeP_CollectionAccessor,