@mojir/lits 2.5.2 → 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.2";
+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;
@@ -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")',
@@ -5328,6 +5375,7 @@ function setNormalExpressionReference(reference) {
 }
 const expressions$1 = {
     // Core categories
+    ...assertionNormalExpression,
     ...bitwiseNormalExpression,
     ...collectionNormalExpression,
     ...arrayNormalExpression,
@@ -5455,121 +5503,6 @@ const condSpecialExpression = {
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].flat(), contextStack, builtin, evaluateNode),
 };
 
-const docs$e = {
-    category: 'special-expression',
-    customVariants: ['switch value switch-branch switch-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.'],
-    ],
-    description: 'Used for branching. `switch-branches` are tested sequentially from the top against `value`. If no branch is tested truthy, `null` is returned.',
-    examples: [
-        `
-switch 1
-  case 1 then write!("One")
-  case 2 then write!("Two")
-end`,
-        `
-switch 2
-  case 1 then write!("One")
-  case 2 then write!("Two")
-end`,
-        `
-switch 3
-  case 1 then write!("One")
-  case 2 then write!("Two")
-end`,
-    ],
-};
-const switchSpecialExpression = {
-    arity: {},
-    docs: docs$e,
-    evaluate: (node, contextStack, { evaluateNode }) => {
-        const [, switchValueNode, cases] = node[1];
-        return chain(evaluateNode(switchValueNode, contextStack), (switchValue) => {
-            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);
-                    }
-                    return processCase(index + 1);
-                });
-            }
-            return processCase(0);
-        });
-    },
-    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1], ...node[1][2].flat()], contextStack, builtin, evaluateNode),
-};
-
-const docs$d = {
-    category: 'special-expression',
-    returns: {
-        type: 'boolean',
-    },
-    args: {
-        symbol: { type: 'any' },
-    },
-    variants: [
-        { argumentNames: ['symbol'] },
-    ],
-    description: `Returns \`true\` if \`symbol\` is defined, \`false\` otherwise.
-
-Built-in symbols are always considered defined. For user-defined symbols, checks if the symbol exists in the current scope.`,
-    examples: [
-        'let x = 42; defined?(x)',
-        'defined?(x)',
-        'defined?(+)',
-    ],
-};
-const definedSpecialExpression = {
-    arity: toFixedArity(1),
-    docs: docs$d,
-    evaluate: (node, contextStack) => {
-        const symbolNode = node[1][1];
-        assertSymbolNode(symbolNode);
-        if (!isUserDefinedSymbolNode(symbolNode)) {
-            return true; // If the symbol is not a user defined symbol, it is defined. normal or special builtin
-        }
-        const lookUpResult = contextStack.lookUp(symbolNode);
-        return lookUpResult !== null;
-    },
-    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode),
-};
-
-const docs$c = {
-    category: 'special-expression',
-    customVariants: ['do body end'],
-    details: [
-        ['body', 'expressions', 'The expressions to evaluate.'],
-    ],
-    description: 'Evaluates `body`. Resulting value is the value of the last expression.',
-    examples: [
-        `
-do
-  let a = 1 + 2 + 3 + 4;
-  let b = -> $ * ( $ + 1 );
-  b(a)
-end`,
-    ],
-};
-const doSpecialExpression = {
-    arity: {},
-    docs: docs$c,
-    evaluate: (node, contextStack, { evaluateNode }) => {
-        const newContext = {};
-        const newContextStack = contextStack.create(newContext);
-        return reduceSequential(node[1][1], (_acc, form) => evaluateNode(form, newContextStack), null);
-    },
-    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
-        return getUndefinedSymbols(node[1][1], contextStack.create({}), builtin, evaluateNode);
-    },
-};
-
 function isJsFunction(fn) {
     return typeof fn === 'object' && fn !== null && 'fn' in fn && typeof fn.fn === 'function';
 }
@@ -5578,6 +5511,8 @@ const bindingTargetTypes = {
     rest: 12,
     object: 13,
     array: 14,
+    literal: 15,
+    wildcard: 16,
 };
 
 function walkDefaults(bindingTarget, onDefault) {
@@ -5601,6 +5536,7 @@ function walkDefaults(bindingTarget, onDefault) {
             walkDefaults(element, onDefault);
         }
     }
+    // literal and wildcard have no defaults - nothing to walk
 }
 function evaluateBindingNodeValues(target, value, evaluate) {
     const sourceCodeInfo = target[2];
@@ -5709,14 +5645,302 @@ function getNamesFromBindingTarget(target, names) {
         }
         names[target[1][0]] = true;
     }
