@mojir/lits 2.1.8 → 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.8";
+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) < Number.EPSILON;
+        return approxEqual(a, b);
     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;
@@ -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
@@ -2308,6 +2307,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) {
@@ -2654,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];
@@ -2686,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,
@@ -2706,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;
                 }); });
             }
         },
@@ -2732,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,
@@ -2788,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,
@@ -3206,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) {
@@ -3825,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,
     },
@@ -4688,6 +4719,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 +6681,141 @@ 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; });
+}
+
+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) {
+            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 +6824,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 +6905,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) {
@@ -6855,10 +7032,10 @@ 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:magnitude'],
+        aliases: ['lin:l2-norm', 'lin:length'],
     },
     'lin:manhattan-distance': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -7161,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,
+    },
 };
 
 /**
@@ -12328,6 +12530,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 +12556,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 +12583,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);
@@ -12687,8 +12890,6 @@ var binaryOperators = [
     '=', // equal
     '!=', // not equal
     '≠', // not equal
-    '~', // approximate
-    '≈', // approximate
     '&', // bitwise AND
     'xor', // bitwise XOR
     '|', // bitwise OR
@@ -13331,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
@@ -13386,8 +13585,6 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '&':
         case 'xor':
         case '|':
-        case '~':
-        case '≈':
         case '|>':
             return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
         case '&&':
@@ -14930,7 +15127,6 @@ var api = {
         '-',
         '*',
         '/',
-        '~',
         'mod',
         'rem',
         'quot',
@@ -14962,6 +15158,8 @@ var api = {
         'asinh',
         'acosh',
         'atanh',
+        'to-rad',
+        'to-deg',
     ],
     functional: [
         '|>',
@@ -15104,6 +15302,7 @@ var api = {
         'grid:row',
         'grid:col',
         'grid:shape',
+        'grid:fill',
         'grid:generate',
         'grid:reshape',
         'grid:transpose',
@@ -15195,6 +15394,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',
@@ -15228,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',
@@ -16916,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',
@@ -17716,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 = {
@@ -19044,6 +19277,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 +23529,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 +23847,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 +24034,7 @@ var linAlgReference = {
         ],
         aliases: [
             'lin:l2-norm',
-            'lin:magnitude',
+            'lin:length',
         ],
     },
     'lin:manhattan-distance': {
@@ -23990,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 = {