@mojir/lits 2.5.0 → 2.5.2

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ var readline = require('node:readline');
 var os = require('node:os');
 var process$1 = require('node:process');
 
-var version = "2.5.0";
+var version = "2.5.2";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -1224,7 +1224,7 @@ filter(
             },
             variants: [{ argumentNames: ['colls', 'fun'] }],
             description: 'Creates a new collection populated with the results of calling $fun on every element in $colls.',
-            seeAlso: ['collection.mapi', 'filter', 'reduce', 'mapcat', 'grid.map', 'grid.mapi'],
+            seeAlso: ['collection.mapi', 'filter', 'reduce', 'mapcat', 'grid.cell-map', 'grid.cell-mapi'],
             examples: [
                 '[1, 2, 3] map -',
                 '[1, 2, 3] map -> -($)',
@@ -1275,7 +1275,7 @@ filter(
             },
             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.',
-            seeAlso: ['collection.reduce-right', 'collection.reducei', 'collection.reductions', 'map', 'grid.reduce', 'grid.reducei'],
+            seeAlso: ['collection.reduce-right', 'collection.reducei', 'collection.reductions', 'map', 'grid.cell-reduce', 'grid.cell-reducei'],
             examples: [
                 'reduce([1, 2, 3], +, 0)',
                 'reduce([], +, 0)',
@@ -1655,7 +1655,7 @@ range(
             },
             variants: [{ argumentNames: ['a', 'b'] }],
             description: 'Returns an array with $a repeated $b times.',
-            seeAlso: ['range', 'vector.ones', 'vector.zeros', 'vector.fill', 'vector.generate', 'string.string-repeat'],
+            seeAlso: ['range', 'string.string-repeat'],
             examples: [
                 'repeat(10, 3)',
                 'repeat(10, 0)',
@@ -1904,7 +1904,7 @@ const sequenceNormalExpression = {
             args: { seq: { type: 'sequence' } },
             variants: [{ argumentNames: ['seq'] }],
             description: 'Returns a copy of $seq with last element removed. If $seq is empty `null` is returned.',
-            seeAlso: ['push', 'sequence.shift', 'last'],
+            seeAlso: ['push', 'last'],
             examples: [
                 'pop([1, 2, 3])',
                 'pop([])',
@@ -2004,7 +2004,7 @@ l`,
             description: `If $seq is an array, returns a new array with all but the first element from $seq.
 If $seq has less than two elements, an empty array is returned.
 For string $seq returns all but the first characters in $seq.`,
-            seeAlso: ['next', 'first', 'sequence.shift'],
+            seeAlso: ['next', 'first'],
             examples: [
                 'rest(["Albert", "Mojir", 160, [1, 2]])',
                 'rest(["Albert"])',
@@ -5183,7 +5183,7 @@ let add = (x, y) -> do
     y: Second number.
   Returns:
     Sum of x and y.
-  """
+  """;
   x + y;
 end;
 
@@ -5246,7 +5246,7 @@ const vectorNormalExpression = {
             },
             variants: [{ argumentNames: ['vector'] }],
             description: 'Returns the **sum** of all elements in the `vector`. Returns `0` for an empty vector.',
-            seeAlso: ['prod', 'mean', 'median', 'vector.sum'],
+            seeAlso: ['prod', 'mean', 'median', 'vector.moving-sum', 'vector.centered-moving-sum', 'vector.running-sum', 'vector.cumsum'],
             examples: [
                 'sum([1, 2, 3, 4, 5])',
                 'sum([1, -2, 3])',
@@ -5268,7 +5268,7 @@ const vectorNormalExpression = {
             },
             variants: [{ argumentNames: ['vector'] }],
             description: 'Returns the **product** of all elements in the `vector`. Returns `1` for an empty vector.',
-            seeAlso: ['sum', 'mean', 'median', 'vector.prod'],
+            seeAlso: ['sum', 'mean', 'median', 'vector.moving-prod', 'vector.centered-moving-prod', 'vector.running-prod', 'vector.cumprod'],
             examples: [
                 'prod([1, 2, 3, 4, 5])',
                 'prod([1, -2, 3])',
@@ -5290,7 +5290,7 @@ const vectorNormalExpression = {
             },
             variants: [{ argumentNames: ['vector'] }],
             description: 'Returns the arithmetic **mean** of all elements in the `vector`. Throws for an empty vector.',
-            seeAlso: ['median', 'sum', 'prod', 'vector.mean'],
+            seeAlso: ['median', 'sum', 'prod', 'vector.moving-mean', 'vector.centered-moving-mean', 'vector.running-mean', 'vector.geometric-mean', 'vector.harmonic-mean', 'vector.rms', 'vector.mode'],
             examples: [
                 'mean([1, 2, 3, 4, 5])',
                 'mean([1, -2, 3])',
@@ -5311,7 +5311,7 @@ const vectorNormalExpression = {
             },
             variants: [{ argumentNames: ['vector'] }],
             description: 'Returns the **median** of all elements in the `vector`. For even-length vectors, returns the average of the two middle values. Throws for an empty vector.',
-            seeAlso: ['mean', 'sum', 'prod', 'vector.median'],
+            seeAlso: ['mean', 'sum', 'prod', 'vector.moving-median', 'vector.centered-moving-median', 'vector.running-median', 'vector.mode', 'vector.quartiles', 'vector.percentile', 'vector.iqr', 'vector.medad'],
             examples: [
                 'median([1, 2, 3, 4, 5])',
                 'median([1, 2, 3, 4])',
@@ -6639,8 +6639,8 @@ const docs = {
     ],
     returns: { type: 'object' },
     examples: [
-        'let v = import(vector); v.mean([1, 2, 3, 4])',
-        'let { fill } = import(vector); fill(3, 0)',
+        'let v = import(vector); v.stdev([1, 2, 3, 4])',
+        'let { linspace } = import(vector); linspace(0, 10, 5)',
         'let g = import(grid); g.row([[1, 2], [3, 4]], 0)',
     ],
 };
@@ -8448,6 +8448,10 @@ function parseDo(ctx, allowDocString = false) {
     let docString = '';
     if (allowDocString && isDocStringToken(ctx.tryPeek())) {
         docString = parseDocString(ctx);
+        if (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+            assertOperatorToken(ctx.tryPeek(), ';');
+            ctx.advance();
+        }
     }
     const expressions = [];
     while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
@@ -10969,7 +10973,7 @@ const assertModule = {
 };
 
 const moduleDocs$5 = {
-    'every?': {
+    'cell-every?': {
         category: 'grid',
         description: 'Checks if all elements in a grid satisfy a predicate. Returns true only if the predicate returns true for every element in the grid.',
         returns: {
@@ -10992,9 +10996,9 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "every?" shadows a builtin function\nlet { every? as grid-every? } = import(grid);\ngrid-every?([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], string?)',
-            '// Using "as" alias because "every?" shadows a builtin function\nlet { every? as grid-every? } = import(grid);\ngrid-every?([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n], string?)',
-            '// Using "as" alias because "every?" shadows a builtin function\nlet { every? as grid-every? } = import(grid);\ngrid-every?([\n  [1, 2],\n  [3, 4],\n], string?)',
+            'let { cell-every? } = import(grid);\ncell-every?([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], string?)',
+            'let { cell-every? } = import(grid);\ncell-every?([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n], string?)',
+            'let { cell-every? } = import(grid);\ncell-every?([\n  [1, 2],\n  [3, 4],\n], string?)',
         ],
         seeAlso: ['collection.every?', 'grid.some?', 'grid.every-row?', 'grid.every-col?'],
     },
@@ -11025,7 +11029,7 @@ const moduleDocs$5 = {
             'let { some? } = import(grid);\nsome?([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n], string?)',
             'let { some? } = import(grid);\nsome?([\n  [1, 2],\n  [3, 4],\n], string?)',
         ],
-        seeAlso: ['collection.any?', 'grid.every?', 'grid.some-row?', 'grid.some-col?'],
+        seeAlso: ['collection.any?', 'grid.cell-every?', 'grid.some-row?', 'grid.some-col?'],
     },
     'every-row?': {
         category: 'grid',
@@ -11054,7 +11058,7 @@ const moduleDocs$5 = {
             'let { every-row? } = import(grid);\nevery-row?([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n], -> string?($[0]))',
             'let { every-row? } = import(grid);\nevery-row?([\n  [1, 2],\n  [3, 4],\n], -> string?($[0]))',
         ],
-        seeAlso: ['grid.some-row?', 'grid.every-col?', 'grid.every?'],
+        seeAlso: ['grid.some-row?', 'grid.every-col?', 'grid.cell-every?'],
     },
     'some-row?': {
         category: 'grid',
@@ -11112,7 +11116,7 @@ const moduleDocs$5 = {
             'let { every-col? } = import(grid);\nevery-col?([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n], -> string?($[0]))',
             'let { every-col? } = import(grid);\nevery-col?([\n  [1, 2],\n  [3, 4],\n], -> string?($[0]))',
         ],
-        seeAlso: ['grid.some-col?', 'grid.every-row?', 'grid.every?'],
+        seeAlso: ['grid.some-col?', 'grid.every-row?', 'grid.cell-every?'],
     },
     'some-col?': {
         category: 'grid',
@@ -11260,7 +11264,7 @@ const moduleDocs$5 = {
             'let { fill } = import(grid);\nfill(2, 3, 0)',
             'let { fill } = import(grid);\nfill(2, 3, "x")',
         ],
-        seeAlso: ['grid.generate', 'grid.from-array', 'vector.fill'],
+        seeAlso: ['grid.generate', 'grid.from-array'],
     },
     'generate': {
         category: 'grid',
@@ -11294,7 +11298,7 @@ const moduleDocs$5 = {
         examples: [
             'let { generate } = import(grid);\ngenerate(3, 3, (i, j) -> i + j)',
         ],
-        seeAlso: ['grid.fill', 'grid.from-array', 'vector.generate'],
+        seeAlso: ['grid.fill', 'grid.from-array'],
     },
     'reshape': {
         category: 'grid',
@@ -11373,7 +11377,7 @@ const moduleDocs$5 = {
             'let { flip-h } = import(grid);\nflip-h([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n])',
             'let { flip-h } = import(grid);\nflip-h([\n  [1, 2],\n  [3, 4],\n])',
         ],
-        seeAlso: ['grid.flip-v', 'grid.transpose', 'grid.rotate', 'grid.reverse-cols'],
+        seeAlso: ['grid.flip-v', 'grid.transpose', 'grid.rotate'],
     },
     'flip-v': {
         category: 'grid',
@@ -11399,7 +11403,7 @@ const moduleDocs$5 = {
             'let { flip-v } = import(grid);\nflip-v([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n])',
             'let { flip-v } = import(grid);\nflip-v([\n  [1, 2],\n  [3, 4],\n])',
         ],
-        seeAlso: ['grid.flip-h', 'grid.transpose', 'grid.rotate', 'grid.reverse-rows'],
+        seeAlso: ['grid.flip-h', 'grid.transpose', 'grid.rotate'],
     },
     'rotate': {
         category: 'grid',
@@ -11434,61 +11438,9 @@ const moduleDocs$5 = {
         ],
         seeAlso: ['grid.transpose', 'grid.flip-h', 'grid.flip-v'],
     },
-    'reverse-rows': {
-        category: 'grid',
-        description: 'Reverses the order of rows in the grid `g`.',
-        returns: {
-            type: 'grid',
-        },
-        args: {
-            g: {
-                type: 'grid',
-                description: 'The grid to reverse rows.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'g',
-                ],
-            },
-        ],
-        examples: [
-            'let { reverse-rows } = import(grid);\nreverse-rows([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n])',
-            'let { reverse-rows } = import(grid);\nreverse-rows([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n])',
-            'let { reverse-rows } = import(grid);\nreverse-rows([\n  [1, 2],\n  [3, 4],\n])',
-        ],
-        seeAlso: ['grid.reverse-cols', 'grid.flip-v'],
-    },
-    'reverse-cols': {
+    'crop': {
         category: 'grid',
-        description: 'Reverses the order of columns in the grid `g`.',
-        returns: {
-            type: 'grid',
-        },
-        args: {
-            g: {
-                type: 'grid',
-                description: 'The grid to reverse columns.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'g',
-                ],
-            },
-        ],
-        examples: [
-            'let { reverse-cols } = import(grid);\nreverse-cols([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n])',
-            'let { reverse-cols } = import(grid);\nreverse-cols([\n  ["Albert", "father"],\n  ["Nina", "mother"],\n  ["Kian", "son"],\n])',
-            'let { reverse-cols } = import(grid);\nreverse-cols([\n  [1, 2],\n  [3, 4],\n])',
-        ],
-        seeAlso: ['grid.reverse-rows', 'grid.flip-h'],
-    },
-    'slice': {
-        category: 'grid',
-        description: 'Slices the grid `g` from the starting index `begin` to the optional ending index `stop`. The slice is inclusive of the starting index and exclusive of the ending index.',
+        description: 'Crops the grid `g` from the starting index `begin` to the optional ending index `stop`. The crop is inclusive of the starting index and exclusive of the ending index.',
         returns: {
             type: 'grid',
         },
@@ -11522,8 +11474,8 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "slice" shadows a builtin function\nlet { slice as grid-slice } = import(grid);\ngrid-slice([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], [1, 1], [2, 2])',
-            '// Using "as" alias because "slice" shadows a builtin function\nlet { slice as grid-slice } = import(grid);\ngrid-slice([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], [1, 1])',
+            'let { crop } = import(grid);\ncrop([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], [1, 1], [2, 2])',
+            'let { crop } = import(grid);\ncrop([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], [1, 1])',
         ],
         hideOperatorForm: true,
         seeAlso: ['grid.slice-rows', 'grid.slice-cols'],
@@ -11568,7 +11520,7 @@ const moduleDocs$5 = {
             'let { slice-rows } = import(grid);\nslice-rows([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], 1)',
         ],
         hideOperatorForm: true,
-        seeAlso: ['grid.slice', 'grid.slice-cols', 'grid.splice-rows'],
+        seeAlso: ['grid.crop', 'grid.slice-cols', 'grid.splice-rows'],
     },
     'slice-cols': {
         category: 'grid',
@@ -11610,7 +11562,7 @@ const moduleDocs$5 = {
             'let { slice-cols } = import(grid);\nslice-cols([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], 1)',
         ],
         hideOperatorForm: true,
-        seeAlso: ['grid.slice', 'grid.slice-rows', 'grid.splice-cols'],
+        seeAlso: ['grid.crop', 'grid.slice-rows', 'grid.splice-cols'],
     },
     'splice-rows': {
         category: 'grid',
@@ -11764,7 +11716,7 @@ const moduleDocs$5 = {
         ],
         seeAlso: ['grid.concat-rows', 'grid.push-cols'],
     },
-    'map': {
+    'cell-map': {
         category: 'grid',
         description: 'Maps a function `a` over each element of the grid `b`, returning a new grid with the results.',
         returns: {
@@ -11787,11 +11739,11 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "map" shadows a builtin function\nlet { map as grid-map } = import(grid);\ngrid-map([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], str)',
+            'let { cell-map } = import(grid);\ncell-map([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], str)',
         ],
-        seeAlso: ['map', 'grid.mapi', 'grid.reduce'],
+        seeAlso: ['map', 'grid.cell-mapi', 'grid.cell-reduce'],
     },
-    'mapi': {
+    'cell-mapi': {
         category: 'grid',
         description: 'Maps a function `a` over each element of the grid `b`, passing the row and column index as additional arguments to the function.',
         returns: {
@@ -11814,11 +11766,11 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "mapi" shadows a builtin function\nlet { mapi as grid-mapi } = import(grid);\ngrid-mapi([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], -> $1 ++ "(" ++ $2 ++ ", " ++ $3 ++ ")")',
+            'let { cell-mapi } = import(grid);\ncell-mapi([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], -> $1 ++ "(" ++ $2 ++ ", " ++ $3 ++ ")")',
         ],
-        seeAlso: ['grid.map', 'grid.reducei', 'map'],
+        seeAlso: ['grid.cell-map', 'grid.cell-reducei', 'map'],
     },
-    'reduce': {
+    'cell-reduce': {
         category: 'grid',
         description: 'Reduces the grid `a` using the function `b`, returning a single value.',
         returns: {
@@ -11848,11 +11800,11 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "reduce" shadows a builtin function\nlet { reduce as grid-reduce } = import(grid);\ngrid-reduce([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], ++, "")',
+            '// Using "as" alias because "reduce" shadows a builtin function\nlet { cell-reduce } = import(grid);\ncell-reduce([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], ++, "")',
         ],
-        seeAlso: ['reduce', 'grid.reducei', 'grid.map'],
+        seeAlso: ['reduce', 'grid.cell-reducei', 'grid.cell-map'],
     },
-    'reducei': {
+    'cell-reducei': {
         category: 'grid',
         description: 'Reduces the grid `a` using the function `b`, passing the row and column indices as additional arguments to the function.',
         returns: {
@@ -11882,9 +11834,9 @@ const moduleDocs$5 = {
             },
         ],
         examples: [
-            '// Using "as" alias because "reducei" shadows a builtin function\nlet { reducei as grid-reducei } = import(grid);\ngrid-reducei([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], ++, "")',
+            '// Using "as" alias because "reducei" shadows a builtin function\nlet { cell-reducei } = import(grid);\ncell-reducei([\n  ["Albert", "father", 10],\n  ["Nina", "mother", 20],\n  ["Kian", "son", 30],\n], ++, "")',
         ],
-        seeAlso: ['grid.reduce', 'grid.mapi', 'reduce'],
+        seeAlso: ['grid.cell-reduce', 'grid.cell-mapi', 'reduce'],
     },
     'push-rows': {
         category: 'grid',
@@ -12169,7 +12121,7 @@ function transpose(grid) {
 }
 
 const gridFunctions = {
-    'every?': {
+    'cell-every?': {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
@@ -12372,21 +12324,7 @@ const gridFunctions = {
         },
         arity: toFixedArity(2),
     },
-    'reverse-rows': {
-        evaluate: ([grid], sourceCodeInfo) => {
-            assertGrid(grid, sourceCodeInfo);
-            return grid.reverse();
-        },
-        arity: toFixedArity(1),
-    },
-    'reverse-cols': {
-        evaluate: ([grid], sourceCodeInfo) => {
-            assertGrid(grid, sourceCodeInfo);
-            return grid.map(row => row.reverse());
-        },
-        arity: toFixedArity(1),
-    },
-    'slice': {
+    'crop': {
         evaluate: ([grid, start, end], sourceCodeInfo) => {
             assertGrid(grid, sourceCodeInfo);
             assertVector(start, sourceCodeInfo);
@@ -12554,7 +12492,7 @@ const gridFunctions = {
         },
         arity: { min: 1 },
     },
-    'map': {
+    'cell-map': {
         evaluate: (params, sourceCodeInfo, contextStack, { executeFunction }) => {
             const fn = asFunctionLike(params.at(-1), sourceCodeInfo);
             const grids = params.slice(0, -1);
@@ -12579,7 +12517,7 @@ const gridFunctions = {
         },
         arity: { min: 2 },
     },
-    'mapi': {
+    'cell-mapi': {
         evaluate: ([grid, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12593,7 +12531,7 @@ const gridFunctions = {
         },
         arity: toFixedArity(2),
     },
-    'reduce': {
+    'cell-reduce': {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12607,7 +12545,7 @@ const gridFunctions = {
         },
         arity: toFixedArity(3),
     },
-    'reducei': {
+    'cell-reducei': {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12761,7 +12699,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random! } = import(random); random!()',
+            `let { random! } = import(random);
+random!()`,
         ],
         seeAlso: ['random.random-float!', 'random.random-int!', 'random.random-boolean!'],
     },
@@ -12790,8 +12729,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-int! } = import(random); random-int!(0, 10)',
-            'let { random-int! } = import(random); random-int!(1, 100)',
+            `let { random-int! } = import(random);
+random-int!(0, 10)`,
+            `let { random-int! } = import(random);
+random-int!(1, 100)`,
         ],
         seeAlso: ['random.random-int-inclusive!', 'random.random-float!', 'random.random!'],
     },
@@ -12820,7 +12761,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-int-inclusive! } = import(random); random-int-inclusive!(0, 10)',
+            `let { random-int-inclusive! } = import(random);
+random-int-inclusive!(0, 10)`,
         ],
         seeAlso: ['random.random-int!', 'random.random-float!'],
     },
@@ -12849,8 +12791,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-float! } = import(random); random-float!(0, 10)',
-            'let { random-float! } = import(random); random-float!(1, 100)',
+            `let { random-float! } = import(random);
+random-float!(0, 10)`,
+            `let { random-float! } = import(random);
+random-float!(1, 100)`,
         ],
         seeAlso: ['random.random!', 'random.random-int!', 'random.random-int-inclusive!'],
     },
@@ -12874,8 +12818,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-boolean! } = import(random); random-boolean!()',
-            'let { random-boolean! } = import(random); random-boolean!(0.99)',
+            `let { random-boolean! } = import(random);
+random-boolean!()`,
+            `let { random-boolean! } = import(random);
+random-boolean!(0.99)`,
         ],
         seeAlso: ['random.random!'],
     },
@@ -12899,8 +12845,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-item! } = import(random); random-item!([1, 2, 3, 4, 5])',
-            'let { random-item! } = import(random); random-item!(["apple", "banana", "cherry"])',
+            `let { random-item! } = import(random);
+random-item!([1, 2, 3, 4, 5])`,
+            `let { random-item! } = import(random);
+random-item!(["apple", "banana", "cherry"])`,
         ],
         seeAlso: ['random.random-sample!', 'random.random-sample-unique!', 'random.random-char!'],
     },
@@ -12929,8 +12877,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-sample-unique! } = import(random); random-sample-unique!([1, 2, 3, 4, 5], 3)',
-            'let { random-sample-unique! } = import(random); random-sample-unique!(["apple", "banana", "cherry"], 2)',
+            `let { random-sample-unique! } = import(random);
+random-sample-unique!([1, 2, 3, 4, 5], 3)`,
+            `let { random-sample-unique! } = import(random);
+random-sample-unique!(["apple", "banana", "cherry"], 2)`,
         ],
         seeAlso: ['random.random-sample!', 'random.random-item!', 'random.shuffle!'],
     },
@@ -12959,8 +12909,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-sample! } = import(random); random-sample!([1, 2, 3, 4, 5], 3)',
-            'let { random-sample! } = import(random); random-sample!(["apple", "banana", "cherry"], 10)',
+            `let { random-sample! } = import(random);
+random-sample!([1, 2, 3, 4, 5], 3)`,
+            `let { random-sample! } = import(random);
+random-sample!(["apple", "banana", "cherry"], 10)`,
         ],
         seeAlso: ['random.random-sample-unique!', 'random.random-item!', 'random.shuffle!'],
     },
@@ -12984,8 +12936,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { shuffle! } = import(random); shuffle!([1, 2, 3, 4, 5])',
-            'let { shuffle! } = import(random); shuffle!(["apple", "banana", "cherry"])',
+            `let { shuffle! } = import(random);
+shuffle!([1, 2, 3, 4, 5])`,
+            `let { shuffle! } = import(random);
+shuffle!(["apple", "banana", "cherry"])`,
         ],
         seeAlso: ['random.random-sample!', 'random.random-sample-unique!'],
     },
@@ -13014,8 +12968,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-normal! } = import(random); random-normal!(0, 1)',
-            'let { random-normal! } = import(random); random-normal!(5, 2)',
+            `let { random-normal! } = import(random);
+random-normal!(0, 1)`,
+            `let { random-normal! } = import(random);
+random-normal!(5, 2)`,
         ],
         seeAlso: ['random.random-exponential!', 'random.random-binomial!', 'random.random-poisson!'],
         hideOperatorForm: true,
@@ -13040,8 +12996,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-exponential! } = import(random); random-exponential!(1)',
-            'let { random-exponential! } = import(random); random-exponential!(0.5)',
+            `let { random-exponential! } = import(random);
+random-exponential!(1)`,
+            `let { random-exponential! } = import(random);
+random-exponential!(0.5)`,
         ],
         seeAlso: ['random.random-normal!', 'random.random-poisson!', 'random.random-gamma!', 'random.random-pareto!'],
     },
@@ -13070,8 +13028,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-binomial! } = import(random); random-binomial!(10, 0.5)',
-            'let { random-binomial! } = import(random); random-binomial!(20, 0.3)',
+            `let { random-binomial! } = import(random);
+random-binomial!(10, 0.5)`,
+            `let { random-binomial! } = import(random);
+random-binomial!(20, 0.3)`,
         ],
         seeAlso: ['random.random-normal!', 'random.random-poisson!'],
         hideOperatorForm: true,
@@ -13096,8 +13056,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-poisson! } = import(random); random-poisson!(1)',
-            'let { random-poisson! } = import(random); random-poisson!(5)',
+            `let { random-poisson! } = import(random);
+random-poisson!(1)`,
+            `let { random-poisson! } = import(random);
+random-poisson!(5)`,
         ],
         seeAlso: ['random.random-binomial!', 'random.random-normal!', 'random.random-exponential!'],
     },
@@ -13126,8 +13088,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-gamma! } = import(random); random-gamma!(2, 2)',
-            'let { random-gamma! } = import(random); random-gamma!(5, 1)',
+            `let { random-gamma! } = import(random);
+random-gamma!(2, 2)`,
+            `let { random-gamma! } = import(random);
+random-gamma!(5, 1)`,
         ],
         seeAlso: ['random.random-exponential!', 'random.random-pareto!'],
         hideOperatorForm: true,
@@ -13152,8 +13116,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-pareto! } = import(random); random-pareto!(1)',
-            'let { random-pareto! } = import(random); random-pareto!(2)',
+            `let { random-pareto! } = import(random);
+random-pareto!(1)`,
+            `let { random-pareto! } = import(random);
+random-pareto!(2)`,
         ],
         seeAlso: ['random.random-gamma!', 'random.random-exponential!'],
     },
@@ -13170,7 +13136,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { uuid! } = import(random); uuid!()',
+            `let { uuid! } = import(random);
+uuid!()`,
         ],
         seeAlso: ['random.random-id!', 'random.random-string!'],
     },
@@ -13194,8 +13161,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-char! } = import(random); random-char!("abcde")',
-            'let { random-char! } = import(random); random-char!("ABCDEFGHIJKLMNOPQRSTUVWXYZ")',
+            `let { random-char! } = import(random);
+random-char!("abcde")`,
+            `let { random-char! } = import(random);
+random-char!("ABCDEFGHIJKLMNOPQRSTUVWXYZ")`,
         ],
         seeAlso: ['random.random-string!', 'random.random-item!'],
     },
@@ -13224,8 +13193,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-string! } = import(random); random-string!(10, "abcde")',
-            'let { random-string! } = import(random); random-string!(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")',
+            `let { random-string! } = import(random);
+random-string!(10, "abcde")`,
+            `let { random-string! } = import(random);
+random-string!(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")`,
         ],
         seeAlso: ['random.random-char!', 'random.random-id!', 'random.uuid!'],
         hideOperatorForm: true,
@@ -13250,8 +13221,10 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-id! } = import(random); random-id!(10)',
-            'let { random-id! } = import(random); random-id!(5)',
+            `let { random-id! } = import(random);
+random-id!(10)`,
+            `let { random-id! } = import(random);
+random-id!(5)`,
         ],
         seeAlso: ['random.random-string!', 'random.uuid!'],
     },
@@ -13268,7 +13241,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-color! } = import(random); random-color!()',
+            `let { random-color! } = import(random);
+random-color!()`,
         ],
     },
 };