-    else {
+    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: ['match value match-branch match-branch ... end'],
+    details: [
+        ['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: '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: [
+        `
+match 1
+  case 1 then "One"
+  case 2 then "Two"
+end`,
+        `
+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`,
+        `
+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 matchSpecialExpression = {
+    arity: {},
+    docs: docs$e,
+    evaluate: (node, contextStack, { evaluateNode }) => {
+        const [, matchValueNode, cases] = node[1];
+        return chain(evaluateNode(matchValueNode, contextStack), (matchValue) => {
+            function processCase(index) {
+                if (index >= cases.length)
+                    return null;
+                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 };
+                    }
+                    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 }) => {
+        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 = {
+    category: 'special-expression',
+    returns: {
+        type: 'boolean',
+    },
+    args: {
+        symbol: { type: 'any' },
+    },
+    variants: [
+        { argumentNames: ['symbol'] },
+    ],
+    description: `Returns \`true\` if \`symbol\` is defined, \`false\` otherwise.
+
+Built-in symbols are always considered defined. For user-defined symbols, checks if the symbol exists in the current scope.`,
+    examples: [
+        'let x = 42; defined?(x)',
+        'defined?(x)',
+        'defined?(+)',
+    ],
+};
+const definedSpecialExpression = {
+    arity: toFixedArity(1),
+    docs: docs$d,
+    evaluate: (node, contextStack) => {
+        const symbolNode = node[1][1];
+        assertSymbolNode(symbolNode);
+        if (!isUserDefinedSymbolNode(symbolNode)) {
+            return true; // If the symbol is not a user defined symbol, it is defined. normal or special builtin
+        }
+        const lookUpResult = contextStack.lookUp(symbolNode);
+        return lookUpResult !== null;
+    },
+    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode),
+};
+
+const docs$c = {
+    category: 'special-expression',
+    customVariants: ['do body end'],
+    details: [
+        ['body', 'expressions', 'The expressions to evaluate.'],
+    ],
+    description: 'Evaluates `body`. Resulting value is the value of the last expression.',
+    examples: [
+        `
+do
+  let a = 1 + 2 + 3 + 4;
+  let b = -> $ * ( $ + 1 );
+  b(a)
+end`,
+    ],
+};
+const doSpecialExpression = {
+    arity: {},
+    docs: docs$c,
+    evaluate: (node, contextStack, { evaluateNode }) => {
+        const newContext = {};
+        const newContextStack = contextStack.create(newContext);
+        return reduceSequential(node[1][1], (_acc, form) => evaluateNode(form, newContextStack), null);
+    },
+    getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
+        return getUndefinedSymbols(node[1][1], contextStack.create({}), builtin, evaluateNode);
+    },
+};
+
 const lambdaSpecialExpression = {
     arity: {},
     evaluate: (node, contextStack, { builtin, getUndefinedSymbols, evaluateNode }) => {
@@ -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';
 }
@@ -8491,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);
@@ -8533,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;
             }
@@ -8597,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(), ',');
@@ -8625,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();
@@ -9050,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();
@@ -9209,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) {
@@ -9265,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':
@@ -9555,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',
@@ -9621,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',
@@ -9662,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',
@@ -9702,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',
@@ -9742,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',
@@ -9782,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',
@@ -9822,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',
@@ -9857,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',
@@ -9892,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',
@@ -9927,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',
@@ -9969,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',
@@ -10010,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',
@@ -10051,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',
@@ -10090,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',
@@ -10124,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',
@@ -10158,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',
@@ -10193,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',
@@ -10228,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',
@@ -10264,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',
@@ -10298,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',
@@ -10332,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',
@@ -10366,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',
@@ -10400,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',
@@ -10434,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',
@@ -10468,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',
@@ -10502,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',
@@ -10537,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',
@@ -10571,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) {
@@ -10968,7 +11208,7 @@ for (const [key, docs] of Object.entries(moduleDocs$6)) {
         assertNormalExpression[key].docs = docs;
 }
 const assertModule = {
-    name: 'assert',
+    name: 'assertion',
     functions: assertNormalExpression,
 };
 
@@ -32733,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,
@@ -32799,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);
@@ -32856,6 +33097,7 @@ function isFunctionReference(ref) {
 }
 const normalExpressionReference = {
     // Core categories — all derived from co-located docs
+    ...assertionRef,
     ...bitwiseReference,
     ...collectionRef,
     ...arrayRef,
@@ -33570,7 +33812,7 @@ const api = {
     ],
     regularExpression: [
         'regexp',
-        'match',
+        're-match',
         'replace',
         'replace-all',
     ],
@@ -33616,35 +33858,37 @@ 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.cell-every?',
@@ -34475,6 +34719,7 @@ const coreApiFunctionNames = [
     ...api.string,
     ...api.bitwise,
     ...api.vector,
+    ...api.assertion,
 ];
 // Core API names (core functions + shorthand + datatype)
 const coreApiNames = [