@mojir/lits 2.1.5 → 2.1.7

package/dist/testFramework.esm.js

@@ -920,6 +920,32 @@ function assertCharArray(value, sourceCodeInfo) {
         throw getAssertionError('array of strings', value, sourceCodeInfo);
 }
 
+function mapObjects(_a) {
+    var colls = _a.colls, contextStack = _a.contextStack, executeFunction = _a.executeFunction, fn = _a.fn, sourceCodeInfo = _a.sourceCodeInfo;
+    assertObj(colls[0], sourceCodeInfo);
+    var keys = Object.keys(colls[0]);
+    var params = {};
+    colls.forEach(function (obj) {
+        assertObj(obj, sourceCodeInfo);
+        var objKeys = Object.keys(obj);
+        if (objKeys.length !== keys.length) {
+            throw new LitsError("All objects must have the same keys. Expected: ".concat(keys.join(', '), ". Found: ").concat(objKeys.join(', ')), sourceCodeInfo);
+        }
+        if (!objKeys.every(function (key) { return keys.includes(key); })) {
+            throw new LitsError("All objects must have the same keys. Expected: ".concat(keys.join(', '), ". Found: ").concat(objKeys.join(', ')), sourceCodeInfo);
+        }
+        Object.entries(obj).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            if (!params[key])
+                params[key] = [];
+            params[key].push(value);
+        });
+    });
+    return keys.reduce(function (result, key) {
+        result[key] = executeFunction(fn, params[key], contextStack, sourceCodeInfo);
+        return result;
+    }, {});
+}
 function cloneAndGetMeta(originalColl, keys, sourceCodeInfo) {
     var coll = cloneColl(originalColl);
     var butLastKeys = keys.slice(0, keys.length - 1);
@@ -1012,6 +1038,188 @@ function assoc(coll, key, value, sourceCodeInfo) {
     return copy;
 }
 var collectionNormalExpression = {
+    'filter': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            if (Array.isArray(coll)) {
+                var result = coll.filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
+                return result;
+            }
+            if (isString(coll)) {
+                return coll
+                    .split('')
+                    .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
+                    .join('');
+            }
+            return Object.entries(coll)
+                .filter(function (_a) {
+                var _b = __read(_a, 2), value = _b[1];
+                return executeFunction(fn, [value], contextStack, sourceCodeInfo);
+            })
+                .reduce(function (result, _a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                result[key] = value;
+                return result;
+            }, {});
+        },
+        paramCount: 2,
+    },
+    'map': {
+        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
+            var executeFunction = _a.executeFunction;
+            var fn = asFunctionLike(params.at(-1), sourceCodeInfo);
+            if (isObj(params[0])) {
+                return mapObjects({
+                    colls: params.slice(0, -1),
+                    fn: fn,
+                    sourceCodeInfo: sourceCodeInfo,
+                    contextStack: contextStack,
+                    executeFunction: executeFunction,
+                });
+            }
+            var seqs = params.slice(0, -1);
+            assertSeq(seqs[0], sourceCodeInfo);
+            var isStr = typeof seqs[0] === 'string';
+            var len = seqs[0].length;
+            seqs.slice(1).forEach(function (seq) {
+                if (isStr) {
+                    assertString(seq, sourceCodeInfo);
+                }
+                else {
+                    assertArray(seq, sourceCodeInfo);
+                }
+                len = Math.min(len, seq.length);
+            });
+            var paramArray = [];
+            var _loop_1 = function (i) {
+                paramArray.push(seqs.map(function (seq) { return seq[i]; }));
+            };
+            for (var i = 0; i < len; i++) {
+                _loop_1(i);
+            }
+            var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
+            if (!isStr) {
+                return mapped;
+            }
+            mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
+            return mapped.join('');
+        },
+        paramCount: { min: 2 },
+    },
+    'reduce': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduce(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduce(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
+    'reduce-right': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduceRight(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduceRight(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduceRight(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
+    'reductions': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_1 = [initial];
+                coll.split('').reduce(function (result, elem) {
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_1.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_1;
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_2 = [initial];
+                coll.reduce(function (result, elem) {
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_2.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_2;
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return [initial];
+                var resultArray_3 = [initial];
+                Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_3.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_3;
+            }
+        },
+        paramCount: 3,
+    },
     'get': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 2), coll = _a[0], key = _a[1];
@@ -1315,13 +1523,15 @@ var arrayNormalExpression = {
         paramCount: 2,
     },
     flatten: {
-        evaluate: function (_a) {
-            var _b = __read(_a, 1), seq = _b[0];
-            if (!Array.isArray(seq))
-                return [];
-            return seq.flat(Number.POSITIVE_INFINITY);
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), seq = _b[0], depth = _b[1];
+            assertArray(seq, sourceCodeInfo);
+            var actualDepth = depth === undefined || depth === Number.POSITIVE_INFINITY
+                ? Number.POSITIVE_INFINITY
+                : asNumber(depth, sourceCodeInfo, { integer: true, nonNegative: true });
+            return seq.flat(actualDepth);
         },
-        paramCount: 1,
+        paramCount: { min: 1, max: 2 },
     },
     mapcat: {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
@@ -1354,23 +1564,6 @@ var sequenceNormalExpression = {
         },
         paramCount: { min: 2, max: 3 },
     },
-    'filter': {
-        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
-            var executeFunction = _b.executeFunction;
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (Array.isArray(seq)) {
-                var result = seq.filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
-                return result;
-            }
-            return seq
-                .split('')
-                .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
-                .join('');
-        },
-        paramCount: 2,
-    },
     'first': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
@@ -1393,39 +1586,6 @@ var sequenceNormalExpression = {
         },
         paramCount: 1,
     },
-    'map': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var fn = asFunctionLike(params.at(-1), sourceCodeInfo);
-            var seqs = params.slice(0, -1);
-            assertSeq(seqs[0], sourceCodeInfo);
-            var isString = typeof seqs[0] === 'string';
-            var len = seqs[0].length;
-            seqs.slice(1).forEach(function (seq) {
-                if (isString) {
-                    assertString(seq, sourceCodeInfo);
-                }
-                else {
-                    assertArray(seq, sourceCodeInfo);
-                }
-                len = Math.min(len, seq.length);
-            });
-            var paramArray = [];
-            var _loop_1 = function (i) {
-                paramArray.push(seqs.map(function (seq) { return seq[i]; }));
-            };
-            for (var i = 0; i < len; i++) {
-                _loop_1(i);
-            }
-            var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
-            if (!isString) {
-                return mapped;
-            }
-            mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
-            return mapped.join('');
-        },
-        paramCount: { min: 2 },
-    },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
@@ -1508,160 +1668,6 @@ var sequenceNormalExpression = {
         },
         paramCount: { min: 2 },
     },
