@mojir/lits 2.1.8 → 2.1.10

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.8";
+var version = "2.1.10";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -824,7 +824,7 @@ function deepEqual(a, b, sourceCodeInfo) {
     if (a === b)
         return true;
     if (typeof a === 'number' && typeof b === 'number')
-        return Math.abs(a - b) < Number.EPSILON;
+        return Math.abs(a - b) < 1e-10;
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length)
             return false;
@@ -843,7 +843,7 @@ function deepEqual(a, b, sourceCodeInfo) {
             return false;
         for (var i = 0; i < aKeys.length; i += 1) {
             var key = asString(aKeys[i], sourceCodeInfo);
-            if (!deepEqual(toAny(a[key]), toAny(b[key]), sourceCodeInfo))
+            if (!deepEqual(a[key], b[key], sourceCodeInfo))
                 return false;
         }
         return true;
@@ -2308,6 +2308,28 @@ function assertVector(vector, sourceCodeInfo) {
         throw new LitsError("Expected a vector, but got ".concat(vector), sourceCodeInfo);
     }
 }
+function is2dVector(vector) {
+    if (!isVector(vector)) {
+        return false;
+    }
+    return vector.length === 2;
+}
+function assert2dVector(vector, sourceCodeInfo) {
+    if (!is2dVector(vector)) {
+        throw new LitsError("Expected a 2d vector, but got ".concat(vector), sourceCodeInfo);
+    }
+}
+function is3dVector(vector) {
+    if (!isVector(vector)) {
+        return false;
+    }
+    return vector.length === 3;
+}
+function assert3dVector(vector, sourceCodeInfo) {
+    if (!is3dVector(vector)) {
+        throw new LitsError("Expected a 3d vector, but got ".concat(vector), sourceCodeInfo);
+    }
+}
 function assertNonEmptyVector(vector, sourceCodeInfo) {
     assertVector(vector, sourceCodeInfo);
     if (vector.length === 0) {
@@ -4688,6 +4710,24 @@ var gridNormalExpression = {
         },
         paramCount: 1,
     },
+    'grid:fill': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), rows = _b[0], cols = _b[1], value = _b[2];
+            assertNumber(rows, sourceCodeInfo, { integer: true, positive: true });
+            assertNumber(cols, sourceCodeInfo, { integer: true, positive: true });
+            assertAny(value, sourceCodeInfo);
+            var result = [];
+            for (var i = 0; i < rows; i += 1) {
+                var row = [];
+                for (var j = 0; j < cols; j += 1) {
+                    row.push(value);
+                }
+                result.push(row);
+            }
+            return result;
+        },
+        paramCount: 3,
+    },
     'grid:generate': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), rows = _c[0], cols = _c[1], generator = _c[2];
@@ -6632,7 +6672,137 @@ function extractOverlappingSegments(vectorA, vectorB, lag) {
     return [segmentA, segmentB];
 }
 
+function getUnit(value, sourceCodeInfo) {
+    if (value.length === 0) {
+        return value;
+    }
+    var length = Math.sqrt(value.reduce(function (acc, item) { return acc + Math.pow(item, 2); }, 0));
+    if (approxZero(length)) {
+        throw new LitsError('The vector must not be zero', sourceCodeInfo);
+    }
+    return value.map(function (item) { return item / length; });
+}
+
+function dot(vector1, vector2) {
+    return vector1.reduce(function (acc, item, index) { return acc + item * vector2[index]; }, 0);
+}
+
+function subtract(vector1, vector2) {
+    return vector1.map(function (item, index) { return item - vector2[index]; });
+}
+
+function scale(vector, scalar) {
+    return vector.map(function (item) { return item * scalar; });
+}
+
 var linearAlgebraNormalExpression = {
+    'lin:rotate2d': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), vector = _b[0], radians = _b[1];
+            assert2dVector(vector, sourceCodeInfo);
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            assertNumber(radians, sourceCodeInfo, { finite: true });
+            var cosTheta = Math.cos(radians);
+            var sinTheta = Math.sin(radians);
+            return [
+                vector[0] * cosTheta - vector[1] * sinTheta,
+                vector[0] * sinTheta + vector[1] * cosTheta,
+            ];
+        },
+        paramCount: 2,
+    },
+    'lin:rotate3d': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vector = _b[0], axis = _b[1], radians = _b[2];
+            assert3dVector(vector, sourceCodeInfo);
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            assertNumber(radians, sourceCodeInfo, { finite: true });
+            assert3dVector(axis, sourceCodeInfo);
+            if (isZeroVector(axis)) {
+                throw new LitsError('Rotation axis must not be zero', sourceCodeInfo);
+            }
+            var cosTheta = Math.cos(radians);
+            var sinTheta = Math.sin(radians);
+            var _c = __read(getUnit(axis, sourceCodeInfo), 3), u = _c[0], v = _c[1], w = _c[2];
+            var dotProduct = vector[0] * u + vector[1] * v + vector[2] * w;
+            return [
+                dotProduct * u * (1 - cosTheta) + vector[0] * cosTheta + (-w * vector[1] + v * vector[2]) * sinTheta,
+                dotProduct * v * (1 - cosTheta) + vector[1] * cosTheta + (w * vector[0] - u * vector[2]) * sinTheta,
+                dotProduct * w * (1 - cosTheta) + vector[2] * cosTheta + (-v * vector[0] + u * vector[1]) * sinTheta,
+            ];
+        },
+        paramCount: 3,
+    },
+    'lin:reflect': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 2), vector = _b[0], normal = _b[1];
+            assertVector(vector, sourceCodeInfo);
+            assertVector(normal, sourceCodeInfo);
+            if (vector.length !== normal.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            if (isZeroVector(normal)) {
+                throw new LitsError('Reflection normal must not be zero', sourceCodeInfo);
+            }
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            var unitNormal = getUnit(normal, sourceCodeInfo);
+            var doubleDot = 2 * dot(vector, unitNormal);
+            return subtract(vector, scale(unitNormal, doubleDot));
+        },
+        paramCount: 2,
+    },
+    'lin:refract': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vector = _b[0], normal = _b[1], eta = _b[2];
+            assertVector(vector, sourceCodeInfo);
+            assertVector(normal, sourceCodeInfo);
+            assertNumber(eta, sourceCodeInfo, { finite: true, positive: true });
+            if (vector.length !== normal.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            if (isZeroVector(normal)) {
+                throw new LitsError('Refraction normal must not be zero', sourceCodeInfo);
+            }
+            if (isZeroVector(vector)) {
+                return vector;
+            }
+            // Make sure vectors are normalized
+            var normalizedV = getUnit(vector, sourceCodeInfo);
+            var normalizedNormal = getUnit(normal, sourceCodeInfo);
+            // Calculate dot product between incident vector and normal
+            var dotProduct = dot(normalizedV, normalizedNormal);
+            // Calculate discriminant
+            var discriminant = 1 - eta * eta * (1 - dotProduct * dotProduct);
+            // Check for total internal reflection
+            if (discriminant < 0) {
+                return vector; // Total internal reflection occurs
+            }
+            // Calculate the refracted vector
+            var scaledIncident = scale(normalizedV, eta);
+            var scaledNormal = scale(normalizedNormal, eta * dotProduct + Math.sqrt(discriminant));
+            return subtract(scaledIncident, scaledNormal);
+        },
+        paramCount: 3,
+    },
+    'lin:lerp': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 3), vectorA = _b[0], vectorB = _b[1], t = _b[2];
+            assertVector(vectorA, sourceCodeInfo);
+            assertVector(vectorB, sourceCodeInfo);
+            assertNumber(t, sourceCodeInfo, { finite: true });
+            if (vectorA.length !== vectorB.length) {
+                throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
+            }
+            return vectorA.map(function (val, i) { return val + (vectorB[i] - val) * t; });
+        },
+        paramCount: 3,
+    },
     'lin:dot': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), vectorA = _b[0], vectorB = _b[1];
