@mojir/lits 2.1.11 → 2.1.13

package/dist/lits.iife.js

@@ -400,6 +400,8 @@ var Lits = (function (exports) {
         if (options === void 0) { options = {}; }
         if (typeof value !== 'number')
             return false;
+        if (Number.isNaN(value))
+            return false;
         if (options.integer && !Number.isInteger(value))
             return false;
         if (options.finite && !Number.isFinite(value))
@@ -973,6 +975,35 @@ var Lits = (function (exports) {
             },
             paramCount: 2,
         },
+        'filteri': {
+            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, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); });
+                    return result;
+                }
+                if (isString(coll)) {
+                    return coll
+                        .split('')
+                        .filter(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); })
+                        .join('');
+                }
+                return Object.entries(coll)
+                    .filter(function (_a) {
+                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                    return executeFunction(fn, [value, key], 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;
@@ -1015,6 +1046,30 @@ var Lits = (function (exports) {
             },
             paramCount: { min: 2 },
         },
+        'mapi': {
+            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)) {
+                    return coll.map(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); });
+                }
+                if (isString(coll)) {
+                    return coll
+                        .split('')
+                        .map(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); })
+                        .join('');
+                }
+                return Object.entries(coll)
+                    .reduce(function (acc, _a) {
+                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                    acc[key] = executeFunction(fn, [value, key], contextStack, sourceCodeInfo);
+                    return acc;
+                }, {});
+            },
+            paramCount: 2,
+        },
         'reduce': {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
                 var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
@@ -1048,6 +1103,39 @@ var Lits = (function (exports) {
             },
             paramCount: 3,
         },
+        'reducei': {
+            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, index) {
+                        return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                    }, initial);
+                }
+                else if (Array.isArray(coll)) {
+                    if (coll.length === 0)
+                        return initial;
+                    return coll.reduce(function (result, elem, index) {
+                        return executeFunction(fn, [result, elem, index], 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), key = _b[0], elem = _b[1];
+                        return executeFunction(fn, [result, elem, key], 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];
@@ -1080,6 +1168,38 @@ var Lits = (function (exports) {
             },
             paramCount: 3,
         },
+        'reducei-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, index) {
+                        return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                    }, initial);
+                }
+                else if (Array.isArray(coll)) {
+                    if (coll.length === 0)
+                        return initial;
+                    return coll.reduceRight(function (result, elem, index) {
+                        return executeFunction(fn, [result, elem, index], 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), key = _b[0], elem = _b[1];
+                        return executeFunction(fn, [result, elem, key], 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];
@@ -1126,6 +1246,52 @@ var Lits = (function (exports) {
             },
             paramCount: 3,
         },
+        'reductionsi': {
+            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_4 = [initial];
+                    coll.split('').reduce(function (result, elem, index) {
+                        var newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                        resultArray_4.push(newVal);
+                        return newVal;
+                    }, initial);
+                    return resultArray_4;
+                }
+                else if (Array.isArray(coll)) {
+                    if (coll.length === 0)
+                        return [initial];
+                    var resultArray_5 = [initial];
+                    coll.reduce(function (result, elem, index) {
+                        var newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                        resultArray_5.push(newVal);
+                        return newVal;
+                    }, initial);
+                    return resultArray_5;
+                }
+                else {
+                    if (Object.keys(coll).length === 0)
+                        return [initial];
+                    var resultArray_6 = [initial];
+                    Object.entries(coll).reduce(function (result, _a) {
+                        var _b = __read(_a, 2), key = _b[0], elem = _b[1];
+                        var newVal = executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
+                        resultArray_6.push(newVal);
+                        return newVal;
+                    }, initial);
+                    return resultArray_6;
+                }
+            },
+            paramCount: 3,
+        },
         'get': {
             evaluate: function (params, sourceCodeInfo) {
                 var _a = __read(params, 2), coll = _a[0], key = _a[1];
@@ -1379,7 +1545,7 @@ var Lits = (function (exports) {
     };
 
     var arrayNormalExpression = {
-        range: {
+        'range': {
             evaluate: function (params, sourceCodeInfo) {
                 var _a = __read(params, 3), first = _a[0], second = _a[1], third = _a[2];
                 var from;
@@ -1417,7 +1583,7 @@ var Lits = (function (exports) {
             },
             paramCount: { min: 1, max: 3 },
         },
-        repeat: {
+        'repeat': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), value = _b[0], count = _b[1];
                 assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
@@ -1428,7 +1594,7 @@ var Lits = (function (exports) {
             },
             paramCount: 2,
         },
-        flatten: {
+        'flatten': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 2), seq = _b[0], depth = _b[1];
                 assertArray(seq, sourceCodeInfo);
@@ -1439,7 +1605,7 @@ var Lits = (function (exports) {
             },
             paramCount: { min: 1, max: 2 },
         },
-        mapcat: {
+        'mapcat': {
             evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
                 var _c = __read(_a, 2), arr = _c[0], fn = _c[1];
                 var executeFunction = _b.executeFunction;
@@ -1449,6 +1615,38 @@ var Lits = (function (exports) {
             },
             paramCount: 2,
         },
+        'moving-fn': {
+            evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+                var _c = __read(_a, 3), arr = _c[0], windowSize = _c[1], fn = _c[2];
+                var executeFunction = _b.executeFunction;
+                assertArray(arr, sourceCodeInfo);
+                assertNumber(windowSize, sourceCodeInfo, { integer: true, lte: arr.length });
+                assertFunctionLike(fn, sourceCodeInfo);
+                var result = [];
+                for (var i = 0; i <= arr.length - windowSize; i++) {
+                    var window_1 = arr.slice(i, i + windowSize);
+                    var value = executeFunction(fn, [window_1], contextStack, sourceCodeInfo);
+                    result.push(value);
+                }
+                return result;
+            },
+            paramCount: 3,
+        },
+        'running-fn': {
+            evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+                var _c = __read(_a, 2), arr = _c[0], fn = _c[1];
+                var executeFunction = _b.executeFunction;
+                assertArray(arr, sourceCodeInfo);
+                assertFunctionLike(fn, sourceCodeInfo);
+                var result = [];
+                for (var i = 0; i < arr.length; i += 1) {
+                    var subArr = arr.slice(0, i + 1);
+                    result.push(executeFunction(fn, [subArr], contextStack, sourceCodeInfo));
+                }
+                return result;
+            },
+            paramCount: 2,
+        },
     };
 
     var sequenceNormalExpression = {
@@ -2180,7 +2378,7 @@ var Lits = (function (exports) {
         if (vectors.has(vector)) {
             return true;
         }
-        if (vector.every(function (elem) { return isNumber(elem, { finite: true }); })) {
+        if (vector.every(function (elem) { return isNumber(elem); })) {
             annotatedArrays.add(vector);
             vectors.add(vector);
             return true;
@@ -2289,7 +2487,7 @@ var Lits = (function (exports) {
                 if (row.length !== nbrOfCols) {
                     return false;
                 }
-                if (row.some(function (cell) { return !isNumber(cell, { finite: true }); })) {
+                if (row.some(function (cell) { return !isNumber(cell); })) {
                     return false;
                 }
             }
@@ -3822,14 +4020,6 @@ var Lits = (function (exports) {
             },
             paramCount: 1,
         },
-        'nan?': {
-            evaluate: function (_a, sourceCodeInfo) {
-                var _b = __read(_a, 1), value = _b[0];
-                assertNumber(value, sourceCodeInfo);
-                return Number.isNaN(value);
-            },
-            paramCount: 1,
-        },
         'positive-infinity?': {
             evaluate: function (_a, sourceCodeInfo) {
                 var _b = __read(_a, 1), value = _b[0];
@@ -12546,8 +12736,13 @@ var Lits = (function (exports) {
                 return contextStack.evaluateSymbol(node);
             case NodeTypes.ReservedSymbol:
                 return evaluateReservedSymbol(node);
-            case NodeTypes.NormalExpression:
-                return annotate(evaluateNormalExpression(node, contextStack));
+            case NodeTypes.NormalExpression: {
+                var result = evaluateNormalExpression(node, contextStack);
+                if (typeof result === 'number' && Number.isNaN(result)) {
+                    throw new LitsError('Number is NaN', node[2]);
+                }
+                return annotate(result);
+            }
             case NodeTypes.SpecialExpression:
                 return annotate(evaluateSpecialExpression(node, contextStack));
             /* v8 ignore next 2 */
@@ -12939,6 +13134,8 @@ var Lits = (function (exports) {
         '|>', // pipe
     ];
     var otherOperators = [
+        '?', // conditional operator
+        ':', // conditional operator
         '->', // lambda
         '...', // rest
         '.', // property accessor
@@ -12948,17 +13145,12 @@ var Lits = (function (exports) {
     ];
     var symbolicOperators = __spreadArray(__spreadArray([], __read(binaryOperators), false), __read(otherOperators), false);
     var nonFunctionOperators = [
-        '??',
-        '&&',
-        '||',
         'comment',
         'cond',
         'def',
         'defined?',
-        // 'defn',
         'do',
         'doseq',
-        // 'fn',
         'if',
         'let',
         'loop',
@@ -13536,8 +13728,9 @@ var Lits = (function (exports) {
         }, '');
     }
 
-    var exponentiationPrecedence = 11;
-    var binaryFunctionalOperatorPrecedence = 2;
+    var exponentiationPrecedence = 12;
+    var binaryFunctionalOperatorPrecedence = 3;
+    var conditionalOperatorPrecedence = 1;
     var placeholderRegexp = /^\$([1-9]\d?)?$/;
     function withSourceCodeInfo(node, sourceCodeInfo) {
         if (sourceCodeInfo) {
@@ -13552,38 +13745,39 @@ var Lits = (function (exports) {
             case '*': // multiplication
             case '/': // division
             case '%': // remainder
-                return 10;
+                return 11;
             case '+': // addition
             case '-': // subtraction
-                return 9;
+                return 10;
             case '<<': // left shift
             case '>>': // signed right shift
             case '>>>': // unsigned right shift
-                return 8;
+                return 9;
             case '++': // string concatenation
-                return 7;
+                return 8;
             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 6;
+                return 7;
             case '=': // equal
             case '!=': // not equal
             case '≠': // not equal
-                return 5;
+                return 6;
             case '&': // bitwise AND
             case 'xor': // bitwise XOR
             case '|': // bitwise OR
-                return 4;
+                return 5;
             case '&&': // logical AND
             case '||': // logical OR
             case '??': // nullish coalescing
-                return 3;
+                return 4;
+            // leave room for binaryFunctionalOperatorPrecedence = 3
             case '|>': // pipe
-                return 1;
-            // leave room for binaryFunctionalOperatorPrecedence = 2
+                return 2;
+            // leave room for conditionalOperatorPrecedence = 1
             /* v8 ignore next 2 */
             default:
                 throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
@@ -13631,13 +13825,15 @@ var Lits = (function (exports) {
             case '||':
             case '??':
                 return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes[operatorName], [left, right]]], sourceCodeInfo);
-            /* v8 ignore next 10 */
+            /* v8 ignore next 11 */
             case '.':
             case ';':
             case ':=':
             case ',':
             case '->':
             case '...':
+            case '?':
+            case ':':
                 throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
             default:
                 throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
@@ -13753,6 +13949,19 @@ var Lits = (function (exports) {
                     }
                     left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
                 }
+                else if ((operator === null || operator === void 0 ? void 0 : operator[1]) === '?') {
+                    if (conditionalOperatorPrecedence <= precedence) {
+                        break;
+                    }
+                    this.advance();
+                    var trueNode = this.parseExpression();
+                    if (!isOperatorToken(this.peek(), ':')) {
+                        throw new LitsError('Expected :', this.peekSourceCodeInfo());
+                    }
+                    this.advance();
+                    var falseNode = this.parseExpression();
+                    left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
+                }
                 else {
                     break;
                 }
@@ -14939,10 +15148,15 @@ var Lits = (function (exports) {
     var api = {
         collection: [
             'filter',
+            'filteri',
             'map',
+            'mapi',
             'reduce',
+            'reducei',
             'reduce-right',
+            'reducei-right',
             'reductions',
+            'reductionsi',
             'count',
             'get',
             'get-in',
@@ -14963,6 +15177,8 @@ var Lits = (function (exports) {
             'repeat',
             'flatten',
             'mapcat',
+            'moving-fn',
+            'running-fn',
         ],
         sequence: [
             'nth',
@@ -15102,7 +15318,6 @@ var Lits = (function (exports) {
             'even?',
             'odd?',
             'finite?',
-            'nan?',
             'negative-infinity?',
             'positive-infinity?',
             'false?',
@@ -15439,7 +15654,7 @@ var Lits = (function (exports) {
     }
 
     var arrayReference = {
-        range: {
+        'range': {
             title: 'range',
             category: 'Array',
             linkName: 'range',
@@ -15464,7 +15679,7 @@ var Lits = (function (exports) {
                 "\nrange(\n  0.25, // start value\n  1,    // end value (exclusive)\n  0.25, // step value\n)",
             ],
         },
-        repeat: {
+        'repeat': {
             title: 'repeat',
             category: 'Array',
             linkName: 'repeat',
@@ -15483,7 +15698,7 @@ var Lits = (function (exports) {
                 '"Albert" repeat 5',
             ],
         },
-        flatten: {
+        'flatten': {
             title: 'flatten',
             category: 'Array',
             linkName: 'flatten',
@@ -15507,7 +15722,7 @@ var Lits = (function (exports) {
             ],
             noOperatorDocumentation: true,
         },
-        mapcat: {
+        'mapcat': {
             title: 'mapcat',
             category: 'Array',
             linkName: 'mapcat',
@@ -15532,6 +15747,60 @@ var Lits = (function (exports) {
                 "\nmapcat(\n  [[1, 2], [2, 2], [2, 3]],\n  -> $ remove even?\n)",
             ],
         },
+        'moving-fn': {
+            title: 'moving-fn',
+            category: 'Array',
+            linkName: 'moving-fn',
+            returns: {
+                type: 'array',
+            },
+            args: {
+                arr: {
+                    type: 'array',
+                },
+                windowSize: {
+                    type: 'number',
+                    description: 'The size of the moving window.',
+                },
+                fn: {
+                    type: 'function',
+                },
+            },
+            variants: [{
+                    argumentNames: ['arr', 'windowSize', 'fn'],
+                }],
+            description: 'Returns the result of applying $fn to each moving window of size $windowSize in $arr.',
+            examples: [
+                'moving-fn([1, 2, 3], 2, vec:sum)',
+                'moving-fn([1, 2, 3], 1, vec:sum)',
+                'moving-fn([1, 2, 3], 3, vec:sum)',
+            ],
+        },
+        'running-fn': {
+            title: 'running-fn',
+            category: 'Array',
+            linkName: 'running-fn',
+            returns: {
+                type: 'array',
+            },
+            args: {
+                a: {
+                    type: 'array',
+                },
+                b: {
+                    type: 'function',
+                },
+            },
+            variants: [{
+                    argumentNames: ['a', 'b'],
+                }],
+            description: 'Returns the result of applying $b to each element of $a.',
+            examples: [
+                'running-fn([1, 2, 3], vec:sum)',
+                'running-fn([1, 2, 3], vec:max)',
+                'running-fn([1, 2, 3], vec:min)',
+            ],
+        },
     };
 
     var assertReference = {
@@ -16192,6 +16461,32 @@ var Lits = (function (exports) {
                 "\nfilter(\n  { a := 1, b := 2 },\n  odd?\n)",
             ],
         },
+        'filteri': {
+            title: 'filteri',
+            category: 'Collection',
+            linkName: 'filteri',
+            returns: {
+                type: 'collection',
+            },
+            args: {
+                a: {
+                    type: 'collection',
+                },
+                b: {
+                    type: 'function',
+                    description: 'The function to call for each element in the collection. The function should take two arguments: the element itself and the index.',
+                },
+            },
+            variants: [
+                { argumentNames: ['a', 'b'] },
+            ],
+            description: 'Creates a new collection with all elements that pass the test implemented by $b. The function is called for each element in the collection, and it should take two arguments: the element itself and the index.',
+            examples: [
+                'filteri([1, 2, 3], (x, i) -> i % 2 = 0)',
+                'filteri([1, 2, 3], (x, i) -> x % 2 = 0)',
+                'filteri([1, 2, 3], (x, i) -> x + i > 3)',
+            ],
+        },
         'map': {
             title: 'map',
             category: 'Collection',
@@ -16220,6 +16515,34 @@ var Lits = (function (exports) {
                 'map({ a := 1, b := 2 }, { a := 10, b := 20 }, +)',
             ],
         },
+        'mapi': {
+            title: 'mapi',
+            category: 'Collection',
+            linkName: 'mapi',
+            returns: {
+                type: 'collection',
+            },
+            args: {
+                a: {
+                    type: 'collection',
+                },
+                b: {
+                    type: 'function',
+                    description: 'The function to call for each element in the collection. The function should take two arguments: the element itself and the index.',
+                },
+            },
+            variants: [
+                { argumentNames: ['a', 'b'] },
+            ],
+            description: 'Creates a new collection populated with the results of calling $b on every element in $a. The function is called for each element in the collection, and it should take two arguments: the element itself and the index.',
+            examples: [
+                'mapi([1, 2, 3], (x, i) -> x + i)',
+                'mapi([1, 2, 3], (x, i) -> x * i)',
+                'mapi([1, 2, 3], (x, i) -> x - i)',
+                'mapi([1, 2, 3], (x, i) -> x / i)',
+                'mapi([1, 2, 3], (x, i) -> x % inc(i))',
+            ],
+        },
         'reduce': {
             title: 'reduce',
             category: 'Collection',
@@ -16276,12 +16599,73 @@ var Lits = (function (exports) {
                 'reduce-right({ a := 1, b := 2 }, +, 0)',
             ],
         },
+        'reducei-right': {
+            title: 'reducei-right',
+            category: 'Collection',
+            linkName: 'reducei-right',
+            returns: {
+                type: 'any',
+            },
+            args: {
+                coll: {
+                    type: 'collection',
+                },
+                fun: {
+                    type: 'function',
+                    description: 'The function to call for each element in the collection. The function should take three arguments: the accumulator, the element itself, and the index.',
+                },
+                initial: {
+                    type: 'any',
+                    description: 'The initial value to use as the accumulator.',
+                },
+            },
+            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. The function is called for each element in the collection, and it should take three arguments: the accumulator, the element itself, and the index.',
+            examples: [
+                'reducei-right([1, 2, 3], (acc, x, i) -> acc + x + i, 0)',
+                'reducei-right("Albert", (acc, x, i) -> acc ++ x ++ i, "")',
+                'reducei-right({ a := 1, b := 2 }, -> $1 ++ $3, "")',
+            ],
+        },
+        'reducei': {
+            title: 'reducei',
+            category: 'Collection',
+            linkName: 'reducei',
+            returns: {
+                type: 'any',
+            },
+            args: {
+                coll: {
+                    type: 'collection',
+                },
+                fun: {
+                    type: 'function',
+                    description: 'The function to call for each element in the collection. The function should take three arguments: the accumulator, the element itself, and the index.',
+                },
+                initial: {
+                    type: 'any',
+                    description: 'The initial value to use as the accumulator.',
+                },
+            },
+            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. The function is called for each element in the collection, and it should take three arguments: the accumulator, the element itself, and the index.',
+            examples: [
+                'reducei([1, 2, 3], (acc, x, i) -> acc + x + i, 0)',
+                'reducei("Albert", (acc, x, i) -> acc ++ x ++ i, "")',
+                'reducei({ a := 1, b := 2 }, -> $1 ++ $3, "")',
+            ],
+        },
         'reductions': {
             title: 'reductions',
             category: 'Collection',
             linkName: 'reductions',
             returns: {
                 type: 'any',
+                array: true,
             },
             args: {
                 fun: {
@@ -16306,6 +16690,37 @@ var Lits = (function (exports) {
                 "\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)",
             ],
         },
+        'reductionsi': {
+            title: 'reductionsi',
+            category: 'Collection',
+            linkName: 'reductionsi',
+            returns: {
+                type: 'any',
+                array: true,
+            },
+            args: {
+                coll: {
+                    type: 'collection',
+                },
+                fun: {
+                    type: 'function',
+                    description: 'The function to call for each element in the collection. The function should take three arguments: the accumulator, the element itself, and the index.',
+                },
+                initial: {
+                    type: 'any',
+                    description: 'The initial value to use as the accumulator.',
+                },
+            },
+            variants: [
+                { argumentNames: ['coll', 'fun', 'initial'] },
+            ],
+            description: 'Returns an array of the intermediate values of the reduction (see `reduce`) of $coll by $fun. The function is called for each element in the collection, and it should take three arguments: the accumulator, the element itself, and the index.',
+            examples: [
+                'reductionsi([1, 2, 3], (acc, x, i) -> acc + x + i, 0)',
+                'reductionsi("Albert", (acc, x, i) -> acc ++ x ++ i, "")',
+                'reductionsi({ a := 1, b := 2 }, -> $1 ++ $3, "")',
+            ],
+        },
         'count': {
             title: 'count',
             category: 'Collection',
@@ -24770,30 +25185,6 @@ var Lits = (function (exports) {
                 'finite?(1.0)',
                 'finite?(1 / 0)',
                 'finite?(-1 / 0)',
-                'finite?(sqrt(-1))',
-            ],
-        },
-        'nan?': {
-            title: 'nan?',
-            category: 'Predicate',
-            linkName: 'nan-question',
-            returns: {
-                type: 'boolean',
-            },
-            args: {
-                x: {
-                    type: 'number',
-                },
-            },
-            variants: [
-                { argumentNames: ['x'] },
-            ],
-            description: 'Returns `true` if $x is NaN (! a number), otherwise `false`.',
-            examples: [
-                'nan?(1.0)',
-                'nan?(1 / 0)',
-                'nan?(-1 / 0)',
-                'nan?(sqrt(-1))',
             ],
         },
         'negative-infinity?': {
@@ -24816,7 +25207,6 @@ var Lits = (function (exports) {
                 'negative-infinity?(1.0)',
                 'negative-infinity?(1 / 0)',
                 'negative-infinity?(-1 / 0)',
-                'negative-infinity?(sqrt(-1))',
             ],
         },
         'positive-infinity?': {
@@ -24839,7 +25229,6 @@ var Lits = (function (exports) {
                 'positive-infinity?(1.0)',
                 'positive-infinity?(1 / 0)',
                 'positive-infinity?(-1 / 0)',
-                'positive-infinity?(sqrt(-1))',
             ],
         },
         'false?': {
@@ -30671,7 +31060,6 @@ var Lits = (function (exports) {
                 '12 nth:lcm  8',
                 'nth:lcm(100, 25)',
                 'nth:lcm(37, 1)',
-                'nth:lcm(0, 0)',
                 'nth:lcm(0, 5)',
                 'nth:lcm(5, 0)',
             ],