@mojir/lits 2.1.10 → 2.1.11

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.10";
+var version = "2.1.11";
 
 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) < 1e-10;
+        return approxEqual(a, b);
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length)
             return false;
@@ -913,9 +913,8 @@ function approxEqual(a, b, epsilon) {
     // Use relative error for larger values
     return diff / (absA + absB) < epsilon;
 }
-function approxZero(value, epsilon) {
-    if (epsilon === void 0) { epsilon = EPSILON; }
-    return Math.abs(value) < epsilon;
+function approxZero(value) {
+    return Math.abs(value) < EPSILON;
 }
 
 // isArray not needed, use Array.isArary
@@ -2676,30 +2675,6 @@ var mathNormalExpression = {
         },
         paramCount: {},
     },
-    '~': {
-        evaluate: function (params, sourceCodeInfo) {
-            var _a;
-            var _b = __read(getNumberVectorOrMatrixOperation([params[0], params[1]], sourceCodeInfo), 2), operation = _b[0], operands = _b[1];
-            var eplsilon = (_a = params[2]) !== null && _a !== void 0 ? _a : 1e-10;
-            assertNumber(eplsilon, sourceCodeInfo, { positive: true, finite: true });
-            if (operation === 'number') {
-                var _c = __read(operands, 2), first = _c[0], second = _c[1];
-                return approxEqual(first, second, eplsilon);
-            }
-            else if (operation === 'vector') {
-                var firstVector = operands[0];
-                var secondVector_1 = operands[1];
-                return firstVector.every(function (val, i) { return approxEqual(val, secondVector_1[i], eplsilon); });
-            }
-            else {
-                var firstMatrix = operands[0];
-                var secondMatrix_1 = operands[1];
-                return firstMatrix.every(function (row, i) { return row.every(function (val, j) { return approxEqual(val, secondMatrix_1[i][j], eplsilon); }); });
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-        aliases: ['≈'],
-    },
     'quot': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
@@ -2708,13 +2683,13 @@ var mathNormalExpression = {
             }
             else if (operation === 'vector') {
                 var firstVector = operands[0];
-                var secondVector_2 = operands[1];
-                return firstVector.map(function (val, i) { return Math.trunc(val / secondVector_2[i]); });
+                var secondVector_1 = operands[1];
+                return firstVector.map(function (val, i) { return Math.trunc(val / secondVector_1[i]); });
             }
             else {
                 var firstMatrix = operands[0];
-                var secondMatrix_2 = operands[1];
-                return firstMatrix.map(function (row, i) { return row.map(function (val, j) { return Math.trunc(val / secondMatrix_2[i][j]); }); });
+                var secondMatrix_1 = operands[1];
+                return firstMatrix.map(function (row, i) { return row.map(function (val, j) { return Math.trunc(val / secondMatrix_1[i][j]); }); });
             }
         },
         paramCount: 2,
@@ -2728,19 +2703,19 @@ var mathNormalExpression = {
             }
             else if (operation === 'vector') {
                 var firstVector = operands[0];
-                var secondVector_3 = operands[1];
+                var secondVector_2 = operands[1];
                 return firstVector.map(function (dividend, i) {
-                    var divisor = secondVector_3[i];
+                    var divisor = secondVector_2[i];
                     var quotient = Math.floor(dividend / divisor);
                     return dividend - divisor * quotient;
                 });
             }
             else {
                 var firstMatrix = operands[0];
-                var secondMatrix_3 = operands[1];
+                var secondMatrix_2 = operands[1];
                 return firstMatrix.map(function (row, i) { return row.map(function (val, j) {
-                    var quotient = Math.floor(val / secondMatrix_3[i][j]);
-                    return val - secondMatrix_3[i][j] * quotient;
+                    var quotient = Math.floor(val / secondMatrix_2[i][j]);
+                    return val - secondMatrix_2[i][j] * quotient;
                 }); });
             }
         },