@@ -6641,7 +6811,7 @@ var linearAlgebraNormalExpression = {
             if (vectorA.length !== vectorB.length) {
                 throw new LitsError('Vectors must be of the same length', sourceCodeInfo);
             }
-            return vectorA.reduce(function (acc, val, i) { return acc + val * vectorB[i]; }, 0);
+            return dot(vectorA, vectorB);
         },
         paramCount: 2,
     },
@@ -6722,16 +6892,10 @@ var linearAlgebraNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), vector = _b[0];
             assertVector(vector, sourceCodeInfo);
-            if (vector.length === 0) {
-                return [];
-            }
-            var norm = Math.sqrt(vector.reduce(function (acc, val) { return acc + Math.pow(val, 2); }, 0));
-            if (norm === 0) {
-                return vector.map(function () { return 0; });
-            }
-            return vector.map(function (val) { return val / norm; });
+            return getUnit(vector, sourceCodeInfo);
         },
         paramCount: 1,
+        aliases: ['lin:unit', 'lin:normalize'],
     },
     'lin:normalize-log': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -6858,7 +7022,7 @@ var linearAlgebraNormalExpression = {
             return Math.sqrt(vector.reduce(function (acc, val) { return acc + val * val; }, 0));
         },
         paramCount: 1,
-        aliases: ['lin:l2-norm', 'lin:magnitude'],
+        aliases: ['lin:l2-norm', 'lin:length'],
     },
     'lin:manhattan-distance': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -12328,6 +12492,7 @@ function evaluateReservedSymbol(node) {
     return asNonUndefined(value, node[2]);
 }
 function evaluateNormalExpression(node, contextStack) {
+    var _a, _b;
     var sourceCodeInfo = node[2];
     var paramNodes = node[1][1];
     var params = [];
@@ -12353,14 +12518,14 @@ function evaluateNormalExpression(node, contextStack) {
         var nameSymbol = node[1][0];
         if (placeholders.length > 0) {
             var fn = evaluateNode(nameSymbol, contextStack);
-            var partialFunction = {
-                '^^fn^^': true,
-                'function': asFunctionLike(fn, sourceCodeInfo),
-                'functionType': 'Partial',
-                params: params,
-                placeholders: placeholders,
-                sourceCodeInfo: sourceCodeInfo,
-            };
+            var partialFunction = (_a = {},
+                _a[FUNCTION_SYMBOL] = true,
+                _a.function = asFunctionLike(fn, sourceCodeInfo),
+                _a.functionType = 'Partial',
+                _a.params = params,
+                _a.placeholders = placeholders,
+                _a.sourceCodeInfo = sourceCodeInfo,
+                _a);
             return partialFunction;
         }
         if (isNormalBuiltinSymbolNode(nameSymbol)) {
@@ -12380,14 +12545,14 @@ function evaluateNormalExpression(node, contextStack) {
         var fnNode = node[1][0];
         var fn = asFunctionLike(evaluateNode(fnNode, contextStack), sourceCodeInfo);
         if (placeholders.length > 0) {
-            var partialFunction = {
-                '^^fn^^': true,
-                'function': asFunctionLike(fn, sourceCodeInfo),
-                'functionType': 'Partial',
-                params: params,
-                placeholders: placeholders,
-                sourceCodeInfo: sourceCodeInfo,
-            };
+            var partialFunction = (_b = {},
+                _b[FUNCTION_SYMBOL] = true,
+                _b.function = asFunctionLike(fn, sourceCodeInfo),
+                _b.functionType = 'Partial',
+                _b.params = params,
+                _b.placeholders = placeholders,
+                _b.sourceCodeInfo = sourceCodeInfo,
+                _b);
             return partialFunction;
         }
         return executeFunction(fn, params, contextStack, sourceCodeInfo);
@@ -15104,6 +15269,7 @@ var api = {
         'grid:row',
         'grid:col',
         'grid:shape',
+        'grid:fill',
         'grid:generate',
         'grid:reshape',
         'grid:transpose',
@@ -15195,6 +15361,11 @@ var api = {
         'vec:smape'
     ], __read(getVectorReductionNames('mean')), false), __read(getVectorReductionNames('median')), false), __read(getVectorReductionNames('variance')), false), __read(getVectorReductionNames('sample-variance')), false), __read(getVectorReductionNames('sum')), false), __read(getVectorReductionNames('prod')), false), __read(getVectorReductionNames('min')), false), __read(getVectorReductionNames('max')), false), __read(getVectorReductionNames('stdev')), false), __read(getVectorReductionNames('sample-stdev')), false), __read(getVectorReductionNames('iqr')), false), __read(getVectorReductionNames('span')), false), __read(getVectorReductionNames('geometric-mean')), false), __read(getVectorReductionNames('harmonic-mean')), false), __read(getVectorReductionNames('skewness')), false), __read(getVectorReductionNames('sample-skewness')), false), __read(getVectorReductionNames('kurtosis')), false), __read(getVectorReductionNames('sample-kurtosis')), false), __read(getVectorReductionNames('excess-kurtosis')), false), __read(getVectorReductionNames('sample-excess-kurtosis')), false), __read(getVectorReductionNames('rms')), false), __read(getVectorReductionNames('mad')), false), __read(getVectorReductionNames('medad')), false), __read(getVectorReductionNames('gini-coefficient')), false), __read(getVectorReductionNames('entropy')), false), __read(getVectorReductionNames('skewness')), false),
     linAlg: [
+        'lin:reflect',
+        'lin:refract',
+        'lin:lerp',
+        'lin:rotate2d',
+        'lin:rotate3d',
         'lin:dot',
         'lin:cross',
         'lin:normalize-minmax',
@@ -19044,6 +19215,36 @@ var gridReference = {
             "grid:shape(".concat(exampleGrid3, ")"),
         ],
     },
