@mojir/lits 2.1.11 → 2.1.13

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.11";
+var version = "2.1.13";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -453,6 +453,8 @@ function isNumber(value, options) {
     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))
@@ -1088,6 +1090,35 @@ var collectionNormalExpression = {
         },
         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;
@@ -1130,6 +1161,30 @@ var collectionNormalExpression = {
         },
         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];
@@ -1163,6 +1218,39 @@ var collectionNormalExpression = {
         },
         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];
@@ -1195,6 +1283,38 @@ var collectionNormalExpression = {
         },
         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];
@@ -1241,6 +1361,52 @@ var collectionNormalExpression = {
         },
         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];
@@ -1494,7 +1660,7 @@ var collectionNormalExpression = {
 };
 
 var arrayNormalExpression = {
-    range: {
+    'range': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 3), first = _a[0], second = _a[1], third = _a[2];
             var from;
@@ -1532,7 +1698,7 @@ var arrayNormalExpression = {
         },
         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 });
@@ -1543,7 +1709,7 @@ var arrayNormalExpression = {
         },
         paramCount: 2,
     },
-    flatten: {
+    'flatten': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], depth = _b[1];
             assertArray(seq, sourceCodeInfo);
@@ -1554,7 +1720,7 @@ var arrayNormalExpression = {
         },
         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;
@@ -1564,6 +1730,38 @@ var arrayNormalExpression = {
         },
         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 = {
@@ -2295,7 +2493,7 @@ function isVector(vector) {
     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;
@@ -2404,7 +2602,7 @@ function isMatrix(matrix) {
             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;
             }
         }
@@ -3937,14 +4135,6 @@ var predicatesNormalExpression = {
         },
         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];
@@ -12506,8 +12696,13 @@ function evaluateNode(node, contextStack) {
             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 */
@@ -12899,6 +13094,8 @@ var binaryOperators = [
     '|>', // pipe
 ];
 var otherOperators = [
+    '?', // conditional operator
+    ':', // conditional operator
     '->', // lambda
     '...', // rest
     '.', // property accessor
@@ -12908,17 +13105,12 @@ var otherOperators = [
 ];
 var symbolicOperators = __spreadArray(__spreadArray([], __read(binaryOperators), false), __read(otherOperators), false);
 var nonFunctionOperators = [
-    '??',
-    '&&',
-    '||',
     'comment',
     'cond',
     'def',
     'defined?',
-    // 'defn',
     'do',
     'doseq',
-    // 'fn',
     'if',
     'let',
     'loop',
@@ -13496,8 +13688,9 @@ function untokenize(tokenStream) {
     }, '');
 }
 
-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) {
@@ -13512,38 +13705,39 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         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);
@@ -13591,13 +13785,15 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         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);
@@ -13713,6 +13909,19 @@ var Parser = /** @class */ (function () {
                 }
                 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;
             }
@@ -15056,10 +15265,15 @@ function getVectorReductionNames(name) {
 var api = {
     collection: [
         'filter',
+        'filteri',
         'map',
+        'mapi',
         'reduce',
+        'reducei',
         'reduce-right',
+        'reducei-right',
         'reductions',
+        'reductionsi',
         'count',
         'get',
         'get-in',
@@ -15080,6 +15294,8 @@ var api = {
         'repeat',
         'flatten',
         'mapcat',
+        'moving-fn',
+        'running-fn',
     ],
     sequence: [
         'nth',
@@ -15219,7 +15435,6 @@ var api = {
         'even?',
         'odd?',
         'finite?',
-        'nan?',
         'negative-infinity?',
         'positive-infinity?',
         'false?',
@@ -15535,7 +15750,7 @@ function getOperatorArgs(a, b) {
 }
 
 var arrayReference = {
-    range: {
+    'range': {
         title: 'range',
         category: 'Array',
         linkName: 'range',
@@ -15560,7 +15775,7 @@ var arrayReference = {
             "\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',
@@ -15579,7 +15794,7 @@ var arrayReference = {
             '"Albert" repeat 5',
         ],
     },
-    flatten: {
+    'flatten': {
         title: 'flatten',
         category: 'Array',
         linkName: 'flatten',
@@ -15603,7 +15818,7 @@ var arrayReference = {
         ],
         noOperatorDocumentation: true,
     },
-    mapcat: {
+    'mapcat': {
         title: 'mapcat',
         category: 'Array',
         linkName: 'mapcat',
@@ -15628,6 +15843,60 @@ var arrayReference = {
             "\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 = {
@@ -16288,6 +16557,32 @@ var collectionReference = {
             "\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',
@@ -16316,6 +16611,34 @@ var collectionReference = {
             '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',
@@ -16372,12 +16695,73 @@ var collectionReference = {
             '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: {
@@ -16402,6 +16786,37 @@ var collectionReference = {
             "\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',
@@ -24866,30 +25281,6 @@ var predicateReference = {
             '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?': {
@@ -24912,7 +25303,6 @@ var predicateReference = {
             'negative-infinity?(1.0)',
             'negative-infinity?(1 / 0)',
             'negative-infinity?(-1 / 0)',
-            'negative-infinity?(sqrt(-1))',
         ],
     },
     'positive-infinity?': {
@@ -24935,7 +25325,6 @@ var predicateReference = {
             'positive-infinity?(1.0)',
             'positive-infinity?(1 / 0)',
             'positive-infinity?(-1 / 0)',
-            'positive-infinity?(sqrt(-1))',
         ],
     },
     'false?': {
@@ -30767,7 +31156,6 @@ var numberTheoryReference = __assign(__assign(__assign(__assign(__assign(__assig
             '12 nth:lcm  8',
             'nth:lcm(100, 25)',
             'nth:lcm(37, 1)',
-            'nth:lcm(0, 0)',
             'nth:lcm(0, 5)',
             'nth:lcm(5, 0)',
         ],
@@ -32999,6 +33387,12 @@ class ExpressionParser {
  * @returns A string containing the symbolic representation
  */
 function prettyPi(num, config = {}) {
+    if (isNaN(num)) {
+        return "NaN";
+    }
+    if (!isFinite(num)) {
+        return num > 0 ? "∞" : "-∞";
+    }
     setConfig(config);
     const parser = new ExpressionParser();
     const exprTree = parser.parseNumber(num);
@@ -33022,10 +33416,6 @@ function stringifyValue(value, html) {
         return value.toString();
     if (typeof value === 'object' && value instanceof RegExp)
         return "".concat(value);
-    if (value === Number.POSITIVE_INFINITY)
-        return "".concat(Number.POSITIVE_INFINITY);
-    if (value === Number.NEGATIVE_INFINITY)
-        return "".concat(Number.NEGATIVE_INFINITY);
     if (typeof value === 'number') {
         return prettyPi(value);
     }
@@ -33049,7 +33439,37 @@ function stringifyValue(value, html) {
             }).join(', '), "]");
         }
     }
-    return JSON.stringify(value, null, 2);
+    return JSON.stringify(replaceInfinities(value), null, 2);
+}
+function replaceInfinities(value) {
+    var e_1, _a;
+    if (value === Number.POSITIVE_INFINITY) {
+        return '∞';
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+        return '-∞';
+    }
+    if (Array.isArray(value)) {
+        return value.map(replaceInfinities);
+    }
+    if (typeof value === 'object' && value !== null) {
+        var result = {};
+        try {
+            for (var _b = __values(Object.entries(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], val = _d[1];
+                result[key] = replaceInfinities(val);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return result;
+    }
+    return value;
 }
 function prettyIfNumber(value) {
     if (typeof value === 'number') {