@mojir/lits 2.5.1 → 2.6.1

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.1";
+var version = "2.6.1";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -98,7 +98,7 @@ const specialExpressionTypes = {
     'loop': 12,
     'object': 13,
     'recur': 14,
-    'switch': 15,
+    'match': 15,
     'throw': 16,
     'try': 17,
     'unless': 18,
@@ -289,85 +289,6 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
     }
 }
 
-function getRangeString(options) {
-    const hasUpperAndLowerBound = (typeof options.gt === 'number' || typeof options.gte === 'number')
-        && (typeof options.lt === 'number' || typeof options.lte === 'number');
-    if (hasUpperAndLowerBound) {
-        return `${typeof options.gt === 'number' ? `${options.gt} < n ` : `${options.gte} <= n `}${typeof options.lt === 'number' ? `< ${options.lt}` : `<= ${options.lte}`}`;
-    }
-    else if (typeof options.gt === 'number' || typeof options.gte === 'number') {
-        return `${typeof options.gt === 'number' ? `n > ${options.gt}` : `n >= ${options.gte}`}`;
-    }
-    else if (typeof options.lt === 'number' || typeof options.lte === 'number') {
-        return `${typeof options.lt === 'number' ? `n < ${options.lt}` : `n <= ${options.lte}`}`;
-    }
-    else {
-        return '';
-    }
-}
-function getSignString(options) {
-    return options.positive
-        ? 'positive'
-        : options.negative
-            ? 'negative'
-            : options.nonNegative
-                ? 'non negative'
-                : options.nonPositive
-                    ? 'non positive'
-                    : options.nonZero
-                        ? 'non zero'
-                        : '';
-}
-function getNumberTypeName(options) {
-    if (options.zero)
-        return 'zero';
-    const sign = getSignString(options);
-    const numberType = options.integer ? 'integer' : 'number';
-    const finite = options.finite ? 'finite' : '';
-    const range = getRangeString(options);
-    return [sign, finite, numberType, range].filter(x => !!x).join(' ');
-}
-function isNumber(value, options = {}) {
-    if (typeof value !== 'number')
-        return false;
-    if (Number.isNaN(value))
-        return false;
-    if (options.integer && !Number.isInteger(value))
-        return false;
-    if (options.finite && !Number.isFinite(value))
-        return false;
-    if (options.zero && value !== 0)
-        return false;
-    if (options.nonZero && value === 0)
-        return false;
-    if (options.positive && value <= 0)
-        return false;
-    if (options.negative && value >= 0)
-        return false;
-    if (options.nonPositive && value > 0)
-        return false;
-    if (options.nonNegative && value < 0)
-        return false;
-    if (typeof options.gt === 'number' && value <= options.gt)
-        return false;
-    if (typeof options.gte === 'number' && value < options.gte)
-        return false;
-    if (typeof options.lt === 'number' && value >= options.lt)
-        return false;
-    if (typeof options.lte === 'number' && value > options.lte)
-        return false;
-    return true;
-}
-function assertNumber(value, sourceCodeInfo, options = {}) {
-    if (!isNumber(value, options)) {
-        throw new LitsError(`Expected ${getNumberTypeName(options)}, got ${valueToString(value)}.`, getSourceCodeInfo(value, sourceCodeInfo));
-    }
-}
-function asNumber(value, sourceCodeInfo, options = {}) {
-    assertNumber(value, sourceCodeInfo, options);
-    return value;
-}
-
 function isNonUndefined(value) {
     return value !== undefined;
 }
@@ -474,6 +395,162 @@ function assertFunctionLike(value, sourceCodeInfo) {
         throw getAssertionError('FunctionLike', value, sourceCodeInfo);
 }
 