+    'grid:fill': {
+        title: 'grid:fill',
+        category: 'Grid',
+        linkName: 'grid-colon-fill',
+        returns: {
+            type: 'grid',
+        },
+        args: {
+            rows: {
+                type: 'integer',
+                description: 'The number of rows in the grid.',
+            },
+            cols: {
+                type: 'integer',
+                description: 'The number of columns in the grid.',
+            },
+            value: {
+                type: 'any',
+                description: 'The value to fill the grid with.',
+            },
+        },
+        variants: [
+            { argumentNames: ['rows', 'cols', 'value'] },
+        ],
+        description: 'Creates a grid of the specified size, filled with the specified value.',
+        examples: [
+            'grid:fill(2, 3, 0)',
+            'grid:fill(2, 3, "x")',
+        ],
+    },
     'grid:generate': {
         title: 'grid:generate',
         category: 'Grid',
@@ -23266,6 +23467,150 @@ var vectorReference = __assign(__assign(__assign(__assign(__assign(__assign(__as
     } });
 
 var linAlgReference = {
+    'lin:reflect': {
+        title: 'lin:reflect',
+        category: 'Linear Algebra',
+        description: 'Reflects a vector across a given axis.',
+        linkName: 'lin-colon-reflect',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            a: {
+                type: 'vector',
+                description: 'Vector to reflect.',
+            },
+            b: {
+                type: 'vector',
+                description: 'Axis of reflection.',
+            },
+        },
+        variants: [
+            { argumentNames: ['a', 'b'] },
+        ],
+        examples: [
+            'lin:reflect([1, 2], [0, 1])',
+            'lin:reflect([1, 2, 3], [0, 0, 1])',
+        ],
+    },
+    'lin:refract': {
+        title: 'lin:refract',
+        category: 'Linear Algebra',
+        description: 'Refracts a vector across a given axis.',
+        linkName: 'lin-colon-refract',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            vector: {
+                type: 'vector',
+                description: 'Vector to refract.',
+            },
+            axis: {
+                type: 'vector',
+                description: 'Axis of refraction.',
+            },
+            eta: {
+                type: 'number',
+                description: 'Refraction index.',
+            },
+        },
+        variants: [
+            { argumentNames: ['vector', 'axis', 'eta'] },
+        ],
+        examples: [
+            'lin:refract([1, 2], [0, 1], 1.5)',
+            'lin:refract([1, 2, 3], [0, 0, 1], 1.5)',
+        ],
+    },
+    'lin:lerp': {
+        title: 'lin:lerp',
+        category: 'Linear Algebra',
+        description: 'Performs linear interpolation between two vectors.',
+        linkName: 'lin-colon-lerp',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            a: {
+                type: 'vector',
+                description: 'Start vector.',
+            },
+            b: {
+                type: 'vector',
+                description: 'End vector.',
+            },
+            t: {
+                type: 'number',
+                description: 'Interpolation factor (0 to 1).',
+            },
+        },
+        variants: [
+            { argumentNames: ['a', 'b', 't'] },
+        ],
+        examples: [
+            'lin:lerp([1, 2], [3, 4], 0.5)',
+            'lin:lerp([1, 2], [3, 4], 2)',
+            'lin:lerp([1, 2], [3, 4], -1)',
+            'lin:lerp([1, 2, 3], [4, 5, 6], 0.25)',
+        ],
+    },
+    'lin:rotate2d': {
+        title: 'lin:rotate2d',
+        category: 'Linear Algebra',
+        description: 'Rotates a 2D vector by a given angle in radians.',
+        linkName: 'lin-colon-rotate2d',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            a: {
+                type: 'vector',
+                description: 'Vector to rotate.',
+            },
+            b: {
+                type: 'number',
+                description: 'Angle in b.',
+            },
+        },
+        variants: [
+            { argumentNames: ['a', 'b'] },
+        ],
+        examples: [
+            'lin:rotate2d([1, 0], PI / 2)',
+            'lin:rotate2d([0, 1], PI)',
+        ],
+    },
+    'lin:rotate3d': {
+        title: 'lin:rotate3d',
+        category: 'Linear Algebra',
+        description: 'Rotates a 3D vector around a given axis by a given angle in radians.',
+        linkName: 'lin-colon-rotate3d',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            v: {
+                type: 'vector',
+                description: 'Vector to rotate.',
+            },
+            axis: {
+                type: 'vector',
+                description: 'Axis of rotation.',
+            },
+            radians: {
+                type: 'number',
+                description: 'Angle in radians.',
+            },
+        },
+        variants: [
+            { argumentNames: ['v', 'axis', 'radians'] },
+        ],
+        examples: [
+            'lin:rotate3d([1, 0, 0], [0, 1, 0], PI / 2)',
+            'lin:rotate3d([0, 1, 0], [1, 0, 0], PI)',
+        ],
+    },
     'lin:dot': {
         title: 'lin:dot',
         category: 'Linear Algebra',
@@ -23440,11 +23785,16 @@ var linAlgReference = {
         ],
         examples: [
             'lin:normalize-l2([1, 2, 3])',
+            'lin:unit([1, 2, 3])',
             'lin:normalize-l2([1, 2, -3])',
             'lin:normalize-l2([1, 2, 3, 4])',
             'lin:normalize-l2([1, 2, -3, 4])',
             'lin:normalize-l2([1, 2, 3, 40, 50])',
         ],
+        aliases: [
+            'lin:unit',
+            'lin:normalize',
+        ],
     },
     'lin:normalize-log': {
         title: 'lin:normalize-log',
@@ -23622,7 +23972,7 @@ var linAlgReference = {
         ],
         aliases: [
             'lin:l2-norm',
-            'lin:magnitude',
+            'lin:length',
         ],
     },
     'lin:manhattan-distance': {

package/dist/cli/reference/api.d.ts

@@ -12,10 +12,10 @@ export declare const api: {
     readonly string: readonly ["string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?"];
     readonly bitwise: readonly ["<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
     readonly assert: readonly ["assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws"];
-    readonly grid: readonly ["grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array"];
+    readonly grid: readonly ["grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:fill", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array"];
     readonly matrix: readonly ["mat:mul", "mat:det", "mat:inv", "mat:adj", "mat:cofactor", "mat:minor", "mat:trace", "mat:symmetric?", "mat:triangular?", "mat:upper-triangular?", "mat:lower-triangular?", "mat:diagonal?", "mat:square?", "mat:orthogonal?", "mat:identity?", "mat:invertible?", "mat:hilbert", "mat:vandermonde", "mat:band", "mat:banded?", "mat:rank", "mat:frobenius-norm", "mat:1-norm", "mat:inf-norm", "mat:max-norm"];
     readonly vector: readonly ["vec:monotonic?", "vec:strictly-monotonic?", "vec:increasing?", "vec:decreasing?", "vec:strictly-increasing?", "vec:strictly-decreasing?", "vec:median", "vec:mode", "vec:min-index", "vec:max-index", "vec:sort-indices", "vec:count-values", "vec:linspace", "vec:ones", "vec:zeros", "vec:fill", "vec:generate", "vec:cumsum", "vec:cumprod", "vec:quartiles", "vec:percentile", "vec:quantile", "vec:histogram", "vec:ecdf", "vec:outliers?", "vec:outliers", "vec:bincount", "vec:winsorize", "vec:mse", "vec:mae", "vec:rmse", "vec:smape", "vec:mean", "vec:moving-mean", "vec:centered-moving-mean", "vec:running-mean", "vec:median", "vec:moving-median", "vec:centered-moving-median", "vec:running-median", "vec:variance", "vec:moving-variance", "vec:centered-moving-variance", "vec:running-variance", "vec:sample-variance", "vec:moving-sample-variance", "vec:centered-moving-sample-variance", "vec:running-sample-variance", "vec:sum", "vec:moving-sum", "vec:centered-moving-sum", "vec:running-sum", "vec:prod", "vec:moving-prod", "vec:centered-moving-prod", "vec:running-prod", "vec:min", "vec:moving-min", "vec:centered-moving-min", "vec:running-min", "vec:max", "vec:moving-max", "vec:centered-moving-max", "vec:running-max", "vec:stdev", "vec:moving-stdev", "vec:centered-moving-stdev", "vec:running-stdev", "vec:sample-stdev", "vec:moving-sample-stdev", "vec:centered-moving-sample-stdev", "vec:running-sample-stdev", "vec:iqr", "vec:moving-iqr", "vec:centered-moving-iqr", "vec:running-iqr", "vec:span", "vec:moving-span", "vec:centered-moving-span", "vec:running-span", "vec:geometric-mean", "vec:moving-geometric-mean", "vec:centered-moving-geometric-mean", "vec:running-geometric-mean", "vec:harmonic-mean", "vec:moving-harmonic-mean", "vec:centered-moving-harmonic-mean", "vec:running-harmonic-mean", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "vec:sample-skewness", "vec:moving-sample-skewness", "vec:centered-moving-sample-skewness", "vec:running-sample-skewness", "vec:kurtosis", "vec:moving-kurtosis", "vec:centered-moving-kurtosis", "vec:running-kurtosis", "vec:sample-kurtosis", "vec:moving-sample-kurtosis", "vec:centered-moving-sample-kurtosis", "vec:running-sample-kurtosis", "vec:excess-kurtosis", "vec:moving-excess-kurtosis", "vec:centered-moving-excess-kurtosis", "vec:running-excess-kurtosis", "vec:sample-excess-kurtosis", "vec:moving-sample-excess-kurtosis", "vec:centered-moving-sample-excess-kurtosis", "vec:running-sample-excess-kurtosis", "vec:rms", "vec:moving-rms", "vec:centered-moving-rms", "vec:running-rms", "vec:mad", "vec:moving-mad", "vec:centered-moving-mad", "vec:running-mad", "vec:medad", "vec:moving-medad", "vec:centered-moving-medad", "vec:running-medad", "vec:gini-coefficient", "vec:moving-gini-coefficient", "vec:centered-moving-gini-coefficient", "vec:running-gini-coefficient", "vec:entropy", "vec:moving-entropy", "vec:centered-moving-entropy", "vec:running-entropy", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness"];
-    readonly linAlg: readonly ["lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve"];
+    readonly linAlg: readonly ["lin:reflect", "lin:refract", "lin:lerp", "lin:rotate2d", "lin:rotate3d", "lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve"];
     readonly numberTheory: readonly ["nth:abundant-seq", "nth:abundant-nth", "nth:abundant-take-while", "nth:abundant?", "nth:bell-seq", "nth:bell-nth", "nth:bell-take-while", "nth:bell?", "nth:catalan-seq", "nth:catalan-nth", "nth:catalan-take-while", "nth:catalan?", "nth:composite-seq", "nth:composite-nth", "nth:composite-take-while", "nth:composite?", "nth:factorial-seq", "nth:factorial-nth", "nth:factorial-take-while", "nth:factorial?", "nth:fibonacci-seq", "nth:fibonacci-nth", "nth:fibonacci-take-while", "nth:fibonacci?", "nth:geometric-seq", "nth:geometric-nth", "nth:geometric-take-while", "nth:geometric?", "nth:golomb-seq", "nth:golomb-nth", "nth:golomb-take-while", "nth:golomb?", "nth:happy-seq", "nth:happy-nth", "nth:happy-take-while", "nth:happy?", "nth:look-and-say-seq", "nth:look-and-say-nth", "nth:look-and-say-take-while", "nth:look-and-say?", "nth:lucas-seq", "nth:lucas-nth", "nth:lucas-take-while", "nth:lucas?", "nth:lucky-seq", "nth:lucky-nth", "nth:lucky-take-while", "nth:lucky?", "nth:mersenne-seq", "nth:mersenne-nth", "nth:mersenne-take-while", "nth:mersenne?", "nth:padovan-seq", "nth:padovan-nth", "nth:padovan-take-while", "nth:padovan?", "nth:partition-seq", "nth:partition-nth", "nth:partition-take-while", "nth:partition?", "nth:pell-seq", "nth:pell-nth", "nth:pell-take-while", "nth:pell?", "nth:perfect-seq", "nth:perfect-nth", "nth:perfect-take-while", "nth:perfect?", "nth:perfect-cube-seq", "nth:perfect-cube-nth", "nth:perfect-cube-take-while", "nth:perfect-cube?", "nth:perfect-power-seq", "nth:perfect-power-nth", "nth:perfect-power-take-while", "nth:perfect-power?", "nth:perfect-square-seq", "nth:perfect-square-nth", "nth:perfect-square-take-while", "nth:perfect-square?", "nth:polygonal-seq", "nth:polygonal-nth", "nth:polygonal-take-while", "nth:polygonal?", "nth:prime-seq", "nth:prime-nth", "nth:prime-take-while", "nth:prime?", "nth:recaman-seq", "nth:recaman-nth", "nth:recaman-take-while", "nth:recaman?", "nth:sylvester-seq", "nth:sylvester-nth", "nth:sylvester-take-while", "nth:sylvester?", "nth:thue-morse-seq", "nth:thue-morse-nth", "nth:thue-morse-take-while", "nth:thue-morse?", "nth:tribonacci-seq", "nth:tribonacci-nth", "nth:tribonacci-take-while", "nth:tribonacci?", "nth:collatz-seq", "nth:juggler-seq", "nth:bernoulli-seq", "nth:bernoulli-take-while", "nth:bernoulli-nth", "nth:combinations", "nth:count-combinations", "nth:derangements", "nth:count-derangements", "nth:divisors", "nth:count-divisors", "nth:proper-divisors", "nth:count-proper-divisors", "nth:prime-factors", "nth:count-prime-factors", "nth:distinct-prime-factors", "nth:count-distinct-prime-factors", "nth:factorial", "nth:partitions", "nth:count-partitions", "nth:permutations", "nth:count-permutations", "nth:power-set", "nth:count-power-set", "nth:coprime?", "nth:divisible-by?", "nth:gcd", "nth:lcm", "nth:multinomial", "nth:amicable?", "nth:euler-totient", "nth:mobius", "nth:mertens", "nth:sigma", "nth:carmichael-lambda", "nth:cartesian-product", "nth:perfect-power", "nth:mod-exp", "nth:mod-inv", "nth:extended-gcd", "nth:chinese-remainder", "nth:stirling-first", "nth:stirling-second"];
     readonly random: readonly ["!:random", "!:random-int", "!:random-int-inclusive", "!:random-float", "!:random-boolean", "!:random-item", "!:random-sample", "!:random-sample-unique", "!:shuffle", "!:random-normal", "!:random-exponential", "!:random-binomial", "!:random-poisson", "!:random-gamma", "!:random-pareto", "!:uuid", "!:random-char", "!:random-string", "!:random-id", "!:random-color"];
     readonly shorthand: ["-short-regexp", "-short-fn"];
@@ -44,7 +44,7 @@ export type NormalExpressionName = CollectionApiName | ArrayApiName | SequenceAp
 export type FunctionName = NormalExpressionName | SpecialExpressionsApiName;
 export type ShorthandName = typeof api.shorthand[number];
 export type DatatypeName = typeof api.datatype[number];
-declare const apiNames: readonly ["filter", "map", "reduce", "reduce-right", "reductions", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "splice", "position", "index-of", "last-index-of", "some", "reverse", "first", "second", "last", "rest", "next", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "starts-with?", "ends-with?", "interleave", "interpose", "+", "-", "*", "/", "~", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "^", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "ln", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull", "≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify", "dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?", "regexp", "match", "replace", "replace-all", "string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?", "<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws", "mat:mul", "mat:det", "mat:inv", "mat:adj", "mat:cofactor", "mat:minor", "mat:trace", "mat:symmetric?", "mat:triangular?", "mat:upper-triangular?", "mat:lower-triangular?", "mat:diagonal?", "mat:square?", "mat:orthogonal?", "mat:identity?", "mat:invertible?", "mat:hilbert", "mat:vandermonde", "mat:band", "mat:banded?", "mat:rank", "mat:frobenius-norm", "mat:1-norm", "mat:inf-norm", "mat:max-norm", "vec:monotonic?", "vec:strictly-monotonic?", "vec:increasing?", "vec:decreasing?", "vec:strictly-increasing?", "vec:strictly-decreasing?", "vec:median", "vec:mode", "vec:min-index", "vec:max-index", "vec:sort-indices", "vec:count-values", "vec:linspace", "vec:ones", "vec:zeros", "vec:fill", "vec:generate", "vec:cumsum", "vec:cumprod", "vec:quartiles", "vec:percentile", "vec:quantile", "vec:histogram", "vec:ecdf", "vec:outliers?", "vec:outliers", "vec:bincount", "vec:winsorize", "vec:mse", "vec:mae", "vec:rmse", "vec:smape", "vec:mean", "vec:moving-mean", "vec:centered-moving-mean", "vec:running-mean", "vec:median", "vec:moving-median", "vec:centered-moving-median", "vec:running-median", "vec:variance", "vec:moving-variance", "vec:centered-moving-variance", "vec:running-variance", "vec:sample-variance", "vec:moving-sample-variance", "vec:centered-moving-sample-variance", "vec:running-sample-variance", "vec:sum", "vec:moving-sum", "vec:centered-moving-sum", "vec:running-sum", "vec:prod", "vec:moving-prod", "vec:centered-moving-prod", "vec:running-prod", "vec:min", "vec:moving-min", "vec:centered-moving-min", "vec:running-min", "vec:max", "vec:moving-max", "vec:centered-moving-max", "vec:running-max", "vec:stdev", "vec:moving-stdev", "vec:centered-moving-stdev", "vec:running-stdev", "vec:sample-stdev", "vec:moving-sample-stdev", "vec:centered-moving-sample-stdev", "vec:running-sample-stdev", "vec:iqr", "vec:moving-iqr", "vec:centered-moving-iqr", "vec:running-iqr", "vec:span", "vec:moving-span", "vec:centered-moving-span", "vec:running-span", "vec:geometric-mean", "vec:moving-geometric-mean", "vec:centered-moving-geometric-mean", "vec:running-geometric-mean", "vec:harmonic-mean", "vec:moving-harmonic-mean", "vec:centered-moving-harmonic-mean", "vec:running-harmonic-mean", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "vec:sample-skewness", "vec:moving-sample-skewness", "vec:centered-moving-sample-skewness", "vec:running-sample-skewness", "vec:kurtosis", "vec:moving-kurtosis", "vec:centered-moving-kurtosis", "vec:running-kurtosis", "vec:sample-kurtosis", "vec:moving-sample-kurtosis", "vec:centered-moving-sample-kurtosis", "vec:running-sample-kurtosis", "vec:excess-kurtosis", "vec:moving-excess-kurtosis", "vec:centered-moving-excess-kurtosis", "vec:running-excess-kurtosis", "vec:sample-excess-kurtosis", "vec:moving-sample-excess-kurtosis", "vec:centered-moving-sample-excess-kurtosis", "vec:running-sample-excess-kurtosis", "vec:rms", "vec:moving-rms", "vec:centered-moving-rms", "vec:running-rms", "vec:mad", "vec:moving-mad", "vec:centered-moving-mad", "vec:running-mad", "vec:medad", "vec:moving-medad", "vec:centered-moving-medad", "vec:running-medad", "vec:gini-coefficient", "vec:moving-gini-coefficient", "vec:centered-moving-gini-coefficient", "vec:running-gini-coefficient", "vec:entropy", "vec:moving-entropy", "vec:centered-moving-entropy", "vec:running-entropy", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve", "grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array", "nth:abundant-seq", "nth:abundant-nth", "nth:abundant-take-while", "nth:abundant?", "nth:bell-seq", "nth:bell-nth", "nth:bell-take-while", "nth:bell?", "nth:catalan-seq", "nth:catalan-nth", "nth:catalan-take-while", "nth:catalan?", "nth:composite-seq", "nth:composite-nth", "nth:composite-take-while", "nth:composite?", "nth:factorial-seq", "nth:factorial-nth", "nth:factorial-take-while", "nth:factorial?", "nth:fibonacci-seq", "nth:fibonacci-nth", "nth:fibonacci-take-while", "nth:fibonacci?", "nth:geometric-seq", "nth:geometric-nth", "nth:geometric-take-while", "nth:geometric?", "nth:golomb-seq", "nth:golomb-nth", "nth:golomb-take-while", "nth:golomb?", "nth:happy-seq", "nth:happy-nth", "nth:happy-take-while", "nth:happy?", "nth:look-and-say-seq", "nth:look-and-say-nth", "nth:look-and-say-take-while", "nth:look-and-say?", "nth:lucas-seq", "nth:lucas-nth", "nth:lucas-take-while", "nth:lucas?", "nth:lucky-seq", "nth:lucky-nth", "nth:lucky-take-while", "nth:lucky?", "nth:mersenne-seq", "nth:mersenne-nth", "nth:mersenne-take-while", "nth:mersenne?", "nth:padovan-seq", "nth:padovan-nth", "nth:padovan-take-while", "nth:padovan?", "nth:partition-seq", "nth:partition-nth", "nth:partition-take-while", "nth:partition?", "nth:pell-seq", "nth:pell-nth", "nth:pell-take-while", "nth:pell?", "nth:perfect-seq", "nth:perfect-nth", "nth:perfect-take-while", "nth:perfect?", "nth:perfect-cube-seq", "nth:perfect-cube-nth", "nth:perfect-cube-take-while", "nth:perfect-cube?", "nth:perfect-power-seq", "nth:perfect-power-nth", "nth:perfect-power-take-while", "nth:perfect-power?", "nth:perfect-square-seq", "nth:perfect-square-nth", "nth:perfect-square-take-while", "nth:perfect-square?", "nth:polygonal-seq", "nth:polygonal-nth", "nth:polygonal-take-while", "nth:polygonal?", "nth:prime-seq", "nth:prime-nth", "nth:prime-take-while", "nth:prime?", "nth:recaman-seq", "nth:recaman-nth", "nth:recaman-take-while", "nth:recaman?", "nth:sylvester-seq", "nth:sylvester-nth", "nth:sylvester-take-while", "nth:sylvester?", "nth:thue-morse-seq", "nth:thue-morse-nth", "nth:thue-morse-take-while", "nth:thue-morse?", "nth:tribonacci-seq", "nth:tribonacci-nth", "nth:tribonacci-take-while", "nth:tribonacci?", "nth:collatz-seq", "nth:juggler-seq", "nth:bernoulli-seq", "nth:bernoulli-take-while", "nth:bernoulli-nth", "nth:combinations", "nth:count-combinations", "nth:derangements", "nth:count-derangements", "nth:divisors", "nth:count-divisors", "nth:proper-divisors", "nth:count-proper-divisors", "nth:prime-factors", "nth:count-prime-factors", "nth:distinct-prime-factors", "nth:count-distinct-prime-factors", "nth:factorial", "nth:partitions", "nth:count-partitions", "nth:permutations", "nth:count-permutations", "nth:power-set", "nth:count-power-set", "nth:coprime?", "nth:divisible-by?", "nth:gcd", "nth:lcm", "nth:multinomial", "nth:amicable?", "nth:euler-totient", "nth:mobius", "nth:mertens", "nth:sigma", "nth:carmichael-lambda", "nth:cartesian-product", "nth:perfect-power", "nth:mod-exp", "nth:mod-inv", "nth:extended-gcd", "nth:chinese-remainder", "nth:stirling-first", "nth:stirling-second", "!:random", "!:random-int", "!:random-int-inclusive", "!:random-float", "!:random-boolean", "!:random-item", "!:random-sample", "!:random-sample-unique", "!:shuffle", "!:random-normal", "!:random-exponential", "!:random-binomial", "!:random-poisson", "!:random-gamma", "!:random-pareto", "!:uuid", "!:random-char", "!:random-string", "!:random-id", "!:random-color", "-short-regexp", "-short-fn", "-type-number", "-type-string", "-type-object", "-type-array", "-type-vector", "-type-matrix", "-type-grid", "-type-boolean", "-type-function", "-type-integer", "-type-any", "-type-null", "-type-collection", "-type-sequence", "-type-regexp", "-type-never"];
+declare const apiNames: readonly ["filter", "map", "reduce", "reduce-right", "reductions", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "splice", "position", "index-of", "last-index-of", "some", "reverse", "first", "second", "last", "rest", "next", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "starts-with?", "ends-with?", "interleave", "interpose", "+", "-", "*", "/", "~", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "^", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "ln", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull", "≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify", "dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?", "regexp", "match", "replace", "replace-all", "string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?", "<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws", "mat:mul", "mat:det", "mat:inv", "mat:adj", "mat:cofactor", "mat:minor", "mat:trace", "mat:symmetric?", "mat:triangular?", "mat:upper-triangular?", "mat:lower-triangular?", "mat:diagonal?", "mat:square?", "mat:orthogonal?", "mat:identity?", "mat:invertible?", "mat:hilbert", "mat:vandermonde", "mat:band", "mat:banded?", "mat:rank", "mat:frobenius-norm", "mat:1-norm", "mat:inf-norm", "mat:max-norm", "vec:monotonic?", "vec:strictly-monotonic?", "vec:increasing?", "vec:decreasing?", "vec:strictly-increasing?", "vec:strictly-decreasing?", "vec:median", "vec:mode", "vec:min-index", "vec:max-index", "vec:sort-indices", "vec:count-values", "vec:linspace", "vec:ones", "vec:zeros", "vec:fill", "vec:generate", "vec:cumsum", "vec:cumprod", "vec:quartiles", "vec:percentile", "vec:quantile", "vec:histogram", "vec:ecdf", "vec:outliers?", "vec:outliers", "vec:bincount", "vec:winsorize", "vec:mse", "vec:mae", "vec:rmse", "vec:smape", "vec:mean", "vec:moving-mean", "vec:centered-moving-mean", "vec:running-mean", "vec:median", "vec:moving-median", "vec:centered-moving-median", "vec:running-median", "vec:variance", "vec:moving-variance", "vec:centered-moving-variance", "vec:running-variance", "vec:sample-variance", "vec:moving-sample-variance", "vec:centered-moving-sample-variance", "vec:running-sample-variance", "vec:sum", "vec:moving-sum", "vec:centered-moving-sum", "vec:running-sum", "vec:prod", "vec:moving-prod", "vec:centered-moving-prod", "vec:running-prod", "vec:min", "vec:moving-min", "vec:centered-moving-min", "vec:running-min", "vec:max", "vec:moving-max", "vec:centered-moving-max", "vec:running-max", "vec:stdev", "vec:moving-stdev", "vec:centered-moving-stdev", "vec:running-stdev", "vec:sample-stdev", "vec:moving-sample-stdev", "vec:centered-moving-sample-stdev", "vec:running-sample-stdev", "vec:iqr", "vec:moving-iqr", "vec:centered-moving-iqr", "vec:running-iqr", "vec:span", "vec:moving-span", "vec:centered-moving-span", "vec:running-span", "vec:geometric-mean", "vec:moving-geometric-mean", "vec:centered-moving-geometric-mean", "vec:running-geometric-mean", "vec:harmonic-mean", "vec:moving-harmonic-mean", "vec:centered-moving-harmonic-mean", "vec:running-harmonic-mean", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "vec:sample-skewness", "vec:moving-sample-skewness", "vec:centered-moving-sample-skewness", "vec:running-sample-skewness", "vec:kurtosis", "vec:moving-kurtosis", "vec:centered-moving-kurtosis", "vec:running-kurtosis", "vec:sample-kurtosis", "vec:moving-sample-kurtosis", "vec:centered-moving-sample-kurtosis", "vec:running-sample-kurtosis", "vec:excess-kurtosis", "vec:moving-excess-kurtosis", "vec:centered-moving-excess-kurtosis", "vec:running-excess-kurtosis", "vec:sample-excess-kurtosis", "vec:moving-sample-excess-kurtosis", "vec:centered-moving-sample-excess-kurtosis", "vec:running-sample-excess-kurtosis", "vec:rms", "vec:moving-rms", "vec:centered-moving-rms", "vec:running-rms", "vec:mad", "vec:moving-mad", "vec:centered-moving-mad", "vec:running-mad", "vec:medad", "vec:moving-medad", "vec:centered-moving-medad", "vec:running-medad", "vec:gini-coefficient", "vec:moving-gini-coefficient", "vec:centered-moving-gini-coefficient", "vec:running-gini-coefficient", "vec:entropy", "vec:moving-entropy", "vec:centered-moving-entropy", "vec:running-entropy", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "lin:reflect", "lin:refract", "lin:lerp", "lin:rotate2d", "lin:rotate3d", "lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve", "grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:fill", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array", "nth:abundant-seq", "nth:abundant-nth", "nth:abundant-take-while", "nth:abundant?", "nth:bell-seq", "nth:bell-nth", "nth:bell-take-while", "nth:bell?", "nth:catalan-seq", "nth:catalan-nth", "nth:catalan-take-while", "nth:catalan?", "nth:composite-seq", "nth:composite-nth", "nth:composite-take-while", "nth:composite?", "nth:factorial-seq", "nth:factorial-nth", "nth:factorial-take-while", "nth:factorial?", "nth:fibonacci-seq", "nth:fibonacci-nth", "nth:fibonacci-take-while", "nth:fibonacci?", "nth:geometric-seq", "nth:geometric-nth", "nth:geometric-take-while", "nth:geometric?", "nth:golomb-seq", "nth:golomb-nth", "nth:golomb-take-while", "nth:golomb?", "nth:happy-seq", "nth:happy-nth", "nth:happy-take-while", "nth:happy?", "nth:look-and-say-seq", "nth:look-and-say-nth", "nth:look-and-say-take-while", "nth:look-and-say?", "nth:lucas-seq", "nth:lucas-nth", "nth:lucas-take-while", "nth:lucas?", "nth:lucky-seq", "nth:lucky-nth", "nth:lucky-take-while", "nth:lucky?", "nth:mersenne-seq", "nth:mersenne-nth", "nth:mersenne-take-while", "nth:mersenne?", "nth:padovan-seq", "nth:padovan-nth", "nth:padovan-take-while", "nth:padovan?", "nth:partition-seq", "nth:partition-nth", "nth:partition-take-while", "nth:partition?", "nth:pell-seq", "nth:pell-nth", "nth:pell-take-while", "nth:pell?", "nth:perfect-seq", "nth:perfect-nth", "nth:perfect-take-while", "nth:perfect?", "nth:perfect-cube-seq", "nth:perfect-cube-nth", "nth:perfect-cube-take-while", "nth:perfect-cube?", "nth:perfect-power-seq", "nth:perfect-power-nth", "nth:perfect-power-take-while", "nth:perfect-power?", "nth:perfect-square-seq", "nth:perfect-square-nth", "nth:perfect-square-take-while", "nth:perfect-square?", "nth:polygonal-seq", "nth:polygonal-nth", "nth:polygonal-take-while", "nth:polygonal?", "nth:prime-seq", "nth:prime-nth", "nth:prime-take-while", "nth:prime?", "nth:recaman-seq", "nth:recaman-nth", "nth:recaman-take-while", "nth:recaman?", "nth:sylvester-seq", "nth:sylvester-nth", "nth:sylvester-take-while", "nth:sylvester?", "nth:thue-morse-seq", "nth:thue-morse-nth", "nth:thue-morse-take-while", "nth:thue-morse?", "nth:tribonacci-seq", "nth:tribonacci-nth", "nth:tribonacci-take-while", "nth:tribonacci?", "nth:collatz-seq", "nth:juggler-seq", "nth:bernoulli-seq", "nth:bernoulli-take-while", "nth:bernoulli-nth", "nth:combinations", "nth:count-combinations", "nth:derangements", "nth:count-derangements", "nth:divisors", "nth:count-divisors", "nth:proper-divisors", "nth:count-proper-divisors", "nth:prime-factors", "nth:count-prime-factors", "nth:distinct-prime-factors", "nth:count-distinct-prime-factors", "nth:factorial", "nth:partitions", "nth:count-partitions", "nth:permutations", "nth:count-permutations", "nth:power-set", "nth:count-power-set", "nth:coprime?", "nth:divisible-by?", "nth:gcd", "nth:lcm", "nth:multinomial", "nth:amicable?", "nth:euler-totient", "nth:mobius", "nth:mertens", "nth:sigma", "nth:carmichael-lambda", "nth:cartesian-product", "nth:perfect-power", "nth:mod-exp", "nth:mod-inv", "nth:extended-gcd", "nth:chinese-remainder", "nth:stirling-first", "nth:stirling-second", "!:random", "!:random-int", "!:random-int-inclusive", "!:random-float", "!:random-boolean", "!:random-item", "!:random-sample", "!:random-sample-unique", "!:shuffle", "!:random-normal", "!:random-exponential", "!:random-binomial", "!:random-poisson", "!:random-gamma", "!:random-pareto", "!:uuid", "!:random-char", "!:random-string", "!:random-id", "!:random-color", "-short-regexp", "-short-fn", "-type-number", "-type-string", "-type-object", "-type-array", "-type-vector", "-type-matrix", "-type-grid", "-type-boolean", "-type-function", "-type-integer", "-type-any", "-type-null", "-type-collection", "-type-sequence", "-type-regexp", "-type-never"];
 export type ApiName = typeof apiNames[number];
 export declare function isApiName(arg: string): arg is ApiName;
 export declare const categoryRecord: {