@danielsimonjr/mathts-functions 0.64.1 → 0.64.3

package/dist/index.js

@@ -22541,12 +22541,10 @@ var createConj = /* @__PURE__ */ factory(
     return typed3(name17, {
       "number | BigNumber | Fraction": (x) => x,
       Complex: (x) => x.conjugate(),
-      Unit: typed3.referToSelf(
-        (self) => (x) => {
-          const ctor = x.constructor;
-          return new ctor(self(x.toNumeric()), x.formatUnits());
-        }
-      ),
+      Unit: typed3.referToSelf((self) => (x) => {
+        const ctor = x.constructor;
+        return new ctor(self(x.toNumeric()), x.formatUnits());
+      }),
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => deepMap(x, self)
       )
@@ -25366,24 +25364,16 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: conf
 // src/matrix/zeros.ts
 var name87 = "zeros";
 var dependencies87 = ["typed", "config", "matrix", "BigNumber"];
-var createZeros = /* @__PURE__ */ factory(
-  name87,
-  dependencies87,
-  (deps) => {
-    return createZerosAndOnes(name87, 0, deps);
-  }
-);
+var createZeros = /* @__PURE__ */ factory(name87, dependencies87, (deps) => {
+  return createZerosAndOnes(name87, 0, deps);
+});
 
 // src/matrix/ones.ts
 var name88 = "ones";
 var dependencies88 = ["typed", "config", "matrix", "BigNumber"];
-var createOnes = /* @__PURE__ */ factory(
-  name88,
-  dependencies88,
-  (deps) => {
-    return createZerosAndOnes(name88, 1, deps);
-  }
-);
+var createOnes = /* @__PURE__ */ factory(name88, dependencies88, (deps) => {
+  return createZerosAndOnes(name88, 1, deps);
+});
 
 // src/matrix/diag.ts
 var name89 = "diag";
@@ -28084,7 +28074,10 @@ var createMatAlgo11xS0s = /* @__PURE__ */ factory(
           eq = _eqCache;
           cf = _cfCache;
         } else {
-          eq = typed3.find(equalScalar3, [dt, dt]) || equalScalar3;
+          eq = typed3.find(equalScalar3, [
+            dt,
+            dt
+          ]) || equalScalar3;
           cf = typed3.find(callback, [dt, dt]) || callback;
           _dtCache = dt;
           _cbCache = callback;
@@ -28343,17 +28336,32 @@ var createRound = /* @__PURE__ */ factory(
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return matAlgo11xS0s(x, n, self, false);
+          return matAlgo11xS0s(
+            x,
+            n,
+            self,
+            false
+          );
         }
       ),
       "DenseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return matAlgo14xDs(x, n, self, false);
+          return matAlgo14xDs(
+            x,
+            n,
+            self,
+            false
+          );
         }
       ),
       "Array, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return matAlgo14xDs(matrix2(x), n, self, false).valueOf();
+          return matAlgo14xDs(
+            matrix2(x),
+            n,
+            self,
+            false
+          ).valueOf();
         }
       ),
       "number | Complex | BigNumber | Fraction, SparseMatrix": typed3.referToSelf(
@@ -28361,7 +28369,12 @@ var createRound = /* @__PURE__ */ factory(
           if (equalScalar3(x, 0)) {
             return zeros4(n.size(), n.storage());
           }
-          return matAlgo12xSfs(n, x, self, true);
+          return matAlgo12xSfs(
+            n,
+            x,
+            self,
+            true
+          );
         }
       ),
       "number | Complex | BigNumber | Fraction, DenseMatrix": typed3.referToSelf(
@@ -28369,12 +28382,22 @@ var createRound = /* @__PURE__ */ factory(
           if (equalScalar3(x, 0)) {
             return zeros4(n.size(), n.storage());
           }
-          return matAlgo14xDs(n, x, self, true);
+          return matAlgo14xDs(
+            n,
+            x,
+            self,
+            true
+          );
         }
       ),
       "number | Complex | BigNumber | Fraction, Array": typed3.referToSelf(
         (self) => (x, n) => {
-          return matAlgo14xDs(matrix2(n), x, self, true).valueOf();
+          return matAlgo14xDs(
+            matrix2(n),
+            x,
+            self,
+            true
+          ).valueOf();
         }
       )
     });
