@mojir/lits 2.0.11 → 2.0.13

package/dist/testFramework.js

@@ -370,19 +370,17 @@ var algebraicOnlyValueTokenTypes = [
     'A_SingleLineComment',
     'A_MultiLineComment',
     'A_Number',
+    'A_BasePrefixedNumber',
 ];
 var algebraicValueTokenTypes = __spreadArray(__spreadArray([], __read(commomValueTokenTypes), false), __read(algebraicOnlyValueTokenTypes), false);
 __spreadArray(__spreadArray([], __read(algebraicSimpleTokenTypes), false), __read(algebraicValueTokenTypes), false);
-var AlgebraicOperators = [
-    // Unary only operators
+var symbolicUnaryOperators = [
     '!', // logical NOT
     '~', // bitwise NOT
-    '=', // property assignemnt operator
-    ',', // element delimiter
-    // Only used in lamda function parser
-    '=>',
-    '...',
-    '.', // property accessor
+    '+', // addition
+    '-', // subtraction
+];
+var symbolicBinaryOperators = [
     '**', // exponentiation
     '*', // multiplication
     '/', // division
@@ -406,12 +404,74 @@ var AlgebraicOperators = [
     '||', // logical OR
     '??', // nullish coalescing
 ];
-function isAlgebraicOperator(operator) {
-    return AlgebraicOperators.includes(operator);
+var otherSymbolicOperators = [
+    '=>', // lambda
+    '...', // rest
+    '.', // property accessor
+    ',', // item separator
+    '=', // property assignment
+];
+var symbolicOperators = __spreadArray(__spreadArray(__spreadArray([], __read(symbolicUnaryOperators), false), __read(symbolicBinaryOperators), false), __read(otherSymbolicOperators), false);
+var nonFunctionOperators = [
+    '??',
+    'and',
+    'comment',
+    'cond',
+    'declared?',
+    'if',
+    'if-not',
+    'or',
+    'when',
+    'when-not',
+    'do',
+    'time!',
+    'throw',
+    'let',
+    'def',
+    'defs',
+    'if-let',
+    'when-let',
+    'when-first',
+    'fn',
+    'defn',
+    'defns',
+    'try',
+    'recur',
+    'loop',
+    'doseq',
+    'while',
+];
+var nonFunctionOperatorSet = new Set(nonFunctionOperators);
+function isFunctionOperator(operator) {
+    return !nonFunctionOperatorSet.has(operator);
+}
+var symbolicUnaryOperatorSet = new Set(symbolicUnaryOperators);
+function isSymbolicUnaryOperator(operator) {
+    return symbolicUnaryOperatorSet.has(operator);
+}
+var symbolicBinaryOperatorSet = new Set(symbolicBinaryOperators);
+function isSymbolicBinaryOperator(operator) {
+    return symbolicBinaryOperatorSet.has(operator);
+}
+var symbolicOperatorSet = new Set(symbolicOperators);
+function isSymbolicOperator(operator) {
+    return symbolicOperatorSet.has(operator);
 }
 function isA_SymbolToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'A_Symbol';
 }
+function assertA_SymbolToken(token) {
+    if (!isA_SymbolToken(token)) {
+        throwUnexpectedToken('A_Symbol', token);
+    }
+}
+function asA_SymbolToken(token) {
+    assertA_SymbolToken(token);
+    return 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';
 }
@@ -432,9 +492,10 @@ function isA_OperatorToken(token, operatorName) {
 }
 function assertA_OperatorToken(token, operatorName) {
     if (!isA_OperatorToken(token, operatorName)) {
-        {
+        if (operatorName) {
             throw new LitsError("Unexpected token: ".concat(token, ", expected operator ").concat(operatorName), undefined);
         }
+        throwUnexpectedToken('A_Operator', token);
     }
 }
 function isA_WhitespaceToken(token) {
@@ -443,6 +504,9 @@ function isA_WhitespaceToken(token) {
 function isA_NumberToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'A_Number';
 }
+function isA_BasePrefixedNumberToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_BasePrefixedNumber';
+}
 
 var modifierNames = ['&', '&let', '&when', '&while'];
 var polishOnlySimpleTokenTypes = [
@@ -1408,7 +1472,7 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'get-in': {
+    'get_in': {
         evaluate: function (params, sourceCodeInfo) {
             var e_1, _a;
             var _b;
@@ -1482,13 +1546,20 @@ var collectionNormalExpression = {
             assertColl(coll, sourceCodeInfo);
             if (Array.isArray(coll))
                 return coll.includes(value);
-            if (typeof coll === 'string')
-                return typeof value === 'string' ? coll.split('').includes(value) : false;
+            if (typeof coll === 'string') {
+                if (typeof value === 'string') {
+                    return coll.includes(value);
+                }
+                else if (typeof value === 'number') {
+                    return coll.includes("".concat(value));
+                }
+                return false;
+            }
             return Object.values(coll).includes(value);
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'has-some?': {
+    'has_some?': {
         evaluate: function (_a, sourceCodeInfo) {
             var e_2, _b, e_3, _c, e_4, _d;
             var _e = __read(_a, 2), coll = _e[0], seq = _e[1];
@@ -1548,7 +1619,7 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'has-every?': {
+    'has_every?': {
         evaluate: function (_a, sourceCodeInfo) {
             var e_5, _b, e_6, _c, e_7, _d;
             var _e = __read(_a, 2), coll = _e[0], seq = _e[1];
@@ -1620,7 +1691,7 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(3, node); },
     },
-    'assoc-in': {
+    'assoc_in': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), originalColl = _b[0], keys = _b[1], value = _b[2];
             assertColl(originalColl, sourceCodeInfo);
@@ -1656,7 +1727,7 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 3 }, node); },
     },
-    'update-in': {
+    'update_in': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a), originalColl = _c[0], keys = _c[1], fn = _c[2], params = _c.slice(3);
             var executeFunction = _b.executeFunction;
@@ -1706,7 +1777,7 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     },
-    'not-empty': {
+    'not_empty': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), coll = _b[0];
             if (coll === null)
@@ -1722,10 +1793,10 @@ var collectionNormalExpression = {
     },
     'every?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], coll = _c[1];
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
-            assertLitsFunction(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
+            assertLitsFunction(fn, sourceCodeInfo);
             if (Array.isArray(coll))
                 return coll.every(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             if (typeof coll === 'string')
@@ -1736,7 +1807,7 @@ var collectionNormalExpression = {
     },
     'any?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], coll = _c[1];
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
@@ -1748,9 +1819,9 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'not-any?': {
+    'not_any?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], coll = _c[1];
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
@@ -1762,9 +1833,9 @@ var collectionNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'not-every?': {
+    'not_every?': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], coll = _c[1];
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
@@ -1778,77 +1849,82 @@ var collectionNormalExpression = {
     },
 };
 
-var evaluateMap = function (params, sourceCodeInfo, contextStack, _a) {
-    var executeFunction = _a.executeFunction;
-    var _b = __read(params, 2), fn = _b[0], firstList = _b[1];
-    assertLitsFunction(fn, sourceCodeInfo);
-    assertSeq(firstList, sourceCodeInfo);
-    var isStringSeq = typeof firstList === 'string';
-    var length = firstList.length;
-    if (params.length === 2) {
-        if (Array.isArray(firstList)) {
-            return firstList.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
-        }
-        else {
-            return firstList
-                .split('')
-                .map(function (elem) {
-                var newVal = executeFunction(fn, [elem], contextStack, sourceCodeInfo);
-                assertString(newVal, sourceCodeInfo, { char: true });
-                return newVal;
-            })
-                .join('');
-        }
-    }
-    else {
-        params.slice(2).forEach(function (collParam) {
-            if (isStringSeq)
-                assertString(collParam, sourceCodeInfo);
-            else
-                assertArray(collParam, sourceCodeInfo);
-            if (length !== collParam.length)
-                throw new LitsError('All arguments to "map" must have the same length.', sourceCodeInfo);
-        });
-        if (isStringSeq) {
-            var result = '';
-            var _loop_1 = function (i) {
-                var fnParams = params.slice(1).map(function (l) { return l[i]; });
-                var newValue = executeFunction(fn, fnParams, contextStack, sourceCodeInfo);
-                assertString(newValue, sourceCodeInfo, { char: true });
-                result += newValue;
-            };
-            for (var i = 0; i < length; i += 1) {
-                _loop_1(i);
+var arrayNormalExpression = {
+    array: {
+        evaluate: function (params) { return params; },
+    },
+    range: {
+        evaluate: function (params, sourceCodeInfo) {
+            var _a = __read(params, 3), first = _a[0], second = _a[1], third = _a[2];
+            var from;
+            var to;
+            var step;
+            assertNumber(first, sourceCodeInfo, { finite: true });
+            if (params.length === 1) {
+                from = 0;
+                to = first;
+                step = to >= 0 ? 1 : -1;
             }
-            return result;
-        }
-        else {
-            var result = [];
-            var _loop_2 = function (i) {
-                var fnParams = params.slice(1).map(function (l) { return toAny(l[i]); });
-                result.push(executeFunction(fn, fnParams, contextStack, sourceCodeInfo));
-            };
-            for (var i = 0; i < length; i += 1) {
-                _loop_2(i);
+            else if (params.length === 2) {
+                assertNumber(second, sourceCodeInfo, { finite: true });
+                from = first;
+                to = second;
+                step = to >= from ? 1 : -1;
+            }
+            else {
+                assertNumber(second, sourceCodeInfo, { finite: true });
+                assertNumber(third, sourceCodeInfo, { finite: true });
+                from = first;
+                to = second;
+                step = third;
+                if (to > from)
+                    assertNumber(step, sourceCodeInfo, { positive: true });
+                else if (to < from)
+                    assertNumber(step, sourceCodeInfo, { negative: true });
+                else
+                    assertNumber(step, sourceCodeInfo, { nonZero: true });
             }
+            var result = [];
+            for (var i = from; step < 0 ? i > to : i < to; i += step)
+                result.push(i);
             return result;
-        }
-    }
-};
-var sequenceNormalExpression = {
-    'cons': {
+        },
+        validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
+    },
+    repeat: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), elem = _b[0], seq = _b[1];
-            assertAny(elem, sourceCodeInfo);
-            assertSeq(seq, sourceCodeInfo);
-            if (Array.isArray(seq))
-                return __spreadArray([elem], __read(seq), false);
-            assertString(elem, sourceCodeInfo, { char: true });
-            return "".concat(elem).concat(seq);
+            var _b = __read(_a, 2), value = _b[0], count = _b[1];
+            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
+            var result = [];
+            for (var i = 0; i < count; i += 1)
+                result.push(value);
+            return result;
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
+    },
+    flatten: {
+        evaluate: function (_a) {
+            var _b = __read(_a, 1), seq = _b[0];
+            if (!Array.isArray(seq))
+                return [];
+            return seq.flat(Number.POSITIVE_INFINITY);
+        },
+        validate: function (node) { return assertNumberOfParams(1, node); },
+    },
+    mapcat: {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), arr = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertArray(arr, sourceCodeInfo);
+            assertLitsFunction(fn, sourceCodeInfo);
+            return arr.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); }).flat(1);
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'nth': {
+};
+
+var sequenceNormalExpression = {
+    nth: {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 2), seq = _a[0], i = _a[1];
             var defaultValue = toAny(params[2]);
@@ -1860,12 +1936,12 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'filter': {
+    filter: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
-            assertLitsFunction(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
+            assertLitsFunction(fn, sourceCodeInfo);
             if (Array.isArray(seq))
                 return seq.filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
             return seq
@@ -1875,7 +1951,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'first': {
+    first: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
             if (array === null)
@@ -1885,7 +1961,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'last': {
+    last: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
             if (array === null)
@@ -1895,25 +1971,42 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'map': {
-        evaluate: evaluateMap,
-        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
+    map: {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertSeq(seq, sourceCodeInfo);
+            assertLitsFunction(fn, sourceCodeInfo);
+            if (Array.isArray(seq)) {
+                return seq.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
+            }
+            else {
+                return seq
+                    .split('')
+                    .map(function (elem) {
+                    var newVal = executeFunction(fn, [elem], contextStack, sourceCodeInfo);
+                    assertString(newVal, sourceCodeInfo, { char: true });
+                    return newVal;
+                })
+                    .join('');
+            }
+        },
+        validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'pop': {
+    pop: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
-            if (typeof seq === 'string')
+            if (typeof seq === 'string') {
                 return seq.substring(0, seq.length - 1);
-            var copy = __spreadArray([], __read(seq), false);
-            copy.pop();
-            return copy;
+            }
+            return seq.slice(0, seq.length - 1);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'position': {
+    position: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             if (seq === null)
@@ -1930,7 +2023,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'index-of': {
+    index_of: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], value = _b[1];
             assertAny(value, sourceCodeInfo);
@@ -1949,7 +2042,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'push': {
+    push: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a), seq = _b[0], values = _b.slice(1);
             assertSeq(seq, sourceCodeInfo);
@@ -1963,20 +2056,19 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
-    'reductions': {
+    reductions: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
-            var fn = params[0];
+            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
+            assertSeq(seq, sourceCodeInfo);
             assertLitsFunction(fn, sourceCodeInfo);
             if (params.length === 2) {
-                var _b = __read(params, 2), arr = _b[1];
-                assertSeq(arr, sourceCodeInfo);
-                if (arr.length === 0)
+                if (seq.length === 0)
                     return [executeFunction(fn, [], contextStack, sourceCodeInfo)];
-                else if (arr.length === 1)
-                    return [toAny(arr[0])];
-                if (typeof arr === 'string') {
-                    var chars = arr.split('');
+                else if (seq.length === 1)
+                    return [toAny(seq[0])];
+                if (typeof seq === 'string') {
+                    var chars = seq.split('');
                     var resultArray_1 = [asAny(chars[0], sourceCodeInfo)];
                     chars.slice(1).reduce(function (result, elem) {
                         var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
@@ -1986,19 +2078,18 @@ var sequenceNormalExpression = {
                     return resultArray_1;
                 }
                 else {
-                    var resultArray_2 = [toAny(arr[0])];
-                    arr.slice(1).reduce(function (result, elem) {
+                    var resultArray_2 = [toAny(seq[0])];
+                    seq.slice(1).reduce(function (result, elem) {
                         var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
                         resultArray_2.push(newVal);
                         return newVal;
-                    }, toAny(arr[0]));
+                    }, toAny(seq[0]));
                     return resultArray_2;
                 }
             }
             else {
-                var _c = __read(params, 3), val = _c[1], seq = _c[2];
+                var val = params[2];
                 assertAny(val, sourceCodeInfo);
-                assertSeq(seq, sourceCodeInfo);
                 if (typeof seq === 'string') {
                     assertString(val, sourceCodeInfo);
                     if (seq.length === 0)
@@ -2026,35 +2117,33 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'reduce': {
+    reduce: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
-            var fn = params[0];
+            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
+            assertSeq(seq, sourceCodeInfo);
             assertLitsFunction(fn, sourceCodeInfo);
             if (params.length === 2) {
-                var _b = __read(params, 2), arr = _b[1];
-                assertSeq(arr, sourceCodeInfo);
-                if (arr.length === 0)
+                if (seq.length === 0)
                     return executeFunction(fn, [], contextStack, sourceCodeInfo);
-                else if (arr.length === 1)
-                    return toAny(arr[0]);
-                if (typeof arr === 'string') {
-                    var chars = arr.split('');
+                else if (seq.length === 1)
+                    return toAny(seq[0]);
+                if (typeof seq === 'string') {
+                    var chars = seq.split('');
                     return chars.slice(1).reduce(function (result, elem) {
                         var val = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
                         return val;
                     }, asAny(chars[0], sourceCodeInfo));
                 }
                 else {
-                    return arr.slice(1).reduce(function (result, elem) {
+                    return seq.slice(1).reduce(function (result, elem) {
                         return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, toAny(arr[0]));
+                    }, toAny(seq[0]));
                 }
             }
             else {
-                var _c = __read(params, 3), val = _c[1], seq = _c[2];
+                var val = params[2];
                 assertAny(val, sourceCodeInfo);
-                assertSeq(seq, sourceCodeInfo);
                 if (typeof seq === 'string') {
                     assertString(val, sourceCodeInfo);
                     if (seq.length === 0)
@@ -2075,14 +2164,13 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'reduce-right': {
+    reduce_right: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
-            var fn = params[0];
+            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
+            assertSeq(seq, sourceCodeInfo);
             assertLitsFunction(fn, sourceCodeInfo);
             if (params.length === 2) {
-                var _b = __read(params, 2), seq = _b[1];
-                assertSeq(seq, sourceCodeInfo);
                 if (seq.length === 0)
                     return executeFunction(fn, [], contextStack, sourceCodeInfo);
                 else if (seq.length === 1)
@@ -2102,7 +2190,7 @@ var sequenceNormalExpression = {
                 }
             }
             else {
-                var _c = __read(params, 3), val = _c[1], seq = _c[2];
+                var val = params[2];
                 assertAny(val, sourceCodeInfo);
                 assertSeq(seq, sourceCodeInfo);
                 if (typeof seq === 'string') {
@@ -2124,20 +2212,20 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'rest': {
+    rest: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertSeq(first, sourceCodeInfo);
-            if (Array.isArray(first)) {
-                if (first.length <= 1)
+            var _b = __read(_a, 1), seq = _b[0];
+            assertSeq(seq, sourceCodeInfo);
+            if (Array.isArray(seq)) {
+                if (seq.length <= 1)
                     return [];
-                return first.slice(1);
+                return seq.slice(1);
             }
-            return first.substring(1);
+            return seq.substring(1);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'nthrest': {
+    nthrest: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], count = _b[1];
             assertSeq(seq, sourceCodeInfo);
@@ -2149,22 +2237,22 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'next': {
+    next: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertSeq(first, sourceCodeInfo);
-            if (Array.isArray(first)) {
-                if (first.length <= 1)
+            var _b = __read(_a, 1), seq = _b[0];
+            assertSeq(seq, sourceCodeInfo);
+            if (Array.isArray(seq)) {
+                if (seq.length <= 1)
                     return null;
-                return first.slice(1);
+                return seq.slice(1);
             }
-            if (first.length <= 1)
+            if (seq.length <= 1)
                 return null;
-            return first.substring(1);
+            return seq.substring(1);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'nthnext': {
+    nthnext: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], count = _b[1];
             assertSeq(seq, sourceCodeInfo);
@@ -2178,7 +2266,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'reverse': {
+    reverse: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             if (seq === null)
@@ -2190,17 +2278,17 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'second': {
+    second: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), array = _b[0];
-            if (array === null)
+            var _b = __read(_a, 1), seq = _b[0];
+            if (seq === null)
                 return null;
-            assertSeq(array, sourceCodeInfo);
-            return toAny(array[1]);
+            assertSeq(seq, sourceCodeInfo);
+            return toAny(seq[1]);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'shift': {
+    shift: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2212,7 +2300,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'slice': {
+    slice: {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 3), seq = _a[0], from = _a[1], to = _a[2];
             assertSeq(seq, sourceCodeInfo);
@@ -2226,10 +2314,10 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
     },
-    'some': {
+    some: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c;
-            var _d = __read(_a, 2), fn = _d[0], seq = _d[1];
+            var _d = __read(_a, 2), seq = _d[0], fn = _d[1];
             var executeFunction = _b.executeFunction;
             assertLitsFunction(fn, sourceCodeInfo);
             if (seq === null)
@@ -2243,12 +2331,12 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'sort': {
+    sort: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
+            var _b = __read(params, 1), seq = _b[0];
             var defaultComparer = params.length === 1;
-            var seq = defaultComparer ? params[0] : params[1];
-            var comparer = defaultComparer ? null : params[0];
+            var comparer = defaultComparer ? null : params[1];
             assertSeq(seq, sourceCodeInfo);
             if (typeof seq === 'string') {
                 var result_1 = seq.split('');
@@ -2281,13 +2369,14 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'sort-by': {
+    sort_by: {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
+            var _b = __read(params, 2), seq = _b[0], keyfn = _b[1];
             var defaultComparer = params.length === 2;
-            var keyfn = asAny(params[0], sourceCodeInfo);
-            var comparer = defaultComparer ? null : params[1];
-            var seq = asSeq(defaultComparer ? params[1] : params[2], sourceCodeInfo);
+            assertSeq(seq, sourceCodeInfo);
+            assertAny(keyfn, sourceCodeInfo);
+            var comparer = defaultComparer ? null : params[2];
             if (typeof seq === 'string') {
                 var result_2 = seq.split('');
                 if (defaultComparer) {
@@ -2331,9 +2420,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'take': {
+    take: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), n = _b[0], input = _b[1];
+            var _b = __read(_a, 2), input = _b[0], n = _b[1];
             assertNumber(n, sourceCodeInfo);
             assertSeq(input, sourceCodeInfo);
             var num = Math.max(Math.ceil(n), 0);
@@ -2341,9 +2430,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'take-last': {
+    take_last: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), n = _b[0], array = _b[1];
+            var _b = __read(_a, 2), array = _b[0], n = _b[1];
             assertSeq(array, sourceCodeInfo);
             assertNumber(n, sourceCodeInfo);
             var num = Math.max(Math.ceil(n), 0);
@@ -2352,10 +2441,10 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'take-while': {
+    take_while: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var e_1, _c;
-            var _d = __read(_a, 2), fn = _d[0], seq = _d[1];
+            var _d = __read(_a, 2), seq = _d[0], fn = _d[1];
             var executeFunction = _b.executeFunction;
             assertSeq(seq, sourceCodeInfo);
             assertLitsFunction(fn, sourceCodeInfo);
@@ -2380,9 +2469,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'drop': {
+    drop: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), n = _b[0], input = _b[1];
+            var _b = __read(_a, 2), input = _b[0], n = _b[1];
             assertNumber(n, sourceCodeInfo);
             var num = Math.max(Math.ceil(n), 0);
             assertSeq(input, sourceCodeInfo);
@@ -2390,9 +2479,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'drop-last': {
+    drop_last: {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), n = _b[0], array = _b[1];
+            var _b = __read(_a, 2), array = _b[0], n = _b[1];
             assertSeq(array, sourceCodeInfo);
             assertNumber(n, sourceCodeInfo);
             var num = Math.max(Math.ceil(n), 0);
@@ -2401,9 +2490,9 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'drop-while': {
+    drop_while: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
+            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
             assertSeq(seq, sourceCodeInfo);
             assertLitsFunction(fn, sourceCodeInfo);
@@ -2417,7 +2506,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'unshift': {
+    unshift: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a), seq = _b[0], values = _b.slice(1);
             assertSeq(seq, sourceCodeInfo);
@@ -2431,59 +2520,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
-    'random-sample!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), prob = _b[0], seq = _b[1];
-            assertNumber(prob, sourceCodeInfo, { finite: true });
-            assertSeq(seq, sourceCodeInfo);
-            if (typeof seq === 'string') {
-                return seq
-                    .split('')
-                    .filter(function () { return Math.random() < prob; })
-                    .join('');
-            }
-            else {
-                return seq.filter(function () { return Math.random() < prob; });
-            }
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    'rand-nth!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), seq = _b[0];
-            assertSeq(seq, sourceCodeInfo);
-            if (seq.length === 0)
-                return null;
-            var index = Math.floor(Math.random() * seq.length);
-            if (typeof seq === 'string')
-                return toAny(seq.split('')[index]);
-            return toAny(seq[index]);
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    'shuffle!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), input = _b[0];
-            assertSeq(input, sourceCodeInfo);
-            var array = typeof input === 'string' ? __spreadArray([], __read(input.split('')), false) : __spreadArray([], __read(input), false);
-            var remainingLength = array.length;
-            var arrayElement;
-            var pickedIndex;
-            // Fisher–Yates Shuffle
-            while (remainingLength) {
-                remainingLength -= 1;
-                // Pick a remaining element
-                pickedIndex = Math.floor(Math.random() * remainingLength);
-                // And swap it with the current element.
-                arrayElement = toAny(array[remainingLength]);
-                array[remainingLength] = toAny(array[pickedIndex]);
-                array[pickedIndex] = arrayElement;
-            }
-            return typeof input === 'string' ? array.join('') : array;
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    'distinct': {
+    distinct: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), input = _b[0];
             assertSeq(input, sourceCodeInfo);
@@ -2493,7 +2530,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'remove': {
+    remove: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), fn = _c[0], input = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2508,7 +2545,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'remove-at': {
+    remove_at: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), index = _b[0], input = _b[1];
             assertNumber(index, sourceCodeInfo);
@@ -2525,7 +2562,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'split-at': {
+    split_at: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), pos = _b[0], seq = _b[1];
             assertNumber(pos, sourceCodeInfo, { finite: true });
@@ -2535,7 +2572,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'split-with': {
+    split_with: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2550,7 +2587,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'frequencies': {
+    frequencies: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
             assertSeq(seq, sourceCodeInfo);
@@ -2566,7 +2603,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'group-by': {
+    group_by: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2584,7 +2621,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(2, node); },
     },
-    'partition': {
+    partition: {
         evaluate: function (params, sourceCodeInfo) {
             var len = params.length;
             var n = toNonNegativeInteger(asNumber(params[0], sourceCodeInfo));
@@ -2599,7 +2636,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 4 }, node); },
     },
-    'partition-all': {
+    partition_all: {
         evaluate: function (params, sourceCodeInfo) {
             var len = params.length;
             var n = toNonNegativeInteger(asNumber(params[0], sourceCodeInfo));
@@ -2609,7 +2646,7 @@ var sequenceNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'partition-by': {
+    partition_by: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), fn = _c[0], seq = _c[1];
             var executeFunction = _b.executeFunction;
@@ -2659,94 +2696,22 @@ function partition(n, step, seq, pad, sourceCodeInfo) {
     return isStringSeq ? result.map(function (x) { return x.join(''); }) : result;
 }
 
-var arrayNormalExpression = {
-    array: {
-        evaluate: function (params) { return params; },
-    },
-    range: {
-        evaluate: function (params, sourceCodeInfo) {
-            var _a = __read(params, 3), first = _a[0], second = _a[1], third = _a[2];
-            var from;
-            var to;
-            var step;
-            assertNumber(first, sourceCodeInfo, { finite: true });
-            if (params.length === 1) {
-                from = 0;
-                to = first;
-                step = to >= 0 ? 1 : -1;
-            }
-            else if (params.length === 2) {
-                assertNumber(second, sourceCodeInfo, { finite: true });
-                from = first;
-                to = second;
-                step = to >= from ? 1 : -1;
-            }
-            else {
-                assertNumber(second, sourceCodeInfo, { finite: true });
-                assertNumber(third, sourceCodeInfo, { finite: true });
-                from = first;
-                to = second;
-                step = third;
-                if (to > from)
-                    assertNumber(step, sourceCodeInfo, { positive: true });
-                else if (to < from)
-                    assertNumber(step, sourceCodeInfo, { negative: true });
-                else
-                    assertNumber(step, sourceCodeInfo, { nonZero: true });
-            }
-            var result = [];
-            for (var i = from; step < 0 ? i > to : i < to; i += step)
-                result.push(i);
-            return result;
+var mathNormalExpression = {
+    'inc': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), first = _b[0];
+            assertNumber(first, sourceCodeInfo);
+            return first + 1;
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1, max: 3 }, node); },
+        validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    repeat: {
+    'dec': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 2), count = _b[0], value = _b[1];
-            assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
-            var result = [];
-            for (var i = 0; i < count; i += 1)
-                result.push(value);
-            return result;
+            var _b = __read(_a, 1), first = _b[0];
+            assertNumber(first, sourceCodeInfo);
+            return first - 1;
         },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-    flatten: {
-        evaluate: function (_a) {
-            var _b = __read(_a, 1), seq = _b[0];
-            if (!Array.isArray(seq))
-                return [];
-            return seq.flat(Number.POSITIVE_INFINITY);
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    mapcat: {
-        evaluate: function (params, sourceCodeInfo, contextStack, helpers) {
-            var mapResult = evaluateMap(params, sourceCodeInfo, contextStack, helpers);
-            assertArray(mapResult, sourceCodeInfo);
-            return mapResult.flat(1);
-        },
-        validate: function (node) { return assertNumberOfParams(2, node); },
-    },
-};
-
-var mathNormalExpression = {
-    'inc': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertNumber(first, sourceCodeInfo);
-            return first + 1;
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
-    'dec': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertNumber(first, sourceCodeInfo);
-            return first - 1;
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
+        validate: function (node) { return assertNumberOfParams(1, node); },
     },
     '+': {
         evaluate: function (params, sourceCodeInfo) {
@@ -2885,21 +2850,6 @@ var mathNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'rand!': {
-        evaluate: function (parameters, sourceCodeInfo) {
-            var num = asNumber(parameters.length === 1 ? parameters[0] : 1, sourceCodeInfo);
-            return Math.random() * num;
-        },
-        validate: function (node) { return assertNumberOfParams({ min: 0, max: 1 }, node); },
-    },
-    'rand-int!': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertNumber(first, sourceCodeInfo);
-            return Math.floor(Math.random() * Math.abs(first)) * Math.sign(first);
-        },
-        validate: function (node) { return assertNumberOfParams(1, node); },
-    },
     'min': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a), first = _b[0], rest = _b.slice(1);
@@ -2942,25 +2892,25 @@ var mathNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'max-safe-integer': {
+    'max_safe_integer': {
         evaluate: function () {
             return Number.MAX_SAFE_INTEGER;
         },
         validate: function (node) { return assertNumberOfParams(0, node); },
     },
-    'min-safe-integer': {
+    'min_safe_integer': {
         evaluate: function () {
             return Number.MIN_SAFE_INTEGER;
         },
         validate: function (node) { return assertNumberOfParams(0, node); },
     },
-    'max-value': {
+    'max_value': {
         evaluate: function () {
             return Number.MAX_VALUE;
         },
         validate: function (node) { return assertNumberOfParams(0, node); },
     },
-    'min-value': {
+    'min_value': {
         evaluate: function () {
             return Number.MIN_VALUE;
         },
@@ -2972,13 +2922,13 @@ var mathNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(0, node); },
     },
-    'positive-infinity': {
+    'positive_infinity': {
         evaluate: function () {
             return Number.POSITIVE_INFINITY;
         },
         validate: function (node) { return assertNumberOfParams(0, node); },
     },
-    'negative-infinity': {
+    'negative_infinity': {
         evaluate: function () {
             return Number.NEGATIVE_INFINITY;
         },
@@ -3132,12 +3082,12 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.11";
+var version = "2.0.13";
 
 var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 var xyRegexp = /[xy]/g;
 var miscNormalExpression = {
-    'not=': {
+    '!=': {
         evaluate: function (params) {
             for (var i = 0; i < params.length - 1; i += 1) {
                 for (var j = i + 1; j < params.length; j += 1) {
@@ -3388,7 +3338,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert-not=': {
+    'assert!=': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3398,7 +3348,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert-equal': {
+    'assert_equal': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3409,7 +3359,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert-not-equal': {
+    'assert_not_equal': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3420,7 +3370,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert>': {
+    'assert_gt': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3430,7 +3380,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert>=': {
+    'assert_gte': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3440,7 +3390,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert<': {
+    'assert_lt': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3450,7 +3400,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert<=': {
+    'assert_lte': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 3), first = _b[0], second = _b[1], message = _b[2];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3460,7 +3410,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert-true': {
+    'assert_true': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), first = _b[0], message = _b[1];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3470,7 +3420,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-false': {
+    'assert_false': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), first = _b[0], message = _b[1];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3480,7 +3430,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-truthy': {
+    'assert_truthy': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), first = _b[0], message = _b[1];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3490,7 +3440,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-falsy': {
+    'assert_falsy': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), first = _b[0], message = _b[1];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3500,7 +3450,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-nil': {
+    'assert_null': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), first = _b[0], message = _b[1];
             message = typeof message === 'string' && message ? " \"".concat(message, "\"") : '';
@@ -3510,7 +3460,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-throws': {
+    'assert_throws': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), func = _c[0], message = _c[1];
             var executeFunction = _b.executeFunction;
@@ -3526,7 +3476,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     },
-    'assert-throws-error': {
+    'assert_throws_error': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), func = _c[0], throwMessage = _c[1], message = _c[2];
             var executeFunction = _b.executeFunction;
@@ -3547,7 +3497,7 @@ var assertNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     },
-    'assert-not-throws': {
+    'assert_not_throws': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), func = _c[0], message = _c[1];
             var executeFunction = _b.executeFunction;
@@ -3581,25 +3531,25 @@ var objectNormalExpression = {
     },
     'keys': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertObj(first, sourceCodeInfo);
-            return Object.keys(first);
+            var _b = __read(_a, 1), obj = _b[0];
+            assertObj(obj, sourceCodeInfo);
+            return Object.keys(obj);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
     'vals': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertObj(first, sourceCodeInfo);
-            return Object.values(first);
+            var _b = __read(_a, 1), obj = _b[0];
+            assertObj(obj, sourceCodeInfo);
+            return Object.values(obj);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
     'entries': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertObj(first, sourceCodeInfo);
-            return Object.entries(first);
+            var _b = __read(_a, 1), obj = _b[0];
+            assertObj(obj, sourceCodeInfo);
+            return Object.entries(obj);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
@@ -3641,11 +3591,11 @@ var objectNormalExpression = {
     'merge-with': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
-            var _b = __read(params), fn = _b[0], first = _b[1], rest = _b.slice(2);
-            assertLitsFunction(fn, sourceCodeInfo);
-            if (params.length === 1)
-                return null;
+            var first = params[0];
+            var fn = params.at(-1);
+            var rest = params.slice(1, -1);
             assertObj(first, sourceCodeInfo);
+            assertLitsFunction(fn, sourceCodeInfo);
             return rest.reduce(function (result, obj) {
                 assertObj(obj, sourceCodeInfo);
                 Object.entries(obj).forEach(function (entry) {
@@ -3659,7 +3609,7 @@ var objectNormalExpression = {
                 return result;
             }, __assign({}, first));
         },
-        validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
+        validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
     'zipmap': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -3825,7 +3775,7 @@ var predicatesNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'positive-infinity?': {
+    'positive_infinity?': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), value = _b[0];
             assertNumber(value, sourceCodeInfo);
@@ -3833,7 +3783,7 @@ var predicatesNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'negative-infinity?': {
+    'negative_infinity?': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), value = _b[0];
             assertNumber(value, sourceCodeInfo);
@@ -3869,7 +3819,7 @@ var predicatesNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'not-empty?': {
+    'not_empty?': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), coll = _b[0];
             if (coll === null)
@@ -4203,7 +4153,7 @@ function applyPlaceholders(templateString, placeholders, sourceCodeInfo) {
 }
 
 var functionalNormalExpression = {
-    'apply': {
+    apply: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a), func = _c[0], params = _c.slice(1);
             var executeFunction = _b.executeFunction;
@@ -4216,14 +4166,14 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 2 }, node); },
     },
-    'identity': {
+    identity: {
         evaluate: function (_a) {
             var _b = __read(_a, 1), value = _b[0];
             return toAny(value);
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'partial': {
+    partial: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a), fn = _c[0], params = _c.slice(1);
@@ -4237,7 +4187,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     },
-    'comp': {
+    comp: {
         evaluate: function (fns, sourceCodeInfo) {
             var _a;
             if (fns.length > 1) {
@@ -4254,7 +4204,7 @@ var functionalNormalExpression = {
                 _a;
         },
     },
-    'constantly': {
+    constantly: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a, 1), value = _c[0];
@@ -4267,7 +4217,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'juxt': {
+    juxt: {
         evaluate: function (fns, sourceCodeInfo) {
             var _a;
             return _a = {},
@@ -4279,7 +4229,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     },
-    'complement': {
+    complement: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a, 1), fn = _c[0];
@@ -4292,7 +4242,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams(1, node); },
     },
-    'every-pred': {
+    every_pred: {
         evaluate: function (fns, sourceCodeInfo) {
             var _a;
             return _a = {},
@@ -4304,7 +4254,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     },
-    'some-pred': {
+    some_pred: {
         evaluate: function (fns, sourceCodeInfo) {
             var _a;
             return _a = {},
@@ -4316,7 +4266,7 @@ var functionalNormalExpression = {
         },
         validate: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     },
-    'fnil': {
+    fnil: {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a), fn = _c[0], params = _c.slice(1);
@@ -6889,13 +6839,34 @@ function parseSymbol(tokenStream, parseState) {
     if (!isA_SymbolToken(tkn) && !isP_SymbolToken(tkn)) {
         throw new LitsError("Expected symbol token, got ".concat(tkn[0]), (_a = getTokenDebugData(tkn)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
     }
-    return {
-        t: AstNodeType.Symbol,
-        v: tkn[1],
-        p: [],
-        n: undefined,
-        token: getTokenDebugData(tkn) && tkn,
-    };
+    if (tkn[1][0] !== '\'') {
+        return {
+            t: AstNodeType.Symbol,
+            v: tkn[1],
+            p: [],
+            n: undefined,
+            token: getTokenDebugData(tkn) && tkn,
+        };
+    }
+    else {
+        var value = tkn[1].substring(1, tkn[1].length - 1)
+            .replace(/(\\{2})|(\\')|\\(.)/g, function (_, backslash, singleQuote, normalChar) {
+            if (backslash) {
+                return '\\';
+            }
+            if (singleQuote) {
+                return '\'';
+            }
+            return "\\".concat(normalChar);
+        });
+        return {
+            t: AstNodeType.Symbol,
+            v: value,
+            p: [],
+            n: undefined,
+            token: getTokenDebugData(tkn) && tkn,
+        };
+    }
 }
 function parseReservedSymbol(tokenStream, parseState) {
     var _a;
@@ -6914,7 +6885,23 @@ function parseReservedSymbol(tokenStream, parseState) {
 function parseNumber(tokenStream, parseState) {
     var _a;
     var tkn = tokenStream.tokens[parseState.position++];
-    if (!isP_NumberToken(tkn) && !isA_NumberToken(tkn)) {
+    if (isA_NumberToken(tkn)) {
+        var numberString_1 = tkn[1];
+        var periodToken = tokenStream.tokens[parseState.position];
+        var decimalToken = tokenStream.tokens[parseState.position + 1];
+        if (isA_OperatorToken(periodToken, '.') && isA_NumberToken(decimalToken)) {
+            numberString_1 += ".".concat(decimalToken[1]);
+            parseState.position += 2;
+        }
+        return {
+            t: AstNodeType.Number,
+            v: Number(numberString_1),
+            p: [],
+            n: undefined,
+            token: getTokenDebugData(tkn) && tkn,
+        };
+    }
+    if (!isP_NumberToken(tkn) && !isA_BasePrefixedNumberToken(tkn)) {
         throw new LitsError("Expected number token, got ".concat(tkn), (_a = getTokenDebugData(tkn)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
     }
     var value = tkn[1];
@@ -6966,63 +6953,60 @@ function parseString(tokenStream, parseState) {
     };
 }
 
-var exponentiationPrecedence = 9;
+var exponentiationPrecedence = 10;
+var binaryFunctionalOperatorPrecedence = 1;
 var placeholderRegexp$1 = /^\$([1-9]\d?)?$/;
-function getPrecedence(operator) {
-    var operatorSign = operator[1];
+function getPrecedence(operatorSign) {
     switch (operatorSign) {
-        case '.': // accessor
-            return 10;
         case '**': // exponentiation
             return exponentiationPrecedence;
         case '*': // multiplication
         case '/': // division
         case '%': // remainder
-            return 8;
+            return 9;
         case '+': // addition
         case '-': // subtraction
-            return 7;
+            return 8;
         case '<<': // left shift
         case '>>': // signed right shift
         case '>>>': // unsigned right shift
-            return 6;
+            return 7;
         case '++': // string concatenation
-            return 5;
+            return 6;
         case '<': // less than
         case '<=': // less than or equal
         case '>': // greater than
         case '>=': // greater than or equal
-            return 4;
+            return 5;
         case '==': // equal
         case '!=': // not equal
-            return 3;
+            return 4;
         case '&': // bitwise AND
         case '^': // bitwise XOR
         case '|': // bitwise OR
-            return 2;
+            return 3;
         case '&&': // logical AND
         case '||': // logical OR
         case '??': // nullish coalescing
-            return 1;
-        /* v8 ignore next 8 */
-        case '!': // logical NOT
-        case '~': // bitwise NOT
-        case '=': // property assignemnt operator
-        case ',': // element delimiter
-        case '=>': // Only used in lamda function parser
-        case '...': // Only used in lamda function parser
-            throw new Error("Unknown binary operator: ".concat(operatorSign));
+            return 2;
+        // leave room for binaryFunctionalOperatorPrecedence = 1
         default:
             throw new Error("Unknown binary operator: ".concat(operatorSign));
     }
 }
 function createNamedNormalExpressionNode(name, params, token) {
-    return {
+    var _a;
+    var node = {
         t: AstNodeType.NormalExpression,
         n: name,
         p: params,
         token: getTokenDebugData(token) && token,
     };
+    var builtinExpression = builtin.normalExpressions[node.n];
+    if (builtinExpression) {
+        (_a = builtinExpression.validate) === null || _a === void 0 ? void 0 : _a.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+    }
+    return node;
 }
 function fromSymbolToStringNode(symbol) {
     return {
@@ -7059,9 +7043,8 @@ function fromUnaryAlgebraicToAstNode(operator, operand) {
             throw new Error("Unknown operator: ".concat(operatorName));
     }
 }
-function fromBinaryAlgebraicToAstNode(operator, left, right) {
+function fromBinaryOperatorToAstNode(operator, left, right, token) {
     var _a, _b, _c;
-    var token = hasTokenDebugData(operator) ? operator : undefined;
     var operatorName = operator[1];
     switch (operatorName) {
         case '.':
@@ -7100,7 +7083,7 @@ function fromBinaryAlgebraicToAstNode(operator, left, right) {
         case '==':
             return createNamedNormalExpressionNode('=', [left, right], token);
         case '!=':
-            return createNamedNormalExpressionNode('not=', [left, right], token);
+            return createNamedNormalExpressionNode('!=', [left, right], token);
         case '&':
             return createNamedNormalExpressionNode('bit-and', [left, right], token);
         case '^':
@@ -7157,45 +7140,82 @@ var AlgebraicParser = /** @class */ (function () {
         var left = this.parseOperand();
         while (!this.isAtEnd() && !isA_OperatorToken(this.peek(), ',') && !isRBracketToken(this.peek()) && !isRParenToken(this.peek())) {
             var operator = this.peek();
-            // Handle index accessor
-            if (isLParenToken(operator)) {
-                if (precedence >= 9) {
-                    break;
-                }
-                left = this.parseFunctionCall(left);
-            }
-            // Handle index accessor
-            else if (isLBracketToken(operator)) {
-                if (precedence >= 9) {
+            if (isA_BinaryOperatorToken(operator)) {
+                var name_1 = operator[1];
+                var newPrecedece = getPrecedence(name_1);
+                if (newPrecedece <= precedence
+                    // ** (exponentiation) is right associative
+                    && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
                     break;
                 }
                 this.advance();
-                var right = this.parseExpression(1);
-                if (!isRBracketToken(this.peek())) {
-                    throw new LitsError('Expected closing bracket', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-                }
-                this.advance();
-                left = createAccessorNode(left, right, operator);
+                var right = this.parseExpression(newPrecedece);
+                var token = hasTokenDebugData(operator) ? operator : undefined;
+                left = fromBinaryOperatorToAstNode(operator, left, right, token);
             }
-            else {
-                if (!isA_OperatorToken(operator)) {
+            else if (isA_SymbolToken(operator)) {
+                if (!isFunctionOperator(operator[1])) {
                     break;
                 }
-                var newPrecedece = getPrecedence(operator);
-                if (newPrecedece <= precedence
-                    // ** (exponentiation) is right associative
-                    && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
+                var newPrecedece = binaryFunctionalOperatorPrecedence;
+                if (newPrecedece <= precedence) {
                     break;
                 }
                 this.advance();
                 var right = this.parseExpression(newPrecedece);
-                left = fromBinaryAlgebraicToAstNode(operator, left, right);
+                var token = hasTokenDebugData(operator) ? operator : undefined;
+                left = createNamedNormalExpressionNode(operator[1], [left, right], token);
             }
+            else {
+                break;
+            }
+        }
+        if (!left) {
+            throw new LitsError('Expected operand', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
         }
         return left;
     };
     AlgebraicParser.prototype.parseOperand = function () {
-        var _a;
+        var _a, _b;
+        var operand = this.parseOperandPart();
+        var token = this.peek();
+        while (isA_OperatorToken(token, '.') || isLBracketToken(token) || isLParenToken(token)) {
+            if (token[1] === '.') {
+                this.advance();
+                var symbolToken = this.peek();
+                if (!isA_SymbolToken(symbolToken)) {
+                    throw new LitsError('Expected symbol', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+                }
+                var stringNode = {
+                    t: AstNodeType.String,
+                    v: symbolToken[1],
+                    token: getTokenDebugData(symbolToken) && symbolToken,
+                    p: [],
+                    n: undefined,
+                };
+                operand = createAccessorNode(operand, stringNode, token);
+                this.advance();
+                token = this.peek();
+            }
+            else if (isLBracketToken(token)) {
+                this.advance();
+                var expression = this.parseExpression();
+                if (!isRBracketToken(this.peek())) {
+                    throw new LitsError('Expected closing bracket', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                }
+                operand = createAccessorNode(operand, expression, token);
+                this.advance();
+                token = this.peek();
+            }
+            else if (isLParenToken(token)) {
+                operand = this.parseFunctionCall(operand);
+                token = this.peek();
+            }
+        }
+        return operand;
+    };
+    AlgebraicParser.prototype.parseOperandPart = function () {
+        var _a, _b;
         var token = this.peek();
         // Parentheses
         if (isLParenToken(token)) {
@@ -7214,14 +7234,17 @@ var AlgebraicParser = /** @class */ (function () {
             return expression;
         }
         // Unary operators
-        if (isA_OperatorToken(token)) {
+        else if (isA_OperatorToken(token)) {
             var operatorName = token[1];
-            if (['-', '+', '!', '~'].includes(operatorName)) {
+            if (isSymbolicUnaryOperator(operatorName)) {
                 this.advance();
                 var operand = this.parseOperand();
+                if (operand === null) {
+                    throw new LitsError('Expected operand', (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+                }
                 return fromUnaryAlgebraicToAstNode(token, operand);
             }
-            else if (operatorName === '=>') {
+            if (operatorName === '=>') {
                 return this.parseShorthandLamdaFunction();
             }
             else {
@@ -7239,6 +7262,7 @@ var AlgebraicParser = /** @class */ (function () {
         var tokenType = token[0];
         switch (tokenType) {
             case 'A_Number':
+            case 'A_BasePrefixedNumber':
                 return parseNumber(this.tokenStream, this.parseState);
             case 'String':
                 return parseString(this.tokenStream, this.parseState);
@@ -7274,18 +7298,21 @@ var AlgebraicParser = /** @class */ (function () {
                 return node;
             }
             default:
-                throw new LitsError("Unknown token type: ".concat(tokenType), (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+                throw new LitsError("Unknown token type: ".concat(tokenType), (_b = getTokenDebugData(token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         }
     };
     AlgebraicParser.prototype.parseObject = function () {
-        var _a, _b;
+        var _a, _b, _c;
         var firstToken = asLBraceToken(this.peek());
         this.advance();
         var params = [];
         while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             var key = this.parseOperand();
+            if (key === null) {
+                throw new LitsError('Expected key', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+            }
             if (key.t !== AstNodeType.Symbol && key.t !== AstNodeType.String) {
-                throw new LitsError('Expected key to be a symbol or a string', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+                throw new LitsError('Expected key to be a symbol or a string', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
             }
             params.push({
                 t: AstNodeType.String,
@@ -7299,7 +7326,7 @@ var AlgebraicParser = /** @class */ (function () {
             params.push(this.parseExpression());
             var nextToken = this.peek();
             if (!isA_OperatorToken(nextToken, ',') && !isRBraceToken(nextToken)) {
-                throw new LitsError('Expected comma or closing brace', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                throw new LitsError('Expected comma or closing brace', (_c = getTokenDebugData(this.peek())) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
             }
             if (isA_OperatorToken(nextToken, ',')) {
                 this.advance();
@@ -7339,9 +7366,13 @@ var AlgebraicParser = /** @class */ (function () {
         };
     };
     AlgebraicParser.prototype.parseFunctionCall = function (symbol) {
-        var _a, _b, _c;
-        var params = [];
+        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());
             var nextToken = this.peek();
@@ -7356,10 +7387,10 @@ var AlgebraicParser = /** @class */ (function () {
             throw new LitsError('Expected closing parenthesis', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
         }
         this.advance();
-        if (isSymbolNode(symbol)) {
+        if (isNamedFunction) {
             if (specialExpressionKeys.includes(symbol.v)) {
-                var name_1 = symbol.v;
-                switch (name_1) {
+                var name_2 = symbol.v;
+                switch (name_2) {
                     case '??':
                     case 'and':
                     case 'comment':
@@ -7373,14 +7404,14 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'do':
                     case 'time!':
                     case 'throw': {
-                        var node_1 = {
+                        var node = {
                             t: AstNodeType.SpecialExpression,
-                            n: name_1,
+                            n: name_2,
                             p: params,
                             token: getTokenDebugData(symbol.token) && symbol.token,
                         };
-                        builtin.specialExpressions[node_1.n].validateParameterCount(node_1);
-                        return node_1;
+                        builtin.specialExpressions[node.n].validateParameterCount(node);
+                        return node;
                     }
                     case 'let':
                         return this.parseLet(symbol, params);
@@ -7396,18 +7427,12 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'recur':
                     case 'loop':
                     case 'doseq':
-                    case 'for':
-                        throw new Error("Special expression ".concat(name_1, " is not available in algebraic notation"));
+                        throw new Error("Special expression ".concat(name_2, " is not available in algebraic notation"));
                     default:
-                        throw new Error("Unknown special expression: ".concat(name_1));
+                        throw new Error("Unknown special expression: ".concat(name_2));
                 }
             }
-            var node = createNamedNormalExpressionNode(symbol.v, params, symbol.token);
-            var builtinExpression = builtin.normalExpressions[node.n];
-            if (builtinExpression) {
-                (_c = builtinExpression.validate) === null || _c === void 0 ? void 0 : _c.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
-            }
-            return node;
+            return createNamedNormalExpressionNode(symbol.v, params, symbol.token);
         }
         else {
             return {
@@ -7498,7 +7523,7 @@ var AlgebraicParser = /** @class */ (function () {
         };
     };
     AlgebraicParser.prototype.parseShorthandLamdaFunction = function () {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         var firstToken = this.peek();
         this.advance();
         var startPos = this.parseState.position;
@@ -7523,9 +7548,6 @@ var AlgebraicParser = /** @class */ (function () {
                         throw new LitsError('Can\'t specify more than 20 arguments', (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
                 }
             }
-            if (isA_OperatorToken(tkn, '=>')) {
-                throw new LitsError('Nested shortcut functions are not allowed', (_d = getTokenDebugData(firstToken)) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
-            }
         }
         var mandatoryArguments = [];
         for (var i = 1; i <= arity; i += 1) {
@@ -7553,10 +7575,10 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseLet = function (nameSymbol, params) {
+    AlgebraicParser.prototype.parseLet = function (letSymbol, params) {
         var _a, _b;
         if (params.length !== 2) {
-            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(nameSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(letSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
         }
         var letObject = params[0];
         if (letObject.t !== AstNodeType.NormalExpression || letObject.n !== 'object') {
@@ -7568,7 +7590,7 @@ var AlgebraicParser = /** @class */ (function () {
             t: AstNodeType.SpecialExpression,
             n: 'let',
             p: [expression],
-            token: getTokenDebugData(nameSymbol.token) && nameSymbol.token,
+            token: getTokenDebugData(letSymbol.token) && letSymbol.token,
             bs: letBindings.map(function (pair) {
                 var key = pair[0];
                 var value = pair[1];
@@ -7582,12 +7604,122 @@ var AlgebraicParser = /** @class */ (function () {
             }),
         };
     };
+    AlgebraicParser.prototype.parseFor = function (forSymbol) {
+        var forLoopBindings = [
+            this.parseForLoopBinding(),
+        ];
+        var nextToken = this.peekAhead();
+        while (isA_SymbolToken(nextToken) && nextToken[1] === 'of') {
+            forLoopBindings.push(this.parseForLoopBinding());
+            nextToken = this.peekAhead();
+        }
+        var expression = this.parseExpression();
+        assertRParenToken(this.peek());
+        this.advance();
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'for',
+            p: [expression],
+            token: getTokenDebugData(forSymbol.token) && forSymbol.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();
+            return {
+                b: bindingNode,
+                m: [],
+            };
+        }
+        var modifiers = [];
+        var token = this.peek();
+        if (!isA_SymbolToken(token)) {
+            throw new LitsError('Expected symbol let, when or while', (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        var letBindings;
+        if (token[1] === 'let') {
+            modifiers.push('&let');
+            letBindings = [];
+            this.advance();
+            var letObject = this.parseObject();
+            letBindings = arrayToPairs(letObject.p).map(function (pair) {
+                var key = pair[0];
+                var value = pair[1];
+                return {
+                    t: AstNodeType.Binding,
+                    n: key.v,
+                    v: value,
+                    p: [],
+                    token: getTokenDebugData(key.token) && key.token,
+                };
+            });
+        }
+        token = this.peek();
+        var whenNode;
+        var whileNode;
+        while (isA_SymbolToken(token)
+            && ((token[1] === 'when' && !modifiers.includes('&when'))
+                || (token[1] === 'while' && !modifiers.includes('&while')))) {
+            this.advance();
+            if (token[1] === 'when') {
+                modifiers.push('&when');
+                whenNode = this.parseExpression();
+            }
+            else {
+                modifiers.push('&while');
+                whileNode = this.parseExpression();
+            }
+            token = this.peek();
+        }
+        assertA_OperatorToken(token, ',');
+        this.advance();
+        return {
+            b: bindingNode,
+            m: modifiers,
+            l: letBindings,
+            wn: whenNode,
+            we: whileNode,
+        };
+    };
+    AlgebraicParser.prototype.parseBinding = function () {
+        var _a;
+        var firstToken = asA_SymbolToken(this.peek());
+        var name = firstToken[1];
+        this.advance();
+        var ofSymbol = asA_SymbolToken(this.peek());
+        if (ofSymbol[1] !== 'of') {
+            throw new LitsError('Expected "of"', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        this.advance();
+        var value = this.parseExpression();
+        var node = {
+            t: AstNodeType.Binding,
+            n: name,
+            v: value,
+            p: [],
+            token: getTokenDebugData(firstToken) && firstToken,
+        };
+        return node;
+    };
     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;
 }());
 
@@ -7779,12 +7911,12 @@ function parseBindings(tokenStream, parseState) {
     return bindings;
 }
 function parseBinding(tokenStream, parseState) {
-    var firstToken = asP_SymbolToken(tokenStream.tokens[parseState.position++]);
-    var name = firstToken[1];
+    var firstToken = asP_SymbolToken(tokenStream.tokens[parseState.position]);
+    var name = parseSymbol(tokenStream, parseState);
     var value = parseState.parseToken(tokenStream, parseState);
     var node = {
         t: AstNodeType.Binding,
-        n: name,
+        n: name.v,
         v: value,
         p: [],
         token: getTokenDebugData(firstToken) && firstToken,
@@ -8023,20 +8155,30 @@ var commonTokenizers = [
     tokenizeString,
 ];
 
-var whitespaceRegExp$1 = /\s|,/;
-var tokenizeP_Comment = function (input, position) {
-    if (input[position] === ';') {
-        var length_1 = 0;
-        var value = '';
-        while (input[position + length_1] !== '\n' && position + length_1 < input.length) {
-            value += input[position + length_1];
-            length_1 += 1;
-        }
-        return [length_1, ['P_Comment', value]];
-    }
-    return NO_MATCH;
+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 tokenizeP_Whitespace = function (input, position) {
+
+var identifierRegExp = new RegExp(algebraicIdentifierCharacterClass);
+var identifierFirstCharacterRegExp = new RegExp(algebraicIdentifierFirstCharacterClass);
+var whitespaceRegExp$1 = /\s/;
+var tokenizeA_Whitespace = function (input, position) {
     var char = input[position];
     if (!char || !whitespaceRegExp$1.test(char)) {
         return NO_MATCH;
@@ -8049,109 +8191,74 @@ var tokenizeP_Whitespace = function (input, position) {
         position += 1;
         char = input[position];
     }
-    return [value.length, ['P_Whitespace', value]];
+    return [value.length, ['A_Whitespace', value]];
 };
-var endOfNumberRegExp = /[\s)\]},;#`]/;
 var decimalNumberRegExp$1 = /\d/;
 var octalNumberRegExp$1 = /[0-7]/;
 var hexNumberRegExp$1 = /[0-9a-f]/i;
 var binaryNumberRegExp$1 = /[01]/;
-var firstCharRegExp$1 = /[0-9.-]/;
-var tokenizeP_Number = function (input, position) {
-    var type = 'decimal';
-    var firstChar = input[position];
-    if (!firstCharRegExp$1.test(firstChar))
-        return NO_MATCH;
-    var hasDecimals = firstChar === '.';
+var tokenizeA_Number = function (input, position) {
     var i;
-    for (i = position + 1; i < input.length; i += 1) {
+    for (i = position; i < input.length; i += 1) {
         var char = input[i];
-        if (endOfNumberRegExp.test(char))
+        if (!decimalNumberRegExp$1.test(char)) {
             break;
-        if (char === '.') {
-            var nextChar = input[i + 1];
-            if (typeof nextChar === 'string' && !decimalNumberRegExp$1.test(nextChar))
-                break;
-        }
-        if (i === position + 1 && firstChar === '0') {
-            if (char === 'b' || char === 'B') {
-                type = 'binary';
-                continue;
-            }
-            if (char === 'o' || char === 'O') {
-                type = 'octal';
-                continue;
-            }
-            if (char === 'x' || char === 'X') {
-                type = 'hex';
-                continue;
-            }
-        }
-        if (type === 'decimal' && hasDecimals) {
-            if (!decimalNumberRegExp$1.test(char))
-                return NO_MATCH;
-        }
-        else if (type === 'binary') {
-            if (!binaryNumberRegExp$1.test(char))
-                return NO_MATCH;
-        }
-        else if (type === 'octal') {
-            if (!octalNumberRegExp$1.test(char))
-                return NO_MATCH;
-        }
-        else if (type === 'hex') {
-            if (!hexNumberRegExp$1.test(char))
-                return NO_MATCH;
-        }
-        else {
-            if (char === '.') {
-                hasDecimals = true;
-                continue;
-            }
-            if (!decimalNumberRegExp$1.test(char))
-                return NO_MATCH;
         }
     }
     var length = i - position;
-    var value = input.substring(position, i);
-    if ((type !== 'decimal' && length <= 2) || value === '.' || value === '-')
+    if (length === 0) {
         return NO_MATCH;
-    return [length, ['P_Number', value]];
+    }
+    return [length, ['A_Number', input.substring(position, i)]];
 };
-var P_symbolRegExp = new RegExp(polishIdentifierCharacterClass);
-var tokenizeP_Symbol = function (input, position) {
-    var char = input[position];
-    var length = 0;
-    var value = '';
-    if (!char || !P_symbolRegExp.test(char))
+var tokenizeA_BasePrefixedNumber = function (input, position) {
+    if (input[position] !== '0') {
         return NO_MATCH;
-    while (char && P_symbolRegExp.test(char)) {
-        value += char;
-        length += 1;
-        char = input[position + length];
     }
-    return [length, ['P_Symbol', value]];
-};
-var tokenizeP_FnShorthand = function (input, position) {
-    if (input.slice(position, position + 2) !== '#(')
+    var baseChar = input[position + 1];
+    var type = baseChar === 'b' || baseChar === 'B'
+        ? 'binary'
+        : baseChar === 'o' || baseChar === 'O'
+            ? 'octal'
+            : baseChar === 'x' || baseChar === 'X'
+                ? 'hex'
+                : null;
+    if (type === null) {
         return NO_MATCH;
-    return [1, ['P_FnShorthand']];
+    }
+    var i;
+    for (i = position + 2; i < input.length; i += 1) {
+        var char = input[i];
+        if (type === 'binary' && !binaryNumberRegExp$1.test(char)) {
+            break;
+        }
+        if (type === 'octal' && !octalNumberRegExp$1.test(char)) {
+            break;
+        }
+        if (type === 'hex' && !hexNumberRegExp$1.test(char)) {
+            break;
+        }
+    }
+    var length = i - position;
+    if (length <= 2) {
+        return NO_MATCH;
+    }
+    return [length, ['A_BasePrefixedNumber', input.substring(position, i)]];
 };
-var tokenizeP_ReservedSymbol = function (input, position) {
+var tokenizeA_ReservedSymbolToken = function (input, position) {
     var e_1, _a;
     try {
-        for (var _b = __values(Object.entries(polishReservedNamesRecord)), _c = _b.next(); !_c.done; _c = _b.next()) {
+        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_2 = reservedName.length;
-            var nextChar = input[position + length_2];
-            if (nextChar && P_symbolRegExp.test(nextChar)) {
+            var length_1 = reservedName.length;
+            var nextChar = input[position + length_1];
+            if (nextChar && identifierRegExp.test(nextChar))
                 continue;
-            }
-            var symbol = input.substring(position, position + length_2);
-            if (symbol === reservedName) {
+            var name_1 = input.substring(position, position + length_1);
+            if (name_1 === reservedName) {
                 if (forbidden)
-                    throw new LitsError("".concat(symbol, " is forbidden!"), undefined);
-                return [length_2, ['P_ReservedSymbol', reservedName]];
+                    throw new LitsError("".concat(name_1, " is forbidden!"), undefined);
+                return [length_1, ['A_ReservedSymbol', reservedName]];
             }
         }
     }
@@ -8164,103 +8271,119 @@ var tokenizeP_ReservedSymbol = function (input, position) {
     }
     return NO_MATCH;
 };
-var tokenizeP_StringShorthand = function (input, position) {
-    if (input[position] !== ':')
+var tokenizeA_Symbol = function (input, position) {
+    var value = input[position];
+    if (!value) {
         return NO_MATCH;
-    var symbolDescription = tokenizeP_Symbol(input, position + 1);
-    if (isNoMatch(symbolDescription)) {
-        return symbolDescription;
     }
-    var symbolToken = asP_SymbolToken(symbolDescription[1]);
-    return [symbolDescription[0] + 1, ['P_StringShorthand', ":".concat(symbolToken[1])]];
-};
-var tokenizeP_Modifier = function (input, position) {
-    var e_2, _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_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_3, ['P_Modifier', value]];
+    if (value === '\'') {
+        var length_2 = 1;
+        var char = input[position + length_2];
+        var escaping = false;
+        while (char !== '\'' || escaping) {
+            if (char === undefined)
+                throw new LitsError("Unclosed string at position ".concat(position, "."), undefined);
+            length_2 += 1;
+            if (escaping) {
+                escaping = false;
+                value += char;
             }
+            else {
+                if (char === '\\') {
+                    escaping = true;
+                }
+                value += char;
+            }
+            char = input[position + length_2];
         }
+        value += '\''; // closing quote
+        return [length_2 + 1, ['A_Symbol', value]];
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (modifierNames_1_1 && !modifierNames_1_1.done && (_a = modifierNames_1.return)) _a.call(modifierNames_1);
+    if (identifierFirstCharacterRegExp.test(value)) {
+        var initialPosition = position;
+        position += 1;
+        var char = input[position];
+        while (char && identifierRegExp.test(char)) {
+            value += char;
+            position += 1;
+            char = input[position];
         }
-        finally { if (e_2) throw e_2.error; }
+        return [position - initialPosition, ['A_Symbol', value]];
     }
     return NO_MATCH;
 };
-var tokenizeP_CollectionAccessor = function (input, position) {
-    var char = input[position];
-    if (char !== '.' && char !== '#')
-        return NO_MATCH;
-    return [1, ['P_CollectionAccessor', char]];
+var tokenizeA_Operator = function (input, position) {
+    var _a;
+    var threeChars = input.slice(position, position + 3);
+    if (position + 2 < input.length && isSymbolicOperator(threeChars)) {
+        return [3, ['A_Operator', threeChars]];
+    }
+    var twoChars = input.slice(position, position + 2);
+    if (position + 1 < input.length && isSymbolicOperator(twoChars)) {
+        return [2, ['A_Operator', twoChars]];
+    }
+    var oneChar = (_a = input[position]) !== null && _a !== void 0 ? _a : '';
+    if (isSymbolicOperator(oneChar)) {
+        return [1, ['A_Operator', oneChar]];
+    }
+    return NO_MATCH;
 };
-var tokenizeP_RegexpShorthand = function (input, position) {
-    if (input[position] !== '#')
-        return NO_MATCH;
-    var _a = __read(tokenizeString(input, position + 1), 2), stringLength = _a[0], token = _a[1];
-    if (!token)
-        return NO_MATCH;
-    position += stringLength + 1;
-    var length = stringLength + 1;
-    var options = '';
-    while (input[position] === 'g' || input[position] === 'i') {
-        if (options.includes(input[position])) {
-            throw new LitsError("Duplicated regexp option \"".concat(input[position], "\" at position ").concat(position, "."), undefined);
+var tokenizeA_MultiLineComment = function (input, position) {
+    if (input[position] === '/' && input[position + 1] === '*') {
+        var length_3 = 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;
         }
-        options += input[position];
-        length += 1;
-        position += 1;
+        if (position + length_3 + 1 >= input.length) {
+            throw new LitsError('Comment not closed', undefined);
+        }
+        value += '*/';
+        length_3 += 2;
+        return [length_3, ['A_MultiLineComment', value]];
     }
-    return [length, ['P_RegexpShorthand', "#".concat(token[1]).concat(options)]];
+    return NO_MATCH;
+};
+var tokenizeA_SingleLineComment = function (input, position) {
+    if (input[position] === '/' && input[position + 1] === '/') {
+        var length_4 = 2;
+        var value = '//';
+        while (input[position + length_4] !== '\n' && position + length_4 < input.length) {
+            value += input[position + length_4];
+            length_4 += 1;
+        }
+        return [length_4, ['A_SingleLineComment', value]];
+    }
+    return NO_MATCH;
 };
 // All tokenizers, order matters!
-var polishTokenizers = __spreadArray(__spreadArray([
-    tokenizeP_Whitespace,
-    tokenizeP_Comment
+var algebraicTokenizers = __spreadArray(__spreadArray([
+    tokenizeA_Whitespace,
+    tokenizeA_MultiLineComment,
+    tokenizeA_SingleLineComment
 ], __read(commonTokenizers), false), [
-    tokenizeP_StringShorthand,
-    tokenizeP_Number,
-    tokenizeP_ReservedSymbol,
-    tokenizeP_Symbol,
-    tokenizeP_Modifier,
-    tokenizeP_RegexpShorthand,
-    tokenizeP_FnShorthand,
-    tokenizeP_CollectionAccessor,
+    tokenizeA_BasePrefixedNumber,
+    tokenizeA_Number,
+    tokenizeA_Operator,
+    tokenizeA_ReservedSymbolToken,
+    tokenizeA_Symbol,
 ], false);
 
-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 },
-    'for': { value: null, forbidden: true },
+var whitespaceRegExp = /\s|,/;
+var tokenizeP_Comment = function (input, position) {
+    if (input[position] === ';') {
+        var length_1 = 0;
+        var value = '';
+        while (input[position + length_1] !== '\n' && position + length_1 < input.length) {
+            value += input[position + length_1];
+            length_1 += 1;
+        }
+        return [length_1, ['P_Comment', value]];
+    }
+    return NO_MATCH;
 };
-
-var identifierRegExp = new RegExp(algebraicIdentifierCharacterClass);
-var identifierFirstCharacterRegExp = new RegExp(algebraicIdentifierFirstCharacterClass);
-var whitespaceRegExp = /\s/;
-var tokenizeA_Whitespace = function (input, position) {
+var tokenizeP_Whitespace = function (input, position) {
     var char = input[position];
     if (!char || !whitespaceRegExp.test(char)) {
         return NO_MATCH;
@@ -8273,14 +8396,15 @@ var tokenizeA_Whitespace = function (input, position) {
         position += 1;
         char = input[position];
     }
-    return [value.length, ['A_Whitespace', value]];
+    return [value.length, ['P_Whitespace', value]];
 };
+var endOfNumberRegExp = /[\s)\]},;#`]/;
 var decimalNumberRegExp = /\d/;
 var octalNumberRegExp = /[0-7]/;
 var hexNumberRegExp = /[0-9a-f]/i;
 var binaryNumberRegExp = /[01]/;
-var firstCharRegExp = /[0-9.]/;
-var tokenizeA_Number = function (input, position) {
+var firstCharRegExp = /[0-9.-]/;
+var tokenizeP_Number = function (input, position) {
     var type = 'decimal';
     var firstChar = input[position];
     if (!firstCharRegExp.test(firstChar))
@@ -8289,7 +8413,14 @@ var tokenizeA_Number = function (input, position) {
     var i;
     for (i = position + 1; i < input.length; i += 1) {
         var char = input[i];
-        if ((i === position + 1 && firstChar === '0')) {
+        if (endOfNumberRegExp.test(char))
+            break;
+        if (char === '.') {
+            var nextChar = input[i + 1];
+            if (typeof nextChar === 'string' && !decimalNumberRegExp.test(nextChar))
+                break;
+        }
+        if (i === position + 1 && firstChar === '0') {
             if (char === 'b' || char === 'B') {
                 type = 'binary';
                 continue;
@@ -8303,30 +8434,6 @@ var tokenizeA_Number = function (input, position) {
                 continue;
             }
         }
-        if (type === 'decimal') {
-            if (hasDecimals) {
-                if (!decimalNumberRegExp.test(char)) {
-                    break;
-                }
-            }
-            else if (char !== '.' && !decimalNumberRegExp.test(char)) {
-                break;
-            }
-        }
-        if (type === 'binary' && !binaryNumberRegExp.test(char)) {
-            break;
-        }
-        if (type === 'octal' && !octalNumberRegExp.test(char)) {
-            break;
-        }
-        if (type === 'hex' && !hexNumberRegExp.test(char)) {
-            break;
-        }
-        if (char === '.') {
-            var nextChar = input[i + 1];
-            if (typeof nextChar === 'string' && !decimalNumberRegExp.test(nextChar))
-                break;
-        }
         if (type === 'decimal' && hasDecimals) {
             if (!decimalNumberRegExp.test(char))
                 return NO_MATCH;
@@ -8356,22 +8463,70 @@ var tokenizeA_Number = function (input, position) {
     var value = input.substring(position, i);
     if ((type !== 'decimal' && length <= 2) || value === '.' || value === '-')
         return NO_MATCH;
-    return [length, ['A_Number', value]];
+    return [length, ['P_Number', value]];
 };
-var tokenizeA_ReservedSymbolToken = function (input, position) {
+var P_symbolRegExp = new RegExp(polishIdentifierCharacterClass);
+var tokenizeP_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 escaping = false;
+        while (char !== '\'' || escaping) {
+            if (char === undefined)
+                throw new LitsError("Unclosed string at position ".concat(position, "."), undefined);
+            length_2 += 1;
+            if (escaping) {
+                escaping = false;
+                value += char;
+            }
+            else {
+                if (char === '\\') {
+                    escaping = true;
+                }
+                value += char;
+            }
+            char = input[position + length_2];
+        }
+        value += '\''; // closing quote
+        return [length_2 + 1, ['P_Symbol', value]];
+    }
+    if (P_symbolRegExp.test(value)) {
+        var initialPosition = position;
+        position += 1;
+        var char = input[position];
+        while (char && P_symbolRegExp.test(char)) {
+            value += char;
+            position += 1;
+            char = input[position];
+        }
+        return [position - initialPosition, ['P_Symbol', value]];
+    }
+    return NO_MATCH;
+};
+var tokenizeP_FnShorthand = function (input, position) {
+    if (input.slice(position, position + 2) !== '#(')
+        return NO_MATCH;
+    return [1, ['P_FnShorthand']];
+};
+var tokenizeP_ReservedSymbol = function (input, position) {
     var e_1, _a;
     try {
-        for (var _b = __values(Object.entries(algebraicReservedNamesRecord)), _c = _b.next(); !_c.done; _c = _b.next()) {
+        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_1 = reservedName.length;
-            var nextChar = input[position + length_1];
-            if (nextChar && identifierRegExp.test(nextChar))
+            var length_3 = reservedName.length;
+            var nextChar = input[position + length_3];
+            if (nextChar && P_symbolRegExp.test(nextChar)) {
                 continue;
-            var name_1 = input.substring(position, position + length_1);
-            if (name_1 === reservedName) {
+            }
+            var symbol = input.substring(position, position + length_3);
+            if (symbol === reservedName) {
                 if (forbidden)
-                    throw new LitsError("".concat(name_1, " is forbidden!"), undefined);
-                return [length_1, ['A_ReservedSymbol', reservedName]];
+                    throw new LitsError("".concat(symbol, " is forbidden!"), undefined);
+                return [length_3, ['P_ReservedSymbol', reservedName]];
             }
         }
     }
@@ -8384,93 +8539,76 @@ var tokenizeA_ReservedSymbolToken = function (input, position) {
     }
     return NO_MATCH;
 };
-var tokenizeA_Symbol = function (input, position) {
-    var initialPosition = position;
-    var value = input[position];
-    if (!value) {
+var tokenizeP_StringShorthand = function (input, position) {
+    if (input[position] !== ':')
         return NO_MATCH;
+    var symbolDescription = tokenizeP_Symbol(input, position + 1);
+    if (isNoMatch(symbolDescription)) {
+        return symbolDescription;
     }
-    if (identifierFirstCharacterRegExp.test(value)) {
-        position += 1;
-        var char = input[position];
-        while (char && identifierRegExp.test(char)) {
-            value += char;
-            position += 1;
-            char = input[position];
+    var symbolToken = asP_SymbolToken(symbolDescription[1]);
+    return [symbolDescription[0] + 1, ['P_StringShorthand', ":".concat(symbolToken[1])]];
+};
+var tokenizeP_Modifier = function (input, position) {
+    var e_2, _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 value = modifierName;
+                return [length_4, ['P_Modifier', value]];
+            }
         }
-        return [position - initialPosition, ['A_Symbol', value]];
     }
-    if (value === '\'') {
-        position += 1;
-        var _a = __read(tokenizeP_Symbol(input, position), 2), count = _a[0], pfSymbolToken = _a[1];
-        if (pfSymbolToken === undefined) {
-            return NO_MATCH;
-        }
-        position += count;
-        if (input[position] !== '\'') {
-            return NO_MATCH;
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (modifierNames_1_1 && !modifierNames_1_1.done && (_a = modifierNames_1.return)) _a.call(modifierNames_1);
         }
-        position += 1;
-        var pfValue = pfSymbolToken[1];
-        return [position - initialPosition, ['A_Symbol', pfValue]];
-    }
-    return NO_MATCH;
-};
-var tokenizeA_Operator = function (input, position) {
-    var _a;
-    var threeChars = input.slice(position, position + 3);
-    if (position + 2 < input.length && isAlgebraicOperator(threeChars)) {
-        return [3, ['A_Operator', threeChars]];
-    }
-    var twoChars = input.slice(position, position + 2);
-    if (position + 1 < input.length && isAlgebraicOperator(twoChars)) {
-        return [2, ['A_Operator', twoChars]];
-    }
-    var oneChar = (_a = input[position]) !== null && _a !== void 0 ? _a : '';
-    if (isAlgebraicOperator(oneChar)) {
-        return [1, ['A_Operator', oneChar]];
+        finally { if (e_2) throw e_2.error; }
     }
     return NO_MATCH;
 };
-var tokenizeA_MultiLineComment = function (input, position) {
-    if (input[position] === '/' && input[position + 1] === '*') {
-        var length_2 = 2;
-        var value = '/*';
-        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_2 + 1 >= input.length) {
-            throw new LitsError('Comment not closed', undefined);
-        }
-        value += '*/';
-        length_2 += 2;
-        return [length_2, ['A_MultiLineComment', value]];
-    }
-    return NO_MATCH;
+var tokenizeP_CollectionAccessor = function (input, position) {
+    var char = input[position];
+    if (char !== '.' && char !== '#')
+        return NO_MATCH;
+    return [1, ['P_CollectionAccessor', char]];
 };
-var tokenizeA_SingleLineComment = function (input, position) {
-    if (input[position] === '/' && input[position + 1] === '/') {
-        var length_3 = 2;
-        var value = '//';
-        while (input[position + length_3] !== '\n' && position + length_3 < input.length) {
-            value += input[position + length_3];
-            length_3 += 1;
+var tokenizeP_RegexpShorthand = function (input, position) {
+    if (input[position] !== '#')
+        return NO_MATCH;
+    var _a = __read(tokenizeString(input, position + 1), 2), stringLength = _a[0], token = _a[1];
+    if (!token)
+        return NO_MATCH;
+    position += stringLength + 1;
+    var length = stringLength + 1;
+    var options = '';
+    while (input[position] === 'g' || input[position] === 'i') {
+        if (options.includes(input[position])) {
+            throw new LitsError("Duplicated regexp option \"".concat(input[position], "\" at position ").concat(position, "."), undefined);
         }
-        return [length_3, ['A_SingleLineComment', value]];
+        options += input[position];
+        length += 1;
+        position += 1;
     }
-    return NO_MATCH;
+    return [length, ['P_RegexpShorthand', "#".concat(token[1]).concat(options)]];
 };
 // All tokenizers, order matters!
-var algebraicTokenizers = __spreadArray(__spreadArray([
-    tokenizeA_Whitespace,
-    tokenizeA_MultiLineComment,
-    tokenizeA_SingleLineComment
+var polishTokenizers = __spreadArray(__spreadArray([
+    tokenizeP_Whitespace,
+    tokenizeP_Comment
 ], __read(commonTokenizers), false), [
-    tokenizeA_Number,
-    tokenizeA_Operator,
-    tokenizeA_ReservedSymbolToken,
-    tokenizeA_Symbol,
+    tokenizeP_StringShorthand,
+    tokenizeP_Number,
+    tokenizeP_ReservedSymbol,
+    tokenizeP_Symbol,
+    tokenizeP_Modifier,
+    tokenizeP_RegexpShorthand,
+    tokenizeP_FnShorthand,
+    tokenizeP_CollectionAccessor,
 ], false);
 
 var applyCollectionAccessors = function (tokenStream) {