@mojir/lits 2.1.5 → 2.1.7

package/dist/index.esm.js

@@ -824,6 +824,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);
@@ -916,6 +942,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];
@@ -1219,13 +1427,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) {
@@ -1258,23 +1468,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];
@@ -1297,39 +1490,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];
@@ -1412,160 +1572,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];
@@ -1884,7 +1890,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);
@@ -1893,7 +1899,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 }; }
@@ -3879,6 +3885,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,
@@ -4197,6 +4210,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);
@@ -4217,20 +4239,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;
@@ -6990,10 +6998,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,
@@ -8245,7 +8253,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];
         },
@@ -10384,7 +10392,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,
     },
@@ -10403,7 +10416,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);
@@ -11197,6 +11210,7 @@ var nonNumberReservedSymbolRecord = {
     function: null,
     export: null,
     as: null,
+    _: null,
 };
 var phi = (1 + Math.sqrt(5)) / 2;
 var numberReservedSymbolRecord = {
@@ -11911,7 +11925,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;
             }
@@ -12161,8 +12179,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;
@@ -12188,66 +12225,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;
     },
@@ -12320,6 +12357,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]);
 }
@@ -12327,7 +12367,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)) {
@@ -12337,12 +12378,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];
@@ -12359,6 +12415,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);
     }
 }
@@ -12664,6 +12731,7 @@ var binaryOperators = [
     '&&', // logical AND
     '||', // logical OR
     '??', // nullish coalescing
+    '|>', // pipe
 ];
 var otherOperators = [
     '->', // lambda
@@ -12842,21 +12910,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;
@@ -12876,7 +12953,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)]];
 };
@@ -13042,10 +13119,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);
         }
@@ -13155,9 +13232,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);
     }
 }
@@ -13227,8 +13301,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) {
@@ -13257,8 +13331,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) {
@@ -13273,38 +13347,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);
@@ -13348,6 +13424,7 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '|':
         case '~':
         case '≈':
+        case '|>':
             return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
         case '&&':
         case '||':
@@ -13373,6 +13450,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];
     };
@@ -13388,7 +13470,7 @@ var Parser = /** @class */ (function () {
             }
             else {
                 if (!this.isAtEnd()) {
-                    throw new LitsError('Expected ;', this.peek()[2]);
+                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
         }
@@ -13477,15 +13559,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]);
@@ -13496,7 +13584,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();
@@ -13510,7 +13598,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;
@@ -13522,7 +13610,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;
@@ -13582,7 +13670,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();
@@ -13598,7 +13686,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();
@@ -13606,7 +13694,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();
@@ -13623,14 +13711,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();
@@ -13641,26 +13729,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
@@ -13690,14 +13779,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']:
@@ -13717,7 +13806,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), '->')) {
@@ -13751,7 +13840,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) {
@@ -13761,25 +13850,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();
@@ -13837,7 +13926,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]);
         }
@@ -13849,7 +13938,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]);
         }
@@ -13857,7 +13946,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) {
@@ -13866,7 +13955,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();
@@ -13874,17 +13963,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]);
         }