@@ -29070,7 +29093,12 @@ var createSubset = /* @__PURE__ */ factory(
       },
       "Array, Index, any, any": referTo("Matrix, Index, any, any", function(subsetRef) {
         return function(value, index, replacement, defaultValue) {
-          const subsetResult = subsetRef(matrix2(value), index, replacement, defaultValue);
+          const subsetResult = subsetRef(
+            matrix2(value),
+            index,
+            replacement,
+            defaultValue
+          );
           return subsetResult.isMatrix ? subsetResult.valueOf() : subsetResult;
         };
       }),
@@ -29589,12 +29617,18 @@ var createMatrixAlgorithmSuite = /* @__PURE__ */ factory(
           ),
           "Array, DenseMatrix": typed3.referToSelf(
             (self) => (x, y) => {
-              return matAlgo13xDD(...bcast(matrix2(x), y), self);
+              return matAlgo13xDD(
+                ...bcast(matrix2(x), y),
+                self
+              );
             }
           ),
           "DenseMatrix, Array": typed3.referToSelf(
             (self) => (x, y) => {
-              return matAlgo13xDD(...bcast(x, matrix2(y)), self);
+              return matAlgo13xDD(
+                ...bcast(x, matrix2(y)),
+                self
+              );
             }
           )
         };
@@ -29636,8 +29670,18 @@ var createMatrixAlgorithmSuite = /* @__PURE__ */ factory(
         if (elop) {
           matrixSignatures["DenseMatrix," + scalar] = (x, y) => matAlgo14xDs(x, y, elop, false);
           matrixSignatures[scalar + ", DenseMatrix"] = (x, y) => matAlgo14xDs(y, x, elop, true);
-          matrixSignatures["Array," + scalar] = (x, y) => matAlgo14xDs(matrix2(x), y, elop, false).valueOf();
-          matrixSignatures[scalar + ", Array"] = (x, y) => matAlgo14xDs(matrix2(y), x, elop, true).valueOf();
+          matrixSignatures["Array," + scalar] = (x, y) => matAlgo14xDs(
+            matrix2(x),
+            y,
+            elop,
+            false
+          ).valueOf();
+          matrixSignatures[scalar + ", Array"] = (x, y) => matAlgo14xDs(
+            matrix2(y),
+            x,
+            elop,
+            true
+          ).valueOf();
         } else {
           matrixSignatures["DenseMatrix," + scalar] = typed3.referToSelf(
             (self) => (x, y) => {
@@ -30147,7 +30191,10 @@ var createMatAlgo09xS0Sf = /* @__PURE__ */ factory(
       let cf = callback;
       if (typeof adt === "string" && adt === bdt && adt !== "mixed") {
         dt = adt;
-        eq = typed3.find(equalScalar3, [dt, dt]);
+        eq = typed3.find(equalScalar3, [
+          dt,
+          dt
+        ]);
         zero = typed3.convert(0, dt);
         cf = typed3.find(callback, [dt, dt]);
       }
@@ -30227,7 +30274,7 @@ var createDotMultiply = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/floor.ts
-import Decimal from "decimal.js";
+import { Decimal } from "decimal.js";
 var name134 = "floor";
 var dependencies134 = ["typed", "config", "round", "matrix", "equalScalar", "zeros", "DenseMatrix"];
 var bigTen = new Decimal(10);
@@ -30335,26 +30382,51 @@ var createFloor = /* @__PURE__ */ factory(
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo11xS0s(x, y, self, false);
+          return matAlgo11xS0s(
+            x,
+            y,
+            self,
+            false
+          );
         }
       ),
       "DenseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo14xDs(x, y, self, false);
+          return matAlgo14xDs(
+            x,
+            y,
+            self,
+            false
+          );
         }
       ),
       "number | Complex | Fraction | BigNumber, Array": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo14xDs(matrix2(y), x, self, true).valueOf();
+          return matAlgo14xDs(
+            matrix2(y),
+            x,
+            self,
+            true
+          ).valueOf();
         }
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
           if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
-          return matAlgo12xSfs(y, x, self, true);
+          return matAlgo12xSfs(
+            y,
+            x,
+            self,
+            true
+          );
         }
       )
     });
