@mojir/lits 2.1.5 → 2.1.7

package/dist/lits.iife.js

@@ -827,6 +827,32 @@ var Lits = (function (exports) {
             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);
@@ -919,6 +945,188 @@ var Lits = (function (exports) {
         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];
@@ -1222,13 +1430,15 @@ var Lits = (function (exports) {
             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) {
@@ -1261,23 +1471,6 @@ var Lits = (function (exports) {
             },
             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];
@@ -1300,39 +1493,6 @@ var Lits = (function (exports) {
             },
             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];
@@ -1415,160 +1575,6 @@ var Lits = (function (exports) {
             },
             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];
@@ -1887,7 +1893,7 @@ var Lits = (function (exports) {
                 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);
@@ -1896,7 +1902,7 @@ var Lits = (function (exports) {
                     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 }; }
@@ -3882,6 +3888,13 @@ var Lits = (function (exports) {
                 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,
@@ -4200,6 +4213,15 @@ var Lits = (function (exports) {
     }
 
     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);
@@ -4220,20 +4242,6 @@ var Lits = (function (exports) {
             },
             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;
@@ -6993,10 +7001,10 @@ var Lits = (function (exports) {
                 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,
@@ -8248,7 +8256,7 @@ var Lits = (function (exports) {
                 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];
             },
@@ -10387,7 +10395,12 @@ var Lits = (function (exports) {
                 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,
         },
@@ -10406,7 +10419,7 @@ var Lits = (function (exports) {
                 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);
@@ -11200,6 +11213,7 @@ var Lits = (function (exports) {
         function: null,
         export: null,
         as: null,
+        _: null,
     };
     var phi = (1 + Math.sqrt(5)) / 2;
     var numberReservedSymbolRecord = {
@@ -11914,7 +11928,11 @@ var Lits = (function (exports) {
                 }
                 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;
                 }
@@ -12164,8 +12182,27 @@ var Lits = (function (exports) {
             }
         },
         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;
@@ -12191,66 +12228,66 @@ var Lits = (function (exports) {
             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;
         },
@@ -12323,6 +12360,9 @@ var Lits = (function (exports) {
     }
     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]);
     }
@@ -12330,7 +12370,8 @@ var Lits = (function (exports) {
         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)) {
@@ -12340,12 +12381,27 @@ var Lits = (function (exports) {
                     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];
@@ -12362,6 +12418,17 @@ var Lits = (function (exports) {
         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);
         }
     }
@@ -12667,6 +12734,7 @@ var Lits = (function (exports) {
         '&&', // logical AND
         '||', // logical OR
         '??', // nullish coalescing
+        '|>', // pipe
     ];
     var otherOperators = [
         '->', // lambda
@@ -12845,21 +12913,30 @@ var Lits = (function (exports) {
             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;
@@ -12879,7 +12956,7 @@ var Lits = (function (exports) {
         }
         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)]];
     };
@@ -13045,10 +13122,10 @@ var Lits = (function (exports) {
             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);
             }
@@ -13158,9 +13235,6 @@ var Lits = (function (exports) {
     }
     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);
         }
     }
@@ -13230,8 +13304,8 @@ var Lits = (function (exports) {
         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) {
@@ -13260,8 +13334,8 @@ var Lits = (function (exports) {
         }, '');
     }
 
-    var exponentiationPrecedence = 10;
-    var binaryFunctionalOperatorPrecedence = 1;
+    var exponentiationPrecedence = 11;
+    var binaryFunctionalOperatorPrecedence = 2;
     var placeholderRegexp = /^\$([1-9]\d?)?$/;
     function withSourceCodeInfo(node, sourceCodeInfo) {
         if (sourceCodeInfo) {
@@ -13276,38 +13350,40 @@ var Lits = (function (exports) {
             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);
@@ -13351,6 +13427,7 @@ var Lits = (function (exports) {
             case '|':
             case '~':
             case '≈':
+            case '|>':
                 return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
             case '&&':
             case '||':
@@ -13376,6 +13453,11 @@ var Lits = (function (exports) {
         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];
         };
@@ -13391,7 +13473,7 @@ var Lits = (function (exports) {
                 }
                 else {
                     if (!this.isAtEnd()) {
-                        throw new LitsError('Expected ;', this.peek()[2]);
+                        throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                     }
                 }
             }
@@ -13480,15 +13562,21 @@ var Lits = (function (exports) {
             }
             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]);
@@ -13499,7 +13587,7 @@ var Lits = (function (exports) {
                     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();
@@ -13513,7 +13601,7 @@ var Lits = (function (exports) {
             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;
@@ -13525,7 +13613,7 @@ var Lits = (function (exports) {
                 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;
@@ -13585,7 +13673,7 @@ var Lits = (function (exports) {
             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();
@@ -13601,7 +13689,7 @@ var Lits = (function (exports) {
                         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();
@@ -13609,7 +13697,7 @@ var Lits = (function (exports) {
                 }
                 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();
@@ -13626,14 +13714,14 @@ var Lits = (function (exports) {
             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();
@@ -13644,26 +13732,27 @@ var Lits = (function (exports) {
             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
@@ -13693,14 +13782,14 @@ var Lits = (function (exports) {
                         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']:
@@ -13720,7 +13809,7 @@ var Lits = (function (exports) {
             }
         };
         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), '->')) {
@@ -13754,7 +13843,7 @@ var Lits = (function (exports) {
             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) {
@@ -13764,25 +13853,25 @@ var Lits = (function (exports) {
                     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();
@@ -13840,7 +13929,7 @@ var Lits = (function (exports) {
                 }
                 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]);
             }
@@ -13852,7 +13941,7 @@ var Lits = (function (exports) {
                 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]);
             }
@@ -13860,7 +13949,7 @@ var Lits = (function (exports) {
             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) {
@@ -13869,7 +13958,7 @@ var Lits = (function (exports) {
                     if (isOperatorToken(token, ',')) {
                         elements.push(null);
                         this.advance();
-                        token = this.peek();
+                        token = this.asToken(this.peek());
                         continue;
                     }
                     var target = this.parseBindingTarget();
@@ -13877,17 +13966,17 @@ var Lits = (function (exports) {
                         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]);
             }
@@ -13895,7 +13984,7 @@ var Lits = (function (exports) {
             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) {
@@ -13906,7 +13995,7 @@ var Lits = (function (exports) {
                         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]);
@@ -13923,7 +14012,7 @@ var Lits = (function (exports) {
                             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])
@@ -13936,17 +14025,17 @@ var Lits = (function (exports) {
                         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; }
@@ -13969,7 +14058,7 @@ var Lits = (function (exports) {
                     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');
@@ -13993,7 +14082,7 @@ var Lits = (function (exports) {
                 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();
@@ -14004,7 +14093,7 @@ var Lits = (function (exports) {
                     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');
@@ -14020,7 +14109,7 @@ var Lits = (function (exports) {
                     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
@@ -14042,7 +14131,7 @@ var Lits = (function (exports) {
                     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');
@@ -14078,7 +14167,7 @@ var Lits = (function (exports) {
                     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');
@@ -14092,13 +14181,13 @@ var Lits = (function (exports) {
             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')
@@ -14118,14 +14207,14 @@ var Lits = (function (exports) {
                         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')) {
@@ -14151,14 +14240,14 @@ var Lits = (function (exports) {
                     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]);
@@ -14195,7 +14284,7 @@ var Lits = (function (exports) {
                     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
@@ -14211,7 +14300,7 @@ var Lits = (function (exports) {
                         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
@@ -14242,7 +14331,7 @@ var Lits = (function (exports) {
                         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
@@ -14277,7 +14366,7 @@ var Lits = (function (exports) {
                         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
@@ -14304,7 +14393,7 @@ var Lits = (function (exports) {
                     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');
@@ -14348,7 +14437,7 @@ var Lits = (function (exports) {
                         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');
@@ -14359,7 +14448,7 @@ var Lits = (function (exports) {
                         ]]], 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) {
@@ -14384,7 +14473,7 @@ var Lits = (function (exports) {
             });
         };
         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]);
@@ -14406,7 +14495,7 @@ var Lits = (function (exports) {
             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] === '-';
@@ -14414,7 +14503,7 @@ var Lits = (function (exports) {
             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) {
@@ -14446,7 +14535,7 @@ var Lits = (function (exports) {
             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);
@@ -14651,6 +14740,11 @@ var Lits = (function (exports) {
     }
     var api = {
         collection: [
+            'filter',
+            'map',
+            'reduce',
+            'reduce-right',
+            'reductions',
             'count',
             'get',
             'get-in',
@@ -14680,11 +14774,6 @@ var Lits = (function (exports) {
             'shift',
             'slice',
             'splice',
-            'reductions',
-            'reduce',
-            'reduce-right',
-            'map',
-            'filter',
             'position',
             'index-of',
             'last-index-of',
@@ -14757,9 +14846,9 @@ var Lits = (function (exports) {
             'atanh',
         ],
         functional: [
+            '|>',
             'apply',
             'identity',
-            'partial',
             'comp',
             'constantly',
             'juxt',
@@ -15208,7 +15297,6 @@ var Lits = (function (exports) {
             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,
         },
@@ -15875,6 +15963,142 @@ var Lits = (function (exports) {
     };
 
     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',
@@ -16258,6 +16482,23 @@ var Lits = (function (exports) {
     };
 
     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',
@@ -16298,33 +16539,6 @@ var Lits = (function (exports) {
             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',
@@ -24636,134 +24850,6 @@ var Lits = (function (exports) {
                 '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',