@mojir/lits 2.1.40 → 2.1.41

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.1.40";
+var version = "2.1.41";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -4086,8 +4086,11 @@ function partition(n, step, seq, pad, sourceCodeInfo) {
 
 const annotatedArrays = new WeakSet();
 const vectors = new WeakSet();
+const notVectors = new WeakSet();
 const matrices = new WeakSet();
+const notMatrices = new WeakSet();
 const grids = new WeakSet();
+const notGrids = new WeakSet();
 function annotate(value) {
     if (!Array.isArray(value)) {
         return value;
@@ -4108,11 +4111,15 @@ function isVector(vector) {
     if (vectors.has(vector)) {
         return true;
     }
+    if (notVectors.has(vector)) {
+        return false;
+    }
     if (vector.every(elem => isNumber(elem))) {
         annotatedArrays.add(vector);
         vectors.add(vector);
         return true;
     }
+    notVectors.add(vector);
     return false;
 }
 function assertVector(vector, sourceCodeInfo) {
@@ -4155,18 +4162,25 @@ function isGrid(grid) {
     if (grids.has(grid)) {
         return true;
     }
+    if (notGrids.has(grid)) {
+        return false;
+    }
     if (grid.length === 0) {
+        notGrids.add(grid);
         return false;
     }
     if (!Array.isArray(grid[0])) {
+        notGrids.add(grid);
         return false;
     }
     const nbrOfCols = grid[0].length;
     for (const row of grid.slice(1)) {
         if (!Array.isArray(row)) {
+            notGrids.add(grid);
             return false;
         }
         if (row.length !== nbrOfCols) {
+            notGrids.add(grid);
             return false;
         }
     }
@@ -4186,24 +4200,21 @@ function isMatrix(matrix) {
     if (matrices.has(matrix)) {
         return true;
     }
-    if (matrix.length === 0) {
+    if (notMatrices.has(matrix)) {
         return false;
     }
-    if (!Array.isArray(matrix[0])) {
+    if (matrix.length === 0) {
+        notMatrices.add(matrix);
         return false;
     }
-    if (matrix[0].length === 0) {
+    if (!Array.isArray(matrix[0]) || matrix[0].length === 0) {
+        notMatrices.add(matrix);
         return false;
     }
     const nbrOfCols = matrix[0].length;
-    for (const row of matrix.slice(1)) {
-        if (!Array.isArray(row)) {
-            return false;
-        }
-        if (row.length !== nbrOfCols) {
-            return false;
-        }
-        if (row.some(cell => !isNumber(cell))) {
+    for (const row of matrix) {
+        if (!Array.isArray(row) || row.length !== nbrOfCols || row.some(cell => !isNumber(cell))) {
+            notMatrices.add(matrix);
             return false;
         }
     }
@@ -6095,7 +6106,7 @@ const predicatesNormalExpression = {
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
             description: 'Returns `true` if $x is a string, otherwise `false`.',
-            seeAlso: ['blank?', 'number?', 'boolean?', 'null?', 'array?', 'object?', 'regexp?', 'function?', 'coll?', 'seq?'],
+            seeAlso: ['blank?', 'number?', 'boolean?', 'null?', 'array?', 'object?', 'regexp?', 'function?', 'collection?', 'sequence?'],
             examples: [
                 'string?("")',
                 'string?("A string")',
@@ -6302,7 +6313,7 @@ const predicatesNormalExpression = {
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
             description: 'Returns `true` if $x is an array, otherwise `false`.',
-            seeAlso: ['seq?', 'coll?', 'object?', 'string?', 'vector?', 'matrix?', 'grid?', 'function?'],
+            seeAlso: ['sequence?', 'collection?', 'object?', 'string?', 'vector?', 'matrix?', 'grid?', 'function?'],
             examples: [
                 'array?([])',
                 'array?([1, 2, 3])',
@@ -6313,7 +6324,7 @@ const predicatesNormalExpression = {
             ],
         },
     },
-    'coll?': {
+    'collection?': {
         evaluate: ([first]) => {
             return isColl(first);
         },
@@ -6323,20 +6334,20 @@ const predicatesNormalExpression = {
             returns: { type: 'boolean' },
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
-            description: 'Returns `true` if $x is a Coll i.e. an array, an object or a string, otherwise `false`.',
-            seeAlso: ['seq?', 'array?', 'object?', 'string?'],
+            description: 'Returns `true` if $x is a collection i.e. an array, an object or a string, otherwise `false`.',
+            seeAlso: ['sequence?', 'array?', 'object?', 'string?'],
             examples: [
-                'coll?([])',
-                'coll?([1, 2, 3])',
-                'coll?(object("a", 10))',
-                'coll?("Albert")',
-                'coll?(42)',
-                'coll?(10.1)',
-                'coll?((x, y) -> x + y)',
+                'collection?([])',
+                'collection?([1, 2, 3])',
+                'collection?(object("a", 10))',
+                'collection?("Albert")',
+                'collection?(42)',
+                'collection?(10.1)',
+                'collection?((x, y) -> x + y)',
             ],
         },
     },
-    'seq?': {
+    'sequence?': {
         evaluate: ([first]) => {
             return isSeq(first);
         },
@@ -6346,16 +6357,16 @@ const predicatesNormalExpression = {
             returns: { type: 'boolean' },
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
-            description: 'Returns `true` if $x is a Seq i.e. an array or a string, otherwise `false`.',
-            seeAlso: ['coll?', 'array?', 'string?'],
+            description: 'Returns `true` if $x is a sequence i.e. an array or a string, otherwise `false`.',
+            seeAlso: ['collection?', 'array?', 'string?'],
             examples: [
-                'seq?([])',
-                'seq?([1, 2, 3])',
-                'seq?(object("a", 10))',
-                'seq?("Albert")',
-                'seq?(42)',
-                'seq?(10.1)',
-                'seq?((x, y) -> x + y)',
+                'sequence?([])',
+                'sequence?([1, 2, 3])',
+                'sequence?(object("a", 10))',
+                'sequence?("Albert")',
+                'sequence?(42)',
+                'sequence?(10.1)',
+                'sequence?((x, y) -> x + y)',
             ],
         },
     },
@@ -6368,7 +6379,7 @@ const predicatesNormalExpression = {
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
             description: 'Returns `true` if $x is an object, otherwise `false`.',
-            seeAlso: ['coll?', 'array?', 'string?', 'function?'],
+            seeAlso: ['collection?', 'array?', 'string?', 'function?'],
             examples: [
                 'object?(object("a", 10))',
                 'object?(42)',
@@ -8059,7 +8070,7 @@ function walkDefaults(bindingTarget, onDefault) {
         }
     }
 }
-function evalueateBindingNodeValues(target, value, evaluate) {
+function evaluateBindingNodeValues(target, value, evaluate) {
     const sourceCodeInfo = target[2];
     const record = {};
     createRecord(target, value, evaluate, sourceCodeInfo, record);
@@ -8159,7 +8170,7 @@ const defSpecialExpression = {
         const target = bindingNode[1][0];
         const value = bindingNode[1][1];
         const bindingValue = evaluateNode(value, contextStack);
-        const values = evalueateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
+        const values = evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
         contextStack.exportValues(values, target[2]);
         return bindingValue;
     },
@@ -8366,7 +8377,7 @@ const letSpecialExpression = {
         const target = bindingNode[1][0];
         const value = bindingNode[1][1];
         const bindingValue = evaluateNode(value, contextStack);
-        const values = evalueateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
+        const values = evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
         contextStack.addValues(values, target[2]);
         return bindingValue;
     },
@@ -8417,7 +8428,7 @@ const loopSpecialExpression = {
         const bindingNodes = node[1][1];
         const bindingContext = bindingNodes.reduce((result, bindingNode) => {
             const val = evaluateNode(bindingNode[1][1], contextStack.create(result));
-            const valueRecord = evalueateBindingNodeValues(bindingNode[1][0], val, Node => evaluateNode(Node, contextStack));
+            const valueRecord = evaluateBindingNodeValues(bindingNode[1][0], val, Node => evaluateNode(Node, contextStack));
             Object.entries(valueRecord).forEach(([name, value]) => {
                 result[name] = { value };
             });
@@ -8437,7 +8448,7 @@ const loopSpecialExpression = {
                         throw new LitsError(`recur expected ${bindingNodes.length} parameters, got ${valueToString(params.length)}`, node[2]);
                     }
                     bindingNodes.forEach((bindingNode, index) => {
-                        const valueRecord = evalueateBindingNodeValues(bindingNode[1][0], asAny(params[index]), Node => evaluateNode(Node, contextStack));
+                        const valueRecord = evaluateBindingNodeValues(bindingNode[1][0], asAny(params[index]), Node => evaluateNode(Node, contextStack));
                         for (const [name, value] of Object.entries(valueRecord)) {
                             bindingContext[name].value = value;
                         }
@@ -8470,7 +8481,7 @@ function addToContext(bindings, context, contextStack, evaluateNode) {
     for (const bindingNode of bindings) {
         const [target, bindingValue] = bindingNode[1];
         const val = evaluateNode(bindingValue, contextStack);
-        const valueRecord = evalueateBindingNodeValues(target, val, Node => evaluateNode(Node, contextStack));
+        const valueRecord = evaluateBindingNodeValues(target, val, Node => evaluateNode(Node, contextStack));
         Object.entries(valueRecord).forEach(([name, value]) => {
             context[name] = { value };
         });
@@ -8508,7 +8519,7 @@ function evaluateLoop(returnResult, loopNode, contextStack, evaluateNode) {
                 break;
             }
             const val = asAny(seq[index], sourceCodeInfo);
-            const valueRecord = evalueateBindingNodeValues(targetNode, val, Node => evaluateNode(Node, newContextStack));
+            const valueRecord = evaluateBindingNodeValues(targetNode, val, Node => evaluateNode(Node, newContextStack));
             Object.entries(valueRecord).forEach(([name, value]) => {
                 context[name] = { value };
             });
@@ -9027,12 +9038,10 @@ const specialExpressions = [
     condSpecialExpression,
     defSpecialExpression,
     definedSpecialExpression,
-    // defnSpecialExpression,
     doSpecialExpression,
     doseqSpecialExpression,
     lambdaSpecialExpression,
     forSpecialExpression,
-    // functionSpecialExpression,
     ifSpecialExpression,
     letSpecialExpression,
     loopSpecialExpression,
@@ -9114,7 +9123,7 @@ const functionExecutors = {
                 : isUnknownRecord(error) && typeof error.message === 'string'
                     ? error.message
                     : '<no message>';
-            throw new LitsError(`Native function throwed: "${message}"`, sourceCodeInfo);
+            throw new LitsError(`Native function threw: "${message}"`, sourceCodeInfo);
         }
     },
     UserDefined: (fn, params, sourceCodeInfo, contextStack, { evaluateNode }) => {
@@ -9122,7 +9131,6 @@ const functionExecutors = {
             if (!arityAcceptsMin(fn.arity, params.length)) {
                 throw new LitsError(`Expected ${fn.arity} arguments, got ${params.length}.`, sourceCodeInfo);
             }
-            // checkParams(fn.evaluatedfunction, params.length, sourceCodeInfo)
             const evaluatedFunction = fn.evaluatedfunction;
             const args = evaluatedFunction[0];
             const nbrOfNonRestArgs = args.filter(arg => arg[0] !== bindingTargetTypes.rest).length;
@@ -9132,7 +9140,7 @@ const functionExecutors = {
             for (let i = 0; i < params.length; i += 1) {
                 if (i < nbrOfNonRestArgs) {
                     const param = toAny(params[i]);
-                    const valueRecord = evalueateBindingNodeValues(args[i], param, node => evaluateNode(node, newContextStack.create(newContext)));
+                    const valueRecord = evaluateBindingNodeValues(args[i], param, node => evaluateNode(node, newContextStack.create(newContext)));
                     Object.entries(valueRecord).forEach(([key, value]) => {
                         newContext[key] = { value };
                     });
@@ -9144,14 +9152,14 @@ const functionExecutors = {
             for (let i = params.length; i < nbrOfNonRestArgs; i++) {
                 const arg = args[i];
                 const defaultValue = evaluateNode(arg[1][1], contextStack.create(newContext));
-                const valueRecord = evalueateBindingNodeValues(arg, defaultValue, node => evaluateNode(node, contextStack.create(newContext)));
+                const valueRecord = evaluateBindingNodeValues(arg, defaultValue, node => evaluateNode(node, contextStack.create(newContext)));
                 Object.entries(valueRecord).forEach(([key, value]) => {
                     newContext[key] = { value };
                 });
             }
             const restArgument = args.find(arg => arg[0] === bindingTargetTypes.rest);
             if (restArgument !== undefined) {
-                const valueRecord = evalueateBindingNodeValues(restArgument, rest, node => evaluateNode(node, contextStack.create(newContext)));
+                const valueRecord = evaluateBindingNodeValues(restArgument, rest, node => evaluateNode(node, contextStack.create(newContext)));
                 Object.entries(valueRecord).forEach(([key, value]) => {
                     newContext[key] = { value };
                 });
@@ -9229,7 +9237,7 @@ const functionExecutors = {
         return executeFunction(asFunctionLike(fn.function, sourceCodeInfo), fnulledParams, contextStack, sourceCodeInfo);
     },
     Builtin: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
-        const normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuitinSymbolType], sourceCodeInfo);
+        const normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuiltinSymbolType], sourceCodeInfo);
         return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction });
     },
     SpecialBuiltin: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
@@ -9464,14 +9472,9 @@ class ContextStackImpl {
             if (this.globalContext[name]) {
                 throw new LitsError(`Cannot redefine exported value "${name}"`, sourceCodeInfo);
             }
-            if (specialExpressionKeys.includes(name)) {
-                throw new LitsError(`Cannot shadow special expression "${name}"`, sourceCodeInfo);
-            }
-            if (normalExpressionKeys.includes(name)) {
-                throw new LitsError(`Cannot shadow builtin function "${name}"`, sourceCodeInfo);
-            }
-            if (name === 'self') {
-                throw new LitsError(`Cannot shadow builtin value "${name}"`, sourceCodeInfo);
+            const shadowedName = getShadowedBuiltinName(name);
+            if (shadowedName) {
+                throw new LitsError(`Cannot shadow ${shadowedName}`, sourceCodeInfo);
             }
             this.globalContext[name] = { value };
         }
@@ -9485,14 +9488,9 @@ class ContextStackImpl {
             if (currentContext[name]) {
                 throw new LitsError(`Cannot redefine value "${name}"`, sourceCodeInfo);
             }
-            if (specialExpressionKeys.includes(name)) {
-                throw new LitsError(`Cannot shadow special expression "${name}"`, sourceCodeInfo);
-            }
-            if (normalExpressionKeys.includes(name)) {
-                throw new LitsError(`Cannot shadow builtin function "${name}"`, sourceCodeInfo);
-            }
-            if (name === 'self') {
-                throw new LitsError(`Cannot shadow builtin value "${name}"`, sourceCodeInfo);
+            const shadowedName = getShadowedBuiltinName(name);
+            if (shadowedName) {
+                throw new LitsError(`Cannot shadow ${shadowedName}`, sourceCodeInfo);
             }
             currentContext[name] = { value: toAny(value) };
         }
@@ -9561,7 +9559,7 @@ class ContextStackImpl {
             return {
                 [FUNCTION_SYMBOL]: true,
                 functionType: 'Builtin',
-                normalBuitinSymbolType: type,
+                normalBuiltinSymbolType: type,
                 sourceCodeInfo: node[2],
                 arity: normalExpression.arity,
                 name,
@@ -9573,20 +9571,20 @@ class ContextStackImpl {
         throw new UndefinedSymbolError(node[1], node[2]);
     }
 }
-function checkNotDefined(name) {
-    if (specialExpressionKeys.includes(name)) {
-        console.warn(`Cannot shadow special expression "${name}", ignoring.`);
-        return false;
-    }
-    if (normalExpressionKeys.includes(name)) {
-        console.warn(`Cannot shadow builtin function "${name}", ignoring.`);
-        return false;
-    }
-    if (name === 'self') {
-        console.warn(`Cannot shadow builtin value "${name}", ignoring.`);
-        return false;
+function getShadowedBuiltinName(name) {
+    if (specialExpressionKeys.includes(name))
+        return `special expression "${name}"`;
+    if (normalExpressionKeys.includes(name))
+        return `builtin function "${name}"`;
+    if (name === 'self')
+        return `builtin value "${name}"`;
+    return null;
+}
+function assertNotShadowingBuiltin(name) {
+    const shadowedName = getShadowedBuiltinName(name);
+    if (shadowedName) {
+        throw new LitsError(`Cannot shadow ${shadowedName}`, undefined);
     }
-    return true;
 }
 function createContextStack(params = {}, modules) {
     const globalContext = params.globalContext ?? {};
@@ -9601,18 +9599,15 @@ function createContextStack(params = {}, modules) {
                 const identifierParts = identifier.split('.');
                 const name = identifierParts.pop();
                 if (/^[A-Z]/.test(name)) {
-                    console.warn(`Invalid identifier "${identifier}" in jsFunctions, function name must not start with an uppercase letter`, undefined);
-                    return acc;
+                    throw new LitsError(`Invalid identifier "${identifier}" in jsFunctions, function name must not start with an uppercase letter`, undefined);
                 }
                 let scope = acc;
                 for (const part of identifierParts) {
                     if (part.length === 0) {
-                        console.warn(`Invalid empty identifier "${identifier}" in nativeJsFunctions`, undefined);
-                        return acc;
+                        throw new LitsError(`Invalid empty identifier "${identifier}" in jsFunctions`, undefined);
                     }
                     if (!/^[A-Z]/.test(part)) {
-                        console.warn(`Invalid identifier "${identifier}" in jsFunctions, module name must start with an uppercase letter`, undefined);
-                        return acc;
+                        throw new LitsError(`Invalid identifier "${identifier}" in jsFunctions, module name must start with an uppercase letter`, undefined);
                     }
                     if (!scope[part]) {
                         scope[part] = {};
@@ -9620,7 +9615,7 @@ function createContextStack(params = {}, modules) {
                     scope = scope[part];
                 }
                 assertJsFunction(entry);
-                const natifeFn = {
+                const nativeFn = {
                     functionType: 'NativeJsFunction',
                     nativeFn: entry,
                     name,
@@ -9628,10 +9623,10 @@ function createContextStack(params = {}, modules) {
                     arity: entry.arity ?? {},
                     docString: entry.docString ?? '',
                 };
-                if (scope === acc && !checkNotDefined(name)) {
-                    return acc;
+                if (scope === acc) {
+                    assertNotShadowingBuiltin(name);
                 }
-                scope[name] = natifeFn;
+                scope[name] = nativeFn;
                 return acc;
             }, {}),
     });
@@ -10333,6 +10328,7 @@ function getSymbolName(symbol) {
 const exponentiationPrecedence = 12;
 const binaryFunctionalOperatorPrecedence = 3;
 const conditionalOperatorPrecedence = 1;
+const maxShorthandLambdaArity = 20;
 const placeholderRegexp = /^\$([1-9]\d?)?$/;
 function withSourceCodeInfo(node, sourceCodeInfo) {
     if (sourceCodeInfo) {
@@ -10637,7 +10633,7 @@ class Parser {
                 return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
             }
             if (operatorName === '->') {
-                return this.parseShorthandLamdaFunction();
+                return this.parseShorthandLambdaFunction();
             }
             else {
                 throw new LitsError(`Illegal operator: ${operatorName}`, token[2]);
@@ -10803,7 +10799,7 @@ class Parser {
                     throw new LitsError(`Unknown special expression: ${type}`, symbol[2]);
             }
         }
-        else if (isNormalBuiltinSymbolNode(symbol) || isNormalBuiltinSymbolNode(symbol)) {
+        else if (isNormalBuiltinSymbolNode(symbol) || isUserDefinedSymbolNode(symbol)) {
             return createNamedNormalExpressionNode(symbol, params, symbol[2]);
         }
         else {
@@ -10887,7 +10883,7 @@ class Parser {
         this.advance();
         return functionArguments;
     }
-    parseShorthandLamdaFunction() {
+    parseShorthandLambdaFunction() {
         const firstToken = this.asToken(this.peek());
         this.advance();
         const startPos = this.parseState.position;
@@ -10917,7 +10913,7 @@ class Parser {
                         dollar1 = match[1] ? 'WITH_1' : 'NAKED';
                     }
                     arity = Math.max(arity, Number(number));
-                    if (arity > 20)
+                    if (arity > maxShorthandLambdaArity)
                         throw new LitsError('Can\'t specify more than 20 arguments', firstToken[2]);
                 }
             }
@@ -12053,16 +12049,558 @@ 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("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',
+        ],
+        seeAlso: ['Assert.assert-false', 'Assert.assert-truthy', 'Assert.assert-falsy', 'Assert.assert', 'Assert.assert-boolean'],
+        hideOperatorForm: true,
+    },
+    'assert-false': {
+        category: 'Assert',
+        description: 'If $value is not `false` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-true', 'Assert.assert-falsy', 'Assert.assert-truthy', 'Assert.assert-boolean'],
+        hideOperatorForm: true,
+    },
+    'assert-truthy': {
+        category: 'Assert',
+        description: 'If $value is not `truthy` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-falsy', 'Assert.assert-true', 'Assert.assert-false', 'Assert.assert', 'Assert.assert-null'],
+        hideOperatorForm: true,
+    },
+    'assert-falsy': {
+        category: 'Assert',
+        description: 'If $value is not `falsy` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-truthy', 'Assert.assert-false', 'Assert.assert-true', 'Assert.assert-null'],
+        hideOperatorForm: true,
+    },
+    'assert-null': {
+        category: 'Assert',
+        description: 'If $value is not `null` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-truthy', 'Assert.assert-falsy'],
+        hideOperatorForm: true,
+    },
+    'assert-throws': {
+        category: 'Assert',
+        description: 'If $fun does not throw, it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'fun',
+                ],
+            },
+            {
+                argumentNames: [
+                    'fun',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-throws-error', 'Assert.assert-not-throws'],
+        hideOperatorForm: true,
+    },
+    'assert-throws-error': {
+        category: 'Assert',
+        description: 'If $fun does not throw $error-message, it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            'fun': {
+                type: 'function',
+            },
+            'error-message': {
+                type: 'string',
+            },
+            'message': {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                    'error-message',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'error-message',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-throws', 'Assert.assert-not-throws'],
+        hideOperatorForm: true,
+    },
+    'assert-not-throws': {
+        category: 'Assert',
+        description: 'If $fun throws, it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'fun',
+                ],
+            },
+            {
+                argumentNames: [
+                    'fun',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-throws', 'Assert.assert-throws-error'],
+        hideOperatorForm: true,
+    },
+    'assert-array': {
+        category: 'Assert',
+        description: 'If $value is not an `array` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-object', 'Assert.assert-collection', 'Assert.assert-sequence'],
+        hideOperatorForm: true,
+    },
+    'assert-boolean': {
+        category: 'Assert',
+        description: 'If $value is not a `boolean` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-true', 'Assert.assert-false', 'Assert.assert-number', 'Assert.assert-string'],
+        hideOperatorForm: true,
+    },
+    'assert-collection': {
+        category: 'Assert',
+        description: 'If $value is not a `collection` (array, object, or string) it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-sequence', 'Assert.assert-array', 'Assert.assert-object'],
+        hideOperatorForm: true,
+    },
+    'assert-function': {
+        category: 'Assert',
+        description: 'If $value is not a `function` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-number', 'Assert.assert-string'],
+        hideOperatorForm: true,
+    },
+    'assert-grid': {
+        category: 'Assert',
+        description: 'If $value is not a `grid` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-matrix', 'Assert.assert-vector'],
+        hideOperatorForm: true,
+    },
+    'assert-integer': {
+        category: 'Assert',
+        description: 'If $value is not an `integer` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-number'],
+        hideOperatorForm: true,
+    },
+    'assert-matrix': {
+        category: 'Assert',
+        description: 'If $value is not a `matrix` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
+        ],
+        seeAlso: ['Assert.assert-vector', 'Assert.assert-grid'],
+        hideOperatorForm: true,
+    },
+    'assert-number': {
+        category: 'Assert',
+        description: 'If $value is not a `number` it throws `AssertionError`.',
+        returns: {
+            type: 'null',
+        },
+        args: {
+            value: {
+                type: 'any',
+            },
+            message: {
+                type: 'string',
+            },
+        },
+        variants: [
+            {
+                argumentNames: [
+                    'value',
+                ],
+            },
+            {
+                argumentNames: [
+                    'value',
+                    'message',
+                ],
+            },
+        ],
+        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',
         ],
-        seeAlso: ['Assert.assert-false', 'Assert.assert-truthy', 'Assert.assert-falsy', 'Assert.assert'],
+        seeAlso: ['Assert.assert-integer', 'Assert.assert-boolean', 'Assert.assert-string', 'Assert.assert-function'],
         hideOperatorForm: true,
     },
-    'assert-false': {
+    'assert-object': {
         category: 'Assert',
-        description: 'If $value is not `false` it throws `AssertionError`.',
+        description: 'If $value is not an `object` it throws `AssertionError`.',
         returns: {
             type: 'null',
         },
@@ -12088,16 +12626,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-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',
         ],
-        seeAlso: ['Assert.assert-true', 'Assert.assert-falsy', 'Assert.assert-truthy'],
+        seeAlso: ['Assert.assert-array', 'Assert.assert-collection'],
         hideOperatorForm: true,
     },
-    'assert-truthy': {
+    'assert-regexp': {
         category: 'Assert',
-        description: 'If $value is not `truthy` it throws `AssertionError`.',
+        description: 'If $value is not a `regexp` it throws `AssertionError`.',
         returns: {
             type: 'null',
         },
@@ -12123,23 +12660,15 @@ 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-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',
         ],
-        seeAlso: ['Assert.assert-falsy', 'Assert.assert-true', 'Assert.assert-false', 'Assert.assert', 'Assert.assert-null'],
+        seeAlso: ['Assert.assert-string'],
         hideOperatorForm: true,
     },
-    'assert-falsy': {
+    'assert-sequence': {
         category: 'Assert',
-        description: 'If $value is not `falsy` it throws `AssertionError`.',
+        description: 'If $value is not a `sequence` (array or string) it throws `AssertionError`.',
         returns: {
             type: 'null',
         },
@@ -12165,22 +12694,16 @@ 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-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',
         ],
-        seeAlso: ['Assert.assert-truthy', 'Assert.assert-false', 'Assert.assert-true', 'Assert.assert-null'],
+        seeAlso: ['Assert.assert-collection', 'Assert.assert-array'],
         hideOperatorForm: true,
     },
-    'assert-null': {
+    'assert-string': {
         category: 'Assert',
-        description: 'If $value is not `null` it throws `AssertionError`.',
+        description: 'If $value is not a `string` it throws `AssertionError`.',
         returns: {
             type: 'null',
         },
@@ -12206,129 +12729,48 @@ 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-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',
         ],
-        seeAlso: ['Assert.assert-truthy', 'Assert.assert-falsy'],
+        seeAlso: ['Assert.assert-number', 'Assert.assert-boolean', 'Assert.assert-regexp', 'Assert.assert-function'],
         hideOperatorForm: true,
     },
-    'assert-throws': {
+    'assert-vector': {
         category: 'Assert',
-        description: 'If $fun does not throw, it throws `AssertionError`.',
+        description: 'If $value is not a `vector` it throws `AssertionError`.',
         returns: {
             type: 'null',
         },
         args: {
-            fun: {
-                type: 'function',
+            value: {
+                type: 'any',
             },
             message: {
                 type: 'string',
             },
         },
-        variants: [
-            {
-                argumentNames: [
-                    'fun',
-                ],
-            },
-            {
-                argumentNames: [
-                    'fun',
-                    'message',
-                ],
-            },
-        ],
-        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',
-        ],
-        seeAlso: ['Assert.assert-throws-error', 'Assert.assert-not-throws'],
-        hideOperatorForm: true,
-    },
-    'assert-throws-error': {
-        category: 'Assert',
-        description: 'If $fun does not throw $error-message, it throws `AssertionError`.',
-        returns: {
-            type: 'null',
-        },
-        args: {
-            'fun': {
-                type: 'function',
-            },
-            'error-message': {
-                type: 'string',
-            },
-            'message': {
-                type: 'string',
-            },
-        },
         variants: [
             {
                 argumentNames: [
                     'value',
-                    'error-message',
                 ],
             },
             {
                 argumentNames: [
                     'value',
-                    'error-message',
-                    'message',
-                ],
-            },
-        ],
-        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',
-        ],
-        seeAlso: ['Assert.assert-throws', 'Assert.assert-not-throws'],
-        hideOperatorForm: true,
-    },
-    'assert-not-throws': {
-        category: 'Assert',
-        description: 'If $fun throws, it throws `AssertionError`.',
-        returns: {
-            type: 'null',
-        },
-        args: {
-            fun: {
-                type: 'function',
-            },
-            message: {
-                type: 'string',
-            },
-        },
-        variants: [
-            {
-                argumentNames: [
-                    'fun',
-                ],
-            },
-            {
-                argumentNames: [
-                    'fun',
                     'message',
                 ],
             },
         ],
         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-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',
         ],
-        seeAlso: ['Assert.assert-throws', 'Assert.assert-throws-error'],
+        seeAlso: ['Assert.assert-matrix', 'Assert.assert-grid'],
         hideOperatorForm: true,
     },
 };
 
-// TODO, remove some, add some. E.g. type guards, assert-number, assert-string, etc.
 const assertNormalExpression = {
     'assert': {
         evaluate: (params, sourceCodeInfo) => {
@@ -12553,6 +12995,175 @@ const assertNormalExpression = {
         },
         arity: { min: 1, max: 2 },
     },
+    'assert-array': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!Array.isArray(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be an array.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-boolean': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (typeof first !== 'boolean')
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a boolean.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-collection': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isColl(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a collection.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-function': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isLitsFunction(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a function.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-grid': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isGrid(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a grid.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-integer': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (typeof first !== 'number' || !isNumber(first, { integer: true }))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be an integer.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-matrix': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isMatrix(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a matrix.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-number': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (typeof first !== 'number')
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a number.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-object': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isObj(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be an object.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-regexp': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isRegularExpression(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a regexp.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-sequence': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isSeq(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a sequence.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-string': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (typeof first !== 'string')
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a string.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
+    'assert-vector': {
+        evaluate: ([first, message], sourceCodeInfo) => {
+            if (message !== undefined) {
+                assertString(message, sourceCodeInfo);
+                message = ` ${message}`;
+            }
+            message ??= '';
+            if (!isVector(first))
+                throw new AssertionError(`Expected ${JSON.stringify(first)} to be a vector.${message}`, sourceCodeInfo);
+            return null;
+        },
+        arity: { min: 1, max: 2 },
+    },
 };
 for (const [key, docs] of Object.entries(moduleDocs$6)) {
     if (assertNormalExpression[key])
@@ -31853,7 +32464,7 @@ function stringifyValue(value, html) {
     const lt = '<';
     if (isLitsFunction(value)) {
         if (value.functionType === 'Builtin')
-            return `${lt}builtin function ${value.normalBuitinSymbolType}${gt}`;
+            return `${lt}builtin function ${value.normalBuiltinSymbolType}${gt}`;
         else
             return `${lt}function ${value.n ?? '\u03BB'}${gt}`;
     }
@@ -32303,8 +32914,8 @@ const api = {
         'integer?',
         'array?',
         'object?',
-        'coll?',
-        'seq?',
+        'collection?',
+        'sequence?',
         'regexp?',
         'zero?',
         'pos?',
@@ -32366,7 +32977,6 @@ const api = {
         'bit-set',
         'bit-test',
     ],
-    // TODO, remove some, add some. E.g. type guards, assert-number, assert-string, etc.
     assert: [
         'Assert.assert',
         'Assert.assert=',
@@ -32383,6 +32993,19 @@ const api = {
         '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',
     ],
     grid: [
         'Grid.every?',
@@ -32990,8 +33613,6 @@ function getCliFunctionExamples(fmt, reference) {
         .map((example) => {
         const oldLog = console.log;
         console.log = function () { };
-        const oldWarn = console.warn;
-        console.warn = function () { };
         let result;
         try {
             result = lits$1.run(`(try (do ${example}) (catch e e))`);
@@ -33002,7 +33623,6 @@ ${fmt.gray(stringifiedResult)}`;
         }
         finally {
             console.log = oldLog;
-            console.warn = oldWarn;
         }
     })
         .join('\n\n');