@@ -2754,13 +2729,13 @@ var mathNormalExpression = {
             }
             else if (operation === 'vector') {
                 var firstVector = operands[0];
-                var secondVector_4 = operands[1];
-                return firstVector.map(function (dividend, i) { return dividend % secondVector_4[i]; });
+                var secondVector_3 = operands[1];
+                return firstVector.map(function (dividend, i) { return dividend % secondVector_3[i]; });
             }
             else {
                 var firstMatrix = operands[0];
-                var secondMatrix_4 = operands[1];
-                return firstMatrix.map(function (row, i) { return row.map(function (dividend, j) { return dividend % secondMatrix_4[i][j]; }); });
+                var secondMatrix_3 = operands[1];
+                return firstMatrix.map(function (row, i) { return row.map(function (dividend, j) { return dividend % secondMatrix_3[i][j]; }); });
             }
         },
         paramCount: 2,
@@ -2810,13 +2785,13 @@ var mathNormalExpression = {
             }
             else if (operation === 'vector') {
                 var firstVector = operands[0];
-                var secondVector_5 = operands[1];
-                return firstVector.map(function (base, i) { return Math.pow(base, secondVector_5[i]); });
+                var secondVector_4 = operands[1];
+                return firstVector.map(function (base, i) { return Math.pow(base, secondVector_4[i]); });
             }
             else {
                 var firstMatrix = operands[0];
-                var secondMatrix_5 = operands[1];
-                return firstMatrix.map(function (row, i) { return row.map(function (base, j) { return Math.pow(base, secondMatrix_5[i][j]); }); });
+                var secondMatrix_4 = operands[1];
+                return firstMatrix.map(function (row, i) { return row.map(function (base, j) { return Math.pow(base, secondMatrix_4[i][j]); }); });
             }
         },
         paramCount: 2,
@@ -3228,6 +3203,40 @@ var mathNormalExpression = {
         },
         paramCount: 1,
     },
+    'to-rad': {
+        evaluate: function (params, sourceCodeInfo) {
+            var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
+            if (operation === 'number') {
+                return (operands[0] * Math.PI) / 180;
+            }
+            else if (operation === 'vector') {
+                var vector = operands[0];
+                return vector.map(function (val) { return (val * Math.PI) / 180; });
+            }
+            else {
+                var matrix = operands[0];
+                return matrix.map(function (row) { return row.map(function (val) { return (val * Math.PI) / 180; }); });
+            }
+        },
+        paramCount: 1,
+    },
+    'to-deg': {
+        evaluate: function (params, sourceCodeInfo) {
+            var _a = __read(getNumberVectorOrMatrixOperation(params, sourceCodeInfo), 2), operation = _a[0], operands = _a[1];
+            if (operation === 'number') {
+                return (operands[0] * 180) / Math.PI;
+            }
+            else if (operation === 'vector') {
+                var vector = operands[0];
+                return vector.map(function (val) { return (val * 180) / Math.PI; });
+            }
+            else {
+                var matrix = operands[0];
+                return matrix.map(function (row) { return row.map(function (val) { return (val * 180) / Math.PI; }); });
+            }
+        },
+        paramCount: 1,
+    },
 };
 
 function isEqual(_a, sourceCodeInfo) {
@@ -3847,9 +3856,9 @@ var predicatesNormalExpression = {
     },
     'zero?': {
         evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), first = _b[0];
-            assertNumber(first, sourceCodeInfo, { finite: true });
-            return first === 0;
+            var _b = __read(_a, 1), value = _b[0];
+            assertNumber(value, sourceCodeInfo, { finite: true });
+            return Math.abs(value) < EPSILON;
         },
         paramCount: 1,
     },
@@ -6695,6 +6704,10 @@ function scale(vector, scalar) {
     return vector.map(function (item) { return item * scalar; });
 }
 