@@ -31329,7 +31401,7 @@ var createPow = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/ceil.ts
-import Decimal2 from "decimal.js";
+import { Decimal as Decimal2 } from "decimal.js";
 var name146 = "ceil";
 var dependencies146 = ["typed", "config", "round", "matrix", "equalScalar", "zeros", "DenseMatrix"];
 var bigTen2 = new Decimal2(10);
@@ -31437,26 +31509,51 @@ var createCeil = /* @__PURE__ */ factory(
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo11xS0s(x, y, self, false);
+          return matAlgo11xS0s(
+            x,
+            y,
+            self,
+            false
+          );
         }
       ),
       "DenseMatrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo14xDs(x, y, self, false);
+          return matAlgo14xDs(
+            x,
+            y,
+            self,
+            false
+          );
         }
       ),
       "number | Complex | Fraction | BigNumber, Array": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo14xDs(matrix2(y), x, self, true).valueOf();
+          return matAlgo14xDs(
+            matrix2(y),
+            x,
+            self,
+            true
+          ).valueOf();
         }
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
           if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
-          return matAlgo12xSfs(y, x, self, true);
+          return matAlgo12xSfs(
+            y,
+            x,
+            self,
+            true
+          );
         }
       )
     });
@@ -31702,7 +31799,12 @@ var createLeftShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo11xS0s(x, y, self, false);
+            return matAlgo11xS0s(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "DenseMatrix, number | BigNumber": typed3.referToSelf(
@@ -31710,7 +31812,12 @@ var createLeftShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo14xDs(x, y, self, false);
+            return matAlgo14xDs(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
@@ -31718,7 +31825,12 @@ var createLeftShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo10xSids(y, x, self, true);
+            return matAlgo10xSids(
+              y,
+              x,
+              self,
+              true
+            );
           }
         ),
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
@@ -31726,7 +31838,12 @@ var createLeftShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
         )
       },
@@ -31773,7 +31890,12 @@ var createRightArithShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo11xS0s(x, y, self, false);
+            return matAlgo11xS0s(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "DenseMatrix, number | BigNumber": typed3.referToSelf(
@@ -31781,7 +31903,12 @@ var createRightArithShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo14xDs(x, y, self, false);
+            return matAlgo14xDs(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
@@ -31789,7 +31916,12 @@ var createRightArithShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo10xSids(y, x, self, true);
+            return matAlgo10xSids(
+              y,
+              x,
+              self,
+              true
+            );
           }
         ),
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
@@ -31797,7 +31929,12 @@ var createRightArithShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
         )
       },