@@ -13892,7 +13981,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) {
@@ -13903,7 +13992,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]);
@@ -13920,7 +14009,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])
@@ -13933,17 +14022,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; }
@@ -13966,7 +14055,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');
@@ -13990,7 +14079,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();
@@ -14001,7 +14090,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');
@@ -14017,7 +14106,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
@@ -14039,7 +14128,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');
@@ -14075,7 +14164,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');
@@ -14089,13 +14178,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')
@@ -14115,14 +14204,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')) {
@@ -14148,14 +14237,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]);
@@ -14192,7 +14281,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
@@ -14208,7 +14297,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
@@ -14239,7 +14328,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
@@ -14274,7 +14363,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
@@ -14301,7 +14390,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');
@@ -14345,7 +14434,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');
@@ -14356,7 +14445,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) {
@@ -14381,7 +14470,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]);
@@ -14403,7 +14492,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] === '-';
@@ -14411,7 +14500,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) {
@@ -14443,7 +14532,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);
@@ -14648,6 +14737,11 @@ function getVectorReductionNames(name) {
 }
 var api = {
     collection: [
+        'filter',
+        'map',
+        'reduce',
+        'reduce-right',
+        'reductions',
         'count',
         'get',
         'get-in',
@@ -14677,11 +14771,6 @@ var api = {
         'shift',
         'slice',
         'splice',
-        'reductions',
-        'reduce',
-        'reduce-right',
-        'map',
-        'filter',
         'position',
         'index-of',
         'last-index-of',
@@ -14754,9 +14843,9 @@ var api = {
         'atanh',
     ],
     functional: [
+        '|>',
         'apply',
         'identity',
-        'partial',
         'comp',
         'constantly',
         'juxt',
@@ -15205,7 +15294,6 @@ var arrayReference = {
         examples: [
             'flatten([1, 2, [3, 4], 5])',
             "\nlet foo := \"bar\";\nflatten([\n  1,\n  \" 2 A \",\n  [foo, [4, [\"ABC\"]]],\n  6,\n])",
-            'flatten(12)',
         ],
         noOperatorDocumentation: true,
     },
@@ -15872,6 +15960,142 @@ var bitwiseReference = {
 };
 
 var collectionReference = {
+    'filter': {
+        title: 'filter',
+        category: 'Collection',
+        linkName: 'filter',
+        returns: {
+            type: 'collection',
+        },
+        args: __assign(__assign({}, getOperatorArgs('collection', 'function')), { coll: {
+                type: 'collection',
+            }, fun: {
+                type: 'function',
+            } }),
+        variants: [
+            { argumentNames: ['coll', 'fun'] },
+        ],
+        description: 'Creates a new collection with all elements that pass the test implemented by $fun.',
+        examples: [
+            "\nfilter(\n  [\"Albert\", \"Mojir\", 160, [1, 2]],\n  string?\n)",
+            "\nfilter(\n  [5, 10, 15, 20],\n  -> $ > 10\n)",
+            "\nfilter(\n  { a := 1, b := 2 },\n  odd?\n)",
+        ],
+    },
+    'map': {
+        title: 'map',
+        category: 'Collection',
+        linkName: 'map',
+        returns: {
+            type: 'collection',
+        },
+        args: __assign(__assign({}, getOperatorArgs('collection', 'function')), { colls: {
+                type: 'collection',
+                rest: true,
+                description: 'At least one.',
+            }, fun: {
+                type: 'function',
+            } }),
+        variants: [
+            { argumentNames: ['colls', 'fun'] },
+        ],
+        description: 'Creates a new collection populated with the results of calling $fun on every element in $colls.',
+        examples: [
+            '[1, 2, 3] map -',
+            '[1, 2, 3] map -> -($)',
+            'map(["Albert", "Mojir", 42], str)',
+            'map([1, 2, 3], inc)',
+            'map([1, 2, 3], [1, 10, 100], *)',
+            'map({ a := 1, b := 2 }, inc)',
+            'map({ a := 1, b := 2 }, { a := 10, b := 20 }, +)',
+        ],
+    },
+    'reduce': {
+        title: 'reduce',
+        category: 'Collection',
+        linkName: 'reduce',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Runs $fun function on each element of the $coll, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $coll is a single value.',
+        examples: [
+            'reduce([1, 2, 3], +, 0)',
+            'reduce([], +, 0)',
+            'reduce({ a := 1, b := 2 }, +, 0)',
+            "\nreduce(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0)",
+        ],
+    },
+    'reduce-right': {
+        title: 'reduce-right',
+        category: 'Collection',
+        linkName: 'reduce-right',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Runs $fun function on each element of the $coll (starting from the last item), passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $coll is a single value.',
+        examples: [
+            'reduce-right(["A", "B", "C"], str, "")',
+            'reduce-right({ a := 1, b := 2 }, +, 0)',
+        ],
+    },
+    'reductions': {
+        title: 'reductions',
+        category: 'Collection',
+        linkName: 'reductions',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Returns an array of the intermediate values of the reduction (see `reduce`) of $coll by $fun.',
+        examples: [
+            'reductions([1, 2, 3], +, 0)',
+            'reductions([1, 2, 3], +, 10)',
+            'reductions([], +, 0)',
+            'reductions({ a := 1, b := 2 }, +, 0)',
+            "\nreductions(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0\n)",
+        ],
+    },
     'count': {
         title: 'count',
         category: 'Collection',
@@ -16255,6 +16479,23 @@ var collectionReference = {
 };
 
 var functionalReference = {
+    '|>': {
+        title: '|>',
+        category: 'Functional',
+        linkName: '-or-gt',
+        returns: {
+            type: 'any',
+        },
+        args: __assign({}, getOperatorArgs('any', 'function')),
+        variants: [
+            { argumentNames: ['a', 'b'] },
+        ],
+        description: 'Takes a value $a and a function $b, and returns the result of applying $b to $a.',
+        examples: [
+            "\n1 |> inc |> inc",
+            "range(10)\n  |> map(_, -> $ ^ 2) // [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n  |> filter(_, odd?)  // [1, 9, 25, 49, 81]\n  |> reduce(_, +, 0)  // 165\n  |> sqrt             // 12.84523257866513\n  |> round(_, 2)",
+        ],
+    },
     'apply': {
         title: 'apply',
         category: 'Functional',
@@ -16295,33 +16536,6 @@ var functionalReference = {
         description: 'Returns $x.',
         examples: ['identity(1)', 'identity("Albert")', 'identity({ a := 1 })', 'identity(null)'],
     },
-    'partial': {
-        title: 'partial',
-        category: 'Functional',
-        linkName: 'partial',
-        returns: {
-            type: 'function',
-        },
-        args: {
-            fun: {
-                type: 'function',
-            },
-            args: {
-                type: 'any',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['fun', 'args'] },
-        ],
-        description: "Takes a function $fun and a optional number arguments $args to $fun.\nIt returns a function that takes the additional additional arguments.\nWhen called, the returned function calls `(`$fun `...`$args` ...additional_arguments)`.",
-        examples: [
-            'partial(+, 100)',
-            "\nlet plusMany := partial(+, 100, 1000);\nplusMany(1, 10)",
-            "\nlet addHundred := partial(+, 100);\naddHundred(10)",
-        ],
-        noOperatorDocumentation: true,
-    },
     'comp': {
         title: 'comp',
         category: 'Functional',
@@ -24633,134 +24847,6 @@ var sequenceReference = {
             'splice("Albert", 2, 2, "fo")',
         ],
     },
-    'reductions': {
-        title: 'reductions',
-        category: 'Sequence',
-        linkName: 'reductions',
-        returns: {
-            type: 'any',
-            rest: true,
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-                rest: true,
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Returns an array of the intermediate values of the reduction (see `reduce`) of $seq by $fun.',
-        examples: [
-            '[1, 2, 3] reductions +',
-            'reductions([1, 2, 3], +)',
-            'reductions([1, 2, 3], +, 10)',
-            'reductions([], +, 0)',
-            "\nreductions(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0\n)",
-        ],
-    },
-    'reduce': {
-        title: 'reduce',
-        category: 'Sequence',
-        linkName: 'reduce',
-        returns: {
-            type: 'any',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Runs $fun function on each element of the $seq, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $seq is a single value.',
-        examples: [
-            '[1, 2, 3] reduce +',
-            'reduce([1, 2, 3], +)',
-            'reduce([1, 2, 3], +, 0)',
-            'reduce([], +, 0)',
-            "\nreduce(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0)",
-        ],
-    },
-    'reduce-right': {
-        title: 'reduce-right',
-        category: 'Sequence',
-        linkName: 'reduce-right',
-        returns: {
-            type: 'sequence',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Runs $fun function on each element of the $seq (starting from the last item), passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $seq is a single value.',
-        examples: [
-            'range(1, 10) reduce-right *',
-            'reduce-right(["A", "B", "C"], str, "")',
-        ],
-    },
-    'map': {
-        title: 'map',
-        category: 'Sequence',
-        linkName: 'map',
-        returns: {
-            type: 'any',
-            rest: true,
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seqs: {
-                type: 'sequence',
-                rest: true,
-                description: 'At least one.',
-            }, fun: {
-                type: 'function',
-            } }),
-        variants: [
-            { argumentNames: ['seqs', 'fun'] },
-        ],
-        description: 'Creates a new array populated with the results of calling $fun on every element in $seqs.',
-        examples: [
-            '[1, 2, 3] map -',
-            '[1, 2, 3] map -> -($)',
-            'map(["Albert", "Mojir", 42], str)',
-            'map([1, 2, 3], inc)',
-            'map([1, 2, 3], [1, 10, 100], *)',
-        ],
-    },
-    'filter': {
-        title: 'filter',
-        category: 'Sequence',
-        linkName: 'filter',
-        returns: {
-            type: 'sequence',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seq: {
-                type: 'sequence',
-            }, fun: {
-                type: 'function',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-        ],
-        description: 'Creates a new array with all elements that pass the test implemented by $fun.',
-        examples: [
-            "\nfilter(\n  [\"Albert\", \"Mojir\", 160, [1, 2]],\n  string?\n)",
-            "\nfilter(\n  [5, 10, 15, 20],\n  -> $ > 10\n)",
-        ],
-    },
     'position': {
         title: 'position',
         category: 'Sequence',