+function isString(value, options = {}) {
+    if (typeof value !== 'string')
+        return false;
+    if (options.nonEmpty && value.length === 0)
+        return false;
+    if (options.char && value.length !== 1)
+        return false;
+    return true;
+}
+function assertString(value, sourceCodeInfo, options = {}) {
+    if (!isString(value, options)) {
+        throw getAssertionError(`${options.nonEmpty ? 'non empty string' : options.char ? 'character' : 'string'}`, value, sourceCodeInfo);
+    }
+}
+function asString(value, sourceCodeInfo, options = {}) {
+    assertString(value, sourceCodeInfo, options);
+    return value;
+}
+function isStringOrNumber(value) {
+    return typeof value === 'string' || typeof value === 'number';
+}
+function asStringOrNumber(value, sourceCodeInfo) {
+    assertStringOrNumber(value, sourceCodeInfo);
+    return value;
+}
+function assertStringOrNumber(value, sourceCodeInfo) {
+    if (!isStringOrNumber(value))
+        throw getAssertionError('string or number', value, sourceCodeInfo);
+}
+
+const assertionNormalExpression = {
+    assert: {
+        evaluate: (params, sourceCodeInfo) => {
+            const value = params[0];
+            const message = params.length === 2 ? params[1] : `${value}`;
+            assertString(message, sourceCodeInfo);
+            if (!value)
+                throw new AssertionError(message, sourceCodeInfo);
+            return asAny(value, sourceCodeInfo);
+        },
+        arity: { min: 1, max: 2 },
+        docs: {
+            category: 'assertion',
+            description: 'If $value is falsy it throws `AssertionError` with $message. If no $message is provided, message is set to $value.',
+            returns: {
+                type: 'any',
+            },
+            args: {
+                value: {
+                    type: 'any',
+                },
+                message: {
+                    type: 'string',
+                },
+            },
+            variants: [
+                {
+                    argumentNames: [
+                        'value',
+                    ],
+                },
+                {
+                    argumentNames: [
+                        'value',
+                        'message',
+                    ],
+                },
+            ],
+            examples: [
+                'try assert(0, "Expected a positive value") catch (e) e.message end',
+            ],
+            seeAlso: ['assertion.assert-truthy', 'assertion.assert-true'],
+            hideOperatorForm: true,
+        },
+    },
+};
+
+function getRangeString(options) {
+    const hasUpperAndLowerBound = (typeof options.gt === 'number' || typeof options.gte === 'number')
+        && (typeof options.lt === 'number' || typeof options.lte === 'number');
+    if (hasUpperAndLowerBound) {
+        return `${typeof options.gt === 'number' ? `${options.gt} < n ` : `${options.gte} <= n `}${typeof options.lt === 'number' ? `< ${options.lt}` : `<= ${options.lte}`}`;
+    }
+    else if (typeof options.gt === 'number' || typeof options.gte === 'number') {
+        return `${typeof options.gt === 'number' ? `n > ${options.gt}` : `n >= ${options.gte}`}`;
+    }
+    else if (typeof options.lt === 'number' || typeof options.lte === 'number') {
+        return `${typeof options.lt === 'number' ? `n < ${options.lt}` : `n <= ${options.lte}`}`;
+    }
+    else {
+        return '';
+    }
+}
+function getSignString(options) {
+    return options.positive
+        ? 'positive'
+        : options.negative
+            ? 'negative'
+            : options.nonNegative
+                ? 'non negative'
+                : options.nonPositive
+                    ? 'non positive'
+                    : options.nonZero
+                        ? 'non zero'
+                        : '';
+}
+function getNumberTypeName(options) {
+    if (options.zero)
+        return 'zero';
+    const sign = getSignString(options);
+    const numberType = options.integer ? 'integer' : 'number';
+    const finite = options.finite ? 'finite' : '';
+    const range = getRangeString(options);
+    return [sign, finite, numberType, range].filter(x => !!x).join(' ');
+}
+function isNumber(value, options = {}) {
+    if (typeof value !== 'number')
+        return false;
+    if (Number.isNaN(value))
+        return false;
+    if (options.integer && !Number.isInteger(value))
+        return false;
+    if (options.finite && !Number.isFinite(value))
+        return false;
+    if (options.zero && value !== 0)
+        return false;
+    if (options.nonZero && value === 0)
+        return false;
+    if (options.positive && value <= 0)
+        return false;
+    if (options.negative && value >= 0)
+        return false;
+    if (options.nonPositive && value > 0)
+        return false;
+    if (options.nonNegative && value < 0)
+        return false;
+    if (typeof options.gt === 'number' && value <= options.gt)
+        return false;
+    if (typeof options.gte === 'number' && value < options.gte)
+        return false;
+    if (typeof options.lt === 'number' && value >= options.lt)
+        return false;
+    if (typeof options.lte === 'number' && value > options.lte)
+        return false;
+    return true;
+}
+function assertNumber(value, sourceCodeInfo, options = {}) {
+    if (!isNumber(value, options)) {
+        throw new LitsError(`Expected ${getNumberTypeName(options)}, got ${valueToString(value)}.`, getSourceCodeInfo(value, sourceCodeInfo));
+    }
+}
+function asNumber(value, sourceCodeInfo, options = {}) {
+    assertNumber(value, sourceCodeInfo, options);
+    return value;
+}
+
 function arityAcceptsMin(arity, nbrOfParams) {
     const { min } = arity;
     if (typeof min === 'number' && nbrOfParams < min) {
@@ -685,36 +762,6 @@ const bitwiseNormalExpression = {
     },
 };
 
-function isString(value, options = {}) {
-    if (typeof value !== 'string')
-        return false;
-    if (options.nonEmpty && value.length === 0)
-        return false;
-    if (options.char && value.length !== 1)
-        return false;
-    return true;
-}
-function assertString(value, sourceCodeInfo, options = {}) {
-    if (!isString(value, options)) {
-        throw getAssertionError(`${options.nonEmpty ? 'non empty string' : options.char ? 'character' : 'string'}`, value, sourceCodeInfo);
-    }
-}
-function asString(value, sourceCodeInfo, options = {}) {
-    assertString(value, sourceCodeInfo, options);
-    return value;
-}
-function isStringOrNumber(value) {
-    return typeof value === 'string' || typeof value === 'number';
-}
-function asStringOrNumber(value, sourceCodeInfo) {
-    assertStringOrNumber(value, sourceCodeInfo);
-    return value;
-}
-function assertStringOrNumber(value, sourceCodeInfo) {
-    if (!isStringOrNumber(value))
-        throw getAssertionError('string or number', value, sourceCodeInfo);
-}
-
 function collHasKey(coll, key) {
     if (!isColl(coll))
         return false;
@@ -1224,7 +1271,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 +1322,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 +1702,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 +1951,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 +2051,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"])',
@@ -4379,7 +4426,7 @@ const predicatesNormalExpression = {
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
             description: 'Returns `true` if $x is a regexp, otherwise `false`.',
-            seeAlso: ['regexp', 'match', 'string?', 'function?'],
+            seeAlso: ['regexp', 're-match', 'string?', 'function?'],
             examples: [
                 'regexp?(regexp("^start"))',
                 'regexp?(#"^start")',
@@ -4649,11 +4696,11 @@ const regexpNormalExpression = {
                 'regexp("albert", "ig")',
                 '#"albert"ig',
             ],
-            seeAlso: ['-short-regexp', 'match', 'replace', 'replace-all', 'regexp?'],
+            seeAlso: ['-short-regexp', 're-match', 'replace', 'replace-all', 'regexp?'],
             hideOperatorForm: true,
         },
     },
-    'match': {
+    're-match': {
         evaluate: ([text, regexp], sourceCodeInfo) => {
             assertRegularExpression(regexp, sourceCodeInfo);
             if (!isString(text))
@@ -4674,16 +4721,16 @@ const regexpNormalExpression = {
             },
             variants: [{ argumentNames: ['a', 'b'] }],
             description: `Matches $b against regular expression $a.
-If $b is a string and matches the regular expression, a \`match\`-array is returned, otherwise \`null\` is returned.`,
+If $b is a string and matches the regular expression, a \`re-match\`-array is returned, otherwise \`null\` is returned.`,
             seeAlso: ['regexp', 'replace', 'replace-all', '-short-regexp', 'regexp?'],
             examples: [
-                'match("  A string", regexp("^\\\\s*(.*)$"))',
-                'match("  A string", #"^\\s*(.*)$")',
-                'match("My name is Albert", #"albert"i)',
-                'match("My name is Ben", #"albert"i)',
-                'match(null, #"albert"i)',
-                'match(1, #"albert"i)',
-                'match({}, #"albert"i)',
+                're-match("  A string", regexp("^\\\\s*(.*)$"))',
+                're-match("  A string", #"^\\s*(.*)$")',
+                're-match("My name is Albert", #"albert"i)',
+                're-match("My name is Ben", #"albert"i)',
+                're-match(null, #"albert"i)',
+                're-match(1, #"albert"i)',
+                're-match({}, #"albert"i)',
             ],
         },
     },
@@ -4706,7 +4753,7 @@ If $b is a string and matches the regular expression, a \`match\`-array is retur
             },
             variants: [{ argumentNames: ['a', 'b', 'x'] }],
             description: 'Returns a new string with first match of regular expression $b replaced by $x.',
-            seeAlso: ['replace-all', 'regexp', 'match', '-short-regexp'],
+            seeAlso: ['replace-all', 'regexp', 're-match', '-short-regexp'],
             examples: [
                 'replace("Duck duck", "u", "i")',
                 'replace("Duck duck", #"u", "i")',
@@ -4736,7 +4783,7 @@ If $b is a string and matches the regular expression, a \`match\`-array is retur
             },
             variants: [{ argumentNames: ['a', 'b', 'x'] }],
             description: 'Returns a new string with all matches of regular expression $b replaced by $x.',
-            seeAlso: ['replace', 'regexp', 'match', '-short-regexp'],
+            seeAlso: ['replace', 'regexp', 're-match', '-short-regexp'],
             examples: [
                 'replace-all("Duck duck", "u", "i")',
                 'replace-all("Duck duck", regexp("u"), "i")',
@@ -5183,7 +5230,7 @@ let add = (x, y) -> do
     y: Second number.
   Returns:
     Sum of x and y.
-  """
+  """;
   x + y;
 end;
 
@@ -5246,7 +5293,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 +5315,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 +5337,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 +5358,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])',
@@ -5328,6 +5375,7 @@ function setNormalExpressionReference(reference) {
 }
 const expressions$1 = {
     // Core categories
+    ...assertionNormalExpression,
     ...bitwiseNormalExpression,
     ...collectionNormalExpression,
     ...arrayNormalExpression,
@@ -5455,55 +5503,378 @@ const condSpecialExpression = {
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].flat(), contextStack, builtin, evaluateNode),
 };
 
+function isJsFunction(fn) {
+    return typeof fn === 'object' && fn !== null && 'fn' in fn && typeof fn.fn === 'function';
+}
+const bindingTargetTypes = {
+    symbol: 11,
+    rest: 12,
+    object: 13,
+    array: 14,
+    literal: 15,
+    wildcard: 16,
+};
+
+function walkDefaults(bindingTarget, onDefault) {
+    if (bindingTarget[0] === bindingTargetTypes.object) {
+        Object.values(bindingTarget[1][0]).forEach((element) => {
+            if (element[1][1]) {
+                onDefault(element[1][1]);
+            }
+            walkDefaults(element, onDefault);
+        });
+    }
+    else if (bindingTarget[0] === bindingTargetTypes.array) {
+        for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
+            const element = bindingTarget[1][0][index] ?? null;
+            if (element === null) {
+                continue;
+            }
+            if (element[1][1]) {
+                onDefault(element[1][1]);
+            }
+            walkDefaults(element, onDefault);
+        }
+    }
+    // literal and wildcard have no defaults - nothing to walk
+}
+function evaluateBindingNodeValues(target, value, evaluate) {
+    const sourceCodeInfo = target[2];
+    const record = {};
+    return chain(createRecord(target, value, evaluate, sourceCodeInfo, record), () => record);
+}
+function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
+    if (bindingTarget[0] === bindingTargetTypes.object) {
+        assertUnknownRecord(value, sourceCodeInfo);
+        const capturedKeys = new Set();
+        let restElement;
+        const entries = Object.entries(bindingTarget[1][0]);
+        return chain(forEachSequential(entries, ([key, element]) => {
+            if (element[0] === bindingTargetTypes.rest) {
+                restElement = element;
+                return;
+            }
+            capturedKeys.add(key);
+            const existingVal = value[key];
+            const maybeVal = existingVal !== undefined
+                ? existingVal
+                : element[1][1]
+                    ? evaluate(element[1][1])
+                    : null;
+            return chain(maybeVal, (resolvedVal) => {
+                const val = resolvedVal ?? null;
+                assertAny(val, sourceCodeInfo);
+                return createRecord(element, val, evaluate, sourceCodeInfo, record);
+            });
+        }), () => {
+            if (restElement) {
+                const restValues = Object.entries(value)
+                    .filter(([key]) => !capturedKeys.has(key))
+                    .reduce((acc, [key, val]) => {
+                    acc[key] = asAny(val);
+                    return acc;
+                }, {});
+                record[restElement[1][0]] = restValues;
+            }
+        });
+    }
+    else if (bindingTarget[0] === bindingTargetTypes.array) {
+        let restIndex = null;
+        assertArray(value, sourceCodeInfo);
+        const elements = [];
+        for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
+            const element = bindingTarget[1][0][index] ?? null;
+            if (element === null) {
+                continue;
+            }
+            if (element[0] === bindingTargetTypes.rest) {
+                restIndex = index;
+                break;
+            }
+            elements.push({ element, index });
+        }
+        return chain(forEachSequential(elements, ({ element, index }) => {
+            const existingVal = value[index];
+            const maybeVal = existingVal !== undefined
+                ? existingVal
+                : element[1][1]
+                    ? evaluate(element[1][1])
+                    : null;
+            return chain(maybeVal, (resolvedVal) => {
+                const val = resolvedVal ?? null;
+                assertAny(val, sourceCodeInfo);
+                return createRecord(element, val, evaluate, sourceCodeInfo, record);
+            });
+        }), () => {
+            if (restIndex !== null) {
+                const restValues = value.slice(restIndex);
+                const restElement = bindingTarget[1][0][restIndex];
+                record[restElement[1][0]] = restValues;
+            }
+        });
+    }
+    else if (bindingTarget[0] === bindingTargetTypes.rest) {
+        record[bindingTarget[1][0]] = asAny(value);
+    }
+    else {
+        record[bindingTarget[1][0][1]] = asAny(value);
+    }
+}
+function getAllBindingTargetNames(bindingTarget) {
+    const names = {};
+    getNamesFromBindingTarget(bindingTarget, names);
+    return names;
+}
+function getNamesFromBindingTarget(target, names) {
+    if (target === null) {
+        return;
+    }
+    if (target[0] === bindingTargetTypes.array) {
+        for (const element of target[1][0]) {
+            getNamesFromBindingTarget(element, names);
+        }
+    }
+    else if (target[0] === bindingTargetTypes.object) {
+        for (const element of Object.values(target[1][0])) {
+            getNamesFromBindingTarget(element, names);
+        }
+    }
+    else if (target[0] === bindingTargetTypes.rest) {
+        if (names[target[1][0]]) {
+            throw new LitsError(`Duplicate binding name: ${target[1][0]}`, target[2]);
+        }
+        names[target[1][0]] = true;
+    }
+    else if (target[0] === bindingTargetTypes.symbol) {
+        if (names[target[1][0][1]]) {
+            throw new LitsError(`Duplicate binding name: ${target[1][0]}`, target[2]);
+        }
+        names[target[1][0][1]] = true;
+    }
+    // literal and wildcard bind no names - skip
+}
+/**
+ * Non-throwing pattern matching. Returns bindings on match, null on mismatch.
+ * Used by `switch` pattern matching.
+ */
+function tryMatch(target, value, evaluate) {
+    const record = {};
+    return chain(tryMatchRecord(target, value, evaluate, record), (matched) => {
+        if (!matched)
+            return null;
+        return record;
+    });
+}
+function tryMatchRecord(bindingTarget, value, evaluate, record) {
+    // Wildcard: always matches, binds nothing
+    if (bindingTarget[0] === bindingTargetTypes.wildcard) {
+        return true;
+    }
+    // Literal: compare with deepEqual
+    else if (bindingTarget[0] === bindingTargetTypes.literal) {
+        const literalNode = bindingTarget[1][0];
+        return chain(evaluate(literalNode), (literalValue) => {
+            return deepEqual(value, literalValue);
+        });
+    }
+    // Symbol: always matches, binds value
+    else if (bindingTarget[0] === bindingTargetTypes.symbol) {
+        const symbolNode = bindingTarget[1][0];
+        const defaultNode = bindingTarget[1][1];
+        if (value === undefined || value === null) {
+            if (defaultNode) {
+                return chain(evaluate(defaultNode), (defaultValue) => {
+                    record[symbolNode[1]] = asAny(defaultValue);
+                    return true;
+                });
+            }
+            record[symbolNode[1]] = value ?? null;
+        }
+        else {
+            record[symbolNode[1]] = asAny(value);
+        }
+        return true;
+    }
+    // Object pattern
+    else if (bindingTarget[0] === bindingTargetTypes.object) {
+        if (!isUnknownRecord(value))
+            return false;
+        const capturedKeys = new Set();
+        let restElement;
+        const entries = Object.entries(bindingTarget[1][0]);
+        let result = true;
+        for (const [key, element] of entries) {
+            result = chain(result, (matched) => {
+                if (!matched)
+                    return false;
+                if (element[0] === bindingTargetTypes.rest) {
+                    restElement = element;
+                    return true;
+                }
+                capturedKeys.add(key);
+                const existingVal = value[key];
+                // For literal sub-patterns, missing key means no match
+                if (existingVal === undefined && element[0] === bindingTargetTypes.literal) {
+                    return chain(evaluate(element[1][0]), (literalValue) => {
+                        return deepEqual(undefined, literalValue);
+                    });
+                }
+                const maybeVal = existingVal !== undefined
+                    ? existingVal
+                    : element[1] && element[1][1]
+                        ? evaluate(element[1][1])
+                        : null;
+                return chain(maybeVal, (resolvedVal) => {
+                    const val = resolvedVal ?? null;
+                    return tryMatchRecord(element, val, evaluate, record);
+                });
+            });
+        }
+        return chain(result, (matched) => {
+            if (!matched)
+                return false;
+            if (restElement) {
+                const restValues = Object.entries(value)
+                    .filter(([key]) => !capturedKeys.has(key))
+                    .reduce((acc, [key, val]) => {
+                    acc[key] = asAny(val);
+                    return acc;
+                }, {});
+                record[restElement[1][0]] = restValues;
+            }
+            return true;
+        });
+    }
+    // Array pattern
+    else {
+        const arrayTarget = bindingTarget;
+        if (!Array.isArray(value))
+            return false;
+        const elements = arrayTarget[1][0];
+        let restIndex = null;
+        // Find rest element index and check length constraints
+        for (let i = 0; i < elements.length; i += 1) {
+            const element = elements[i];
+            if (element !== null && element[0] === bindingTargetTypes.rest) {
+                restIndex = i;
+                break;
+            }
+        }
+        // Without rest: array length must match exactly
+        if (restIndex === null && value.length !== elements.length) {
+            return false;
+        }
+        // With rest: array must have at least the non-rest elements
+        if (restIndex !== null && value.length < restIndex) {
+            return false;
+        }
+        let result = true;
+        for (let i = 0; i < elements.length; i += 1) {
+            const element = elements[i];
+            if (element === null)
+                continue; // skipped position
+            if (element[0] === bindingTargetTypes.rest) {
+                // Rest collects remaining elements
+                record[element[1][0]] = value.slice(i);
+                break;
+            }
+            const el = element;
+            result = chain(result, (matched) => {
+                if (!matched)
+                    return false;
+                return tryMatchRecord(el, asAny(value[i]), evaluate, record);
+            });
+        }
+        return result;
+    }
+}
+
 const docs$e = {
     category: 'special-expression',
-    customVariants: ['switch value switch-branch switch-branch ... end'],
+    customVariants: ['match value match-branch match-branch ... end'],
     details: [
-        ['value', 'any', 'The value to test.'],
-        ['switch-branch', 'case test then body', 'A branch of the switch expression.'],
-        ['test', 'expression', 'The condition to test.'],
-        ['body', 'expressions', 'The expressions to evaluate if the test is truthy.'],
+        ['value', 'any', 'The value to match against patterns.'],
+        ['match-branch', 'case pattern [when guard] then body', 'A branch of the match expression.'],
+        ['pattern', 'pattern', 'A pattern to match: literal, variable, array destructuring, object destructuring, or wildcard (_).'],
+        ['guard', 'expression', 'An optional guard expression that must be truthy for the match to succeed.'],
+        ['body', 'expressions', 'The expressions to evaluate if the pattern matches.'],
     ],
-    description: 'Used for branching. `switch-branches` are tested sequentially from the top against `value`. If no branch is tested truthy, `null` is returned.',
+    description: 'Pattern matching expression. Matches `value` against each `pattern` sequentially. If a pattern matches (and the optional `when` guard is truthy), the corresponding `body` is evaluated and its result returned. Bound variables from the pattern are available in the guard and body. If no pattern matches, `null` is returned.',
     examples: [
         `
-switch 1
-  case 1 then write!("One")
-  case 2 then write!("Two")
+match 1
+  case 1 then "One"
+  case 2 then "Two"
 end`,
         `
-switch 2
-  case 1 then write!("One")
-  case 2 then write!("Two")
+match [1, 2, 3]
+  case [x] then "one element"
+  case [x, y] then "two elements"
+  case [x, ...xs] then "first: " ++ str(x) ++ " rest: " ++ str(xs)
 end`,
         `
-switch 3
-  case 1 then write!("One")
-  case 2 then write!("Two")
+match { type: "click", x: 10, y: 20 }
+  case { type: "click", x, y } then "Click at " ++ str(x) ++ ", " ++ str(y)
+  case { type: "keydown", key } then "Key: " ++ key
+  case _ then "unknown event"
+end`,
+        `
+match { role: "admin", name: "Alice" }
+  case { role: "admin", name } then "Admin: " ++ name
+  case { role, name } when role == "user" then "User: " ++ name
+  case _ then "Unknown role"
 end`,
     ],
 };
-const switchSpecialExpression = {
+const matchSpecialExpression = {
     arity: {},
     docs: docs$e,
     evaluate: (node, contextStack, { evaluateNode }) => {
-        const [, switchValueNode, cases] = node[1];
-        return chain(evaluateNode(switchValueNode, contextStack), (switchValue) => {
+        const [, matchValueNode, cases] = node[1];
+        return chain(evaluateNode(matchValueNode, contextStack), (matchValue) => {
             function processCase(index) {
                 if (index >= cases.length)
                     return null;
-                const [test, form] = cases[index];
-                return chain(evaluateNode(test, contextStack), (value) => {
-                    if (value === switchValue) {
-                        return evaluateNode(form, contextStack);
+                const [pattern, body, guard] = cases[index];
+                return chain(tryMatch(pattern, matchValue, n => evaluateNode(n, contextStack)), (bindings) => {
+                    if (bindings === null)
+                        return processCase(index + 1);
+                    // Pattern matched - create context with bound variables
+                    const context = {};
+                    for (const [name, value] of Object.entries(bindings)) {
+                        context[name] = { value };
                     }
-                    return processCase(index + 1);
+                    const newContextStack = contextStack.create(context);
+                    // Check guard if present
+                    if (guard) {
+                        return chain(evaluateNode(guard, newContextStack), (guardResult) => {
+                            if (!guardResult)
+                                return processCase(index + 1);
+                            return evaluateNode(body, newContextStack);
+                        });
+                    }
+                    return evaluateNode(body, newContextStack);
                 });
             }
             return processCase(0);
         });
     },
-    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1], ...node[1][2].flat()], contextStack, builtin, evaluateNode),
+    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+        const result = new Set();
+        // The match value expression
+        getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode).forEach(s => result.add(s));
+        // Each case
+        for (const [pattern, body, guard] of node[1][2]) {
+            const newContext = {};
+            Object.assign(newContext, getAllBindingTargetNames(pattern));
+            const caseContextStack = contextStack.create(newContext);
+            if (guard) {
+                getUndefinedSymbols([guard], caseContextStack, builtin, evaluateNode).forEach(s => result.add(s));
+            }
+            getUndefinedSymbols([body], caseContextStack, builtin, evaluateNode).forEach(s => result.add(s));
+        }
+        return result;
+    },
 };
 
 const docs$d = {
@@ -5570,153 +5941,6 @@ const doSpecialExpression = {
     },
 };
 
-function isJsFunction(fn) {
-    return typeof fn === 'object' && fn !== null && 'fn' in fn && typeof fn.fn === 'function';
-}
-const bindingTargetTypes = {
-    symbol: 11,
-    rest: 12,
-    object: 13,
-    array: 14,
-};
-
-function walkDefaults(bindingTarget, onDefault) {
-    if (bindingTarget[0] === bindingTargetTypes.object) {
-        Object.values(bindingTarget[1][0]).forEach((element) => {
-            if (element[1][1]) {
-                onDefault(element[1][1]);
-            }
-            walkDefaults(element, onDefault);
-        });
-    }
-    else if (bindingTarget[0] === bindingTargetTypes.array) {
-        for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
-            const element = bindingTarget[1][0][index] ?? null;
-            if (element === null) {
-                continue;
-            }
-            if (element[1][1]) {
-                onDefault(element[1][1]);
-            }
-            walkDefaults(element, onDefault);
-        }
-    }
-}
-function evaluateBindingNodeValues(target, value, evaluate) {
-    const sourceCodeInfo = target[2];
-    const record = {};
-    return chain(createRecord(target, value, evaluate, sourceCodeInfo, record), () => record);
-}
-function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
-    if (bindingTarget[0] === bindingTargetTypes.object) {
-        assertUnknownRecord(value, sourceCodeInfo);
-        const capturedKeys = new Set();
-        let restElement;
-        const entries = Object.entries(bindingTarget[1][0]);
-        return chain(forEachSequential(entries, ([key, element]) => {
-            if (element[0] === bindingTargetTypes.rest) {
-                restElement = element;
-                return;
-            }
-            capturedKeys.add(key);
-            const existingVal = value[key];
-            const maybeVal = existingVal !== undefined
-                ? existingVal
-                : element[1][1]
-                    ? evaluate(element[1][1])
-                    : null;
-            return chain(maybeVal, (resolvedVal) => {
-                const val = resolvedVal ?? null;
-                assertAny(val, sourceCodeInfo);
-                return createRecord(element, val, evaluate, sourceCodeInfo, record);
-            });
-        }), () => {
-            if (restElement) {
-                const restValues = Object.entries(value)
-                    .filter(([key]) => !capturedKeys.has(key))
-                    .reduce((acc, [key, val]) => {
-                    acc[key] = asAny(val);
-                    return acc;
-                }, {});
-                record[restElement[1][0]] = restValues;
-            }
-        });
-    }
-    else if (bindingTarget[0] === bindingTargetTypes.array) {
-        let restIndex = null;
-        assertArray(value, sourceCodeInfo);
-        const elements = [];
-        for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
-            const element = bindingTarget[1][0][index] ?? null;
-            if (element === null) {
-                continue;
-            }
-            if (element[0] === bindingTargetTypes.rest) {
-                restIndex = index;
-                break;
-            }
-            elements.push({ element, index });
-        }
-        return chain(forEachSequential(elements, ({ element, index }) => {
-            const existingVal = value[index];
-            const maybeVal = existingVal !== undefined
-                ? existingVal
-                : element[1][1]
-                    ? evaluate(element[1][1])
-                    : null;
-            return chain(maybeVal, (resolvedVal) => {
-                const val = resolvedVal ?? null;
-                assertAny(val, sourceCodeInfo);
-                return createRecord(element, val, evaluate, sourceCodeInfo, record);
-            });
-        }), () => {
-            if (restIndex !== null) {
-                const restValues = value.slice(restIndex);
-                const restElement = bindingTarget[1][0][restIndex];
-                record[restElement[1][0]] = restValues;
-            }
-        });
-    }
-    else if (bindingTarget[0] === bindingTargetTypes.rest) {
-        record[bindingTarget[1][0]] = asAny(value);
-    }
-    else {
-        record[bindingTarget[1][0][1]] = asAny(value);
-    }
-}
-function getAllBindingTargetNames(bindingTarget) {
-    const names = {};
-    getNamesFromBindingTarget(bindingTarget, names);
-    return names;
-}
-function getNamesFromBindingTarget(target, names) {
-    if (target === null) {
-        return;
-    }
-    if (target[0] === bindingTargetTypes.array) {
-        for (const element of target[1][0]) {
-            getNamesFromBindingTarget(element, names);
-        }
-    }
-    else if (target[0] === bindingTargetTypes.object) {
-        for (const element of Object.values(target[1][0])) {
-            getNamesFromBindingTarget(element, names);
-        }
-    }
-    else if (target[0] === bindingTargetTypes.rest) {
-        if (names[target[1][0]]) {
-            throw new LitsError(`Duplicate binding name: ${target[1][0]}`, target[2]);
-        }
-        names[target[1][0]] = true;
-    }
-    else {
-        if (names[target[1][0][1]]) {
-            throw new LitsError(`Duplicate binding name: ${target[1][0]}`, target[2]);
-        }
-        names[target[1][0][1]] = true;
-    }
-}
-
 const lambdaSpecialExpression = {
     arity: {},
     evaluate: (node, contextStack, { builtin, getUndefinedSymbols, evaluateNode }) => {
@@ -6639,8 +6863,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)',
     ],
 };
@@ -6693,7 +6917,7 @@ const specialExpressions = [
     loopSpecialExpression,
     objectSpecialExpression,
     recurSpecialExpression,
-    switchSpecialExpression,
+    matchSpecialExpression,
     throwSpecialExpression,
     trySpecialExpression,
     unlessSpecialExpression,
@@ -7924,6 +8148,12 @@ function assertOperatorToken(token, operatorName) {
 function isWhitespaceToken(token) {
     return token?.[0] === 'Whitespace';
 }
+function isNumberToken(token) {
+    return token?.[0] === 'Number';
+}
+function isBasePrefixedNumberToken(token) {
+    return token?.[0] === 'BasePrefixedNumber';
+}
 function isLParenToken(token) {
     return token?.[0] === 'LParen';
 }
@@ -8448,6 +8678,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')) {
@@ -8487,8 +8721,48 @@ function parseSymbol(ctx) {
     }
 }
 
-function parseBindingTarget(ctx, { requireDefaultValue, noRest } = {}) {
+function parseNumber(ctx) {
+    const token = ctx.peek();
+    ctx.advance();
+    const value = token[1];
+    const negative = value[0] === '-';
+    const numberString = (negative ? value.substring(1) : value).replace(/_/g, '');
+    return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
+}
+
+function parseBindingTarget(ctx, { requireDefaultValue, noRest, allowLiteralPatterns } = {}) {
     const firstToken = ctx.tryPeek();
+    // Wildcard _ (only in pattern matching context)
+    if (allowLiteralPatterns && isReservedSymbolToken(firstToken, '_')) {
+        ctx.advance();
+        return withSourceCodeInfo([bindingTargetTypes.wildcard, []], firstToken[2]);
+    }
+    // Literal patterns: number, string, true, false, null (only in pattern matching context)
+    if (allowLiteralPatterns && isLiteralToken(firstToken)) {
+        if (isNumberToken(firstToken) || isBasePrefixedNumberToken(firstToken)) {
+            const node = parseNumber(ctx);
+            return withSourceCodeInfo([bindingTargetTypes.literal, [node]], firstToken[2]);
+        }
+        if (isStringToken(firstToken)) {
+            const node = parseString(ctx, firstToken);
+            return withSourceCodeInfo([bindingTargetTypes.literal, [node]], firstToken[2]);
+        }
+        if (isReservedSymbolToken(firstToken, 'true')) {
+            ctx.advance();
+            const node = withSourceCodeInfo([NodeTypes.ReservedSymbol, 'true'], firstToken[2]);
+            return withSourceCodeInfo([bindingTargetTypes.literal, [node]], firstToken[2]);
+        }
+        if (isReservedSymbolToken(firstToken, 'false')) {
+            ctx.advance();
+            const node = withSourceCodeInfo([NodeTypes.ReservedSymbol, 'false'], firstToken[2]);
+            return withSourceCodeInfo([bindingTargetTypes.literal, [node]], firstToken[2]);
+        }
+        if (isReservedSymbolToken(firstToken, 'null')) {
+            ctx.advance();
+            const node = withSourceCodeInfo([NodeTypes.ReservedSymbol, 'null'], firstToken[2]);
+            return withSourceCodeInfo([bindingTargetTypes.literal, [node]], firstToken[2]);
+        }
+    }
     // Symbol
     if (isSymbolToken(firstToken)) {
         const symbol = parseSymbol(ctx);
@@ -8529,7 +8803,7 @@ function parseBindingTarget(ctx, { requireDefaultValue, noRest } = {}) {
                 token = ctx.peek();
                 continue;
             }
-            const target = parseBindingTarget(ctx);
+            const target = parseBindingTarget(ctx, { allowLiteralPatterns });
             if (target[0] === bindingTargetTypes.rest) {
                 rest = true;
             }
@@ -8593,10 +8867,18 @@ function parseBindingTarget(ctx, { requireDefaultValue, noRest } = {}) {
             else if (isOperatorToken(token, ':')) {
                 ctx.advance();
                 token = ctx.peek();
-                if (!isLBraceToken(token) && !isLBracketToken(token)) {
-                    throw new LitsError('Expected object or array', token[2]);
+                if (allowLiteralPatterns) {
+                    // In pattern matching context, allow literals, nested objects/arrays, and variable bindings after ':'
+                    if (!isLBraceToken(token) && !isLBracketToken(token) && !isLiteralToken(token)) {
+                        throw new LitsError('Expected literal, object or array pattern', token[2]);
+                    }
                 }
-                elements[keyName] = parseBindingTarget(ctx);
+                else {
+                    if (!isLBraceToken(token) && !isLBracketToken(token)) {
+                        throw new LitsError('Expected object or array', token[2]);
+                    }
+                }
+                elements[keyName] = parseBindingTarget(ctx, { allowLiteralPatterns });
             }
             if (!isRBraceToken(ctx.peek())) {
                 assertOperatorToken(ctx.peek(), ',');
@@ -8621,6 +8903,14 @@ function parseOptionalDefaulValue(ctx) {
     }
     return undefined;
 }
+function isLiteralToken(token) {
+    return isNumberToken(token)
+        || isBasePrefixedNumberToken(token)
+        || isStringToken(token)
+        || isReservedSymbolToken(token, 'true')
+        || isReservedSymbolToken(token, 'false')
+        || isReservedSymbolToken(token, 'null');
+}
 
 function parseLet(ctx, token) {
     ctx.advance();
@@ -9046,15 +9336,6 @@ function parseFunctionCall(ctx, symbol) {
     }
 }
 
-function parseNumber(ctx) {
-    const token = ctx.peek();
-    ctx.advance();
-    const value = token[1];
-    const negative = value[0] === '-';
-    const numberString = (negative ? value.substring(1) : value).replace(/_/g, '');
-    return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
-}
-
 function parseObject(ctx) {
     const firstToken = asLBraceToken(ctx.tryPeek());
     ctx.advance();
@@ -9205,25 +9486,32 @@ function createAccessorNode(left, right, sourceCodeInfo) {
     return withSourceCodeInfo([NodeTypes.NormalExpression, [[NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.get], [left, right]]], sourceCodeInfo);
 }
 
-function parseSwitch(ctx, token) {
+function parseMatch(ctx, token) {
     ctx.advance();
     const valueExpression = ctx.parseExpression();
     const params = [];
     while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
         assertReservedSymbolToken(ctx.tryPeek(), 'case');
         ctx.advance();
-        const caseExpression = ctx.parseExpression();
+        // Parse pattern instead of expression
+        const pattern = parseBindingTarget(ctx, { allowLiteralPatterns: true });
+        // Check for optional guard: `when <expression>`
+        let guard;
+        if (isReservedSymbolToken(ctx.tryPeek(), 'when')) {
+            ctx.advance();
+            guard = ctx.parseExpression();
+        }
         assertReservedSymbolToken(ctx.tryPeek(), 'then');
         ctx.advance();
         const thenExpression = parseImplicitBlock(ctx, ['case', 'end']);
-        params.push([caseExpression, thenExpression]);
+        params.push([pattern, thenExpression, guard]);
         if (isReservedSymbolToken(ctx.tryPeek(), 'end')) {
             break;
         }
     }
     assertReservedSymbolToken(ctx.tryPeek(), 'end');
     ctx.advance();
-    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.match, valueExpression, params]], token[2]);
 }
 
 function parseTry(ctx, token) {
@@ -9261,8 +9549,8 @@ function parseExpression(ctx, precedence = 0) {
             case 'cond':
                 left = parseCond(ctx, token);
                 break;
-            case 'switch':
-                left = parseSwitch(ctx, token);
+            case 'match':
+                left = parseMatch(ctx, token);
                 break;
             case 'for':
             case 'doseq':
@@ -9551,41 +9839,8 @@ class Lits {
 }
 
 const moduleDocs$6 = {
-    'assert': {
-        category: 'assert',
-        description: 'If $value is falsy it throws `AssertionError` with $message. If no $message is provided, message is set to $value.',
-        returns: {
-            type: 'any',
-        },
-        args: {
-            value: {
-                type: 'any',
-            },
-            message: {
-                type: 'string',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'value',
-                ],
-            },
-            {
-                argumentNames: [
-                    'value',
-                    'message',
-                ],
-            },
-        ],
-        examples: [
-            'let { assert } = import(assert);\ntry assert(0, "Expected a positive value") catch (e) e.message end',
-        ],
-        seeAlso: ['assert.assert-truthy', 'assert.assert-true'],
-        hideOperatorForm: true,
-    },
     'assert!=': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is the same as $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9617,16 +9872,16 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert!= } = import(assert);\ntry assert!=(0, 0, "Expected different values") catch (e) e.message end',
-            'let { assert!= } = import(assert);\ntry assert!=(0, 0) catch (e) e.message end',
-            'let { assert!= } = import(assert);\ntry 0 assert!= 0 catch (e) e.message end',
-            'let { assert!= } = import(assert);\ntry assert!=(0, 1) catch (e) e.message end',
+            'let { assert!= } = import(assertion);\ntry assert!=(0, 0, "Expected different values") catch (e) e.message end',
+            'let { assert!= } = import(assertion);\ntry assert!=(0, 0) catch (e) e.message end',
+            'let { assert!= } = import(assertion);\ntry 0 assert!= 0 catch (e) e.message end',
+            'let { assert!= } = import(assertion);\ntry assert!=(0, 1) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert='],
+        seeAlso: ['assertion.assert='],
         hideOperatorForm: true,
     },
     'assert=': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is not structural equal to $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9658,15 +9913,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert= } = import(assert);\ntry assert=({ "a": 1 }, { "a": 2 }, "Expected equal values") catch (e) e.message end',
-            'let { assert= } = import(assert);\ntry assert=({ "a": 1 }, { "a": 2 }) catch (e) e.message end',
-            'let { assert= } = import(assert);\ntry assert=({ "a": 1 }, { "a": 1 }) catch (e) e.message end',
+            'let { assert= } = import(assertion);\ntry assert=({ "a": 1 }, { "a": 2 }, "Expected equal values") catch (e) e.message end',
+            'let { assert= } = import(assertion);\ntry assert=({ "a": 1 }, { "a": 2 }) catch (e) e.message end',
+            'let { assert= } = import(assertion);\ntry assert=({ "a": 1 }, { "a": 1 }) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert!='],
+        seeAlso: ['assertion.assert!='],
         hideOperatorForm: true,
     },
     'assert-gt': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is not greater than $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9698,15 +9953,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-gt } = import(assert);\ntry assert-gt(0, 1, "Expected greater value") catch (e) e.message end',
-            'let { assert-gt } = import(assert);\ntry assert-gt(0, 0) catch (e) e.message end',
-            'let { assert-gt } = import(assert);\ntry assert-gt(1, 0) catch (e) e.message end',
+            'let { assert-gt } = import(assertion);\ntry assert-gt(0, 1, "Expected greater value") catch (e) e.message end',
+            'let { assert-gt } = import(assertion);\ntry assert-gt(0, 0) catch (e) e.message end',
+            'let { assert-gt } = import(assertion);\ntry assert-gt(1, 0) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-lt', 'assert.assert-gte', 'assert.assert-lte'],
+        seeAlso: ['assertion.assert-lt', 'assertion.assert-gte', 'assertion.assert-lte'],
         hideOperatorForm: true,
     },
     'assert-lt': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is not less than $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9738,15 +9993,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-lt } = import(assert);\ntry assert-lt(1, 0, "Expected smaller value value") catch (e) e.message end',
-            'let { assert-lt } = import(assert);\ntry assert-lt(1, 1) catch (e) e.message end',
-            'let { assert-lt } = import(assert);\ntry assert-lt(0, 1) catch (e) e.message end',
+            'let { assert-lt } = import(assertion);\ntry assert-lt(1, 0, "Expected smaller value value") catch (e) e.message end',
+            'let { assert-lt } = import(assertion);\ntry assert-lt(1, 1) catch (e) e.message end',
+            'let { assert-lt } = import(assertion);\ntry assert-lt(0, 1) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-gt', 'assert.assert-lte', 'assert.assert-gte'],
+        seeAlso: ['assertion.assert-gt', 'assertion.assert-lte', 'assertion.assert-gte'],
         hideOperatorForm: true,
     },
     'assert-gte': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is less than $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9778,15 +10033,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-gte } = import(assert);\ntry assert-gte(0, 1, "Expected greater value") catch (e) e.message end',
-            'let { assert-gte } = import(assert);\ntry assert-gte(0, 1) catch (e) e.message end',
-            'let { assert-gte } = import(assert);\ntry assert-gte(1, 1) catch (e) e.message end',
+            'let { assert-gte } = import(assertion);\ntry assert-gte(0, 1, "Expected greater value") catch (e) e.message end',
+            'let { assert-gte } = import(assertion);\ntry assert-gte(0, 1) catch (e) e.message end',
+            'let { assert-gte } = import(assertion);\ntry assert-gte(1, 1) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-lte', 'assert.assert-gt', 'assert.assert-lt'],
+        seeAlso: ['assertion.assert-lte', 'assertion.assert-gt', 'assertion.assert-lt'],
         hideOperatorForm: true,
     },
     'assert-lte': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $a is grater than $b it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9818,15 +10073,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-lte } = import(assert);\ntry assert-lte(1, 0, "Expected smaller value value") catch (e) e.message end',
-            'let { assert-lte } = import(assert);\ntry assert-lte(1, 0) catch (e) e.message end',
-            'let { assert-lte } = import(assert);\ntry assert-lte(1, 1) catch (e) e.message end',
+            'let { assert-lte } = import(assertion);\ntry assert-lte(1, 0, "Expected smaller value value") catch (e) e.message end',
+            'let { assert-lte } = import(assertion);\ntry assert-lte(1, 0) catch (e) e.message end',
+            'let { assert-lte } = import(assertion);\ntry assert-lte(1, 1) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-gte', 'assert.assert-lt', 'assert.assert-gt'],
+        seeAlso: ['assertion.assert-gte', 'assertion.assert-lt', 'assertion.assert-gt'],
         hideOperatorForm: true,
     },
     'assert-true': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not `true` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9853,15 +10108,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-true } = import(assert);\ntry assert-true(false, "Expected true") catch (e) e.message end',
-            'let { assert-true } = import(assert);\ntry assert-true(false) catch (e) e.message end',
-            'let { assert-true } = import(assert);\ntry assert-true(true) catch (e) e.message end',
+            'let { assert-true } = import(assertion);\ntry assert-true(false, "Expected true") catch (e) e.message end',
+            'let { assert-true } = import(assertion);\ntry assert-true(false) catch (e) e.message end',
+            'let { assert-true } = import(assertion);\ntry assert-true(true) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-false', 'assert.assert-truthy', 'assert.assert-falsy', 'assert.assert', 'assert.assert-boolean'],
+        seeAlso: ['assertion.assert-false', 'assertion.assert-truthy', 'assertion.assert-falsy', 'assert', 'assertion.assert-boolean'],
         hideOperatorForm: true,
     },
     'assert-false': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not `false` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9888,15 +10143,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-false } = import(assert);\ntry assert-false(true, "Expected false") catch (e) e.message end',
-            'let { assert-false } = import(assert);\ntry assert-false(true) catch (e) e.message end',
-            'let { assert-false } = import(assert);\ntry assert-false(false) catch (e) e.message end',
+            'let { assert-false } = import(assertion);\ntry assert-false(true, "Expected false") catch (e) e.message end',
+            'let { assert-false } = import(assertion);\ntry assert-false(true) catch (e) e.message end',
+            'let { assert-false } = import(assertion);\ntry assert-false(false) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-true', 'assert.assert-falsy', 'assert.assert-truthy', 'assert.assert-boolean'],
+        seeAlso: ['assertion.assert-true', 'assertion.assert-falsy', 'assertion.assert-truthy', 'assertion.assert-boolean'],
         hideOperatorForm: true,
     },
     'assert-truthy': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not `truthy` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9923,22 +10178,22 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(false, "Expected truthy") catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(false) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(0) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(null) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy("") catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(true) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(1) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy("x") catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy([]) catch (e) e.message end',
-            'let { assert-truthy } = import(assert);\ntry assert-truthy(nd) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(false, "Expected truthy") catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(false) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(0) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(null) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy("") catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(true) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(1) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy("x") catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy([]) catch (e) e.message end',
+            'let { assert-truthy } = import(assertion);\ntry assert-truthy(nd) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-falsy', 'assert.assert-true', 'assert.assert-false', 'assert.assert', 'assert.assert-null'],
+        seeAlso: ['assertion.assert-falsy', 'assertion.assert-true', 'assertion.assert-false', 'assert', 'assertion.assert-null'],
         hideOperatorForm: true,
     },
     'assert-falsy': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not `falsy` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -9965,21 +10220,21 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(true, "Expected falsy") catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy("x") catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy([]) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(nd) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(1) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(false) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(0) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy(null) catch (e) e.message end',
-            'let { assert-falsy } = import(assert);\ntry assert-falsy("") catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(true, "Expected falsy") catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy("x") catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy([]) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(nd) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(1) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(false) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(0) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy(null) catch (e) e.message end',
+            'let { assert-falsy } = import(assertion);\ntry assert-falsy("") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-truthy', 'assert.assert-false', 'assert.assert-true', 'assert.assert-null'],
+        seeAlso: ['assertion.assert-truthy', 'assertion.assert-false', 'assertion.assert-true', 'assertion.assert-null'],
         hideOperatorForm: true,
     },
     'assert-null': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not `null` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10006,21 +10261,21 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-null } = import(assert);\ntry assert-null(null) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null(true, "Expected null") catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null("x") catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null([]) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null(nd) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null(1) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null(false) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null(0) catch (e) e.message end',
-            'let { assert-null } = import(assert);\ntry assert-null("") catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(null) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(true, "Expected null") catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null("x") catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null([]) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(nd) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(1) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(false) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null(0) catch (e) e.message end',
+            'let { assert-null } = import(assertion);\ntry assert-null("") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-truthy', 'assert.assert-falsy'],
+        seeAlso: ['assertion.assert-truthy', 'assertion.assert-falsy'],
         hideOperatorForm: true,
     },
     'assert-throws': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $fun does not throw, it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10047,14 +10302,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-throws } = import(assert);\nassert-throws(-> throw("Error"))',
-            'let { assert-throws } = import(assert);\ntry assert-throws(-> identity("Error")) catch (e) e.message end',
+            'let { assert-throws } = import(assertion);\nassert-throws(-> throw("Error"))',
+            'let { assert-throws } = import(assertion);\ntry assert-throws(-> identity("Error")) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-throws-error', 'assert.assert-not-throws'],
+        seeAlso: ['assertion.assert-throws-error', 'assertion.assert-not-throws'],
         hideOperatorForm: true,
     },
     'assert-throws-error': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $fun does not throw $error-message, it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10086,14 +10341,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-throws-error } = import(assert);\ntry assert-throws-error(-> throw("Error"), "Error") catch (e) e.message end',
-            'let { assert-throws-error } = import(assert);\ntry assert-throws-error(-> identity("Error"), "Error") catch (e) e.message end',
+            'let { assert-throws-error } = import(assertion);\ntry assert-throws-error(-> throw("Error"), "Error") catch (e) e.message end',
+            'let { assert-throws-error } = import(assertion);\ntry assert-throws-error(-> identity("Error"), "Error") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-throws', 'assert.assert-not-throws'],
+        seeAlso: ['assertion.assert-throws', 'assertion.assert-not-throws'],
         hideOperatorForm: true,
     },
     'assert-not-throws': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $fun throws, it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10120,14 +10375,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-not-throws } = import(assert);\ntry assert-not-throws(-> identity("Error")) catch (e) e.message end',
-            'let { assert-not-throws } = import(assert);\ntry assert-not-throws(-> throw("Error")) catch (e) e.message end',
+            'let { assert-not-throws } = import(assertion);\ntry assert-not-throws(-> identity("Error")) catch (e) e.message end',
+            'let { assert-not-throws } = import(assertion);\ntry assert-not-throws(-> throw("Error")) catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-throws', 'assert.assert-throws-error'],
+        seeAlso: ['assertion.assert-throws', 'assertion.assert-throws-error'],
         hideOperatorForm: true,
     },
     'assert-array': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not an `array` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10154,15 +10409,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-array } = import(assert);\ntry assert-array([1, 2, 3]) catch (e) e.message end',
-            'let { assert-array } = import(assert);\ntry assert-array("string") catch (e) e.message end',
-            'let { assert-array } = import(assert);\ntry assert-array(42, "Expected an array") catch (e) e.message end',
+            'let { assert-array } = import(assertion);\ntry assert-array([1, 2, 3]) catch (e) e.message end',
+            'let { assert-array } = import(assertion);\ntry assert-array("string") catch (e) e.message end',
+            'let { assert-array } = import(assertion);\ntry assert-array(42, "Expected an array") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-object', 'assert.assert-collection', 'assert.assert-sequence'],
+        seeAlso: ['assertion.assert-object', 'assertion.assert-collection', 'assertion.assert-sequence'],
         hideOperatorForm: true,
     },
     'assert-boolean': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `boolean` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10189,15 +10444,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-boolean } = import(assert);\ntry assert-boolean(true) catch (e) e.message end',
-            'let { assert-boolean } = import(assert);\ntry assert-boolean(false) catch (e) e.message end',
-            'let { assert-boolean } = import(assert);\ntry assert-boolean(1, "Expected a boolean") catch (e) e.message end',
+            'let { assert-boolean } = import(assertion);\ntry assert-boolean(true) catch (e) e.message end',
+            'let { assert-boolean } = import(assertion);\ntry assert-boolean(false) catch (e) e.message end',
+            'let { assert-boolean } = import(assertion);\ntry assert-boolean(1, "Expected a boolean") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-true', 'assert.assert-false', 'assert.assert-number', 'assert.assert-string'],
+        seeAlso: ['assertion.assert-true', 'assertion.assert-false', 'assertion.assert-number', 'assertion.assert-string'],
         hideOperatorForm: true,
     },
     'assert-collection': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `collection` (array, object, or string) it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10224,16 +10479,16 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-collection } = import(assert);\ntry assert-collection([1, 2]) catch (e) e.message end',
-            'let { assert-collection } = import(assert);\ntry assert-collection({ a: 1 }) catch (e) e.message end',
-            'let { assert-collection } = import(assert);\ntry assert-collection("hello") catch (e) e.message end',
-            'let { assert-collection } = import(assert);\ntry assert-collection(42, "Expected a collection") catch (e) e.message end',
+            'let { assert-collection } = import(assertion);\ntry assert-collection([1, 2]) catch (e) e.message end',
+            'let { assert-collection } = import(assertion);\ntry assert-collection({ a: 1 }) catch (e) e.message end',
+            'let { assert-collection } = import(assertion);\ntry assert-collection("hello") catch (e) e.message end',
+            'let { assert-collection } = import(assertion);\ntry assert-collection(42, "Expected a collection") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-sequence', 'assert.assert-array', 'assert.assert-object'],
+        seeAlso: ['assertion.assert-sequence', 'assertion.assert-array', 'assertion.assert-object'],
         hideOperatorForm: true,
     },
     'assert-function': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `function` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10260,14 +10515,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-function } = import(assert);\ntry assert-function(-> $ + 1) catch (e) e.message end',
-            'let { assert-function } = import(assert);\ntry assert-function(42, "Expected a function") catch (e) e.message end',
+            'let { assert-function } = import(assertion);\ntry assert-function(-> $ + 1) catch (e) e.message end',
+            'let { assert-function } = import(assertion);\ntry assert-function(42, "Expected a function") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-number', 'assert.assert-string'],
+        seeAlso: ['assertion.assert-number', 'assertion.assert-string'],
         hideOperatorForm: true,
     },
     'assert-grid': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `grid` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10294,14 +10549,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-grid } = import(assert);\ntry assert-grid([[1, 2], [3, 4]]) catch (e) e.message end',
-            'let { assert-grid } = import(assert);\ntry assert-grid([1, 2], "Expected a grid") catch (e) e.message end',
+            'let { assert-grid } = import(assertion);\ntry assert-grid([[1, 2], [3, 4]]) catch (e) e.message end',
+            'let { assert-grid } = import(assertion);\ntry assert-grid([1, 2], "Expected a grid") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-matrix', 'assert.assert-vector'],
+        seeAlso: ['assertion.assert-matrix', 'assertion.assert-vector'],
         hideOperatorForm: true,
     },
     'assert-integer': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not an `integer` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10328,14 +10583,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-integer } = import(assert);\ntry assert-integer(42) catch (e) e.message end',
-            'let { assert-integer } = import(assert);\ntry assert-integer(3.14, "Expected an integer") catch (e) e.message end',
+            'let { assert-integer } = import(assertion);\ntry assert-integer(42) catch (e) e.message end',
+            'let { assert-integer } = import(assertion);\ntry assert-integer(3.14, "Expected an integer") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-number'],
+        seeAlso: ['assertion.assert-number'],
         hideOperatorForm: true,
     },
     'assert-matrix': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `matrix` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10362,14 +10617,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-matrix } = import(assert);\ntry assert-matrix([[1, 2], [3, 4]]) catch (e) e.message end',
-            'let { assert-matrix } = import(assert);\ntry assert-matrix([1, 2], "Expected a matrix") catch (e) e.message end',
+            'let { assert-matrix } = import(assertion);\ntry assert-matrix([[1, 2], [3, 4]]) catch (e) e.message end',
+            'let { assert-matrix } = import(assertion);\ntry assert-matrix([1, 2], "Expected a matrix") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-vector', 'assert.assert-grid'],
+        seeAlso: ['assertion.assert-vector', 'assertion.assert-grid'],
         hideOperatorForm: true,
     },
     'assert-number': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `number` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10396,14 +10651,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-number } = import(assert);\ntry assert-number(42) catch (e) e.message end',
-            'let { assert-number } = import(assert);\ntry assert-number("hello", "Expected a number") catch (e) e.message end',
+            'let { assert-number } = import(assertion);\ntry assert-number(42) catch (e) e.message end',
+            'let { assert-number } = import(assertion);\ntry assert-number("hello", "Expected a number") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-integer', 'assert.assert-boolean', 'assert.assert-string', 'assert.assert-function'],
+        seeAlso: ['assertion.assert-integer', 'assertion.assert-boolean', 'assertion.assert-string', 'assertion.assert-function'],
         hideOperatorForm: true,
     },
     'assert-object': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not an `object` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10430,14 +10685,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-object } = import(assert);\ntry assert-object({ a: 1 }) catch (e) e.message end',
-            'let { assert-object } = import(assert);\ntry assert-object([1, 2], "Expected an object") catch (e) e.message end',
+            'let { assert-object } = import(assertion);\ntry assert-object({ a: 1 }) catch (e) e.message end',
+            'let { assert-object } = import(assertion);\ntry assert-object([1, 2], "Expected an object") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-array', 'assert.assert-collection'],
+        seeAlso: ['assertion.assert-array', 'assertion.assert-collection'],
         hideOperatorForm: true,
     },
     'assert-regexp': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `regexp` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10464,14 +10719,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-regexp } = import(assert);\ntry assert-regexp(#"^start") catch (e) e.message end',
-            'let { assert-regexp } = import(assert);\ntry assert-regexp("hello", "Expected a regexp") catch (e) e.message end',
+            'let { assert-regexp } = import(assertion);\ntry assert-regexp(#"^start") catch (e) e.message end',
+            'let { assert-regexp } = import(assertion);\ntry assert-regexp("hello", "Expected a regexp") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-string'],
+        seeAlso: ['assertion.assert-string'],
         hideOperatorForm: true,
     },
     'assert-sequence': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `sequence` (array or string) it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10498,15 +10753,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-sequence } = import(assert);\ntry assert-sequence([1, 2]) catch (e) e.message end',
-            'let { assert-sequence } = import(assert);\ntry assert-sequence("hello") catch (e) e.message end',
-            'let { assert-sequence } = import(assert);\ntry assert-sequence({ a: 1 }, "Expected a sequence") catch (e) e.message end',
+            'let { assert-sequence } = import(assertion);\ntry assert-sequence([1, 2]) catch (e) e.message end',
+            'let { assert-sequence } = import(assertion);\ntry assert-sequence("hello") catch (e) e.message end',
+            'let { assert-sequence } = import(assertion);\ntry assert-sequence({ a: 1 }, "Expected a sequence") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-collection', 'assert.assert-array'],
+        seeAlso: ['assertion.assert-collection', 'assertion.assert-array'],
         hideOperatorForm: true,
     },
     'assert-string': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `string` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10533,14 +10788,14 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-string } = import(assert);\ntry assert-string("hello") catch (e) e.message end',
-            'let { assert-string } = import(assert);\ntry assert-string(42, "Expected a string") catch (e) e.message end',
+            'let { assert-string } = import(assertion);\ntry assert-string("hello") catch (e) e.message end',
+            'let { assert-string } = import(assertion);\ntry assert-string(42, "Expected a string") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-number', 'assert.assert-boolean', 'assert.assert-regexp', 'assert.assert-function'],
+        seeAlso: ['assertion.assert-number', 'assertion.assert-boolean', 'assertion.assert-regexp', 'assertion.assert-function'],
         hideOperatorForm: true,
     },
     'assert-vector': {
-        category: 'assert',
+        category: 'assertion',
         description: 'If $value is not a `vector` it throws `AssertionError`.',
         returns: {
             type: 'null',
@@ -10567,26 +10822,15 @@ const moduleDocs$6 = {
             },
         ],
         examples: [
-            'let { assert-vector } = import(assert);\ntry assert-vector([1, 2, 3]) catch (e) e.message end',
-            'let { assert-vector } = import(assert);\ntry assert-vector(["a", "b"], "Expected a vector") catch (e) e.message end',
+            'let { assert-vector } = import(assertion);\ntry assert-vector([1, 2, 3]) catch (e) e.message end',
+            'let { assert-vector } = import(assertion);\ntry assert-vector(["a", "b"], "Expected a vector") catch (e) e.message end',
         ],
-        seeAlso: ['assert.assert-matrix', 'assert.assert-grid'],
+        seeAlso: ['assertion.assert-matrix', 'assertion.assert-grid'],
         hideOperatorForm: true,
     },
 };
 
 const assertNormalExpression = {
-    'assert': {
-        evaluate: (params, sourceCodeInfo) => {
-            const value = params[0];
-            const message = params.length === 2 ? params[1] : `${value}`;
-            assertString(message, sourceCodeInfo);
-            if (!value)
-                throw new AssertionError(message, sourceCodeInfo);
-            return asAny(value, sourceCodeInfo);
-        },
-        arity: { min: 1, max: 2 },
-    },
     'assert=': {
         evaluate: ([first, second, message], sourceCodeInfo) => {
             if (message !== undefined) {
@@ -10964,12 +11208,12 @@ for (const [key, docs] of Object.entries(moduleDocs$6)) {
         assertNormalExpression[key].docs = docs;
 }
 const assertModule = {
-    name: 'assert',
+    name: 'assertion',
     functions: assertNormalExpression,
 };
 
 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 +11236,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 +11269,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 +11298,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 +11356,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 +11504,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 +11538,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 +11617,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 +11643,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 +11678,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': {
-        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': {
+    'crop': {
         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 +11714,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 +11760,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 +11802,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 +11956,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 +11979,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 +12006,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 +12040,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 +12074,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 +12361,7 @@ function transpose(grid) {
 }
 
 const gridFunctions = {
-    'every?': {
+    'cell-every?': {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
@@ -12372,21 +12564,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 +12732,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 +12757,7 @@ const gridFunctions = {
         },
         arity: { min: 2 },
     },
-    'mapi': {
+    'cell-mapi': {
         evaluate: ([grid, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12593,7 +12771,7 @@ const gridFunctions = {
         },
         arity: toFixedArity(2),
     },
-    'reduce': {
+    'cell-reduce': {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12607,7 +12785,7 @@ const gridFunctions = {
         },
         arity: toFixedArity(3),
     },
-    'reducei': {
+    'cell-reducei': {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
@@ -12761,7 +12939,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 +12969,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 +13001,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 +13031,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 +13058,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 +13085,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 +13117,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 +13149,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 +13176,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 +13208,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 +13236,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 +13268,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 +13296,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 +13328,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 +13356,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 +13376,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { uuid! } = import(random); uuid!()',
+            `let { uuid! } = import(random);
+uuid!()`,
         ],
         seeAlso: ['random.random-id!', 'random.random-string!'],
     },
@@ -13194,8 +13401,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 +13433,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 +13461,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 +13481,8 @@ const moduleDocs$4 = {
             },
         ],
         examples: [
-            'let { random-color! } = import(random); random-color!()',
+            `let { random-color! } = import(random);
+random-color!()`,
         ],
     },
 };
@@ -13566,31 +13780,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 +13814,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 +13874,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 +13898,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 +13923,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 +14068,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 +14190,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 +14224,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 +14284,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 +14308,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 +14926,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 +15052,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 +15086,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 +15146,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 +15171,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 +15207,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 +15266,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 +15291,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 +16326,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 +16623,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 +17247,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 +17397,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 +17424,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 +17451,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 +17477,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 +17526,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 +18441,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 +18687,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 +19411,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 +19991,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 +21034,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 +21171,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 +21300,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 +21320,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 +21350,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 +22122,7 @@ const matrixNormalExpression = {
         },
         arity: toFixedArity(1),
     },
-    'orthogonal?': {
+    'orthogonal-matrix?': {
         evaluate: ([matrix], sourceCodeInfo) => {
             assertMatrix(matrix, sourceCodeInfo);
             return isOrthogonal(matrix);
@@ -29431,12 +29358,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 +29386,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 +29412,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 +29438,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 +29464,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 +29492,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 +29518,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 +29544,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 +29572,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 +29600,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 +29626,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 +29650,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 +29676,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 +29702,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 +29728,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 +29754,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 +29782,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 +30026,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 +30055,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 +30076,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 +30097,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 +30120,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 +30143,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 +30180,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 +30219,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 +30272,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 +30319,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 +30348,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 +30367,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 +30391,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 +30410,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 +31131,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 +31419,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 +31543,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 +32216,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 +32604,7 @@ const allBuiltinModules = [
     collectionUtilsModule,
     sequenceUtilsModule,
     bitwiseUtilsModule,
+    convertModule,
 ];
 
 function runTest({ testPath: filePath, testNamePattern }) {
@@ -32556,7 +32973,7 @@ const shorthand = {
             '#"^\\s*(.*)$"',
             '#"albert"ig',
         ],
-        seeAlso: ['regexp', 'match', 'replace', 'replace-all'],
+        seeAlso: ['regexp', 're-match', 'replace', 'replace-all'],
     },
     '-short-fn': {
         shorthand: true,
@@ -32568,7 +32985,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)',
@@ -32622,6 +33039,7 @@ function moduledDocsToReference(moduleName, expressions) {
     return result;
 }
 // Derive all core category references from co-located docs
+const assertionRef = docsToReference(assertionNormalExpression);
 const bitwiseReference = docsToReference(bitwiseNormalExpression);
 const arrayRef = docsToReference(arrayNormalExpression);
 const collectionRef = docsToReference(collectionNormalExpression);
@@ -32679,6 +33097,7 @@ function isFunctionReference(ref) {
 }
 const normalExpressionReference = {
     // Core categories — all derived from co-located docs
+    ...assertionRef,
     ...bitwiseReference,
     ...collectionRef,
     ...arrayRef,
@@ -32709,6 +33128,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 +33613,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 +33677,6 @@ const api = {
     sequenceUtils: [
         'sequence.position',
         'sequence.last-index-of',
-        'sequence.shift',
         'sequence.unshift',
         'sequence.splice',
         'sequence.sort-by',
@@ -33390,7 +33812,7 @@ const api = {
     ],
     regularExpression: [
         'regexp',
-        'match',
+        're-match',
         'replace',
         'replace-all',
     ],
@@ -33436,38 +33858,40 @@ const api = {
         'bitwise.bit-set',
         'bitwise.bit-test',
     ],
-    assert: [
-        'assert.assert',
-        'assert.assert=',
-        'assert.assert!=',
-        'assert.assert-gt',
-        'assert.assert-lt',
-        'assert.assert-gte',
-        'assert.assert-lte',
-        'assert.assert-true',
-        'assert.assert-false',
-        'assert.assert-truthy',
-        'assert.assert-falsy',
-        'assert.assert-null',
-        'assert.assert-throws',
-        'assert.assert-throws-error',
-        'assert.assert-not-throws',
-        'assert.assert-array',
-        'assert.assert-boolean',
-        'assert.assert-collection',
-        'assert.assert-function',
-        'assert.assert-grid',
-        'assert.assert-integer',
-        'assert.assert-matrix',
-        'assert.assert-number',
-        'assert.assert-object',
-        'assert.assert-regexp',
-        'assert.assert-sequence',
-        'assert.assert-string',
-        'assert.assert-vector',
+    assertion: [
+        'assert',
+    ],
+    assertionUtils: [
+        'assertion.assert=',
+        'assertion.assert!=',
+        'assertion.assert-gt',
+        'assertion.assert-lt',
+        'assertion.assert-gte',
+        'assertion.assert-lte',
+        'assertion.assert-true',
+        'assertion.assert-false',
+        'assertion.assert-truthy',
+        'assertion.assert-falsy',
+        'assertion.assert-null',
+        'assertion.assert-throws',
+        'assertion.assert-throws-error',
+        'assertion.assert-not-throws',
+        'assertion.assert-array',
+        'assertion.assert-boolean',
+        'assertion.assert-collection',
+        'assertion.assert-function',
+        'assertion.assert-grid',
+        'assertion.assert-integer',
+        'assertion.assert-matrix',
+        'assertion.assert-number',
+        'assertion.assert-object',
+        'assertion.assert-regexp',
+        'assertion.assert-sequence',
+        'assertion.assert-string',
+        'assertion.assert-vector',
     ],
     grid: [
-        'grid.every?',
+        'grid.cell-every?',
         'grid.some?',
         'grid.every-row?',
         'grid.some-row?',
@@ -33483,19 +33907,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 +33942,7 @@ const api = {
         'matrix.lower-triangular?',
         'matrix.diagonal?',
         'matrix.square?',
-        'matrix.orthogonal?',
+        'matrix.orthogonal-matrix?',
         'matrix.identity?',
         'matrix.invertible?',
         'matrix.hilbert',
@@ -33546,17 +33968,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 +33989,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 +34151,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',
@@ -33772,6 +34719,7 @@ const coreApiFunctionNames = [
     ...api.string,
     ...api.bitwise,
     ...api.vector,
+    ...api.assertion,
 ];
 // Core API names (core functions + shorthand + datatype)
 const coreApiNames = [