+function length(vector) {
+    return Math.sqrt(vector.reduce(function (acc, item) { return acc + Math.pow(item, 2); }, 0));
+}
+
 var linearAlgebraNormalExpression = {
     'lin:rotate2d': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -7019,7 +7032,7 @@ var linearAlgebraNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), vector = _b[0];
             assertNonEmptyVector(vector, sourceCodeInfo);
-            return Math.sqrt(vector.reduce(function (acc, val) { return acc + val * val; }, 0));
+            return length(vector);
         },
         paramCount: 1,
         aliases: ['lin:l2-norm', 'lin:length'],
@@ -7325,6 +7338,31 @@ var linearAlgebraNormalExpression = {
         },
         paramCount: 2,
     },
+    'lin:to-polar': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), vector = _b[0];
+            assert2dVector(vector, sourceCodeInfo);
+            if (isZeroVector(vector)) {
+                return [0, 0];
+            }
+            var r = Math.sqrt(Math.pow(vector[0], 2) + Math.pow(vector[1], 2));
+            var theta = Math.atan2(vector[1], vector[0]);
+            return [r, theta];
+        },
+        paramCount: 1,
+    },
+    'lin:from-polar': {
+        evaluate: function (_a, sourceCodeInfo) {
+            var _b = __read(_a, 1), polar = _b[0];
+            assert2dVector(polar, sourceCodeInfo);
+            var _c = __read(polar, 2), r = _c[0], theta = _c[1];
+            if (r === 0) {
+                return [0, 0];
+            }
+            return [r * Math.cos(theta), r * Math.sin(theta)];
+        },
+        paramCount: 1,
+    },
 };
 
 /**
@@ -12852,8 +12890,6 @@ var binaryOperators = [
     '=', // equal
     '!=', // not equal
     '≠', // not equal
-    '~', // approximate
-    '≈', // approximate
     '&', // bitwise AND
     'xor', // bitwise XOR
     '|', // bitwise OR
@@ -13496,8 +13532,6 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         case '=': // equal
         case '!=': // not equal
         case '≠': // not equal
-        case '~': // approximate
-        case '≈': // approximate
             return 5;
         case '&': // bitwise AND
         case 'xor': // bitwise XOR
@@ -13551,8 +13585,6 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '&':
         case 'xor':
         case '|':
-        case '~':
-        case '≈':
         case '|>':
             return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
         case '&&':
@@ -15095,7 +15127,6 @@ var api = {
         '-',
         '*',
         '/',
-        '~',
         'mod',
         'rem',
         'quot',
@@ -15127,6 +15158,8 @@ var api = {
         'asinh',
         'acosh',
         'atanh',
+        'to-rad',
+        'to-deg',
     ],
     functional: [
         '|>',
@@ -15399,6 +15432,8 @@ var api = {
         'lin:cross-correlation',
         'lin:rref',
         'lin:solve',
+        'lin:to-polar',
+        'lin:from-polar',
     ],
     numberTheory: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(getNumberTheorySequenceNames('abundant')), false), __read(getNumberTheorySequenceNames('bell')), false), __read(getNumberTheorySequenceNames('catalan')), false), __read(getNumberTheorySequenceNames('composite')), false), __read(getNumberTheorySequenceNames('factorial')), false), __read(getNumberTheorySequenceNames('fibonacci')), false), __read(getNumberTheorySequenceNames('geometric')), false), __read(getNumberTheorySequenceNames('golomb')), false), __read(getNumberTheorySequenceNames('happy')), false), __read(getNumberTheorySequenceNames('look-and-say')), false), __read(getNumberTheorySequenceNames('lucas')), false), __read(getNumberTheorySequenceNames('lucky')), false), __read(getNumberTheorySequenceNames('mersenne')), false), __read(getNumberTheorySequenceNames('padovan')), false), __read(getNumberTheorySequenceNames('partition')), false), __read(getNumberTheorySequenceNames('pell')), false), __read(getNumberTheorySequenceNames('perfect')), false), __read(getNumberTheorySequenceNames('perfect-cube')), false), __read(getNumberTheorySequenceNames('perfect-power')), false), __read(getNumberTheorySequenceNames('perfect-square')), false), __read(getNumberTheorySequenceNames('polygonal')), false), __read(getNumberTheorySequenceNames('prime')), false), __read(getNumberTheorySequenceNames('recaman')), false), __read(getNumberTheorySequenceNames('sylvester')), false), __read(getNumberTheorySequenceNames('thue-morse')), false), __read(getNumberTheorySequenceNames('tribonacci')), false), [
         'nth:collatz-seq',
@@ -17087,29 +17122,6 @@ var mathReference = {
             '[[1, 2, 3], [4, 5, 6]] / 2',
         ],
     },
-    '~': {
-        title: '~',
-        category: 'Math',
-        linkName: '-tilde',
-        returns: {
-            type: ['number', 'vector', 'matrix'],
-        },
-        args: __assign({}, mixedOperatorArgs),
-        variants: [
-            { argumentNames: ['a, b'] },
-        ],
-        description: 'The `~` checks for approximately equal values, returning `true` if the absolute difference between the two numbers is less than or equal to a small threshold (default: `1e-10`). It works on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it checks each element for approximate equality.',
-        examples: [
-            '~(0.1, 0.1)',
-            '~(0.1, 0.10000000000001)',
-            '~(0.1, 0.2)',
-            '~(0.1, 0.101, 0.1)',
-            '~([1, 2, 3], [1.00000000000001, 2.00000000000001, 3.00000000000001])',
-            '~([1, 2, 3], [1.1, 2.1, 3.1])',
-            '~([[1, 2, 3], [1, 2, 3]], [[1.01, 2.01, 3.01], [1.01, 2.01, 3.01]], 0.1)',
-        ],
-        aliases: ['≈'],
-    },
     'mod': {
         title: 'mod',
         category: 'Math',
@@ -17887,6 +17899,56 @@ var mathReference = {
             'atanh([[0.1, 0.2], [0.3, 0.4]])',
         ],
     },
+    'to-rad': {
+        title: 'to-rad',
+        category: 'Math',
+        linkName: 'to-rad',
+        returns: {
+            type: ['number', 'vector', 'matrix'],
+        },
+        args: {
+            x: {
+                type: ['number', 'vector', 'matrix'],
+            },
+        },
+        variants: [
+            { argumentNames: ['x'] },
+        ],
+        description: 'The `to-rad` function converts an angle from degrees to radians, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
+        examples: [
+            'to-rad(0)',
+            'to-rad(90)',
+            'to-rad(180)',
+            'to-rad(360)',
+            'to-rad([0, 90, 180])',
+            'to-rad([[0, 90], [180, 360]])',
+        ],
+    },
+    'to-deg': {
+        title: 'to-deg',
+        category: 'Math',
+        linkName: 'to-deg',
+        returns: {
+            type: ['number', 'vector', 'matrix'],
+        },
+        args: {
+            x: {
+                type: ['number', 'vector', 'matrix'],
+            },
+        },
+        variants: [
+            { argumentNames: ['x'] },
+        ],
+        description: 'The `to-deg` function converts an angle from radians to degrees, working on `numbers` and element-wise on `vectors` and `matrices`. When applied to collections, it converts each element while preserving the original structure.',
+        examples: [
+            'to-deg(0)',
+            'to-deg(PI)',
+            'to-deg(PI / 2)',
+            'to-deg(3 * PI / 2)',
+            'to-deg([0, PI, PI / 2])',
+            'to-deg([[0, PI], [PI / 2, 3 * PI / 2]])',
+        ],
+    },
 };
 
 var miscReference = {
@@ -24340,6 +24402,51 @@ var linAlgReference = {
             'lin:solve([[2, 3], [1, -1]], [8, 2])',
         ],
     },
+    'lin:to-polar': {
+        title: 'lin:to-polar',
+        category: 'Linear Algebra',
+        description: 'Converts a 2D vector to polar coordinates.',
+        linkName: 'lin-colon-to-polar',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            vector: {
+                type: 'vector',
+                description: '2D Vector to convert.',
+            },
+        },
+        variants: [
+            { argumentNames: ['vector'] },
+        ],
+        examples: [
+            'lin:to-polar([1, 2])',
+            'lin:to-polar([3, 4])',
+        ],
+    },
+    'lin:from-polar': {
+        title: 'lin:from-polar',
+        category: 'Linear Algebra',
+        description: 'Converts polar coordinates to a 2D vector.',
+        linkName: 'lin-colon-from-polar',
+        returns: {
+            type: 'vector',
+        },
+        args: {
+            polar: {
+                type: 'vector',
+                description: 'Polar coordinates to convert.',
+            },
+        },
+        variants: [
+            { argumentNames: ['polar'] },
+        ],
+        examples: [
+            'lin:from-polar([1, PI / 4])',
+            'lin:from-polar([1, 0])',
+            'lin:from-polar([1, -PI / 2])',
+        ],
+    },
 };
 
 var predicateReference = {

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

@@ -3,7 +3,7 @@ export declare const api: {
     readonly collection: 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"];
     readonly array: readonly ["range", "repeat", "flatten", "mapcat"];
     readonly sequence: readonly ["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"];
-    readonly math: readonly ["+", "-", "*", "/", "~", "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"];
+    readonly math: readonly ["+", "-", "*", "/", "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", "to-rad", "to-deg"];
     readonly functional: readonly ["|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull"];
     readonly misc: readonly ["≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify"];
     readonly object: readonly ["dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys"];
@@ -15,7 +15,7 @@ export declare const api: {
     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: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 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", "lin:to-polar", "lin:from-polar"];
     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: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"];
+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", "to-rad", "to-deg", "|>", "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", "lin:to-polar", "lin:from-polar", "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: {

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

@@ -140,7 +140,6 @@ export declare const functionReference: {
     "*": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "/": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "-": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
-    "~": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     quot: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     mod: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     rem: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
@@ -168,6 +167,8 @@ export declare const functionReference: {
     atan: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     tanh: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     atanh: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "to-rad": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "to-deg": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "=": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "\u2260": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "identical?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
@@ -391,6 +392,8 @@ export declare const functionReference: {
     "lin:cross-correlation": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "lin:rref": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "lin:solve": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "lin:to-polar": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "lin:from-polar": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "mat:mul": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "mat:det": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "mat:inv": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;

package/dist/cli/src/builtin/normalExpressions/categories/namespaces/linearAlgebra/helpers/length.d.ts

@@ -0,0 +1 @@
+export declare function length(vector: number[]): number;

package/dist/cli/src/builtin/normalExpressions/categories/namespaces/linearAlgebra/helpers/scale.d.ts

@@ -1 +1 @@
-export declare function scale(vector: number[], scalar: number): number[];
+export declare function scale<T extends number[]>(vector: T, scalar: number): T;

package/dist/cli/src/builtin/normalExpressions/categories/namespaces/linearAlgebra/helpers/subtract.d.ts

@@ -1 +1 @@
-export declare function subtract(vector1: number[], vector2: number[]): number[];
+export declare function subtract<T extends number[]>(vector1: T, vector2: T): T;

package/dist/cli/src/tokenizer/operators.d.ts

@@ -1,5 +1,5 @@
-declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "~", "≈", "&", "xor", "|", "&&", "||", "??", "|>"];
-declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "~", "≈", "&", "xor", "|", "&&", "||", "??", "|>", "->", "...", ".", ",", ":=", ";"];
+declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>"];
+declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>", "->", "...", ".", ",", ":=", ";"];
 export declare function isFunctionOperator(operator: string): boolean;
 export type SymbolicBinaryOperator = typeof binaryOperators[number];
 export type SymbolicOperator = typeof symbolicOperators[number];