@@ -31843,7 +31980,12 @@ var createRightLogShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo11xS0s(x, y, self, false);
+            return matAlgo11xS0s(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "DenseMatrix, number | BigNumber": typed3.referToSelf(
@@ -31851,7 +31993,12 @@ var createRightLogShift = /* @__PURE__ */ factory(
             if (equalScalar3(y, 0)) {
               return x.clone();
             }
-            return matAlgo14xDs(x, y, self, false);
+            return matAlgo14xDs(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "number | BigNumber, SparseMatrix": typed3.referToSelf(
@@ -31859,7 +32006,12 @@ var createRightLogShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo10xSids(y, x, self, true);
+            return matAlgo10xSids(
+              y,
+              x,
+              self,
+              true
+            );
           }
         ),
         "number | BigNumber, DenseMatrix": typed3.referToSelf(
@@ -31867,7 +32019,12 @@ var createRightLogShift = /* @__PURE__ */ factory(
             if (equalScalar3(x, 0)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
         )
       },
@@ -32626,16 +32783,31 @@ var createFix = /* @__PURE__ */ factory(
       ),
       "number | Complex | Fraction | BigNumber, Array": typed3.referToSelf(
         (self) => (x, y) => {
-          return matAlgo14xDs(matrix2(y), x, self, true).valueOf();
+          return matAlgo14xDs(
+            matrix2(y),
+            x,
+            self,
+            true
+          ).valueOf();
         }
       ),
       "number | Complex | Fraction | BigNumber, Matrix": typed3.referToSelf(
         (self) => (x, y) => {
           if (equalScalar3(x, 0)) return zeros4(y.size(), y.storage());
           if (y.storage() === "dense") {
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
-          return matAlgo12xSfs(y, x, self, true);
+          return matAlgo12xSfs(
+            y,
+            x,
+            self,
+            true
+          );
         }
       )
     });
@@ -32713,7 +32885,12 @@ var createAnd = /* @__PURE__ */ factory(
             if (not3(y)) {
               return zeros4(x.size(), x.storage());
             }
-            return matAlgo11xS0s(x, y, self, false);
+            return matAlgo11xS0s(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "DenseMatrix, any": typed3.referToSelf(
@@ -32721,7 +32898,12 @@ var createAnd = /* @__PURE__ */ factory(
             if (not3(y)) {
               return zeros4(x.size(), x.storage());
             }
-            return matAlgo14xDs(x, y, self, false);
+            return matAlgo14xDs(
+              x,
+              y,
+              self,
+              false
+            );
           }
         ),
         "any, SparseMatrix": typed3.referToSelf(
@@ -32729,7 +32911,12 @@ var createAnd = /* @__PURE__ */ factory(
             if (not3(x)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo11xS0s(y, x, self, true);
+            return matAlgo11xS0s(
+              y,
+              x,
+              self,
+              true
+            );
           }
         ),
         "any, DenseMatrix": typed3.referToSelf(
@@ -32737,7 +32924,12 @@ var createAnd = /* @__PURE__ */ factory(
             if (not3(x)) {
               return zeros4(y.size(), y.storage());
             }
-            return matAlgo14xDs(y, x, self, true);
+            return matAlgo14xDs(
+              y,
+              x,
+              self,
+              true
+            );
           }
         ),
         "Array, any": typed3.referToSelf(
@@ -33835,29 +34027,65 @@ var createNullish = /* @__PURE__ */ factory(
       },
       // DenseMatrix-first handlers (no broadcasting between collections)
       "DenseMatrix, DenseMatrix": typed3.referToSelf(
-        (self) => (x, y) => matAlgo13xDD(x, y, self)
+        (self) => (x, y) => matAlgo13xDD(
+          x,
+          y,
+          self
+        )
       ),
       "DenseMatrix, SparseMatrix": typed3.referToSelf(
-        (self) => (x, y) => matAlgo03xDSf(x, y, self, false)
+        (self) => (x, y) => matAlgo03xDSf(
+          x,
+          y,
+          self,
+          false
+        )
       ),
       "DenseMatrix, Array": typed3.referToSelf(
-        (self) => (x, y) => matAlgo13xDD(x, toMatrix(y), self)
+        (self) => (x, y) => matAlgo13xDD(
+          x,
+          toMatrix(y),
+          self
+        )
       ),
       "DenseMatrix, any": typed3.referToSelf(
-        (self) => (x, y) => matAlgo14xDs(x, y, self, false)
+        (self) => (x, y) => matAlgo14xDs(
+          x,
+          y,
+          self,
+          false
+        )
       ),
       // Array-first handlers (bridge via matrix() where needed)
       "Array, Array": typed3.referToSelf(
-        (self) => (x, y) => matAlgo13xDD(toMatrix(x), toMatrix(y), self).valueOf()
+        (self) => (x, y) => matAlgo13xDD(
+          toMatrix(x),
+          toMatrix(y),
+          self
+        ).valueOf()
       ),
       "Array, DenseMatrix": typed3.referToSelf(
-        (self) => (x, y) => matAlgo13xDD(toMatrix(x), y, self)
+        (self) => (x, y) => matAlgo13xDD(
+          toMatrix(x),
+          y,
+          self
+        )
       ),
       "Array, SparseMatrix": typed3.referToSelf(
-        (self) => (x, y) => matAlgo03xDSf(toMatrix(x), y, self, false)
+        (self) => (x, y) => matAlgo03xDSf(
+          toMatrix(x),
+          y,
+          self,
+          false
+        )
       ),
       "Array, any": typed3.referToSelf(
-        (self) => (x, y) => matAlgo14xDs(toMatrix(x), y, self, false).valueOf()
+        (self) => (x, y) => matAlgo14xDs(
+          toMatrix(x),
+          y,
+          self,
+          false
+        ).valueOf()
       )
     });
   }
@@ -34955,7 +35183,12 @@ var createUtil = /* @__PURE__ */ factory(
       if (isOperatorNode(node)) {
         return function(args) {
           try {
-            return new OperatorNode(node.op, node.fn, args, node.implicit);
+            return new OperatorNode(
+              node.op,
+              node.fn,
+              args,
+              node.implicit
+            );
           } catch (err) {
             console.error(err);
             return [];
@@ -35172,7 +35405,10 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
         const remainingDims = Array.from(index.dimensions);
         while (remainingDims.length > 0) {
           if (isConstantNode(remainingDims[0]) && typeof remainingDims[0].value !== "string") {
-            const first = _toNumber(remainingDims.shift().value, options);
+            const first = _toNumber(
+              remainingDims.shift().value,
+              options
+            );
             if (isArrayNode(obj)) {
               obj = obj.items[first - 1];
             } else {
@@ -35182,7 +35418,10 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
               }
             }
           } else if (remainingDims.length > 1 && isConstantNode(remainingDims[1]) && typeof remainingDims[1].value !== "string") {
-            const second = _toNumber(remainingDims[1].value, options);
+            const second = _toNumber(
+              remainingDims[1].value,
+              options
+            );
             const tryItems = [];
             const fromItems = isArrayNode(obj) ? obj.items : obj.valueOf();
             for (const item of fromItems) {
@@ -35295,7 +35534,10 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
                 }
                 return matrix2(sz);
               }
-              return new FunctionNode(node.name, args.map(_ensureNode));
+              return new FunctionNode(
+                node.name,
+                args.map(_ensureNode)
+              );
             }
             return _foldOperatorNode(node, options);
           }
@@ -35320,13 +35562,18 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
         }
         case "IndexNode": {
           return new IndexNode(
-            node.dimensions.map((n) => simplifyConstant2(n, options))
+            node.dimensions.map(
+              (n) => simplifyConstant2(n, options)
+            )
           );
         }
         case "ObjectNode": {
           const foldProps = {};
           for (const prop in node.properties) {
-            foldProps[prop] = simplifyConstant2(node.properties[prop], options);
+            foldProps[prop] = simplifyConstant2(
+              node.properties[prop],
+              options
+            );
           }
           return new ObjectNode(foldProps);
         }
@@ -35385,7 +35632,9 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
           res = foldOp(fn, args, makeNode, options);
         }
       } else {
-        args = node.args.map((arg3) => foldFraction(arg3, options));
+        args = node.args.map(
+          (arg3) => foldFraction(arg3, options)
+        );
         res = foldOp(fn, args, makeNode, options);
       }
       return res;
@@ -35801,15 +36050,7 @@ var dependencies199 = [
 var createDivide = /* @__PURE__ */ factory(
   name199,
   dependencies199,
-  ({
-    typed: typed3,
-    matrix: matrix2,
-    multiply: multiply2,
-    equalScalar: equalScalar3,
-    divideScalar: divideScalar2,
-    pinv: pinv2,
-    nodeOperations: nodeOperations2
-  }) => {
+  ({ typed: typed3, matrix: matrix2, multiply: multiply2, equalScalar: equalScalar3, divideScalar: divideScalar2, pinv: pinv2, nodeOperations: nodeOperations2 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     return typed3(
@@ -35987,6 +36228,10 @@ var createIndexClass = /* @__PURE__ */ factory(
        * @internal
        */
       _isScalar;
+      /**
+       * Create an index from the given ranges.
+       * @param {...*} ranges The index for each dimension
+       */
       constructor(...ranges) {
         if (!(this instanceof Index)) {
           throw new SyntaxError("Constructor must be called with the new operator");
@@ -36660,28 +36905,23 @@ var createImmutableDenseMatrixClass = /* @__PURE__ */ factory(
         }
       }
       /**
-       * Replace a single element in the matrix.
-       * @param {Number[]} index Zero-based index
-       * @param {MatrixValue} value
-       * @param {MatrixValue} [defaultValue] Default value, filled in on new entries when
-       *                           the matrix is resized. If not provided,
-       *                           new matrix elements will be left undefined.
-       * @return {ImmutableDenseMatrix} self
+       * Disallows replacing an element in favor of immutability.
+       * @param {Number[]} _index Zero-based index (not used)
+       * @param {MatrixValue} _value The new value (not used)
+       * @param {MatrixValue} [_defaultValue] Default value for new entries (not used)
+       * @throws {Error} Operation not allowed
        */
       set(_index, _value, _defaultValue) {
         throw new Error("Cannot invoke set on an Immutable Matrix instance");
       }
       /**
-       * Resize the matrix to the given size. Returns a copy of the matrix when
-       * `copy=true`, otherwise return the matrix itself (resize in place).
+       * Disallows resizing in favor of immutability.
        *
-       * @param {Number[]} size The new size the matrix should have.
-       * @param {MatrixValue} [defaultValue=0] Default value, filled in on new entries.
-       *                             If not provided, the matrix elements will
-       *                             be filled with zeros.
-       * @param {boolean} [copy] Return a resized copy of the matrix
+       * @param {Number[]} _size The new size (not used)
+       * @param {MatrixValue} [_defaultValue=0] Default value for new entries (not used)
+       * @param {boolean} [_copy] Return a resized copy (not used)
        *
-       * @return {ImmutableDenseMatrix} The resized matrix
+       * @throws {Error} Operation not allowed
        */
       resize(_size, _defaultValue, _copy) {
         throw new Error("Cannot invoke resize on an Immutable Matrix instance");
@@ -36734,12 +36974,12 @@ var createImmutableDenseMatrixClass = /* @__PURE__ */ factory(
         return new ImmutableDenseMatrix(json);
       }
       /**
-       * Swap rows i and j in Matrix.
+       * Disallows swapping rows in favor of immutability.
        *
-       * @param {Number} i Matrix row index 1
-       * @param {Number} j Matrix row index 2
+       * @param {Number} _i Matrix row index 1 (not used)
+       * @param {Number} _j Matrix row index 2 (not used)
        *
-       * @return {Matrix} The matrix reference
+       * @throws {Error} Operation not allowed
        */
       swapRows(_i, _j) {
         throw new Error("Cannot invoke swapRows on an Immutable Matrix instance");
@@ -37912,7 +38152,7 @@ var createSpaClass = /* @__PURE__ */ factory(
        * Set the value for index i.
        *
        * @param {number} i                       The index
-       * @param {number | BigNumber | Complex}   The value at index i
+       * @param {number | BigNumber | Complex} v The value at index i
        */
       set(i, v) {
         if (!this._values[i]) {
@@ -39530,7 +39770,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         if (node.op === "-") {
           if (isOperatorNode(a0)) {
             if (a0.isBinary() && a0.fn === "subtract") {
-              node = new OperatorNode("-", "subtract", [a0.args[1], a0.args[0]]);
+              node = new OperatorNode("-", "subtract", [
+                a0.args[1],
+                a0.args[0]
+              ]);
               finish = false;
             }
             if (a0.isUnary() && a0.op === "-") {
@@ -39538,7 +39781,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
             }
           }
         }
-        if (finish) return new OperatorNode(node.op, node.fn, [a0]);
+        if (finish)
+          return new OperatorNode(node.op, node.fn, [
+            a0
+          ]);
       }
       if (isOperatorNode(node) && node.isBinary()) {
         const a0 = _simplifyCore(node.args[0], options);
@@ -39557,7 +39803,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         }
         if (node.op === "-") {
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
-            return _simplifyCore(new OperatorNode("+", "add", [a0, a1.args[0]]), options);
+            return _simplifyCore(
+              new OperatorNode("+", "add", [a0, a1.args[0]]),
+              options
+            );
           }
           if (isConstantNode(a0) && isZero4(a0.value)) {
             return _simplifyCore(new OperatorNode("-", "unaryMinus", [a1]));
@@ -39565,7 +39814,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           if (isConstantNode(a1) && isZero4(a1.value)) {
             return a0;
           }
-          return new OperatorNode(node.op, node.fn, [a0, a1]);
+          return new OperatorNode(node.op, node.fn, [
+            a0,
+            a1
+          ]);
         }
         if (node.op === "*") {
           if (isConstantNode(a0)) {
@@ -39582,10 +39834,20 @@ var createSimplifyCore = /* @__PURE__ */ factory(
               return a0;
             }
             if (isCommutative(node, context)) {
-              return new OperatorNode(node.op, node.fn, [a1, a0], node.implicit);
+              return new OperatorNode(
+                node.op,
+                node.fn,
+                [a1, a0],
+                node.implicit
+              );
             }
           }
-          return new OperatorNode(node.op, node.fn, [a0, a1], node.implicit);
+          return new OperatorNode(
+            node.op,
+            node.fn,
+            [a0, a1],
+            node.implicit
+          );
         }
         if (node.op === "/") {
           if (isConstantNode(a0) && isZero4(a0.value)) {
@@ -39594,7 +39856,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           if (isConstantNode(a1) && equal2(a1.value, 1)) {
             return a0;
           }
-          return new OperatorNode(node.op, node.fn, [a0, a1]);
+          return new OperatorNode(node.op, node.fn, [
+            a0,
+            a1
+          ]);
         }
         if (node.op === "^") {
           if (isConstantNode(a1)) {
@@ -39640,7 +39905,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
             }
           }
         }
-        return new OperatorNode(node.op, node.fn, [a0, a1]);
+        return new OperatorNode(node.op, node.fn, [
+          a0,
+          a1
+        ]);
       }
       if (isOperatorNode(node)) {
         return new OperatorNode(
@@ -39650,7 +39918,9 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         );
       }
       if (isArrayNode(node)) {
-        return new ArrayNode(node.items.map((n) => _simplifyCore(n, options)));
+        return new ArrayNode(
+          node.items.map((n) => _simplifyCore(n, options))
+        );
       }
       if (isAccessorNode(node)) {
         return new AccessorNode(
@@ -39659,7 +39929,9 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         );
       }
       if (isIndexNode(node)) {
-        return new IndexNode(node.dimensions.map((n) => _simplifyCore(n, options)));
+        return new IndexNode(
+          node.dimensions.map((n) => _simplifyCore(n, options))
+        );
       }
       if (isObjectNode(node)) {
         const newProps = {};
@@ -43242,9 +43514,7 @@ var createRationalize = /* @__PURE__ */ factory(
           } else {
             const op = node2.op;
             if (op !== "+" && op !== "-" && op !== "*" && op !== "^" && (!extended || op !== "/")) {
-              throw new Error(
-                "Operator " + op + " invalid in polynomial expression"
-              );
+              throw new Error("Operator " + op + " invalid in polynomial expression");
             }
             for (let i = 0; i < node2.args.length; i++) {
               recPoly(node2.args[i]);
@@ -47447,7 +47717,9 @@ function cumtrapz(y, x) {
   } else if (x !== void 0) {
     const xs = toArr(x);
     if (xs.length < a.length)
-      throw new Error(`cumtrapz: abscissa x (length ${xs.length}) is shorter than y (length ${a.length})`);
+      throw new Error(
+        `cumtrapz: abscissa x (length ${xs.length}) is shorter than y (length ${a.length})`
+      );
     dxAt = (i) => xs[i + 1] - xs[i];
   } else {
     dxAt = () => 1;
@@ -47534,7 +47806,9 @@ function wilcoxon(x, y) {
   const a = arr2(x);
   const yy = y !== void 0 ? arr2(y) : void 0;
   if (yy !== void 0 && yy.length !== a.length)
-    throw new Error(`wilcoxon: paired samples must have equal length (${a.length} vs ${yy.length})`);
+    throw new Error(
+      `wilcoxon: paired samples must have equal length (${a.length} vs ${yy.length})`
+    );
   const diffs = yy !== void 0 ? a.map((v, i) => v - yy[i]) : a;
   const d = diffs.filter((v) => v !== 0);
   const n = d.length;
@@ -47590,7 +47864,13 @@ function studentizedRangeCDF(q, k, df) {
   const fU = (u) => Math.exp(logc + (nu - 1) * Math.log(u) - nu * u * u / 2);
   let umax = 1 + 12 / Math.sqrt(nu);
   for (let iter = 0; iter < 20 && simpson2(fU, 1e-5, umax, 120) < 1 - 1e-6; iter++) umax *= 1.5;
-  return Math.min(1, Math.max(0, simpson2((u) => fU(u) * rangeProb(q * u, k), 1e-5, umax, 120)));
+  return Math.min(
+    1,
+    Math.max(
+      0,
+      simpson2((u) => fU(u) * rangeProb(q * u, k), 1e-5, umax, 120)
+    )
+  );
 }
 function studentizedRangeQuantile(p, k, df) {
   if (!(p > 0 && p < 1)) throw new Error("studentizedRangeQuantile: p must be in (0, 1)");
@@ -47616,7 +47896,9 @@ function tukeyHSD(groups, alpha2 = 0.05) {
   const N2 = gs.reduce((s, g) => s + g.length, 0);
   const dfErr = N2 - k;
   if (dfErr <= 0)
-    throw new Error("tukeyHSD: residual df must be > 0 (groups must hold more observations than groups)");
+    throw new Error(
+      "tukeyHSD: residual df must be > 0 (groups must hold more observations than groups)"
+    );
   const sse = gs.reduce((s, g) => s + sampleVar(g) * (g.length - 1), 0);
   const mse = sse / dfErr;
   const qCrit = studentizedRangeQuantile(1 - alpha2, k, dfErr);
@@ -54038,7 +54320,10 @@ function quaternionFromAxisAngle(axis, angle) {
   return [Math.cos(angle / 2), axis[0] / n * s, axis[1] / n * s, axis[2] / n * s];
 }
 function quaternionRotate(q, v) {
-  const r = quaternionMultiply(quaternionMultiply(q, [0, v[0], v[1], v[2]]), quaternionConjugate(q));
+  const r = quaternionMultiply(
+    quaternionMultiply(q, [0, v[0], v[1], v[2]]),
+    quaternionConjugate(q)
+  );
   return [r[1], r[2], r[3]];
 }
 function quaternionToRotationMatrix(q) {