-    'reductions': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return [executeFunction(fn, [], contextStack, sourceCodeInfo)];
-                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);
-                        resultArray_1.push(newVal);
-                        return newVal;
-                    }, asAny(chars[0], sourceCodeInfo));
-                    return resultArray_1;
-                }
-                else {
-                    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(seq[0]));
-                    return resultArray_2;
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    assertString(val, sourceCodeInfo);
-                    if (seq.length === 0)
-                        return [val];
-                    var resultArray_3 = [val];
-                    seq.split('').reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_3.push(newVal);
-                        return newVal;
-                    }, val);
-                    return resultArray_3;
-                }
-                else {
-                    if (seq.length === 0)
-                        return [val];
-                    var resultArray_4 = [val];
-                    seq.reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_4.push(newVal);
-                        return newVal;
-                    }, val);
-                    return resultArray_4;
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
-    'reduce': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return executeFunction(fn, [], contextStack, sourceCodeInfo);
-                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 seq.slice(1).reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, toAny(seq[0]));
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    assertString(val, sourceCodeInfo);
-                    if (seq.length === 0)
-                        return val;
-                    return seq.split('').reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-                else {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
-    'reduce-right': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return executeFunction(fn, [], contextStack, sourceCodeInfo);
-                else if (seq.length === 1)
-                    return toAny(seq[0]);
-                if (typeof seq === 'string') {
-                    var chars = seq.split('');
-                    return chars.slice(0, chars.length - 1).reduceRight(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        assertString(newVal, sourceCodeInfo);
-                        return newVal;
-                    }, chars[chars.length - 1]);
-                }
-                else {
-                    return seq.slice(0, seq.length - 1).reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, asAny(seq[seq.length - 1], sourceCodeInfo));
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                assertSeq(seq, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.split('').reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-                else {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
@@ -1980,7 +1986,7 @@ var sequenceNormalExpression = {
             assertSeq(input, sourceCodeInfo);
             if (Array.isArray(input)) {
                 var result = [];
-                var _loop_2 = function (item) {
+                var _loop_1 = function (item) {
                     assertAny(item, sourceCodeInfo);
                     if (!result.some(function (existingItem) { return deepEqual(existingItem, item, sourceCodeInfo); })) {
                         result.push(item);
@@ -1989,7 +1995,7 @@ var sequenceNormalExpression = {
                 try {
                     for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
                         var item = input_1_1.value;
-                        _loop_2(item);
+                        _loop_1(item);
                     }
                 }
                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -3975,6 +3981,13 @@ var regexpNormalExpression = {
             assertString(sourceArg, sourceCodeInfo);
             var source = sourceArg || '(?:)';
             var flags = typeof flagsArg === 'string' ? flagsArg : '';
+            try {
+                // eslint-disable-next-line no-new
+                new RegExp(source, flags); // Throws if invalid regexp
+            }
+            catch (e) {
+                throw new LitsError("Invalid regular expression: ".concat(source, " ").concat(flags), sourceCodeInfo);
+            }
             return _b = {},
                 _b[REGEXP_SYMBOL] = true,
                 _b.sourceCodeInfo = sourceCodeInfo,
@@ -4293,6 +4306,15 @@ function applyPlaceholders(templateString, placeholders, sourceCodeInfo) {
 }
 
 var functionalNormalExpression = {
+    '|>': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), value = _c[0], func = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertFunctionLike(func, sourceCodeInfo);
+            return executeFunction(func, [value], contextStack, sourceCodeInfo);
+        },
+        paramCount: 2,
+    },
     'apply': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a), func = _c[0], params = _c.slice(1);
@@ -4313,20 +4335,6 @@ var functionalNormalExpression = {
         },
         paramCount: 1,
     },
-    'partial': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b;
-            var _c = __read(_a), fn = _c[0], params = _c.slice(1);
-            return _b = {},
-                _b[FUNCTION_SYMBOL] = true,
-                _b.sourceCodeInfo = sourceCodeInfo,
-                _b.functionType = 'Partial',
-                _b.function = asFunctionLike(fn, sourceCodeInfo),
-                _b.params = params,
-                _b;
-        },
-        paramCount: { min: 1 },
-    },
     'comp': {
         evaluate: function (params, sourceCodeInfo) {
             var _a;
@@ -7086,10 +7094,10 @@ var linearAlgebraNormalExpression = {
             assertVector(vectorA, sourceCodeInfo);
             assertVector(vectorB, sourceCodeInfo);
             if (vectorA.length < 2) {
-                throw new Error('Vectors must have at least 2 elements');
+                throw new LitsError('Vectors must have at least 2 elements', sourceCodeInfo);
             }
             if (vectorA.length !== vectorB.length) {
-                throw new Error('Vectors must be of the same length');
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
             }
             assertNumber(lag, sourceCodeInfo, {
                 integer: true,
@@ -8341,7 +8349,7 @@ var partitionsNormalExpressions = {
             if (n === 0)
                 return 1;
             if (n > partitionNumbers.length) {
-                throw new Error("n is too large. The maximum value is ".concat(partitionNumbers.length - 1, "."));
+                throw new LitsError("n is too large. The maximum value is ".concat(partitionNumbers.length - 1, "."), sourceCodeInfo);
             }
             return partitionNumbers[n - 1];
         },
@@ -10480,7 +10488,12 @@ var combinatoricalNormalExpression = {
             var _b = __read(_a, 2), a = _b[0], m = _b[1];
             assertNumber(a, sourceCodeInfo, { integer: true, positive: true });
             assertNumber(m, sourceCodeInfo, { integer: true, positive: true });
-            return modInverse(a, m);
+            try {
+                return modInverse(a, m);
+            }
+            catch (error) {
+                throw new LitsError(error, sourceCodeInfo);
+            }
         },
         paramCount: 2,
     },
@@ -10499,7 +10512,7 @@ var combinatoricalNormalExpression = {
             assertVector(remainders, sourceCodeInfo);
             assertVector(moduli, sourceCodeInfo);
             if (remainders.length !== moduli.length) {
-                throw new Error('Remainders and moduli must have the same length.');
+                throw new LitsError('Remainders and moduli must have the same length.', sourceCodeInfo);
             }
             try {
                 return chineseRemainder(remainders, moduli);
@@ -11253,6 +11266,7 @@ var nonNumberReservedSymbolRecord = {
     function: null,
     export: null,
     as: null,
+    _: null,
 };
 var phi = (1 + Math.sqrt(5)) / 2;
 var numberReservedSymbolRecord = {
@@ -11942,7 +11956,11 @@ var objectSpecialExpression = {
             }
             else {
                 var key = evaluateNode(keyNode, contextStack);
-                var value = evaluateNode(params[i + 1], contextStack);
+                var valueNode = params[i + 1];
+                if (valueNode === undefined) {
+                    throw new LitsError('Missing value for key', keyNode[2]);
+                }
+                var value = evaluateNode(valueNode, contextStack);
                 assertString(key, keyNode[2]);
                 result[key] = value;
             }
@@ -12102,8 +12120,27 @@ var functionExecutors = {
         }
     },
     Partial: function (fn, params, sourceCodeInfo, contextStack, _a) {
+        var e_2, _b;
         var executeFunction = _a.executeFunction;
-        return executeFunction(fn.function, __spreadArray(__spreadArray([], __read(fn.params), false), __read(params), false), contextStack, sourceCodeInfo);
+        var actualParams = __spreadArray([], __read(fn.params), false);
+        if (params.length !== fn.placeholders.length) {
+            throw new LitsError("(partial) expects ".concat(fn.placeholders.length, " arguments, got ").concat(params.length, "."), sourceCodeInfo);
+        }
+        var paramsCopy = __spreadArray([], __read(params), false);
+        try {
+            for (var _c = __values(fn.placeholders), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var placeholderIndex = _d.value;
+                actualParams.splice(placeholderIndex, 0, paramsCopy.shift());
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return executeFunction(fn.function, actualParams, contextStack, sourceCodeInfo);
     },
     Comp: function (fn, params, sourceCodeInfo, contextStack, _a) {
         var executeFunction = _a.executeFunction;
@@ -12129,66 +12166,66 @@ var functionExecutors = {
         return !executeFunction(fn.function, params, contextStack, sourceCodeInfo);
     },
     EveryPred: function (fn, params, sourceCodeInfo, contextStack, _a) {
-        var e_2, _b, e_3, _c;
+        var e_3, _b, e_4, _c;
         var executeFunction = _a.executeFunction;
         try {
             for (var _d = __values(fn.params), _e = _d.next(); !_e.done; _e = _d.next()) {
                 var f = _e.value;
                 try {
-                    for (var params_1 = (e_3 = void 0, __values(params)), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    for (var params_1 = (e_4 = void 0, __values(params)), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
                         var param = params_1_1.value;
                         var result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
                         if (!result)
                             return false;
                     }
                 }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
                 finally {
                     try {
                         if (params_1_1 && !params_1_1.done && (_c = params_1.return)) _c.call(params_1);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return true;
     },
     SomePred: function (fn, params, sourceCodeInfo, contextStack, _a) {
-        var e_4, _b, e_5, _c;
+        var e_5, _b, e_6, _c;
         var executeFunction = _a.executeFunction;
         try {
             for (var _d = __values(fn.params), _e = _d.next(); !_e.done; _e = _d.next()) {
                 var f = _e.value;
                 try {
-                    for (var params_2 = (e_5 = void 0, __values(params)), params_2_1 = params_2.next(); !params_2_1.done; params_2_1 = params_2.next()) {
+                    for (var params_2 = (e_6 = void 0, __values(params)), params_2_1 = params_2.next(); !params_2_1.done; params_2_1 = params_2.next()) {
                         var param = params_2_1.value;
                         var result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
                         if (result)
                             return true;
                     }
                 }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
                 finally {
                     try {
                         if (params_2_1 && !params_2_1.done && (_c = params_2.return)) _c.call(params_2);
                     }
-                    finally { if (e_5) throw e_5.error; }
+                    finally { if (e_6) throw e_6.error; }
                 }
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_5) throw e_5.error; }
         }
         return false;
     },
@@ -12261,6 +12298,9 @@ function evaluateString(node) {
 }
 function evaluateReservedSymbol(node) {
     var reservedName = node[1];
+    if (!['true', 'false', 'null'].includes(reservedName)) {
+        throw new LitsError("Reserved symbol ".concat(reservedName, " cannot be evaluated"), node[2]);
+    }
     var value = reservedSymbolRecord[reservedName];
     return asNonUndefined(value, node[2]);
 }
@@ -12268,7 +12308,8 @@ function evaluateNormalExpression(node, contextStack) {
     var sourceCodeInfo = node[2];
     var paramNodes = node[1][1];
     var params = [];
-    paramNodes.forEach(function (paramNode) {
+    var placeholders = [];
+    paramNodes.forEach(function (paramNode, index) {
         if (isSpreadNode(paramNode)) {
             var spreadValue = evaluateNode(paramNode[1], contextStack);
             if (Array.isArray(spreadValue)) {
@@ -12278,12 +12319,27 @@ function evaluateNormalExpression(node, contextStack) {
                 throw new LitsError("Spread operator requires an array, got ".concat(valueToString(paramNode)), paramNode[2]);
             }
         }
+        else if (paramNode[0] === NodeTypes.ReservedSymbol && paramNode[1] === '_') {
+            placeholders.push(index);
+        }
         else {
             params.push(evaluateNode(paramNode, contextStack));
         }
     });
     if (isNormalExpressionNodeWithName(node)) {
         var nameSymbol = node[1][0];
+        if (placeholders.length > 0) {
+            var fn = evaluateNode(nameSymbol, contextStack);
+            var partialFunction = {
+                '^^fn^^': true,
+                'function': asFunctionLike(fn, sourceCodeInfo),
+                'functionType': 'Partial',
+                params: params,
+                placeholders: placeholders,
+                sourceCodeInfo: sourceCodeInfo,
+            };
+            return partialFunction;
+        }
         if (isNormalBuiltinSymbolNode(nameSymbol)) {
             var type = nameSymbol[1];
             var normalExpression = builtin.allNormalExpressions[type];
@@ -12300,6 +12356,17 @@ function evaluateNormalExpression(node, contextStack) {
     else {
         var fnNode = node[1][0];
         var fn = asFunctionLike(evaluateNode(fnNode, contextStack), sourceCodeInfo);
+        if (placeholders.length > 0) {
+            var partialFunction = {
+                '^^fn^^': true,
+                'function': asFunctionLike(fn, sourceCodeInfo),
+                'functionType': 'Partial',
+                params: params,
+                placeholders: placeholders,
+                sourceCodeInfo: sourceCodeInfo,
+            };
+            return partialFunction;
+        }
         return executeFunction(fn, params, contextStack, sourceCodeInfo);
     }
 }
@@ -12605,6 +12672,7 @@ var binaryOperators = [
     '&&', // logical AND
     '||', // logical OR
     '??', // nullish coalescing
+    '|>', // pipe
 ];
 var otherOperators = [
     '->', // lambda
@@ -12783,21 +12851,30 @@ var tokenizeNumber = function (input, position) {
         var char = input[i];
         if (char === '_') {
             if (!decimalNumberRegExp.test(input[i - 1]) || !decimalNumberRegExp.test(input[i + 1])) {
-                return NO_MATCH;
+                if (i === start) {
+                    return NO_MATCH;
+                }
+                throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
             }
         }
         else if (char === '.') {
-            if (i === start || hasDecimalPoint || hasExponent) {
+            if (i === start) {
                 return NO_MATCH;
             }
+            if (hasDecimalPoint || hasExponent) {
+                throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
+            }
             hasDecimalPoint = true;
         }
         else if (char === 'e' || char === 'E') {
-            if (i === start || hasExponent) {
+            if (i === start) {
                 return NO_MATCH;
             }
+            if (hasExponent) {
+                throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
+            }
             if (input[i - 1] === '.' || input[i - 1] === '+' || input[i - 1] === '-') {
-                return NO_MATCH;
+                throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
             }
             if (input[i + 1] === '+' || input[i + 1] === '-') {
                 i += 1;
@@ -12817,7 +12894,7 @@ var tokenizeNumber = function (input, position) {
     }
     var nextChar = input[i];
     if (nextChar && !postNumberRegExp.test(nextChar)) {
-        return NO_MATCH;
+        throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
     }
     return [length, ['Number', input.substring(position, i)]];
 };
@@ -12983,10 +13060,10 @@ function tokenize(input, debug, filePath) {
         hasDebugData: debug,
     };
     while (position < input.length) {
-        var tokenDescriptor = getCurrentToken(input, position);
         var sourceCodeInfo = debug
             ? createSourceCodeInfo(input, position, filePath)
             : undefined;
+        var tokenDescriptor = getCurrentToken(input, position);
         if (!tokenDescriptor) {
             throw new LitsError("Unrecognized character '".concat(input[position], "'."), sourceCodeInfo);
         }
@@ -13096,9 +13173,6 @@ function isOperatorToken(token, operatorName) {
 }
 function assertOperatorToken(token, operatorName) {
     if (!isOperatorToken(token, operatorName)) {
-        if (operatorName) {
-            throw new LitsError("Unexpected token: ".concat(token, ", expected operator ").concat(operatorName), token[2]);
-        }
         throwUnexpectedToken('Operator', operatorName, token);
     }
 }
@@ -13168,8 +13242,8 @@ function isA_BinaryOperatorToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'Operator' && isBinaryOperator(token[1]);
 }
 function throwUnexpectedToken(expected, expectedValue, actual) {
-    var actualOutput = "".concat(actual[0], " '").concat(actual[1], "'");
-    throw new LitsError("Unexpected token: ".concat(actualOutput, ", expected ").concat(expected).concat(expectedValue ? " '".concat(expectedValue, "'") : ''), actual[2]);
+    var actualOutput = actual ? "".concat(actual[0], " '").concat(actual[1], "'") : 'end of input';
+    throw new LitsError("Unexpected token: ".concat(actualOutput, ", expected ").concat(expected).concat(expectedValue ? " '".concat(expectedValue, "'") : ''), actual === null || actual === void 0 ? void 0 : actual[2]);
 }
 
 function minifyTokenStream(tokenStream, _a) {
@@ -13198,8 +13272,8 @@ function untokenize(tokenStream) {
     }, '');
 }
 
-var exponentiationPrecedence = 10;
-var binaryFunctionalOperatorPrecedence = 1;
+var exponentiationPrecedence = 11;
+var binaryFunctionalOperatorPrecedence = 2;
 var placeholderRegexp = /^\$([1-9]\d?)?$/;
 function withSourceCodeInfo(node, sourceCodeInfo) {
     if (sourceCodeInfo) {
@@ -13214,38 +13288,40 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         case '*': // multiplication
         case '/': // division
         case '%': // remainder
-            return 9;
+            return 10;
         case '+': // addition
         case '-': // subtraction
-            return 8;
+            return 9;
         case '<<': // left shift
         case '>>': // signed right shift
         case '>>>': // unsigned right shift
-            return 7;
+            return 8;
         case '++': // string concatenation
-            return 6;
+            return 7;
         case '<': // less than
         case '<=': // less than or equal
         case '≤': // less than or equal
         case '>': // greater than
         case '>=': // greater than or equal
         case '≥': // greater than or equal
-            return 5;
+            return 6;
         case '=': // equal
         case '!=': // not equal
         case '≠': // not equal
         case '~': // approximate
         case '≈': // approximate
-            return 4;
+            return 5;
         case '&': // bitwise AND
         case 'xor': // bitwise XOR
         case '|': // bitwise OR
-            return 3;
+            return 4;
         case '&&': // logical AND
         case '||': // logical OR
         case '??': // nullish coalescing
-            return 2;
-        // leave room for binaryFunctionalOperatorPrecedence = 1
+            return 3;
+        case '|>': // pipe
+            return 1;
+        // leave room for binaryFunctionalOperatorPrecedence = 2
         /* v8 ignore next 2 */
         default:
             throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
@@ -13289,6 +13365,7 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '|':
         case '~':
         case '≈':
+        case '|>':
             return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
         case '&&':
         case '||':
@@ -13314,6 +13391,11 @@ var Parser = /** @class */ (function () {
     Parser.prototype.peek = function () {
         return this.tokenStream.tokens[this.parseState.position];
     };
+    Parser.prototype.peekSourceCodeInfo = function () {
+        var _a;
+        var currentToken = this.peek();
+        return currentToken ? currentToken[2] : (_a = this.tokenStream.tokens.at(-1)) === null || _a === void 0 ? void 0 : _a[2];
+    };
     Parser.prototype.peekAhead = function (count) {
         return this.tokenStream.tokens[this.parseState.position + count];
     };
@@ -13329,7 +13411,7 @@ var Parser = /** @class */ (function () {
             }
             else {
                 if (!this.isAtEnd()) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
         }
@@ -13418,15 +13500,21 @@ var Parser = /** @class */ (function () {
         }
         return left;
     };
+    Parser.prototype.asToken = function (token) {
+        if (!token) {
+            throw new LitsError('Unexpected end of input', this.peekSourceCodeInfo());
+        }
+        return token;
+    };
     Parser.prototype.parseOperand = function () {
         var operand = this.parseOperandPart();
         var token = this.peek();
         while (isOperatorToken(token, '.') || isLBracketToken(token) || isLParenToken(token)) {
             if (token[1] === '.') {
                 this.advance();
-                var symbolToken = this.peek();
+                var symbolToken = this.asToken(this.peek());
                 if (!isSymbolToken(symbolToken)) {
-                    throw new LitsError('Expected symbol', this.peek()[2]);
+                    throw new LitsError('Expected symbol', this.peekSourceCodeInfo());
                 }
                 var stringNode = withSourceCodeInfo([NodeTypes.String, symbolToken[1]], symbolToken[2]);
                 operand = createAccessorNode(operand, stringNode, token[2]);
@@ -13437,7 +13525,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
                 var expression = this.parseExpression();
                 if (!isRBracketToken(this.peek())) {
-                    throw new LitsError('Expected closing bracket', this.peek()[2]);
+                    throw new LitsError('Expected closing bracket', this.peekSourceCodeInfo());
                 }
                 operand = createAccessorNode(operand, expression, token[2]);
                 this.advance();
@@ -13451,7 +13539,7 @@ var Parser = /** @class */ (function () {
         return operand;
     };
     Parser.prototype.parseOperandPart = function () {
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         // Parentheses
         if (isLParenToken(token)) {
             var positionBefore = this.parseState.position;
@@ -13463,7 +13551,7 @@ var Parser = /** @class */ (function () {
             this.advance();
             var expression = this.parseExpression();
             if (!isRParenToken(this.peek())) {
-                throw new LitsError('Expected closing parenthesis', this.peek()[2]);
+                throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
             }
             this.advance();
             return expression;
@@ -13523,7 +13611,7 @@ var Parser = /** @class */ (function () {
         while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             if (isOperatorToken(this.peek(), '...')) {
                 this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
             }
             else {
                 var token = this.peek();
@@ -13539,7 +13627,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 else {
-                    throw new LitsError('Expected key to be a symbol or a string', this.peek()[2]);
+                    throw new LitsError('Expected key to be a symbol or a string', this.peekSourceCodeInfo());
                 }
                 assertOperatorToken(this.peek(), ':=');
                 this.advance();
@@ -13547,7 +13635,7 @@ var Parser = /** @class */ (function () {
             }
             var nextToken = this.peek();
             if (!isOperatorToken(nextToken, ',') && !isRBraceToken(nextToken)) {
-                throw new LitsError('Expected comma or closing brace', this.peek()[2]);
+                throw new LitsError('Expected comma or closing brace', this.peekSourceCodeInfo());
             }
             if (isOperatorToken(nextToken, ',')) {
                 this.advance();
@@ -13564,14 +13652,14 @@ var Parser = /** @class */ (function () {
         while (!this.isAtEnd() && !isRBracketToken(this.peek())) {
             if (isOperatorToken(this.peek(), '...')) {
                 this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
             }
             else {
                 params.push(this.parseExpression());
             }
             var nextToken = this.peek();
             if (!isOperatorToken(nextToken, ',') && !isRBracketToken(nextToken)) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
+                throw new LitsError('Expected comma or closing parenthesis', this.peekSourceCodeInfo());
             }
             if (isOperatorToken(nextToken, ',')) {
                 this.advance();
@@ -13582,26 +13670,27 @@ var Parser = /** @class */ (function () {
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.array, params]], firstToken[2]);
     };
     Parser.prototype.parseFunctionCall = function (symbol) {
+        var _a;
         this.advance();
         var params = [];
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
             if (isOperatorToken(this.peek(), '...')) {
                 this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
             }
             else {
                 params.push(this.parseExpression());
             }
             var nextToken = this.peek();
             if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
+                throw new LitsError('Expected comma or closing parenthesis', (_a = this.peek()) === null || _a === void 0 ? void 0 : _a[2]);
             }
             if (isOperatorToken(nextToken, ',')) {
                 this.advance();
             }
         }
         if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', this.peek()[2]);
+            throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
         }
         this.advance();
         if (isSpecialBuiltinSymbolNode(symbol)) { // Named function
@@ -13631,14 +13720,14 @@ var Parser = /** @class */ (function () {
                     if (params.length !== 1) {
                         throw new LitsError('Expected exactly one parameter', symbol[2]);
                     }
-                    var _a = __read(params, 1), param = _a[0];
+                    var _b = __read(params, 1), param = _b[0];
                     return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                 }
                 case specialExpressionTypes.throw: {
                     if (params.length !== 1) {
                         throw new LitsError('Expected exactly one parameter', symbol[2]);
                     }
-                    var _b = __read(params, 1), param = _b[0];
+                    var _c = __read(params, 1), param = _c[0];
                     return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                 }
                 case specialExpressionTypes['0_fn']:
@@ -13658,7 +13747,7 @@ var Parser = /** @class */ (function () {
         }
     };
     Parser.prototype.parseLambdaFunction = function () {
-        var firstToken = this.peek();
+        var firstToken = this.asToken(this.peek());
         if (isLParenToken(firstToken)
             && isSymbolToken(this.peekAhead(1))
             && isOperatorToken(this.peekAhead(2), '->')) {
@@ -13692,7 +13781,7 @@ var Parser = /** @class */ (function () {
         var functionArguments = [];
         while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isSymbolToken(this.peek(), 'let')) {
             if (rest) {
-                throw new LitsError('Rest argument must be last', this.peek()[2]);
+                throw new LitsError('Rest argument must be last', this.peekSourceCodeInfo());
             }
             var bindingTarget = this.parseBindingTarget();
             if (bindingTarget[1][1] !== undefined) {
@@ -13702,25 +13791,25 @@ var Parser = /** @class */ (function () {
                 rest = true;
             }
             if (defaults && !bindingTarget[1][1]) {
-                throw new LitsError('Default arguments must be last', this.peek()[2]);
+                throw new LitsError('Default arguments must be last', this.peekSourceCodeInfo());
             }
             functionArguments.push(bindingTarget);
             if (!isOperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isSymbolToken(this.peek(), 'let')) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
+                throw new LitsError('Expected comma or closing parenthesis', this.peekSourceCodeInfo());
             }
             if (isOperatorToken(this.peek(), ',')) {
                 this.advance();
             }
         }
         if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', this.peek()[2]);
+            throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
         }
         this.advance();
         return functionArguments;
     };
     Parser.prototype.parseShorthandLamdaFunction = function () {
         var _a;
-        var firstToken = this.peek();
+        var firstToken = this.asToken(this.peek());
         this.advance();
         var startPos = this.parseState.position;
         var exprNode = this.parseExpression();
@@ -13778,7 +13867,7 @@ var Parser = /** @class */ (function () {
             }
             var defaultValue = this.parseOptionalDefaulValue();
             if (requireDefaultValue && !defaultValue) {
-                throw new LitsError('Expected assignment', this.peek()[2]);
+                throw new LitsError('Expected assignment', this.peekSourceCodeInfo());
             }
             return withSourceCodeInfo([bindingTargetTypes.symbol, [symbol, defaultValue]], firstToken[2]);
         }
@@ -13790,7 +13879,7 @@ var Parser = /** @class */ (function () {
             this.advance();
             var symbol = asUserDefinedSymbolNode(this.parseSymbol());
             if (isOperatorToken(this.peek(), ':=')) {
-                throw new LitsError('Rest argument can not have default value', this.peek()[2]);
+                throw new LitsError('Rest argument can not have default value', this.peekSourceCodeInfo());
             }
             return withSourceCodeInfo([bindingTargetTypes.rest, [symbol[1], undefined]], firstToken[2]);
         }
@@ -13798,7 +13887,7 @@ var Parser = /** @class */ (function () {
         if (isLBracketToken(firstToken)) {
             this.advance();
             var elements = [];
-            var token = this.peek();
+            var token = this.asToken(this.peek());
             var rest = false;
             while (!isRBracketToken(token)) {
                 if (rest) {
@@ -13807,7 +13896,7 @@ var Parser = /** @class */ (function () {
                 if (isOperatorToken(token, ',')) {
                     elements.push(null);
                     this.advance();
-                    token = this.peek();
+                    token = this.asToken(this.peek());
                     continue;
                 }
                 var target = this.parseBindingTarget();
@@ -13815,17 +13904,17 @@ var Parser = /** @class */ (function () {
                     rest = true;
                 }
                 elements.push(target);
-                token = this.peek();
+                token = this.asToken(this.peek());
                 if (!isRBracketToken(token)) {
                     assertOperatorToken(token, ',');
                     this.advance();
                 }
-                token = this.peek();
+                token = this.asToken(this.peek());
             }
             this.advance();
             var defaultValue = this.parseOptionalDefaulValue();
             if (requireDefaultValue && !defaultValue) {
-                throw new LitsError('Expected assignment', this.peek()[2]);
+                throw new LitsError('Expected assignment', this.peekSourceCodeInfo());
             }
             return withSourceCodeInfo([bindingTargetTypes.array, [elements, defaultValue]], firstToken[2]);
         }
@@ -13833,7 +13922,7 @@ var Parser = /** @class */ (function () {
         if (isLBraceToken(firstToken)) {
             this.advance();
             var elements = {};
-            var token = this.peek();
+            var token = this.asToken(this.peek());
             var rest = false;
             while (!isRBraceToken(token)) {
                 if (rest) {
@@ -13844,7 +13933,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 var key = asUserDefinedSymbolNode(this.parseSymbol());
-                token = this.peek();
+                token = this.asToken(this.peek());
                 if (isReservedSymbolToken(token, 'as')) {
                     if (rest) {
                         throw new LitsError('Rest argument can not have alias', token[2]);
@@ -13861,7 +13950,7 @@ var Parser = /** @class */ (function () {
                         throw new LitsError("Duplicate binding name: ".concat(key), token[2]);
                     }
                     if (rest && isOperatorToken(this.peek(), ':=')) {
-                        throw new LitsError('Rest argument can not have default value', this.peek()[2]);
+                        throw new LitsError('Rest argument can not have default value', this.peekSourceCodeInfo());
                     }
                     elements[key[1]] = rest
                         ? withSourceCodeInfo([bindingTargetTypes.rest, [key[1], this.parseOptionalDefaulValue()]], firstToken[2])
@@ -13874,17 +13963,17 @@ var Parser = /** @class */ (function () {
                     assertOperatorToken(this.peek(), ',');
                     this.advance();
                 }
-                token = this.peek();
+                token = this.asToken(this.peek());
             }
             this.advance();
-            token = this.peek();
+            token = this.asToken(this.peek());
             var defaultValue = this.parseOptionalDefaulValue();
             if (requireDefaultValue && !defaultValue) {
                 throw new LitsError('Expected assignment', token[2]);
             }
             return withSourceCodeInfo([bindingTargetTypes.object, [elements, defaultValue]], firstToken[2]);
         }
-        throw new LitsError('Expected symbol', this.peek()[2]);
+        throw new LitsError('Expected symbol', this.peekSourceCodeInfo());
     };
     Parser.prototype.parseLet = function (token, optionalSemicolon) {
         if (optionalSemicolon === void 0) { optionalSemicolon = false; }
@@ -13907,7 +13996,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         assertReservedSymbolToken(this.peek(), 'end');
@@ -13931,7 +14020,7 @@ var Parser = /** @class */ (function () {
             token = this.peek();
         }
         if (bindingNodes.length === 0) {
-            throw new LitsError('Expected binding', this.peek()[2]);
+            throw new LitsError('Expected binding', this.peekSourceCodeInfo());
         }
         assertSymbolToken(token, 'do');
         this.advance();
@@ -13942,7 +14031,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         assertReservedSymbolToken(this.peek(), 'end');
@@ -13958,7 +14047,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'catch')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         var tryExpression = tryExpressions.length === 1
@@ -13980,7 +14069,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         assertReservedSymbolToken(this.peek(), 'end');
@@ -14016,7 +14105,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         assertReservedSymbolToken(this.peek(), 'end');
@@ -14030,13 +14119,13 @@ var Parser = /** @class */ (function () {
         this.advance();
         var bindingNode = this.parseBinding();
         var modifiers = [];
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each') && !isOperatorToken(token, ',')) {
             throw new LitsError('Expected do, each or comma', token[2]);
         }
         if (isOperatorToken(token, ',')) {
             this.advance();
-            token = this.peek();
+            token = this.asToken(this.peek());
         }
         if (!isSymbolToken(token, 'let')
             && !isReservedSymbolToken(token, 'when')
@@ -14056,14 +14145,14 @@ var Parser = /** @class */ (function () {
                     throw new LitsError('Duplicate binding', letNode[1][1][2]);
                 }
                 letBindings.push(letNode[1][1]);
-                token = this_2.peek();
+                token = this_2.asToken(this_2.peek());
                 if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this_2.peek(), 'each') && !isOperatorToken(token, ',')) {
                     throw new LitsError('Expected do, each or comma', token[2]);
                 }
                 if (isOperatorToken(token, ',')) {
                     this_2.advance();
                 }
-                token = this_2.peek();
+                token = this_2.asToken(this_2.peek());
             };
             var this_2 = this;
             while (isSymbolToken(token, 'let')) {
@@ -14089,14 +14178,14 @@ var Parser = /** @class */ (function () {
                 modifiers.push('&while');
                 whileNode = this.parseExpression();
             }
-            token = this.peek();
+            token = this.asToken(this.peek());
             if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each') && !isOperatorToken(token, ',')) {
                 throw new LitsError('Expected do or comma', token[2]);
             }
             if (isOperatorToken(token, ',')) {
                 this.advance();
             }
-            token = this.peek();
+            token = this.asToken(this.peek());
         }
         if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each')) {
             throw new LitsError('Expected do or each', token[2]);
@@ -14133,7 +14222,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'else') && !isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         var thenExpression = thenExpressions.length === 1
@@ -14149,7 +14238,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             elseExpression = elseExpressions.length === 1
@@ -14180,7 +14269,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
@@ -14215,7 +14304,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
@@ -14242,7 +14331,7 @@ var Parser = /** @class */ (function () {
                 this.advance();
             }
             else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peek()[2]);
+                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
         assertReservedSymbolToken(this.peek(), 'end');
@@ -14286,7 +14375,7 @@ var Parser = /** @class */ (function () {
                     this.advance();
                 }
                 else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             assertReservedSymbolToken(this.peek(), 'end');
@@ -14297,7 +14386,7 @@ var Parser = /** @class */ (function () {
                     ]]], token[2]);
         }
         else {
-            throw new LitsError('Expected let or function', this.peek()[2]);
+            throw new LitsError('Expected let or function', this.peekSourceCodeInfo());
         }
     };
     Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
@@ -14322,7 +14411,7 @@ var Parser = /** @class */ (function () {
         });
     };
     Parser.prototype.parseSymbol = function () {
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         this.advance();
         if (!isSymbolToken(token)) {
             throw new LitsError("Expected symbol token, got ".concat(token[0]), token[2]);
@@ -14344,7 +14433,7 @@ var Parser = /** @class */ (function () {
         return withSourceCodeInfo([NodeTypes.ReservedSymbol, token[1]], token[2]);
     };
     Parser.prototype.parseNumber = function () {
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         this.advance();
         var value = token[1];
         var negative = value[0] === '-';
@@ -14352,7 +14441,7 @@ var Parser = /** @class */ (function () {
         return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
     };
     Parser.prototype.parseString = function () {
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         this.advance();
         var value = token[1].substring(1, token[1].length - 1)
             .replace(/(\\{2})|(\\")|(\\n)|(\\t)|(\\r)|(\\b)|(\\f)|\\(.)/g, function (_, backslash, doubleQuote, newline, tab, carriageReturn, backspace, formFeed, normalChar) {
@@ -14384,7 +14473,7 @@ var Parser = /** @class */ (function () {
         return withSourceCodeInfo([NodeTypes.String, value], token[2]);
     };
     Parser.prototype.parseRegexpShorthand = function () {
-        var token = this.peek();
+        var token = this.asToken(this.peek());
         this.advance();
         var endStringPosition = token[1].lastIndexOf('"');
         var regexpString = token[1].substring(2, endStringPosition);