@@ -13566,31 +13540,6 @@ const randomModule = {
 };
 
 const moduleDocs$3 = {
-    'mean': {
-        category: 'vector',
-        description: 'Returns the **mean** of all elements in the `vector`.',
-        returns: {
-            type: 'number',
-        },
-        args: {
-            vector: {
-                type: 'vector',
-                description: 'The `vector` to calculate the **mean** of.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'vector',
-                ],
-            },
-        ],
-        examples: [
-            'mean([1, 2, 3])',
-            'mean([1, 2, -3])',
-        ],
-        seeAlso: ['mean', 'vector.moving-mean', 'vector.centered-moving-mean', 'vector.running-mean', 'vector.geometric-mean', 'vector.harmonic-mean', 'vector.median', 'vector.mode', 'vector.sum', 'vector.rms'],
-    },
     'moving-mean': {
         category: 'vector',
         description: 'Returns the **moving mean** of the `vector` with a given window size.',
@@ -13625,7 +13574,7 @@ const moduleDocs$3 = {
             'let { moving-mean } = import(vector);\nmoving-mean([1, 2, 3, 4, 5], 3)',
             'let { moving-mean } = import(vector);\nmoving-mean([1, 2, 3, 4, 5], 5)',
         ],
-        seeAlso: ['moving-fn', 'vector.mean', 'vector.centered-moving-mean', 'vector.running-mean'],
+        seeAlso: ['moving-fn', 'mean', 'vector.centered-moving-mean', 'vector.running-mean'],
     },
     'centered-moving-mean': {
         category: 'vector',
@@ -13685,7 +13634,7 @@ const moduleDocs$3 = {
             'let { centered-moving-mean } = import(vector);\ncentered-moving-mean([1, 2, 3, 4, 5], 3, 0, 10)',
             'let { centered-moving-mean } = import(vector);\ncentered-moving-mean([1, 2, 3, 4, 5], 3, 10)',
         ],
-        seeAlso: ['vector.mean', 'vector.moving-mean', 'vector.running-mean'],
+        seeAlso: ['mean', 'vector.moving-mean', 'vector.running-mean'],
     },
     'running-mean': {
         category: 'vector',
@@ -13709,7 +13658,7 @@ const moduleDocs$3 = {
         examples: [
             'let { running-mean } = import(vector);\nrunning-mean([1, 2, 3, 4, 5])',
         ],
-        seeAlso: ['running-fn', 'vector.mean', 'vector.moving-mean', 'vector.centered-moving-mean'],
+        seeAlso: ['running-fn', 'mean', 'vector.moving-mean', 'vector.centered-moving-mean'],
     },
     'geometric-mean': {
         category: 'vector',
@@ -13734,7 +13683,7 @@ const moduleDocs$3 = {
             'let { geometric-mean } = import(vector);\ngeometric-mean([1, 2, 3])',
             'let { geometric-mean } = import(vector);\ngeometric-mean([1, 2, 9])',
         ],
-        seeAlso: ['vector.moving-geometric-mean', 'vector.centered-moving-geometric-mean', 'vector.running-geometric-mean', 'vector.mean', 'vector.harmonic-mean'],
+        seeAlso: ['vector.moving-geometric-mean', 'vector.centered-moving-geometric-mean', 'vector.running-geometric-mean', 'mean', 'vector.harmonic-mean'],
     },
     'moving-geometric-mean': {
         category: 'vector',
@@ -13879,7 +13828,7 @@ const moduleDocs$3 = {
             'let { harmonic-mean } = import(vector);\nharmonic-mean([1, 2, 3])',
             'let { harmonic-mean } = import(vector);\nharmonic-mean([1, 2, 9])',
         ],
-        seeAlso: ['vector.moving-harmonic-mean', 'vector.centered-moving-harmonic-mean', 'vector.running-harmonic-mean', 'vector.mean', 'vector.geometric-mean'],
+        seeAlso: ['vector.moving-harmonic-mean', 'vector.centered-moving-harmonic-mean', 'vector.running-harmonic-mean', 'mean', 'vector.geometric-mean'],
     },
     'moving-harmonic-mean': {
         category: 'vector',
@@ -14001,33 +13950,6 @@ const moduleDocs$3 = {
         ],
         seeAlso: ['vector.harmonic-mean', 'vector.moving-harmonic-mean', 'vector.centered-moving-harmonic-mean'],
     },
-    'median': {
-        category: 'vector',
-        description: 'Returns the median of all elements in the vector.',
-        returns: {
-            type: 'number',
-        },
-        args: {
-            vector: {
-                type: 'vector',
-                description: 'The vector to calculate the median of.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'vector',
-                ],
-            },
-        ],
-        examples: [
-            'median([1, 2, 3])',
-            'median([1, 2, -3])',
-            'median([1, 2, 3, 4])',
-            'median([1, 2, -3, 4])',
-        ],
-        seeAlso: ['median', 'vector.moving-median', 'vector.centered-moving-median', 'vector.running-median', 'vector.mean', 'vector.mode', 'vector.quartiles', 'vector.percentile', 'vector.iqr', 'vector.medad'],
-    },
     'moving-median': {
         category: 'vector',
         description: 'Returns the **moving median** of the `vector` with a given window size.',
@@ -14062,7 +13984,7 @@ const moduleDocs$3 = {
             'let { moving-median } = import(vector);\nmoving-median([1, 2, 3, 4, 5], 3)',
             'let { moving-median } = import(vector);\nmoving-median([1, 2, 3, 4, 5], 5)',
         ],
-        seeAlso: ['vector.median', 'vector.centered-moving-median', 'vector.running-median'],
+        seeAlso: ['median', 'vector.centered-moving-median', 'vector.running-median'],
     },
     'centered-moving-median': {
         category: 'vector',
@@ -14122,7 +14044,7 @@ const moduleDocs$3 = {
             'let { centered-moving-median } = import(vector);\ncentered-moving-median([1, 2, 3, 4, 5], 3, 0, 10)',
             'let { centered-moving-median } = import(vector);\ncentered-moving-median([1, 2, 3, 4, 5], 3, 10)',
         ],
-        seeAlso: ['vector.median', 'vector.moving-median', 'vector.running-median'],
+        seeAlso: ['median', 'vector.moving-median', 'vector.running-median'],
     },
     'running-median': {
         category: 'vector',
@@ -14146,7 +14068,7 @@ const moduleDocs$3 = {
         examples: [
             'let { running-median } = import(vector);\nrunning-median([1, 2, 3, 4, 5])',
         ],
-        seeAlso: ['vector.median', 'vector.moving-median', 'vector.centered-moving-median'],
+        seeAlso: ['median', 'vector.moving-median', 'vector.centered-moving-median'],
     },
     'variance': {
         category: 'vector',
@@ -14764,10 +14686,10 @@ const moduleDocs$3 = {
             'let { iqr } = import(vector);\niqr([1, 2, 3, 4])',
             'let { iqr } = import(vector);\niqr([5, 4, 3, 2, 1, 2, 3, 4, 5])',
             'let { iqr } = import(vector);\niqr(range(1, 1000))',
-            'let { iqr, generate } = import(vector);\niqr(generate(1000, -> 1e6 / ($ + 1) ^ 2))',
-            'let { iqr, generate } = import(vector);\nlet { ln } = import(math);\niqr(generate(1000, -> ln($ + 1)))',
+            'let { iqr } = import(vector);\niqr(map(range(1000), -> 1e6 / ($ + 1) ^ 2))',
+            'let { iqr } = import(vector);\nlet { ln } = import(math);\niqr(map(range(1000), -> ln($ + 1)))',
         ],
-        seeAlso: ['vector.moving-iqr', 'vector.centered-moving-iqr', 'vector.running-iqr', 'vector.quartiles', 'vector.median', 'vector.mad', 'vector.medad', 'vector.outliers?', 'vector.outliers'],
+        seeAlso: ['vector.moving-iqr', 'vector.centered-moving-iqr', 'vector.running-iqr', 'vector.quartiles', 'median', 'vector.mad', 'vector.medad', 'vector.outliers?', 'vector.outliers'],
     },
     'moving-iqr': {
         category: 'vector',
@@ -14890,31 +14812,6 @@ const moduleDocs$3 = {
         ],
         seeAlso: ['vector.iqr', 'vector.moving-iqr', 'vector.centered-moving-iqr'],
     },
-    'sum': {
-        category: 'vector',
-        description: 'Returns the sum of all elements in the vector.',
-        returns: {
-            type: 'number',
-        },
-        args: {
-            vector: {
-                type: 'vector',
-                description: 'The vector to sum.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'vector',
-                ],
-            },
-        ],
-        examples: [
-            'sum([1, 2, 3])',
-            'sum([1, 2, -3])',
-        ],
-        seeAlso: ['sum', 'vector.moving-sum', 'vector.centered-moving-sum', 'vector.running-sum', 'vector.prod', 'vector.cumsum', 'vector.mean'],
-    },
     'moving-sum': {
         category: 'vector',
         description: 'Returns the **moving sum** of the `vector` with a given window size.',
@@ -14949,7 +14846,7 @@ const moduleDocs$3 = {
             'let { moving-sum } = import(vector);\nmoving-sum([1, 2, 3, 4, 5], 3)',
             'let { moving-sum } = import(vector);\nmoving-sum([1, 2, 3, 4, 5], 5)',
         ],
-        seeAlso: ['vector.sum', 'vector.centered-moving-sum', 'vector.running-sum'],
+        seeAlso: ['sum', 'vector.centered-moving-sum', 'vector.running-sum'],
     },
     'centered-moving-sum': {
         category: 'vector',
@@ -15009,7 +14906,7 @@ const moduleDocs$3 = {
             'let { centered-moving-sum } = import(vector);\ncentered-moving-sum([1, 2, 3, 4, 5], 3, 0, 0)',
             'let { centered-moving-sum } = import(vector);\ncentered-moving-sum([1, 2, 3, 4, 5], 3, 10)',
         ],
-        seeAlso: ['vector.sum', 'vector.moving-sum', 'vector.running-sum'],
+        seeAlso: ['sum', 'vector.moving-sum', 'vector.running-sum'],
     },
     'running-sum': {
         category: 'vector',
@@ -15034,32 +14931,7 @@ const moduleDocs$3 = {
             'let { running-sum } = import(vector);\nrunning-sum([1, 2, 3])',
             'let { running-sum } = import(vector);\nrunning-sum([1, -2, -3])',
         ],
-        seeAlso: ['vector.sum', 'vector.moving-sum', 'vector.centered-moving-sum', 'vector.cumsum'],
-    },
-    'prod': {
-        category: 'vector',
-        description: 'Returns the **product** of all elements in the `vector`.',
-        returns: {
-            type: 'number',
-        },
-        args: {
-            vector: {
-                type: 'vector',
-                description: 'The `vector` to calculate the **product** of.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'vector',
-                ],
-            },
-        ],
-        examples: [
-            'prod([1, 2, 3])',
-            'prod([1, 2, -3])',
-        ],
-        seeAlso: ['prod', 'vector.moving-prod', 'vector.centered-moving-prod', 'vector.running-prod', 'vector.sum', 'vector.cumprod'],
+        seeAlso: ['sum', 'vector.moving-sum', 'vector.centered-moving-sum', 'vector.cumsum'],
     },
     'moving-prod': {
         category: 'vector',
@@ -15095,7 +14967,7 @@ const moduleDocs$3 = {
             'let { moving-prod } = import(vector);\nmoving-prod([1, 2, 3, 4, 5], 3)',
             'let { moving-prod } = import(vector);\nmoving-prod([1, 2, 3, 4, 5], 5)',
         ],
-        seeAlso: ['vector.prod', 'vector.centered-moving-prod', 'vector.running-prod'],
+        seeAlso: ['prod', 'vector.centered-moving-prod', 'vector.running-prod'],
     },
     'centered-moving-prod': {
         category: 'vector',
@@ -15154,7 +15026,7 @@ const moduleDocs$3 = {
             'let { centered-moving-prod } = import(vector);\ncentered-moving-prod([1, 2, 3, 4, 5], 3)',
             'let { centered-moving-prod } = import(vector);\ncentered-moving-prod([1, 2, 3, 4, 5], 3, 0, 0)',
         ],
-        seeAlso: ['vector.prod', 'vector.moving-prod', 'vector.running-prod'],
+        seeAlso: ['prod', 'vector.moving-prod', 'vector.running-prod'],
     },
     'running-prod': {
         category: 'vector',
@@ -15179,7 +15051,7 @@ const moduleDocs$3 = {
             'let { running-prod } = import(vector);\nrunning-prod([1, 2, 3, 4, 5])',
             'let { running-prod } = import(vector);\nrunning-prod([1, -2, -3])',
         ],
-        seeAlso: ['vector.prod', 'vector.moving-prod', 'vector.centered-moving-prod', 'vector.cumprod'],
+        seeAlso: ['prod', 'vector.moving-prod', 'vector.centered-moving-prod', 'vector.cumprod'],
     },
     'span': {
         category: 'vector',
@@ -16214,10 +16086,10 @@ const moduleDocs$3 = {
             'let { rms } = import(vector);\nrms([1, 2, 3, 4])',
             'let { rms } = import(vector);\nrms([5, 4, 3, 2, 1])',
             'let { rms } = import(vector);\nrms(range(1, 1000))',
-            'let { rms, generate } = import(vector);\nrms(generate(1000, -> 1e6 / ($ + 1) ^ 2))',
-            'let { rms, generate } = import(vector);\nlet { ln } = import(math);\nrms(generate(1000, -> ln($ + 1)))',
+            'let { rms } = import(vector);\nrms(map(range(1000), -> 1e6 / ($ + 1) ^ 2))',
+            'let { rms } = import(vector);\nlet { ln } = import(math);\nrms(map(range(1000), -> ln($ + 1)))',
         ],
-        seeAlso: ['vector.moving-rms', 'vector.centered-moving-rms', 'vector.running-rms', 'vector.mean', 'vector.stdev'],
+        seeAlso: ['vector.moving-rms', 'vector.centered-moving-rms', 'vector.running-rms', 'mean', 'vector.stdev'],
     },
     'moving-rms': {
         category: 'vector',
@@ -16511,7 +16383,7 @@ const moduleDocs$3 = {
             'let { medad } = import(vector);\nmedad([1, 2, 3])',
             'let { medad } = import(vector);\nmedad([1, 2, -3])',
         ],
-        seeAlso: ['vector.moving-medad', 'vector.centered-moving-medad', 'vector.running-medad', 'vector.mad', 'vector.median', 'vector.iqr'],
+        seeAlso: ['vector.moving-medad', 'vector.centered-moving-medad', 'vector.running-medad', 'vector.mad', 'median', 'vector.iqr'],
     },
     'moving-medad': {
         category: 'vector',
@@ -17135,7 +17007,7 @@ const moduleDocs$3 = {
             'let { mode } = import(vector);\nmode([2, 2, 3, 3])',
             'let { mode } = import(vector);\nmode([1, 2, 3, 2, 1, 2])',
         ],
-        seeAlso: ['vector.mean', 'vector.median'],
+        seeAlso: ['mean', 'median'],
     },
     'min-index': {
         category: 'vector',
@@ -17285,165 +17157,6 @@ const moduleDocs$3 = {
         ],
         seeAlso: [
             'range',
-            'vector.ones',
-            'vector.zeros',
-            'vector.fill',
-            'vector.generate',
-        ],
-    },
-    'ones': {
-        category: 'vector',
-        description: 'Generates a vector of ones.',
-        returns: {
-            type: 'number',
-            array: true,
-        },
-        args: {
-            length: {
-                type: 'integer',
-                description: 'The length of the vector.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'length',
-                ],
-            },
-        ],
-        examples: [
-            'let { ones } = import(vector);\nones(5)',
-            'let { ones } = import(vector);\nones(10)',
-            'let { ones } = import(vector);\nones(0)',
-        ],
-        seeAlso: [
-            'repeat',
-            'vector.zeros',
-            'vector.fill',
-            'vector.generate',
-            'vector.linspace',
-        ],
-    },
-    'zeros': {
-        category: 'vector',
-        description: 'Generates a vector of zeros.',
-        returns: {
-            type: 'number',
-            array: true,
-        },
-        args: {
-            length: {
-                type: 'integer',
-                description: 'The length of the vector.',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'length',
-                ],
-            },
-        ],
-        examples: [
-            'let { zeros } = import(vector);\nzeros(5)',
-            'let { zeros } = import(vector);\nzeros(10)',
-            'let { zeros } = import(vector);\nzeros(0)',
-        ],
-        seeAlso: [
-            'repeat',
-            'vector.ones',
-            'vector.fill',
-            'vector.generate',
-            'vector.linspace',
-        ],
-    },
-    'fill': {
-        category: 'vector',
-        description: 'Generates a vector filled with a number.',
-        returns: {
-            type: 'number',
-            array: true,
-        },
-        args: {
-            length: {
-                type: 'integer',
-                description: 'The length of the vector.',
-            },
-            value: {
-                type: 'number',
-                description: 'The value to fill the vector with.',
-            },
-            a: {
-                type: 'number',
-            },
-            b: {
-                type: 'integer',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'length',
-                    'value',
-                ],
-            },
-        ],
-        examples: [
-            'let { fill } = import(vector);\nfill(5, PI)',
-            'let { fill } = import(vector);\nfill(10, -1)',
-        ],
-        seeAlso: [
-            'repeat',
-            'vector.ones',
-            'vector.zeros',
-            'vector.generate',
-            'vector.linspace',
-            'grid.fill',
-        ],
-    },
-    'generate': {
-        category: 'vector',
-        description: 'Generates a vector of numbers based on a function.',
-        returns: {
-            type: 'number',
-            array: true,
-        },
-        args: {
-            length: {
-                type: 'integer',
-                description: 'The length of the vector.',
-            },
-            func: {
-                type: 'function',
-                description: 'A function that takes an index and returns a number.',
-            },
-            a: {
-                type: 'number',
-            },
-            b: {
-                type: 'integer',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'length',
-                    'func',
-                ],
-            },
-        ],
-        examples: [
-            'let { generate } = import(vector);\ngenerate(5, -> $ * 2)',
-            'let { generate } = import(vector);\ngenerate(10, -> $ + 1)',
-            'let { generate } = import(vector);\ngenerate(0, -> $ + 1)',
-        ],
-        seeAlso: [
-            'repeat',
-            'vector.ones',
-            'vector.zeros',
-            'vector.fill',
-            'vector.linspace',
-            'grid.generate',
         ],
     },
     'cumsum': {
@@ -17471,7 +17184,7 @@ const moduleDocs$3 = {
             'let { cumsum } = import(vector);\ncumsum([1, 2, -3])',
             'let { cumsum } = import(vector);\ncumsum([])',
         ],
-        seeAlso: ['vector.cumprod', 'vector.sum', 'vector.running-sum'],
+        seeAlso: ['vector.cumprod', 'sum', 'vector.running-sum'],
     },
     'cumprod': {
         category: 'vector',
@@ -17498,7 +17211,7 @@ const moduleDocs$3 = {
             'let { cumprod } = import(vector);\ncumprod([1, 2, -3, 0, 10])',
             'let { cumprod } = import(vector);\ncumprod([])',
         ],
-        seeAlso: ['vector.cumsum', 'vector.prod', 'vector.running-prod'],
+        seeAlso: ['vector.cumsum', 'prod', 'vector.running-prod'],
     },
     'quartiles': {
         category: 'vector',
@@ -17524,10 +17237,10 @@ const moduleDocs$3 = {
             'let { quartiles } = import(vector);\nquartiles([1, 2, 3, 4])',
             'let { quartiles } = import(vector);\nquartiles([5, 4, 3, 2, 1, 2, 3, 4, 5])',
             'let { quartiles } = import(vector);\nquartiles(range(1, 1000))',
-            'let { quartiles, generate } = import(vector);\nquartiles(generate(1000, -> 1e6 / ($ + 1) ^ 2))',
-            'let { quartiles, generate } = import(vector);\nlet { ln } = import(math);\nquartiles(generate(1000, -> ln($ + 1)))',
+            'let { quartiles } = import(vector);\nquartiles(map(range(1000), -> 1e6 / ($ + 1) ^ 2))',
+            'let { quartiles } = import(vector);\nlet { ln } = import(math);\nquartiles(map(range(1000), -> ln($ + 1)))',
         ],
-        seeAlso: ['vector.percentile', 'vector.quantile', 'vector.median', 'vector.iqr'],
+        seeAlso: ['vector.percentile', 'vector.quantile', 'median', 'vector.iqr'],
     },
     'percentile': {
         category: 'vector',
@@ -17573,7 +17286,7 @@ const moduleDocs$3 = {
             'let { percentile } = import(vector);\npercentile(range(100) ^ 0.5, 90)',
             'let { percentile } = import(vector);\npercentile(range(100) ^ 0.5, 100)',
         ],
-        seeAlso: ['vector.quantile', 'vector.quartiles', 'vector.median', 'vector.ecdf', 'vector.winsorize'],
+        seeAlso: ['vector.quantile', 'vector.quartiles', 'median', 'vector.ecdf', 'vector.winsorize'],
     },
     'quantile': {
         category: 'vector',
@@ -18488,6 +18201,12 @@ addReductionFunctions$1(madReductionFunction);
 addReductionFunctions$1(medadReductionFunction);
 addReductionFunctions$1(giniCoefficientReductionFunction);
 addReductionFunctions$1(entropyReductionFunction);
+// Remove base variants that duplicate core built-ins (sum, prod, mean, median).
+// The moving/centered-moving/running variants are unique to the vector module.
+delete reductionFunctionNormalExpressions.sum;
+delete reductionFunctionNormalExpressions.prod;
+delete reductionFunctionNormalExpressions.mean;
+delete reductionFunctionNormalExpressions.median;
 function addReductionFunctions$1(fns) {
     for (const [key, value] of Object.entries(fns)) {
         /* v8 ignore next 3 */
@@ -18728,40 +18447,6 @@ const vectorFunctions = {
         },
         arity: toFixedArity(3),
     },
-    'ones': {
-        evaluate: ([length], sourceCodeInfo) => {
-            assertNumber(length, sourceCodeInfo, { integer: true, nonNegative: true });
-            return Array.from({ length }, () => 1);
-        },
-        arity: toFixedArity(1),
-    },
-    'zeros': {
-        evaluate: ([length], sourceCodeInfo) => {
-            assertNumber(length, sourceCodeInfo, { integer: true, nonNegative: true });
-            return Array.from({ length }, () => 0);
-        },
-        arity: toFixedArity(1),
-    },
-    'fill': {
-        evaluate: ([length, value], sourceCodeInfo) => {
-            assertNumber(length, sourceCodeInfo, { integer: true, nonNegative: true });
-            return Array.from({ length }, () => value);
-        },
-        arity: toFixedArity(2),
-    },
-    'generate': {
-        evaluate: ([length, generator], sourceCodeInfo, contextStack, { executeFunction }) => {
-            assertNumber(length, sourceCodeInfo, { integer: true, nonNegative: true });
-            assertFunctionLike(generator, sourceCodeInfo);
-            return mapSequential(Array.from({ length }), (_, i) => {
-                return chain(executeFunction(generator, [i], contextStack, sourceCodeInfo), (value) => {
-                    assertNumber(value, sourceCodeInfo, { finite: true });
-                    return value;
-                });
-            });
-        },
-        arity: toFixedArity(2),
-    },
     'cumsum': {
         evaluate: ([vector], sourceCodeInfo) => {
             assertVector(vector, sourceCodeInfo);
@@ -19486,7 +19171,7 @@ const moduleDocs$2 = {
             'let { orthogonal? } = import(linear-algebra);\northogonal?([1, 0, 1], [0, 1, 0])',
             'let { orthogonal? } = import(linear-algebra);\northogonal?([1, 2], [2, -1])',
         ],
-        seeAlso: ['linear-algebra.collinear?', 'linear-algebra.parallel?', 'linear-algebra.dot', 'matrix.orthogonal?', 'linear-algebra.angle'],
+        seeAlso: ['linear-algebra.collinear?', 'linear-algebra.parallel?', 'linear-algebra.dot', 'matrix.orthogonal-matrix?', 'linear-algebra.angle'],
     },
     'cosine-similarity': {
         category: 'linear-algebra',
@@ -20066,8 +19751,10 @@ const moduleDocs$2 = {
         ],
         examples: [
             'let { solve } = import(linear-algebra);\nsolve([\n  [2, 1, -1, 1], \n  [4, 5, -3, 2], \n  [6, -2, 5, -3], \n  [8, 3, 2, 4]\n], [5, 10, 2, 17])',
-            'let { solve } = import(linear-algebra); solve([[2, 0, 0], [3, 1, 0], [4, 5, 6]], [4, 5, 38])',
-            'let { solve } = import(linear-algebra); solve([[2, 3], [1, -1]], [8, 2])',
+            `let { solve } = import(linear-algebra);
+solve([[2, 0, 0], [3, 1, 0], [4, 5, 6]], [4, 5, 38])`,
+            `let { solve } = import(linear-algebra);
+solve([[2, 3], [1, -1]], [8, 2])`,
         ],
         seeAlso: ['linear-algebra.rref', 'matrix.inv'],
     },
@@ -21107,7 +20794,7 @@ const moduleDocs$1 = {
             'let { inv } = import(matrix);\ninv([[1, 2], [3, 4]])',
             'let { inv } = import(matrix);\ninv([[1, 2, 3], [4, 5, 7], [7, 8, 10]])',
         ],
-        seeAlso: ['matrix.det', 'matrix.adj', 'matrix.invertible?', 'linear-algebra.solve', 'matrix.mul', 'matrix.orthogonal?'],
+        seeAlso: ['matrix.det', 'matrix.adj', 'matrix.invertible?', 'linear-algebra.solve', 'matrix.mul', 'matrix.orthogonal-matrix?'],
     },
     'adj': {
         category: 'matrix',
@@ -21244,7 +20931,7 @@ const moduleDocs$1 = {
             'let { symmetric? } = import(matrix);\nsymmetric?([[1, 2], [2, 1]])',
             'let { symmetric? } = import(matrix);\nsymmetric?([[1, 2, 3], [2, 1, 4], [3, 4, 1]])',
         ],
-        seeAlso: ['matrix.orthogonal?', 'matrix.diagonal?', 'matrix.square?', 'matrix.hilbert'],
+        seeAlso: ['matrix.orthogonal-matrix?', 'matrix.diagonal?', 'matrix.square?', 'matrix.hilbert'],
     },
     'triangular?': {
         category: 'matrix',
@@ -21373,7 +21060,7 @@ const moduleDocs$1 = {
         ],
         seeAlso: ['matrix.symmetric?', 'matrix.identity?', 'matrix.invertible?'],
     },
-    'orthogonal?': {
+    'orthogonal-matrix?': {
         category: 'matrix',
         description: 'Checks if a `matrix` is **orthogonal**.',
         returns: {
@@ -21393,9 +21080,9 @@ const moduleDocs$1 = {
             },
         ],
         examples: [
-            'let { orthogonal? } = import(matrix);\northogonal?([[1, 0], [0, 1]])',
-            'let { orthogonal? } = import(matrix);\northogonal?([[1, 0], [0, -1]])',
-            'let { orthogonal? } = import(matrix);\northogonal?([[1, 2], [3, 4]])',
+            'let { orthogonal-matrix? } = import(matrix);\northogonal-matrix?([[1, 0], [0, 1]])',
+            'let { orthogonal-matrix? } = import(matrix);\northogonal-matrix?([[1, 0], [0, -1]])',
+            'let { orthogonal-matrix? } = import(matrix);\northogonal-matrix?([[1, 2], [3, 4]])',
         ],
         seeAlso: ['matrix.symmetric?', 'matrix.inv', 'matrix.identity?', 'linear-algebra.orthogonal?'],
     },
@@ -21423,7 +21110,7 @@ const moduleDocs$1 = {
             'let { identity? } = import(matrix);\nidentity?([[1, 0, 0], [0, 1, 0], [0, 0, 1]])',
             'let { identity? } = import(matrix);\nidentity?([[1, 0, 0], [0, 1, 0], [0, 0, 0]])',
         ],
-        seeAlso: ['matrix.diagonal?', 'matrix.square?', 'matrix.orthogonal?'],
+        seeAlso: ['matrix.diagonal?', 'matrix.square?', 'matrix.orthogonal-matrix?'],
     },
     'invertible?': {
         category: 'matrix',
@@ -22195,7 +21882,7 @@ const matrixNormalExpression = {
         },
         arity: toFixedArity(1),
     },
-    'orthogonal?': {
+    'orthogonal-matrix?': {
         evaluate: ([matrix], sourceCodeInfo) => {
             assertMatrix(matrix, sourceCodeInfo);
             return isOrthogonal(matrix);
@@ -29431,12 +29118,18 @@ const mathUtilsFunctions = {
             description: 'The `sin` function computes the sine of an angle (in radians), working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the sine of each element while preserving the original structure.',
             seeAlso: ['math.asin', 'math.sinh', 'math.cos', 'math.tan', 'math.to-rad'],
             examples: [
-                'let { sin } = import(math); sin(0)',
-                'let { sin } = import(math); sin(1)',
-                'let { sin } = import(math); sin(PI)',
-                'let { sin } = import(math); sin(-0.5)',
-                'let { sin } = import(math); sin([1, 2, 3])',
-                'let { sin } = import(math); sin([[1, 2], [3, 4]])',
+                `let { sin } = import(math);
+sin(0)`,
+                `let { sin } = import(math);
+sin(1)`,
+                `let { sin } = import(math);
+sin(PI)`,
+                `let { sin } = import(math);
+sin(-0.5)`,
+                `let { sin } = import(math);
+sin([1, 2, 3])`,
+                `let { sin } = import(math);
+sin([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29453,11 +29146,16 @@ const mathUtilsFunctions = {
             description: 'The `asin` function computes the arcsine (inverse sine) of a `number` in radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the arcsine of each element while preserving the original structure.',
             seeAlso: ['math.sin', 'math.asinh', 'math.acos', 'math.atan'],
             examples: [
-                'let { asin } = import(math); asin(0)',
-                'let { asin } = import(math); asin(1)',
-                'let { asin } = import(math); asin(-0.5)',
-                'let { asin } = import(math); asin([1, 2, 3])',
-                'let { asin } = import(math); asin([[1, 2], [3, 4]])',
+                `let { asin } = import(math);
+asin(0)`,
+                `let { asin } = import(math);
+asin(1)`,
+                `let { asin } = import(math);
+asin(-0.5)`,
+                `let { asin } = import(math);
+asin([1, 2, 3])`,
+                `let { asin } = import(math);
+asin([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29474,11 +29172,16 @@ const mathUtilsFunctions = {
             description: 'The `sinh` function computes the hyperbolic sine of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the hyperbolic sine of each element while preserving the original structure.',
             seeAlso: ['math.asinh', 'math.sin', 'math.cosh', 'math.tanh'],
             examples: [
-                'let { sinh } = import(math); sinh(0)',
-                'let { sinh } = import(math); sinh(1)',
-                'let { sinh } = import(math); sinh(-0.5)',
-                'let { sinh } = import(math); sinh([0.1, 0.2, 0.3])',
-                'let { sinh } = import(math); sinh([[0.1, 0.2], [0.3, 0.4]])',
+                `let { sinh } = import(math);
+sinh(0)`,
+                `let { sinh } = import(math);
+sinh(1)`,
+                `let { sinh } = import(math);
+sinh(-0.5)`,
+                `let { sinh } = import(math);
+sinh([0.1, 0.2, 0.3])`,
+                `let { sinh } = import(math);
+sinh([[0.1, 0.2], [0.3, 0.4]])`,
             ],
         },
     },
@@ -29495,11 +29198,16 @@ const mathUtilsFunctions = {
             description: 'The `asinh` function computes the inverse hyperbolic sine of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the inverse hyperbolic sine of each element while preserving the original structure.',
             seeAlso: ['math.sinh', 'math.asin', 'math.acosh', 'math.atanh'],
             examples: [
-                'let { asinh } = import(math); asinh(10)',
-                'let { asinh } = import(math); asinh(90)',
-                'let { asinh } = import(math); asinh(50)',
-                'let { asinh } = import(math); asinh([10, 20, 30])',
-                'let { asinh } = import(math); asinh([[10, 20], [30, 40]])',
+                `let { asinh } = import(math);
+asinh(10)`,
+                `let { asinh } = import(math);
+asinh(90)`,
+                `let { asinh } = import(math);
+asinh(50)`,
+                `let { asinh } = import(math);
+asinh([10, 20, 30])`,
+                `let { asinh } = import(math);
+asinh([[10, 20], [30, 40]])`,
             ],
         },
     },
@@ -29516,12 +29224,18 @@ const mathUtilsFunctions = {
             description: 'The `cos` function computes the cosine of an angle (in radians), working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the cosine of each element while preserving the original structure.',
             seeAlso: ['math.acos', 'math.cosh', 'math.sin', 'math.tan', 'math.to-rad'],
             examples: [
-                'let { cos } = import(math); cos(0)',
-                'let { cos } = import(math); cos(1)',
-                'let { cos } = import(math); cos(PI)',
-                'let { cos } = import(math); cos(-0.5)',
-                'let { cos } = import(math); cos([1, 2, 3])',
-                'let { cos } = import(math); cos([[1, 2], [3, 4]])',
+                `let { cos } = import(math);
+cos(0)`,
+                `let { cos } = import(math);
+cos(1)`,
+                `let { cos } = import(math);
+cos(PI)`,
+                `let { cos } = import(math);
+cos(-0.5)`,
+                `let { cos } = import(math);
+cos([1, 2, 3])`,
+                `let { cos } = import(math);
+cos([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29538,11 +29252,16 @@ const mathUtilsFunctions = {
             description: 'The `acos` function computes the arccosine (inverse cosine) of a `number` in radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the arccosine of each element while preserving the original structure.',
             seeAlso: ['math.cos', 'math.acosh', 'math.asin', 'math.atan'],
             examples: [
-                'let { acos } = import(math); acos(0)',
-                'let { acos } = import(math); acos(1)',
-                'let { acos } = import(math); acos(-0.5)',
-                'let { acos } = import(math); acos([0.1, 0.2, 0.3])',
-                'let { acos } = import(math); acos([[0.1, 0.2], [0.3, 0.4]])',
+                `let { acos } = import(math);
+acos(0)`,
+                `let { acos } = import(math);
+acos(1)`,
+                `let { acos } = import(math);
+acos(-0.5)`,
+                `let { acos } = import(math);
+acos([0.1, 0.2, 0.3])`,
+                `let { acos } = import(math);
+acos([[0.1, 0.2], [0.3, 0.4]])`,
             ],
         },
     },
@@ -29559,11 +29278,16 @@ const mathUtilsFunctions = {
             description: 'The `cosh` function computes the hyperbolic cosine of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the hyperbolic cosine of each element while preserving the original structure.',
             seeAlso: ['math.acosh', 'math.cos', 'math.sinh', 'math.tanh'],
             examples: [
-                'let { cosh } = import(math); cosh(0)',
-                'let { cosh } = import(math); cosh(1)',
-                'let { cosh } = import(math); cosh(-0.5)',
-                'let { cosh } = import(math); cosh([0.1, 0.2, 0.3])',
-                'let { cosh } = import(math); cosh([[0.1, 0.2], [0.3, 0.4]])',
+                `let { cosh } = import(math);
+cosh(0)`,
+                `let { cosh } = import(math);
+cosh(1)`,
+                `let { cosh } = import(math);
+cosh(-0.5)`,
+                `let { cosh } = import(math);
+cosh([0.1, 0.2, 0.3])`,
+                `let { cosh } = import(math);
+cosh([[0.1, 0.2], [0.3, 0.4]])`,
             ],
         },
     },
@@ -29580,12 +29304,18 @@ const mathUtilsFunctions = {
             description: 'The `acosh` function computes the inverse hyperbolic cosine of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the inverse hyperbolic cosine of each element while preserving the original structure.',
             seeAlso: ['math.cosh', 'math.acos', 'math.asinh', 'math.atanh'],
             examples: [
-                'let { acosh } = import(math); acosh(1)',
-                'let { acosh } = import(math); acosh(2)',
-                'let { acosh } = import(math); acosh(100)',
-                'let { acosh } = import(math); acosh(50)',
-                'let { acosh } = import(math); acosh([1, 2, 3])',
-                'let { acosh } = import(math); acosh([[1, 2], [3, 4]])',
+                `let { acosh } = import(math);
+acosh(1)`,
+                `let { acosh } = import(math);
+acosh(2)`,
+                `let { acosh } = import(math);
+acosh(100)`,
+                `let { acosh } = import(math);
+acosh(50)`,
+                `let { acosh } = import(math);
+acosh([1, 2, 3])`,
+                `let { acosh } = import(math);
+acosh([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29602,12 +29332,18 @@ const mathUtilsFunctions = {
             description: 'The `tan` function computes the tangent of an angle (in radians), working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the tangent of each element while preserving the original structure.',
             seeAlso: ['math.atan', 'math.tanh', 'math.sin', 'math.cos', 'math.to-rad'],
             examples: [
-                'let { tan } = import(math); tan(0)',
-                'let { tan } = import(math); tan(1)',
-                'let { tan } = import(math); tan(PI)',
-                'let { tan } = import(math); tan(-0.5)',
-                'let { tan } = import(math); tan([1, 2, 3])',
-                'let { tan } = import(math); tan([[1, 2], [3, 4]])',
+                `let { tan } = import(math);
+tan(0)`,
+                `let { tan } = import(math);
+tan(1)`,
+                `let { tan } = import(math);
+tan(PI)`,
+                `let { tan } = import(math);
+tan(-0.5)`,
+                `let { tan } = import(math);
+tan([1, 2, 3])`,
+                `let { tan } = import(math);
+tan([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29624,11 +29360,16 @@ const mathUtilsFunctions = {
             description: 'The `atan` function computes the arctangent (inverse tangent) of a `number` in radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the arctangent of each element while preserving the original structure.',
             seeAlso: ['math.tan', 'math.atanh', 'math.asin', 'math.acos'],
             examples: [
-                'let { atan } = import(math); atan(0)',
-                'let { atan } = import(math); atan(1)',
-                'let { atan } = import(math); atan(-0.5)',
-                'let { atan } = import(math); atan([0.1, 0.2, 0.3])',
-                'let { atan } = import(math); atan([[0.1, 0.2], [0.3, 0.4]])',
+                `let { atan } = import(math);
+atan(0)`,
+                `let { atan } = import(math);
+atan(1)`,
+                `let { atan } = import(math);
+atan(-0.5)`,
+                `let { atan } = import(math);
+atan([0.1, 0.2, 0.3])`,
+                `let { atan } = import(math);
+atan([[0.1, 0.2], [0.3, 0.4]])`,
             ],
         },
     },
@@ -29645,10 +29386,14 @@ const mathUtilsFunctions = {
             description: 'The `tanh` function computes the hyperbolic tangent of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the hyperbolic tangent of each element while preserving the original structure.',
             seeAlso: ['math.atanh', 'math.tan', 'math.sinh', 'math.cosh'],
             examples: [
-                'let { tanh } = import(math); tanh(0)',
-                'let { tanh } = import(math); tanh(1)',
-                'let { tanh } = import(math); tanh(-0.5)',
-                'let { tanh } = import(math); tanh(50)',
+                `let { tanh } = import(math);
+tanh(0)`,
+                `let { tanh } = import(math);
+tanh(1)`,
+                `let { tanh } = import(math);
+tanh(-0.5)`,
+                `let { tanh } = import(math);
+tanh(50)`,
             ],
         },
     },
@@ -29665,11 +29410,16 @@ const mathUtilsFunctions = {
             description: 'The `atanh` function computes the inverse hyperbolic tangent of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the inverse hyperbolic tangent of each element while preserving the original structure.',
             seeAlso: ['math.tanh', 'math.atan', 'math.asinh', 'math.acosh'],
             examples: [
-                'let { atanh } = import(math); atanh(0)',
-                'let { atanh } = import(math); atanh(0.9)',
-                'let { atanh } = import(math); atanh(-0.5)',
-                'let { atanh } = import(math); atanh([0.1, 0.2, 0.3])',
-                'let { atanh } = import(math); atanh([[0.1, 0.2], [0.3, 0.4]])',
+                `let { atanh } = import(math);
+atanh(0)`,
+                `let { atanh } = import(math);
+atanh(0.9)`,
+                `let { atanh } = import(math);
+atanh(-0.5)`,
+                `let { atanh } = import(math);
+atanh([0.1, 0.2, 0.3])`,
+                `let { atanh } = import(math);
+atanh([[0.1, 0.2], [0.3, 0.4]])`,
             ],
         },
     },
@@ -29686,11 +29436,16 @@ const mathUtilsFunctions = {
             description: 'The `ln` function computes the natural logarithm (base `e`) of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the natural logarithm of each element while preserving the original structure.',
             seeAlso: ['math.log2', 'math.log10', '^'],
             examples: [
-                'let { ln } = import(math); ln(0.01)',
-                'let { ln } = import(math); ln(2.5)',
-                'let { ln } = import(math); ln(E)',
-                'let { ln } = import(math); ln([1, 2, 3])',
-                'let { ln } = import(math); ln([[1, 2], [3, 4]])',
+                `let { ln } = import(math);
+ln(0.01)`,
+                `let { ln } = import(math);
+ln(2.5)`,
+                `let { ln } = import(math);
+ln(E)`,
+                `let { ln } = import(math);
+ln([1, 2, 3])`,
+                `let { ln } = import(math);
+ln([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29707,11 +29462,16 @@ const mathUtilsFunctions = {
             description: 'The `log2` function computes the base `2` logarithm of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the base-2 logarithm of each element while preserving the original structure.',
             seeAlso: ['math.ln', 'math.log10'],
             examples: [
-                'let { log2 } = import(math); log2(0.01)',
-                'let { log2 } = import(math); log2(2 ^ 12)',
-                'let { log2 } = import(math); log2(2.5)',
-                'let { log2 } = import(math); log2([1, 2, 3])',
-                'let { log2 } = import(math); log2([[1, 2], [3, 4]])',
+                `let { log2 } = import(math);
+log2(0.01)`,
+                `let { log2 } = import(math);
+log2(2 ^ 12)`,
+                `let { log2 } = import(math);
+log2(2.5)`,
+                `let { log2 } = import(math);
+log2([1, 2, 3])`,
+                `let { log2 } = import(math);
+log2([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29728,11 +29488,16 @@ const mathUtilsFunctions = {
             description: 'The `log10` function computes the base `10` logarithm of a `number`, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it returns the base-10 logarithm of each element while preserving the original structure.',
             seeAlso: ['math.ln', 'math.log2'],
             examples: [
-                'let { log10 } = import(math); log10(0.01)',
-                'let { log10 } = import(math); log10(10 ^ 12)',
-                'let { log10 } = import(math); log10(2.5)',
-                'let { log10 } = import(math); log10([1, 2, 3])',
-                'let { log10 } = import(math); log10([[1, 2], [3, 4]])',
+                `let { log10 } = import(math);
+log10(0.01)`,
+                `let { log10 } = import(math);
+log10(10 ^ 12)`,
+                `let { log10 } = import(math);
+log10(2.5)`,
+                `let { log10 } = import(math);
+log10([1, 2, 3])`,
+                `let { log10 } = import(math);
+log10([[1, 2], [3, 4]])`,
             ],
         },
     },
@@ -29749,12 +29514,18 @@ const mathUtilsFunctions = {
             description: 'The `to-rad` function converts an angle from degrees to radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
             seeAlso: ['math.to-deg', 'math.sin', 'math.cos', 'math.tan'],
             examples: [
-                'let { to-rad } = import(math); to-rad(0)',
-                'let { to-rad } = import(math); to-rad(90)',
-                'let { to-rad } = import(math); to-rad(180)',
-                'let { to-rad } = import(math); to-rad(360)',
-                'let { to-rad } = import(math); to-rad([0, 90, 180])',
-                'let { to-rad } = import(math); to-rad([[0, 90], [180, 360]])',
+                `let { to-rad } = import(math);
+to-rad(0)`,
+                `let { to-rad } = import(math);
+to-rad(90)`,
+                `let { to-rad } = import(math);
+to-rad(180)`,
+                `let { to-rad } = import(math);
+to-rad(360)`,
+                `let { to-rad } = import(math);
+to-rad([0, 90, 180])`,
+                `let { to-rad } = import(math);
+to-rad([[0, 90], [180, 360]])`,
             ],
         },
     },
@@ -29771,12 +29542,18 @@ const mathUtilsFunctions = {
             description: 'The `to-deg` function converts an angle from radians to degrees, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
             seeAlso: ['math.to-rad'],
             examples: [
-                'let { to-deg } = import(math); to-deg(0)',
-                'let { to-deg } = import(math); to-deg(PI)',
-                'let { to-deg } = import(math); to-deg(PI / 2)',
-                'let { to-deg } = import(math); to-deg(3 * PI / 2)',
-                'let { to-deg } = import(math); to-deg([0, PI, PI / 2])',
-                'let { to-deg } = import(math); to-deg([[0, PI], [PI / 2, 3 * PI / 2]])',
+                `let { to-deg } = import(math);
+to-deg(0)`,
+                `let { to-deg } = import(math);
+to-deg(PI)`,
+                `let { to-deg } = import(math);
+to-deg(PI / 2)`,
+                `let { to-deg } = import(math);
+to-deg(3 * PI / 2)`,
+                `let { to-deg } = import(math);
+to-deg([0, PI, PI / 2])`,
+                `let { to-deg } = import(math);
+to-deg([[0, PI], [PI / 2, 3 * PI / 2]])`,
             ],
         },
     },
@@ -30009,9 +29786,12 @@ const stringUtilsFunctions = {
             description: 'Repeates $s $n times.',
             seeAlso: ['str', 'repeat'],
             examples: [
-                'let { string-repeat } = import(string); "*" string-repeat 10',
-                'let { string-repeat } = import(string); string-repeat("*", 10)',
-                'let { string-repeat } = import(string); string-repeat("***", 0)',
+                `let { string-repeat } = import(string);
+"*" string-repeat 10`,
+                `let { string-repeat } = import(string);
+string-repeat("*", 10)`,
+                `let { string-repeat } = import(string);
+string-repeat("***", 0)`,
             ],
         },
     },
@@ -30035,8 +29815,10 @@ const stringUtilsFunctions = {
             description: 'Return character for code point $code.',
             seeAlso: ['string.to-char-code'],
             examples: [
-                'let { from-char-code } = import(string); from-char-code(65)',
-                'let { from-char-code } = import(string); from-char-code(0)',
+                `let { from-char-code } = import(string);
+from-char-code(65)`,
+                `let { from-char-code } = import(string);
+from-char-code(0)`,
             ],
         },
     },
@@ -30054,8 +29836,10 @@ const stringUtilsFunctions = {
             description: 'Return code point for first character in $c.',
             seeAlso: ['string.from-char-code'],
             examples: [
-                'let { to-char-code } = import(string); to-char-code("A")',
-                'let { to-char-code } = import(string); to-char-code("Albert")',
+                `let { to-char-code } = import(string);
+to-char-code("A")`,
+                `let { to-char-code } = import(string);
+to-char-code("Albert")`,
             ],
         },
     },
@@ -30073,9 +29857,12 @@ const stringUtilsFunctions = {
             description: 'Returns a new string with leading whitespaces removed.',
             seeAlso: ['trim', 'string.trim-right'],
             examples: [
-                'let { trim-left } = import(string); trim-left("  Albert  ")',
-                'let { trim-left } = import(string); trim-left("   ")',
-                'let { trim-left } = import(string); trim-left("")',
+                `let { trim-left } = import(string);
+trim-left("  Albert  ")`,
+                `let { trim-left } = import(string);
+trim-left("   ")`,
+                `let { trim-left } = import(string);
+trim-left("")`,
             ],
         },
     },
@@ -30093,9 +29880,12 @@ const stringUtilsFunctions = {
             description: 'Returns a new string with trailing whitespaces removed.',
             seeAlso: ['trim', 'string.trim-left'],
             examples: [
-                'let { trim-right } = import(string); trim-right("  Albert  ")',
-                'let { trim-right } = import(string); trim-right("   ")',
-                'let { trim-right } = import(string); trim-right("")',
+                `let { trim-right } = import(string);
+trim-right("  Albert  ")`,
+                `let { trim-right } = import(string);
+trim-right("   ")`,
+                `let { trim-right } = import(string);
+trim-right("")`,
             ],
         },
     },
@@ -30113,10 +29903,14 @@ const stringUtilsFunctions = {
             description: 'Divides $s into an array of substrings, each representing a line.',
             seeAlso: ['split'],
             examples: [
-                'let { split-lines } = import(string); split-lines("Albert\nMojir\n")',
-                'let { split-lines } = import(string); split-lines("Albert\n\nMojir")',
-                'let { split-lines } = import(string); split-lines("Albert\nMojir\n\n")',
-                'let { split-lines } = import(string); split-lines("")',
+                `let { split-lines } = import(string);
+split-lines("Albert\nMojir\n")`,
+                `let { split-lines } = import(string);
+split-lines("Albert\n\nMojir")`,
+                `let { split-lines } = import(string);
+split-lines("Albert\nMojir\n\n")`,
+                `let { split-lines } = import(string);
+split-lines("")`,
             ],
         },
     },
@@ -30146,11 +29940,16 @@ const stringUtilsFunctions = {
             description: 'Pads from the start of $s with `padString` (multiple times, if needed) until the resulting string reaches the given $length.',
             seeAlso: ['string.pad-right'],
             examples: [
-                'let { pad-left } = import(string); "Albert" pad-left 20',
-                'let { pad-left } = import(string); pad-left("Albert", 20)',
-                'let { pad-left } = import(string); pad-left("Albert", 20, "-*-")',
-                'let { pad-left } = import(string); pad-left("Albert", 5)',
-                'let { pad-left } = import(string); pad-left("Albert", -1)',
+                `let { pad-left } = import(string);
+"Albert" pad-left 20`,
+                `let { pad-left } = import(string);
+pad-left("Albert", 20)`,
+                `let { pad-left } = import(string);
+pad-left("Albert", 20, "-*-")`,
+                `let { pad-left } = import(string);
+pad-left("Albert", 5)`,
+                `let { pad-left } = import(string);
+pad-left("Albert", -1)`,
             ],
         },
     },
@@ -30180,11 +29979,16 @@ const stringUtilsFunctions = {
             description: 'Pads from the start of $s with `padString` (multiple times, if needed) until the resulting string reaches the given `length`.',
             seeAlso: ['string.pad-left'],
             examples: [
-                'let { pad-right } = import(string); "Albert" pad-right 20',
-                'let { pad-right } = import(string); pad-right("Albert", 20)',
-                'let { pad-right } = import(string); pad-right("Albert", 20, "-*-")',
-                'let { pad-right } = import(string); pad-right("Albert", 5)',
-                'let { pad-right } = import(string); pad-right("Albert", -1)',
+                `let { pad-right } = import(string);
+"Albert" pad-right 20`,
+                `let { pad-right } = import(string);
+pad-right("Albert", 20)`,
+                `let { pad-right } = import(string);
+pad-right("Albert", 20, "-*-")`,
+                `let { pad-right } = import(string);
+pad-right("Albert", 5)`,
+                `let { pad-right } = import(string);
+pad-right("Albert", -1)`,
             ],
         },
     },
@@ -30228,19 +30032,32 @@ const stringUtilsFunctions = {
             description: 'Applies placeholders to a string. Support for basic pluralization - see examples. If pluralization is used, first placeholder must be a number.',
             seeAlso: ['str'],
             examples: [
-                'let { template } = import(string); template("Hi, $1 and $2", "Carl", "Larry")',
-                'let { template } = import(string); template("Hi $1, $2, $3, $4, $5, $6, $7, $8 and $9", "A", "B", "C", "D", "E", "F", "G", "H", "I")',
-                'let { template } = import(string); template("$1 book||||$1 books", 0)',
-                'let { template } = import(string); template("$1 book||||$1 books", 1)',
-                'let { template } = import(string); template("$1 book||||$1 books", 2)',
-                'let { template } = import(string); template("No book||||$1 book||||$1 books", 0)',
-                'let { template } = import(string); template("No book||||$1 book||||$1 books", 1)',
-                'let { template } = import(string); template("No book||||$1 book||||$1 books", 10)',
-                'let { template } = import(string); template("No book||||One book||||Two books||||Three books||||$1 books", 0)',
-                'let { template } = import(string); template("No book||||One book||||Two books||||Three books||||$1 books", 1)',
-                'let { template } = import(string); template("No book||||One book||||Two books||||Three books||||$1 books", 2)',
-                'let { template } = import(string); template("No book||||One book||||Two books||||Three books||||$1 books", 3)',
-                'let { template } = import(string); template("No book||||One book||||Two books||||Three books||||$1 books", 4)',
+                `let { template } = import(string);
+template("Hi, $1 and $2", "Carl", "Larry")`,
+                `let { template } = import(string);
+template("Hi $1, $2, $3, $4, $5, $6, $7, $8 and $9", "A", "B", "C", "D", "E", "F", "G", "H", "I")`,
+                `let { template } = import(string);
+template("$1 book||||$1 books", 0)`,
+                `let { template } = import(string);
+template("$1 book||||$1 books", 1)`,
+                `let { template } = import(string);
+template("$1 book||||$1 books", 2)`,
+                `let { template } = import(string);
+template("No book||||$1 book||||$1 books", 0)`,
+                `let { template } = import(string);
+template("No book||||$1 book||||$1 books", 1)`,
+                `let { template } = import(string);
+template("No book||||$1 book||||$1 books", 10)`,
+                `let { template } = import(string);
+template("No book||||One book||||Two books||||Three books||||$1 books", 0)`,
+                `let { template } = import(string);
+template("No book||||One book||||Two books||||Three books||||$1 books", 1)`,
+                `let { template } = import(string);
+template("No book||||One book||||Two books||||Three books||||$1 books", 2)`,
+                `let { template } = import(string);
+template("No book||||One book||||Two books||||Three books||||$1 books", 3)`,
+                `let { template } = import(string);
+template("No book||||One book||||Two books||||Three books||||$1 books", 4)`,
             ],
             hideOperatorForm: true,
         },
@@ -30262,7 +30079,8 @@ const stringUtilsFunctions = {
             description: 'Returns a Base64 encoded string from $s.',
             seeAlso: ['string.decode-base64'],
             examples: [
-                'let { encode-base64 } = import(string); encode-base64("Albert")',
+                `let { encode-base64 } = import(string);
+encode-base64("Albert")`,
             ],
         },
     },
@@ -30290,7 +30108,8 @@ const stringUtilsFunctions = {
             description: 'Returns a Base64 decoded string from $base64string.',
             seeAlso: ['string.encode-base64'],
             examples: [
-                'let { decode-base64 } = import(string); decode-base64("QWxiZXJ0IPCfkLs=")',
+                `let { decode-base64 } = import(string);
+decode-base64("QWxiZXJ0IPCfkLs=")`,
             ],
         },
     },
@@ -30308,7 +30127,8 @@ const stringUtilsFunctions = {
             description: 'Returns an escaped `URI` string.',
             seeAlso: ['string.decode-uri-component'],
             examples: [
-                'let { encode-uri-component } = import(string); encode-uri-component("Hi everyone!?")',
+                `let { encode-uri-component } = import(string);
+encode-uri-component("Hi everyone!?")`,
             ],
         },
     },
@@ -30331,7 +30151,8 @@ const stringUtilsFunctions = {
             description: 'Returns an un-escaped `URI` string.',
             seeAlso: ['string.encode-uri-component'],
             examples: [
-                'let { decode-uri-component } = import(string); decode-uri-component("Hi%20everyone!%3F%20%F0%9F%91%8D")',
+                `let { decode-uri-component } = import(string);
+decode-uri-component("Hi%20everyone!%3F%20%F0%9F%91%8D")`,
             ],
         },
     },
@@ -30349,10 +30170,14 @@ const stringUtilsFunctions = {
             description: 'Returns $s with the first character converted to uppercase and the rest to lowercase.',
             seeAlso: ['lower-case', 'upper-case'],
             examples: [
-                'let { capitalize } = import(string); capitalize("albert")',
-                'let { capitalize } = import(string); capitalize("ALBERT")',
-                'let { capitalize } = import(string); capitalize("aLBERT")',
-                'let { capitalize } = import(string); capitalize("")',
+                `let { capitalize } = import(string);
+capitalize("albert")`,
+                `let { capitalize } = import(string);
+capitalize("ALBERT")`,
+                `let { capitalize } = import(string);
+capitalize("aLBERT")`,
+                `let { capitalize } = import(string);
+capitalize("")`,
             ],
         },
     },
@@ -31066,7 +30891,7 @@ cu.reductions(
             },
             variants: [{ argumentNames: ['a', 'b'] }],
             description: 'Returns `true` if all entries in $a pass the test implemented by $b, otherwise returns `false`.',
-            seeAlso: ['collection.any?', 'collection.not-every?', 'collection.not-any?', 'functional.every-pred', 'grid.every?'],
+            seeAlso: ['collection.any?', 'collection.not-every?', 'collection.not-any?', 'functional.every-pred', 'grid.cell-every?'],
             examples: [
                 'let cu = import(collection); cu.every?([1, 2, 3], number?)',
                 'let cu = import(collection); cu.every?([1, 2, 3], even?)',
@@ -31354,29 +31179,6 @@ su.position(
             ],
         },
     },
-    'shift': {
-        evaluate: ([seq], sourceCodeInfo) => {
-            assertSeq(seq, sourceCodeInfo);
-            if (typeof seq === 'string')
-                return seq.substring(1);
-            const copy = [...seq];
-            copy.shift();
-            return copy;
-        },
-        arity: toFixedArity(1),
-        docs: {
-            category: 'sequence',
-            returns: { type: ['sequence', 'null'] },
-            args: { seq: { type: 'sequence' } },
-            variants: [{ argumentNames: ['seq'] }],
-            description: 'Returns a copy of $seq with first element removed. If $seq is empty `null` is returned.',
-            seeAlso: ['sequence.unshift', 'pop', 'rest'],
-            examples: [
-                'let su = import(sequence); su.shift([1, 2, 3])',
-                'let su = import(sequence); su.shift([])',
-            ],
-        },
-    },
     'splice': {
         evaluate: (params, sourceCodeInfo) => {
             const [seq, start, deleteCount, ...rest] = params;
@@ -31501,7 +31303,7 @@ su.position(
             },
             variants: [{ argumentNames: ['seq', 'values'] }],
             description: 'Returns copy of $seq with $values added to the beginning.',
-            seeAlso: ['push', 'sequence.shift', '++'],
+            seeAlso: ['push', '++'],
             examples: [
                 'let su = import(sequence); su.unshift([1, 2, 3], 4)',
                 'let su = import(sequence); su.unshift([1, 2, 3], 4)',
@@ -32174,6 +31976,380 @@ const bitwiseUtilsModule = {
     functions: bitwiseUtilsNormalExpression,
 };
 
+const lengthUnits = {
+    baseUnit: 'm',
+    description: 'length',
+    units: {
+        angstrom: 1e-10,
+        um: 0.000001,
+        mm: 0.001,
+        cm: 0.01,
+        m: 1,
+        km: 1000,
+        in: 0.0254,
+        ft: 0.3048,
+        yd: 0.9144,
+        mi: 1609.344,
+        nmi: 1852,
+    },
+};
+const weightUnits = {
+    baseUnit: 'kg',
+    description: 'weight',
+    units: {
+        mg: 0.000001,
+        g: 0.001,
+        kg: 1,
+        t: 1000,
+        oz: 0.028349523125,
+        lb: 0.45359237,
+        st: 6.35029318,
+    },
+};
+const volumeUnits = {
+    baseUnit: 'l',
+    description: 'volume',
+    units: {
+        'ml': 0.001,
+        'cl': 0.01,
+        'dl': 0.1,
+        'l': 1,
+        'tsp': 0.00492892159375,
+        'tbsp': 0.01478676478125,
+        'fl-oz': 0.0295735295625,
+        'cup': 0.2365882365,
+        'pt': 0.473176473,
+        'qt': 0.946352946,
+        'gal': 3.785411784,
+    },
+};
+const timeUnits = {
+    baseUnit: 's',
+    description: 'time',
+    units: {
+        ms: 0.001,
+        s: 1,
+        min: 60,
+        h: 3600,
+        day: 86400,
+        week: 604800,
+    },
+};
+const areaUnits = {
+    baseUnit: 'm2',
+    description: 'area',
+    units: {
+        mm2: 0.000001,
+        cm2: 0.0001,
+        m2: 1,
+        km2: 1000000,
+        in2: 0.00064516,
+        ft2: 0.09290304,
+        yd2: 0.83612736,
+        acre: 4046.8564224,
+        hectare: 10000,
+    },
+};
+const speedUnits = {
+    baseUnit: 'm/s',
+    description: 'speed',
+    units: {
+        'm/s': 1,
+        'km/h': 1 / 3.6,
+        'mph': 0.44704,
+        'kn': 0.514444,
+        'ft/s': 0.3048,
+    },
+};
+const dataUnits = {
+    baseUnit: 'b',
+    description: 'data',
+    units: {
+        b: 1,
+        kb: 1000,
+        mb: 1000000,
+        gb: 1e9,
+        tb: 1e12,
+        pb: 1e15,
+    },
+};
+const pressureUnits = {
+    baseUnit: 'pa',
+    description: 'pressure',
+    units: {
+        pa: 1,
+        kpa: 1000,
+        bar: 100000,
+        atm: 101325,
+        psi: 6894.757293168,
+        mmhg: 133.322387415,
+    },
+};
+const energyUnits = {
+    baseUnit: 'j',
+    description: 'energy',
+    units: {
+        j: 1,
+        kj: 1000,
+        cal: 4.184,
+        kcal: 4184,
+        wh: 3600,
+        kwh: 3600000,
+        btu: 1055.06,
+    },
+};
+const powerUnits = {
+    baseUnit: 'w',
+    description: 'power',
+    units: {
+        w: 1,
+        kw: 1000,
+        mw: 1000000,
+        hp: 745.7,
+    },
+};
+const frequencyUnits = {
+    baseUnit: 'hz',
+    description: 'frequency',
+    units: {
+        hz: 1,
+        khz: 1000,
+        mhz: 1000000,
+        ghz: 1000000000,
+    },
+};
+const angleUnits = {
+    baseUnit: 'rad',
+    description: 'angle',
+    units: {
+        deg: Math.PI / 180,
+        rad: 1,
+        grad: Math.PI / 200,
+        turn: 2 * Math.PI,
+    },
+};
+// --- Temperature conversion functions ---
+function celsiusTo(unit, value) {
+    switch (unit) {
+        case 'c': return value;
+        case 'f': return value * 9 / 5 + 32;
+        case 'k': return value + 273.15;
+    }
+}
+function toCelsius(unit, value) {
+    switch (unit) {
+        case 'c': return value;
+        case 'f': return (value - 32) * 5 / 9;
+        case 'k': return value - 273.15;
+    }
+}
+const temperatureUnits = ['c', 'f', 'k'];
+const unitDescriptions = {
+    // Length
+    'angstrom': 'ångströms',
+    'um': 'micrometers',
+    'mm': 'millimeters',
+    'cm': 'centimeters',
+    'm': 'meters',
+    'km': 'kilometers',
+    'in': 'inches',
+    'ft': 'feet',
+    'yd': 'yards',
+    'mi': 'miles',
+    'nmi': 'nautical miles',
+    // Weight
+    'mg': 'milligrams',
+    'g': 'grams',
+    'kg': 'kilograms',
+    't': 'metric tons',
+    'oz': 'ounces',
+    'lb': 'pounds',
+    'st': 'stones',
+    // Volume
+    'ml': 'milliliters',
+    'cl': 'centiliters',
+    'dl': 'deciliters',
+    'l': 'liters',
+    'tsp': 'teaspoons',
+    'tbsp': 'tablespoons',
+    'fl-oz': 'fluid ounces',
+    'cup': 'cups',
+    'pt': 'pints',
+    'qt': 'quarts',
+    'gal': 'gallons',
+    // Time
+    'ms': 'milliseconds',
+    's': 'seconds',
+    'min': 'minutes',
+    'h': 'hours',
+    'day': 'days',
+    'week': 'weeks',
+    // Area
+    'mm2': 'square millimeters',
+    'cm2': 'square centimeters',
+    'm2': 'square meters',
+    'km2': 'square kilometers',
+    'in2': 'square inches',
+    'ft2': 'square feet',
+    'yd2': 'square yards',
+    'acre': 'acres',
+    'hectare': 'hectares',
+    // Speed
+    'm/s': 'meters per second',
+    'km/h': 'kilometers per hour',
+    'mph': 'miles per hour',
+    'kn': 'knots',
+    'ft/s': 'feet per second',
+    // Data
+    'b': 'bytes',
+    'kb': 'kilobytes',
+    'mb': 'megabytes',
+    'gb': 'gigabytes',
+    'tb': 'terabytes',
+    'pb': 'petabytes',
+    // Pressure
+    'pa': 'pascals',
+    'kpa': 'kilopascals',
+    'bar': 'bars',
+    'atm': 'atmospheres',
+    'psi': 'pounds per square inch',
+    'mmhg': 'millimeters of mercury',
+    // Energy
+    'j': 'joules',
+    'kj': 'kilojoules',
+    'cal': 'calories',
+    'kcal': 'kilocalories',
+    'wh': 'watt-hours',
+    'kwh': 'kilowatt-hours',
+    'btu': 'British thermal units',
+    // Power
+    'w': 'watts',
+    'kw': 'kilowatts',
+    'mw': 'megawatts',
+    'hp': 'horsepower',
+    // Frequency
+    'hz': 'hertz',
+    'khz': 'kilohertz',
+    'mhz': 'megahertz',
+    'ghz': 'gigahertz',
+    // Angle
+    'deg': 'degrees',
+    'rad': 'radians',
+    'grad': 'gradians',
+    'turn': 'turns',
+    // Temperature
+    'c': 'Celsius',
+    'f': 'Fahrenheit',
+    'k': 'Kelvin',
+};
+// --- Generate linear conversion functions ---
+function generateLinearConversions(category) {
+    const result = {};
+    const unitNames = Object.keys(category.units);
+    for (const from of unitNames) {
+        for (const to of unitNames) {
+            if (from === to)
+                continue;
+            const fromFactor = category.units[from];
+            const toFactor = category.units[to];
+            const conversionFactor = fromFactor / toFactor;
+            const fnName = `${from}->${to}`;
+            const fromDesc = unitDescriptions[from];
+            const toDesc = unitDescriptions[to];
+            const seeAlso = [
+                `convert.${to}->${from}`,
+                ...unitNames
+                    .filter(u => u !== from && u !== to)
+                    .map(u => `convert.${from}->${u}`),
+            ];
+            result[fnName] = {
+                evaluate: ([value], sourceCodeInfo) => {
+                    assertNumber(value, sourceCodeInfo);
+                    return value * conversionFactor;
+                },
+                arity: toFixedArity(1),
+                docs: {
+                    category: 'convert',
+                    returns: { type: 'number' },
+                    args: {
+                        value: { type: 'number', description: `Value in ${fromDesc}` },
+                    },
+                    variants: [{ argumentNames: ['value'] }],
+                    description: `Converts a value from ${fromDesc} (\`${from}\`) to ${toDesc} (\`${to}\`).`,
+                    seeAlso,
+                    examples: [
+                        `let { ${fnName} } = import(convert);
+${fnName}(1)`,
+                    ],
+                },
+            };
+        }
+    }
+    return result;
+}
+// --- Generate temperature conversion functions ---
+function generateTemperatureConversions() {
+    const result = {};
+    for (const from of temperatureUnits) {
+        for (const to of temperatureUnits) {
+            if (from === to)
+                continue;
+            const fnName = `${from}->${to}`;
+            const fromDesc = unitDescriptions[from];
+            const toDesc = unitDescriptions[to];
+            const seeAlso = [
+                `convert.${to}->${from}`,
+                ...temperatureUnits
+                    .filter(u => u !== from && u !== to)
+                    .map(u => `convert.${from}->${u}`),
+            ];
+            result[fnName] = {
+                evaluate: ([value], sourceCodeInfo) => {
+                    assertNumber(value, sourceCodeInfo);
+                    const celsius = toCelsius(from, value);
+                    return celsiusTo(to, celsius);
+                },
+                arity: toFixedArity(1),
+                docs: {
+                    category: 'convert',
+                    returns: { type: 'number' },
+                    args: {
+                        value: { type: 'number', description: `Value in ${fromDesc}` },
+                    },
+                    variants: [{ argumentNames: ['value'] }],
+                    description: `Converts a temperature from ${fromDesc} (\`${from}\`) to ${toDesc} (\`${to}\`).`,
+                    seeAlso,
+                    examples: [
+                        `let { ${fnName} } = import(convert);
+${fnName}(100)`,
+                    ],
+                },
+            };
+        }
+    }
+    return result;
+}
+// --- Assemble all conversion functions ---
+const convertFunctions = {
+    ...generateLinearConversions(lengthUnits),
+    ...generateLinearConversions(weightUnits),
+    ...generateLinearConversions(volumeUnits),
+    ...generateLinearConversions(timeUnits),
+    ...generateLinearConversions(areaUnits),
+    ...generateLinearConversions(speedUnits),
+    ...generateLinearConversions(dataUnits),
+    ...generateLinearConversions(pressureUnits),
+    ...generateLinearConversions(energyUnits),
+    ...generateLinearConversions(powerUnits),
+    ...generateLinearConversions(frequencyUnits),
+    ...generateLinearConversions(angleUnits),
+    ...generateTemperatureConversions(),
+};
+const convertModule = {
+    name: 'convert',
+    functions: convertFunctions,
+};
+
 const allBuiltinModules = [
     assertModule,
     gridModule,
@@ -32188,6 +32364,7 @@ const allBuiltinModules = [
     collectionUtilsModule,
     sequenceUtilsModule,
     bitwiseUtilsModule,
+    convertModule,
 ];
 
 function runTest({ testPath: filePath, testNamePattern }) {
@@ -32568,7 +32745,7 @@ Shorthand for \`(args, ...) -> expression\`.
 
 You can reference the first argument using either \`$1\` or \`$\`.
 However, please note that \`$1\` and \`$\` are mutually exclusive and cannot be used simultaneously.
-E.g. \`#(* $ $1)\` is not valid.`,
+E.g. \`-> $ * $1\` is not valid.`,
         examples: [
             '-> $1 + $2',
             '(-> $ * $)(9)',
@@ -32709,6 +32886,7 @@ const moduleReference = {
     ...moduledDocsToReference(mathUtilsModule.name, mathUtilsModule.functions),
     ...moduledDocsToReference(functionalUtilsModule.name, functionalUtilsModule.functions),
     ...moduledDocsToReference(bitwiseUtilsModule.name, bitwiseUtilsModule.functions),
+    ...moduledDocsToReference(convertModule.name, convertModule.functions),
 };
 Object.entries(normalExpressionReference).forEach(([key, obj]) => {
     if (!normalExpressions[key]) {
@@ -33193,6 +33371,9 @@ function getVectorReductionNames(name) {
     const baseName = name.replace(/^/, '');
     return [`vector.${name}`, `vector.moving-${baseName}`, `vector.centered-moving-${baseName}`, `vector.running-${baseName}`];
 }
+function getVectorMovingNames(name) {
+    return [`vector.moving-${name}`, `vector.centered-moving-${name}`, `vector.running-${name}`];
+}
 const api = {
     collection: [
         'filter',
@@ -33254,7 +33435,6 @@ const api = {
     sequenceUtils: [
         'sequence.position',
         'sequence.last-index-of',
-        'sequence.shift',
         'sequence.unshift',
         'sequence.splice',
         'sequence.sort-by',
@@ -33467,7 +33647,7 @@ const api = {
         'assert.assert-vector',
     ],
     grid: [
-        'grid.every?',
+        'grid.cell-every?',
         'grid.some?',
         'grid.every-row?',
         'grid.some-row?',
@@ -33483,19 +33663,17 @@ const api = {
         'grid.flip-h',
         'grid.flip-v',
         'grid.rotate',
-        'grid.reverse-rows',
-        'grid.reverse-cols',
-        'grid.slice',
+        'grid.crop',
         'grid.slice-rows',
         'grid.slice-cols',
         'grid.splice-rows',
         'grid.splice-cols',
         'grid.concat-rows',
         'grid.concat-cols',
-        'grid.map',
-        'grid.mapi',
-        'grid.reduce',
-        'grid.reducei',
+        'grid.cell-map',
+        'grid.cell-mapi',
+        'grid.cell-reduce',
+        'grid.cell-reducei',
         'grid.push-rows',
         'grid.unshift-rows',
         'grid.pop-row',
@@ -33520,7 +33698,7 @@ const api = {
         'matrix.lower-triangular?',
         'matrix.diagonal?',
         'matrix.square?',
-        'matrix.orthogonal?',
+        'matrix.orthogonal-matrix?',
         'matrix.identity?',
         'matrix.invertible?',
         'matrix.hilbert',
@@ -33546,17 +33724,12 @@ const api = {
         'vector.decreasing?',
         'vector.strictly-increasing?',
         'vector.strictly-decreasing?',
-        'vector.median',
         'vector.mode',
         'vector.min-index',
         'vector.max-index',
         'vector.sort-indices',
         'vector.count-values',
         'vector.linspace',
-        'vector.ones',
-        'vector.zeros',
-        'vector.fill',
-        'vector.generate',
         'vector.cumsum',
         'vector.cumprod',
         'vector.quartiles',
@@ -33572,12 +33745,12 @@ const api = {
         'vector.mae',
         'vector.rmse',
         'vector.smape',
-        ...getVectorReductionNames('mean'),
-        ...getVectorReductionNames('median'),
+        ...getVectorMovingNames('mean'),
+        ...getVectorMovingNames('median'),
         ...getVectorReductionNames('variance'),
         ...getVectorReductionNames('sample-variance'),
-        ...getVectorReductionNames('sum'),
-        ...getVectorReductionNames('prod'),
+        ...getVectorMovingNames('sum'),
+        ...getVectorMovingNames('prod'),
         ...getVectorReductionNames('stdev'),
         ...getVectorReductionNames('sample-stdev'),
         ...getVectorReductionNames('iqr'),
@@ -33734,6 +33907,536 @@ const api = {
         'random.random-id!',
         'random.random-color!',
     ],
+    convert: [
+        'convert.angstrom->um',
+        'convert.angstrom->mm',
+        'convert.angstrom->cm',
+        'convert.angstrom->m',
+        'convert.angstrom->km',
+        'convert.angstrom->in',
+        'convert.angstrom->ft',
+        'convert.angstrom->yd',
+        'convert.angstrom->mi',
+        'convert.angstrom->nmi',
+        'convert.um->angstrom',
+        'convert.um->mm',
+        'convert.um->cm',
+        'convert.um->m',
+        'convert.um->km',
+        'convert.um->in',
+        'convert.um->ft',
+        'convert.um->yd',
+        'convert.um->mi',
+        'convert.um->nmi',
+        'convert.mm->angstrom',
+        'convert.mm->um',
+        'convert.mm->cm',
+        'convert.mm->m',
+        'convert.mm->km',
+        'convert.mm->in',
+        'convert.mm->ft',
+        'convert.mm->yd',
+        'convert.mm->mi',
+        'convert.mm->nmi',
+        'convert.cm->angstrom',
+        'convert.cm->um',
+        'convert.cm->mm',
+        'convert.cm->m',
+        'convert.cm->km',
+        'convert.cm->in',
+        'convert.cm->ft',
+        'convert.cm->yd',
+        'convert.cm->mi',
+        'convert.cm->nmi',
+        'convert.m->angstrom',
+        'convert.m->um',
+        'convert.m->mm',
+        'convert.m->cm',
+        'convert.m->km',
+        'convert.m->in',
+        'convert.m->ft',
+        'convert.m->yd',
+        'convert.m->mi',
+        'convert.m->nmi',
+        'convert.km->angstrom',
+        'convert.km->um',
+        'convert.km->mm',
+        'convert.km->cm',
+        'convert.km->m',
+        'convert.km->in',
+        'convert.km->ft',
+        'convert.km->yd',
+        'convert.km->mi',
+        'convert.km->nmi',
+        'convert.in->angstrom',
+        'convert.in->um',
+        'convert.in->mm',
+        'convert.in->cm',
+        'convert.in->m',
+        'convert.in->km',
+        'convert.in->ft',
+        'convert.in->yd',
+        'convert.in->mi',
+        'convert.in->nmi',
+        'convert.ft->angstrom',
+        'convert.ft->um',
+        'convert.ft->mm',
+        'convert.ft->cm',
+        'convert.ft->m',
+        'convert.ft->km',
+        'convert.ft->in',
+        'convert.ft->yd',
+        'convert.ft->mi',
+        'convert.ft->nmi',
+        'convert.yd->angstrom',
+        'convert.yd->um',
+        'convert.yd->mm',
+        'convert.yd->cm',
+        'convert.yd->m',
+        'convert.yd->km',
+        'convert.yd->in',
+        'convert.yd->ft',
+        'convert.yd->mi',
+        'convert.yd->nmi',
+        'convert.mi->angstrom',
+        'convert.mi->um',
+        'convert.mi->mm',
+        'convert.mi->cm',
+        'convert.mi->m',
+        'convert.mi->km',
+        'convert.mi->in',
+        'convert.mi->ft',
+        'convert.mi->yd',
+        'convert.mi->nmi',
+        'convert.nmi->angstrom',
+        'convert.nmi->um',
+        'convert.nmi->mm',
+        'convert.nmi->cm',
+        'convert.nmi->m',
+        'convert.nmi->km',
+        'convert.nmi->in',
+        'convert.nmi->ft',
+        'convert.nmi->yd',
+        'convert.nmi->mi',
+        'convert.mg->g',
+        'convert.mg->kg',
+        'convert.mg->t',
+        'convert.mg->oz',
+        'convert.mg->lb',
+        'convert.mg->st',
+        'convert.g->mg',
+        'convert.g->kg',
+        'convert.g->t',
+        'convert.g->oz',
+        'convert.g->lb',
+        'convert.g->st',
+        'convert.kg->mg',
+        'convert.kg->g',
+        'convert.kg->t',
+        'convert.kg->oz',
+        'convert.kg->lb',
+        'convert.kg->st',
+        'convert.t->mg',
+        'convert.t->g',
+        'convert.t->kg',
+        'convert.t->oz',
+        'convert.t->lb',
+        'convert.t->st',
+        'convert.oz->mg',
+        'convert.oz->g',
+        'convert.oz->kg',
+        'convert.oz->t',
+        'convert.oz->lb',
+        'convert.oz->st',
+        'convert.lb->mg',
+        'convert.lb->g',
+        'convert.lb->kg',
+        'convert.lb->t',
+        'convert.lb->oz',
+        'convert.lb->st',
+        'convert.st->mg',
+        'convert.st->g',
+        'convert.st->kg',
+        'convert.st->t',
+        'convert.st->oz',
+        'convert.st->lb',
+        'convert.ml->cl',
+        'convert.ml->dl',
+        'convert.ml->l',
+        'convert.ml->tsp',
+        'convert.ml->tbsp',
+        'convert.ml->fl-oz',
+        'convert.ml->cup',
+        'convert.ml->pt',
+        'convert.ml->qt',
+        'convert.ml->gal',
+        'convert.cl->ml',
+        'convert.cl->dl',
+        'convert.cl->l',
+        'convert.cl->tsp',
+        'convert.cl->tbsp',
+        'convert.cl->fl-oz',
+        'convert.cl->cup',
+        'convert.cl->pt',
+        'convert.cl->qt',
+        'convert.cl->gal',
+        'convert.dl->ml',
+        'convert.dl->cl',
+        'convert.dl->l',
+        'convert.dl->tsp',
+        'convert.dl->tbsp',
+        'convert.dl->fl-oz',
+        'convert.dl->cup',
+        'convert.dl->pt',
+        'convert.dl->qt',
+        'convert.dl->gal',
+        'convert.l->ml',
+        'convert.l->cl',
+        'convert.l->dl',
+        'convert.l->tsp',
+        'convert.l->tbsp',
+        'convert.l->fl-oz',
+        'convert.l->cup',
+        'convert.l->pt',
+        'convert.l->qt',
+        'convert.l->gal',
+        'convert.tsp->ml',
+        'convert.tsp->cl',
+        'convert.tsp->dl',
+        'convert.tsp->l',
+        'convert.tsp->tbsp',
+        'convert.tsp->fl-oz',
+        'convert.tsp->cup',
+        'convert.tsp->pt',
+        'convert.tsp->qt',
+        'convert.tsp->gal',
+        'convert.tbsp->ml',
+        'convert.tbsp->cl',
+        'convert.tbsp->dl',
+        'convert.tbsp->l',
+        'convert.tbsp->tsp',
+        'convert.tbsp->fl-oz',
+        'convert.tbsp->cup',
+        'convert.tbsp->pt',
+        'convert.tbsp->qt',
+        'convert.tbsp->gal',
+        'convert.fl-oz->ml',
+        'convert.fl-oz->cl',
+        'convert.fl-oz->dl',
+        'convert.fl-oz->l',
+        'convert.fl-oz->tsp',
+        'convert.fl-oz->tbsp',
+        'convert.fl-oz->cup',
+        'convert.fl-oz->pt',
+        'convert.fl-oz->qt',
+        'convert.fl-oz->gal',
+        'convert.cup->ml',
+        'convert.cup->cl',
+        'convert.cup->dl',
+        'convert.cup->l',
+        'convert.cup->tsp',
+        'convert.cup->tbsp',
+        'convert.cup->fl-oz',
+        'convert.cup->pt',
+        'convert.cup->qt',
+        'convert.cup->gal',
+        'convert.pt->ml',
+        'convert.pt->cl',
+        'convert.pt->dl',
+        'convert.pt->l',
+        'convert.pt->tsp',
+        'convert.pt->tbsp',
+        'convert.pt->fl-oz',
+        'convert.pt->cup',
+        'convert.pt->qt',
+        'convert.pt->gal',
+        'convert.qt->ml',
+        'convert.qt->cl',
+        'convert.qt->dl',
+        'convert.qt->l',
+        'convert.qt->tsp',
+        'convert.qt->tbsp',
+        'convert.qt->fl-oz',
+        'convert.qt->cup',
+        'convert.qt->pt',
+        'convert.qt->gal',
+        'convert.gal->ml',
+        'convert.gal->cl',
+        'convert.gal->dl',
+        'convert.gal->l',
+        'convert.gal->tsp',
+        'convert.gal->tbsp',
+        'convert.gal->fl-oz',
+        'convert.gal->cup',
+        'convert.gal->pt',
+        'convert.gal->qt',
+        'convert.ms->s',
+        'convert.ms->min',
+        'convert.ms->h',
+        'convert.ms->day',
+        'convert.ms->week',
+        'convert.s->ms',
+        'convert.s->min',
+        'convert.s->h',
+        'convert.s->day',
+        'convert.s->week',
+        'convert.min->ms',
+        'convert.min->s',
+        'convert.min->h',
+        'convert.min->day',
+        'convert.min->week',
+        'convert.h->ms',
+        'convert.h->s',
+        'convert.h->min',
+        'convert.h->day',
+        'convert.h->week',
+        'convert.day->ms',
+        'convert.day->s',
+        'convert.day->min',
+        'convert.day->h',
+        'convert.day->week',
+        'convert.week->ms',
+        'convert.week->s',
+        'convert.week->min',
+        'convert.week->h',
+        'convert.week->day',
+        'convert.mm2->cm2',
+        'convert.mm2->m2',
+        'convert.mm2->km2',
+        'convert.mm2->in2',
+        'convert.mm2->ft2',
+        'convert.mm2->yd2',
+        'convert.mm2->acre',
+        'convert.mm2->hectare',
+        'convert.cm2->mm2',
+        'convert.cm2->m2',
+        'convert.cm2->km2',
+        'convert.cm2->in2',
+        'convert.cm2->ft2',
+        'convert.cm2->yd2',
+        'convert.cm2->acre',
+        'convert.cm2->hectare',
+        'convert.m2->mm2',
+        'convert.m2->cm2',
+        'convert.m2->km2',
+        'convert.m2->in2',
+        'convert.m2->ft2',
+        'convert.m2->yd2',
+        'convert.m2->acre',
+        'convert.m2->hectare',
+        'convert.km2->mm2',
+        'convert.km2->cm2',
+        'convert.km2->m2',
+        'convert.km2->in2',
+        'convert.km2->ft2',
+        'convert.km2->yd2',
+        'convert.km2->acre',
+        'convert.km2->hectare',
+        'convert.in2->mm2',
+        'convert.in2->cm2',
+        'convert.in2->m2',
+        'convert.in2->km2',
+        'convert.in2->ft2',
+        'convert.in2->yd2',
+        'convert.in2->acre',
+        'convert.in2->hectare',
+        'convert.ft2->mm2',
+        'convert.ft2->cm2',
+        'convert.ft2->m2',
+        'convert.ft2->km2',
+        'convert.ft2->in2',
+        'convert.ft2->yd2',
+        'convert.ft2->acre',
+        'convert.ft2->hectare',
+        'convert.yd2->mm2',
+        'convert.yd2->cm2',
+        'convert.yd2->m2',
+        'convert.yd2->km2',
+        'convert.yd2->in2',
+        'convert.yd2->ft2',
+        'convert.yd2->acre',
+        'convert.yd2->hectare',
+        'convert.acre->mm2',
+        'convert.acre->cm2',
+        'convert.acre->m2',
+        'convert.acre->km2',
+        'convert.acre->in2',
+        'convert.acre->ft2',
+        'convert.acre->yd2',
+        'convert.acre->hectare',
+        'convert.hectare->mm2',
+        'convert.hectare->cm2',
+        'convert.hectare->m2',
+        'convert.hectare->km2',
+        'convert.hectare->in2',
+        'convert.hectare->ft2',
+        'convert.hectare->yd2',
+        'convert.hectare->acre',
+        'convert.m/s->km/h',
+        'convert.m/s->mph',
+        'convert.m/s->kn',
+        'convert.m/s->ft/s',
+        'convert.km/h->m/s',
+        'convert.km/h->mph',
+        'convert.km/h->kn',
+        'convert.km/h->ft/s',
+        'convert.mph->m/s',
+        'convert.mph->km/h',
+        'convert.mph->kn',
+        'convert.mph->ft/s',
+        'convert.kn->m/s',
+        'convert.kn->km/h',
+        'convert.kn->mph',
+        'convert.kn->ft/s',
+        'convert.ft/s->m/s',
+        'convert.ft/s->km/h',
+        'convert.ft/s->mph',
+        'convert.ft/s->kn',
+        'convert.b->kb',
+        'convert.b->mb',
+        'convert.b->gb',
+        'convert.b->tb',
+        'convert.b->pb',
+        'convert.kb->b',
+        'convert.kb->mb',
+        'convert.kb->gb',
+        'convert.kb->tb',
+        'convert.kb->pb',
+        'convert.mb->b',
+        'convert.mb->kb',
+        'convert.mb->gb',
+        'convert.mb->tb',
+        'convert.mb->pb',
+        'convert.gb->b',
+        'convert.gb->kb',
+        'convert.gb->mb',
+        'convert.gb->tb',
+        'convert.gb->pb',
+        'convert.tb->b',
+        'convert.tb->kb',
+        'convert.tb->mb',
+        'convert.tb->gb',
+        'convert.tb->pb',
+        'convert.pb->b',
+        'convert.pb->kb',
+        'convert.pb->mb',
+        'convert.pb->gb',
+        'convert.pb->tb',
+        'convert.pa->kpa',
+        'convert.pa->bar',
+        'convert.pa->atm',
+        'convert.pa->psi',
+        'convert.pa->mmhg',
+        'convert.kpa->pa',
+        'convert.kpa->bar',
+        'convert.kpa->atm',
+        'convert.kpa->psi',
+        'convert.kpa->mmhg',
+        'convert.bar->pa',
+        'convert.bar->kpa',
+        'convert.bar->atm',
+        'convert.bar->psi',
+        'convert.bar->mmhg',
+        'convert.atm->pa',
+        'convert.atm->kpa',
+        'convert.atm->bar',
+        'convert.atm->psi',
+        'convert.atm->mmhg',
+        'convert.psi->pa',
+        'convert.psi->kpa',
+        'convert.psi->bar',
+        'convert.psi->atm',
+        'convert.psi->mmhg',
+        'convert.mmhg->pa',
+        'convert.mmhg->kpa',
+        'convert.mmhg->bar',
+        'convert.mmhg->atm',
+        'convert.mmhg->psi',
+        'convert.j->kj',
+        'convert.j->cal',
+        'convert.j->kcal',
+        'convert.j->wh',
+        'convert.j->kwh',
+        'convert.j->btu',
+        'convert.kj->j',
+        'convert.kj->cal',
+        'convert.kj->kcal',
+        'convert.kj->wh',
+        'convert.kj->kwh',
+        'convert.kj->btu',
+        'convert.cal->j',
+        'convert.cal->kj',
+        'convert.cal->kcal',
+        'convert.cal->wh',
+        'convert.cal->kwh',
+        'convert.cal->btu',
+        'convert.kcal->j',
+        'convert.kcal->kj',
+        'convert.kcal->cal',
+        'convert.kcal->wh',
+        'convert.kcal->kwh',
+        'convert.kcal->btu',
+        'convert.wh->j',
+        'convert.wh->kj',
+        'convert.wh->cal',
+        'convert.wh->kcal',
+        'convert.wh->kwh',
+        'convert.wh->btu',
+        'convert.kwh->j',
+        'convert.kwh->kj',
+        'convert.kwh->cal',
+        'convert.kwh->kcal',
+        'convert.kwh->wh',
+        'convert.kwh->btu',
+        'convert.btu->j',
+        'convert.btu->kj',
+        'convert.btu->cal',
+        'convert.btu->kcal',
+        'convert.btu->wh',
+        'convert.btu->kwh',
+        'convert.w->kw',
+        'convert.w->mw',
+        'convert.w->hp',
+        'convert.kw->w',
+        'convert.kw->mw',
+        'convert.kw->hp',
+        'convert.mw->w',
+        'convert.mw->kw',
+        'convert.mw->hp',
+        'convert.hp->w',
+        'convert.hp->kw',
+        'convert.hp->mw',
+        'convert.hz->khz',
+        'convert.hz->mhz',
+        'convert.hz->ghz',
+        'convert.khz->hz',
+        'convert.khz->mhz',
+        'convert.khz->ghz',
+        'convert.mhz->hz',
+        'convert.mhz->khz',
+        'convert.mhz->ghz',
+        'convert.ghz->hz',
+        'convert.ghz->khz',
+        'convert.ghz->mhz',
+        'convert.deg->rad',
+        'convert.deg->grad',
+        'convert.deg->turn',
+        'convert.rad->deg',
+        'convert.rad->grad',
+        'convert.rad->turn',
+        'convert.grad->deg',
+        'convert.grad->rad',
+        'convert.grad->turn',
+        'convert.turn->deg',
+        'convert.turn->rad',
+        'convert.turn->grad',
+        'convert.c->f',
+        'convert.c->k',
+        'convert.f->c',
+        'convert.f->k',
+        'convert.k->c',
+        'convert.k->f',
+    ],
     shorthand: [
         '-short-regexp',
         '-short-fn',
@@ -34668,6 +35371,7 @@ const HIST_SIZE = 1000;
 const PROMPT = fmt.bright.gray('> ');
 const historyResults = [];
 const formatValue = getInlineCodeFormatter(fmt);
+const booleanFlags = new Set(['-s', '--silent', '--pure']);
 const commands = ['`help', '`quit', '`builtins', '`context'];
 const expressionRegExp = new RegExp(`^(.*\\(\\s*)(${polishSymbolFirstCharacterClass}${polishSymbolCharacterClass}*)$`);
 const nameRegExp = new RegExp(`^(.*?)(${polishSymbolFirstCharacterClass}${polishSymbolCharacterClass}*)$`);
@@ -34846,14 +35550,26 @@ function setReplHistoryVariables(context) {
 }
 function parseOption(args, i) {
     const option = args[i];
-    if (option === '-s') {
-        return { option, argument: null, count: 1 };
-    }
-    if (/^-[a-z]$/i.test(option))
+    // Short option: -x
+    if (/^-[a-z]$/i.test(option)) {
+        if (booleanFlags.has(option)) {
+            return { option, argument: null, count: 1 };
+        }
         return { option, argument: args[i + 1] ?? null, count: 2 };
+    }
+    // Long option: --foo or --foo=value
     const match = /^(--[a-z-]+)(?:=(.*))?$/i.exec(option);
-    if (match)
-        return { option: match[1], argument: match[2] ?? null, count: 1 };
+    if (match) {
+        const name = match[1];
+        const inlineArg = match[2];
+        if (inlineArg !== undefined) {
+            return { option: name, argument: inlineArg, count: 1 };
+        }
+        if (booleanFlags.has(name)) {
+            return { option: name, argument: null, count: 1 };
+        }
+        return { option: name, argument: args[i + 1] ?? null, count: 2 };
+    }
     return null;
 }
 function parseContextOptions(args, startIndex) {
@@ -34928,11 +35644,19 @@ function parseRunEvalOptions(args, startIndex) {
     let context = {};
     let printResult = true;
     let pure = false;
+    let positional = null;
     let i = startIndex;
     while (i < args.length) {
         const parsed = parseOption(args, i);
-        if (!parsed)
-            break;
+        if (!parsed) {
+            if (positional !== null) {
+                printErrorMessage(`Unexpected argument "${args[i]}"`);
+                process.exit(1);
+            }
+            positional = args[i];
+            i += 1;
+            continue;
+        }
         switch (parsed.option) {
             case '-c':
             case '--context':
@@ -34959,11 +35683,7 @@ function parseRunEvalOptions(args, startIndex) {
                 process.exit(1);
         }
     }
-    if (i < args.length) {
-        printErrorMessage(`Unknown argument "${args[i]}"`);
-        process.exit(1);
-    }
-    return { context, printResult, pure, nextIndex: i };
+    return { context, printResult, pure, positional, nextIndex: i };
 }
 function processArguments(args) {
     // Global flags (no subcommand)
@@ -34979,45 +35699,43 @@ function processArguments(args) {
     }
     switch (first) {
         case 'run': {
-            const filename = args[1];
-            if (!filename || filename.startsWith('-')) {
+            const { positional: filename, context, printResult, pure } = parseRunEvalOptions(args, 1);
+            if (!filename) {
                 printErrorMessage('Missing filename after "run"');
                 process.exit(1);
             }
-            const { context, printResult, pure } = parseRunEvalOptions(args, 2);
             return { subcommand: 'run', filename, context, printResult, pure };
         }
         case 'run-bundle': {
-            const filename = args[1];
-            if (!filename || filename.startsWith('-')) {
+            const { positional: filename, context, printResult, pure } = parseRunEvalOptions(args, 1);
+            if (!filename) {
                 printErrorMessage('Missing filename after "run-bundle"');
                 process.exit(1);
             }
-            const { context, printResult, pure } = parseRunEvalOptions(args, 2);
             return { subcommand: 'run-bundle', filename, context, printResult, pure };
         }
         case 'eval': {
-            const expression = args[1];
-            if (!expression || expression.startsWith('-')) {
+            const { positional: expression, context, printResult, pure } = parseRunEvalOptions(args, 1);
+            if (!expression) {
                 printErrorMessage('Missing expression after "eval"');
                 process.exit(1);
             }
-            const { context, printResult, pure } = parseRunEvalOptions(args, 2);
             return { subcommand: 'eval', expression, context, printResult, pure };
         }
         case 'bundle': {
-            const filename = args[1];
-            if (!filename || filename.startsWith('-')) {
-                printErrorMessage('Missing filename after "bundle"');
-                process.exit(1);
-            }
+            let filename = null;
             let output = null;
-            let i = 2;
+            let i = 1;
             while (i < args.length) {
                 const parsed = parseOption(args, i);
                 if (!parsed) {
-                    printErrorMessage(`Unknown argument "${args[i]}"`);
-                    process.exit(1);
+                    if (filename !== null) {
+                        printErrorMessage(`Unexpected argument "${args[i]}"`);
+                        process.exit(1);
+                    }
+                    filename = args[i];
+                    i += 1;
+                    continue;
                 }
                 switch (parsed.option) {
                     case '-o':
@@ -35034,21 +35752,26 @@ function processArguments(args) {
                         process.exit(1);
                 }
             }
+            if (!filename) {
+                printErrorMessage('Missing filename after "bundle"');
+                process.exit(1);
+            }
             return { subcommand: 'bundle', filename, output };
         }
         case 'test': {
-            const filename = args[1];
-            if (!filename || filename.startsWith('-')) {
-                printErrorMessage('Missing filename after "test"');
-                process.exit(1);
-            }
+            let filename = null;
             let testPattern = null;
-            let i = 2;
+            let i = 1;
             while (i < args.length) {
                 const parsed = parseOption(args, i);
                 if (!parsed) {
-                    printErrorMessage(`Unknown argument "${args[i]}"`);
-                    process.exit(1);
+                    if (filename !== null) {
+                        printErrorMessage(`Unexpected argument "${args[i]}"`);
+                        process.exit(1);
+                    }
+                    filename = args[i];
+                    i += 1;
+                    continue;
                 }
                 switch (parsed.option) {
                     case '--pattern':
@@ -35064,6 +35787,10 @@ function processArguments(args) {
                         process.exit(1);
                 }
             }
+            if (!filename) {
+                printErrorMessage('Missing filename after "test"');
+                process.exit(1);
+            }
             return { subcommand: 'test', filename, testPattern };
         }
         case 'repl': {