@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/layout/lib/node_modules/ml-matrix/matrix2.js

@@ -0,0 +1,2936 @@
+var Ve = Object.defineProperty;
+var Pt = (D) => {
+  throw TypeError(D);
+};
+var Le = (D, C, B) => C in D ? Ve(D, C, { enumerable: !0, configurable: !0, writable: !0, value: B }) : D[C] = B;
+var Vt = (D, C, B) => Le(D, typeof C != "symbol" ? C + "" : C, B), kt = (D, C, B) => C.has(D) || Pt("Cannot " + B);
+var x = (D, C, B) => (kt(D, C, "read from private field"), B ? B.call(D) : C.get(D)), Rt = (D, C, B) => C.has(D) ? Pt("Cannot add the same private member more than once") : C instanceof WeakSet ? C.add(D) : C.set(D, B), Mt = (D, C, B, ht) => (kt(D, C, "write to private field"), ht ? ht.call(D, B) : C.set(D, B), B), vt = (D, C, B) => (kt(D, C, "access private method"), B);
+import { __exports as I } from "../../_virtual/matrix2.js";
+import Ue from "../../_virtual/index2.js";
+import Be from "../../_virtual/index3.js";
+var Lt;
+function Je() {
+  var ut, Nt, J;
+  if (Lt) return I;
+  Lt = 1, Object.defineProperty(I, "__esModule", { value: !0 });
+  var D = Ue, C = Be;
+  const B = " ".repeat(2), ht = " ".repeat(4);
+  function Ut() {
+    return qt(this);
+  }
+  function qt(i, o = {}) {
+    const {
+      maxRows: e = 15,
+      maxColumns: t = 10,
+      maxNumSize: s = 8,
+      padMinus: r = "auto"
+    } = o;
+    return `${i.constructor.name} {
+${B}[
+${ht}${Bt(i, e, t, s, r)}
+${B}]
+${B}rows: ${i.rows}
+${B}columns: ${i.columns}
+}`;
+  }
+  function Bt(i, o, e, t, s) {
+    const { rows: r, columns: n } = i, l = Math.min(r, o), h = Math.min(n, e), u = [];
+    if (s === "auto") {
+      s = !1;
+      t: for (let w = 0; w < l; w++)
+        for (let f = 0; f < h; f++)
+          if (i.get(w, f) < 0) {
+            s = !0;
+            break t;
+          }
+    }
+    for (let w = 0; w < l; w++) {
+      let f = [];
+      for (let a = 0; a < h; a++)
+        f.push(Ot(i.get(w, a), t, s));
+      u.push(`${f.join(" ")}`);
+    }
+    return h !== n && (u[u.length - 1] += ` ... ${n - e} more columns`), l !== r && u.push(`... ${r - o} more rows`), u.join(`
+${ht}`);
+  }
+  function Ot(i, o, e) {
+    return (i >= 0 && e ? ` ${Tt(i, o - 1)}` : Tt(i, o)).padEnd(o);
+  }
+  function Tt(i, o) {
+    let e = i.toString();
+    if (e.length <= o) return e;
+    let t = i.toFixed(o);
+    if (t.length > o && (t = i.toFixed(Math.max(0, o - (t.length - o)))), t.length <= o && !t.startsWith("0.000") && !t.startsWith("-0.000"))
+      return t;
+    let s = i.toExponential(o);
+    return s.length > o && (s = i.toExponential(Math.max(0, o - (s.length - o)))), s.slice(0);
+  }
+  function Qt(i, o) {
+    i.prototype.add = function(t) {
+      return typeof t == "number" ? this.addS(t) : this.addM(t);
+    }, i.prototype.addS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) + t);
+      return this;
+    }, i.prototype.addM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) + t.get(s, r));
+      return this;
+    }, i.add = function(t, s) {
+      return new o(t).add(s);
+    }, i.prototype.sub = function(t) {
+      return typeof t == "number" ? this.subS(t) : this.subM(t);
+    }, i.prototype.subS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) - t);
+      return this;
+    }, i.prototype.subM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) - t.get(s, r));
+      return this;
+    }, i.sub = function(t, s) {
+      return new o(t).sub(s);
+    }, i.prototype.subtract = i.prototype.sub, i.prototype.subtractS = i.prototype.subS, i.prototype.subtractM = i.prototype.subM, i.subtract = i.sub, i.prototype.mul = function(t) {
+      return typeof t == "number" ? this.mulS(t) : this.mulM(t);
+    }, i.prototype.mulS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) * t);
+      return this;
+    }, i.prototype.mulM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) * t.get(s, r));
+      return this;
+    }, i.mul = function(t, s) {
+      return new o(t).mul(s);
+    }, i.prototype.multiply = i.prototype.mul, i.prototype.multiplyS = i.prototype.mulS, i.prototype.multiplyM = i.prototype.mulM, i.multiply = i.mul, i.prototype.div = function(t) {
+      return typeof t == "number" ? this.divS(t) : this.divM(t);
+    }, i.prototype.divS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) / t);
+      return this;
+    }, i.prototype.divM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) / t.get(s, r));
+      return this;
+    }, i.div = function(t, s) {
+      return new o(t).div(s);
+    }, i.prototype.divide = i.prototype.div, i.prototype.divideS = i.prototype.divS, i.prototype.divideM = i.prototype.divM, i.divide = i.div, i.prototype.mod = function(t) {
+      return typeof t == "number" ? this.modS(t) : this.modM(t);
+    }, i.prototype.modS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) % t);
+      return this;
+    }, i.prototype.modM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) % t.get(s, r));
+      return this;
+    }, i.mod = function(t, s) {
+      return new o(t).mod(s);
+    }, i.prototype.modulus = i.prototype.mod, i.prototype.modulusS = i.prototype.modS, i.prototype.modulusM = i.prototype.modM, i.modulus = i.mod, i.prototype.and = function(t) {
+      return typeof t == "number" ? this.andS(t) : this.andM(t);
+    }, i.prototype.andS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) & t);
+      return this;
+    }, i.prototype.andM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) & t.get(s, r));
+      return this;
+    }, i.and = function(t, s) {
+      return new o(t).and(s);
+    }, i.prototype.or = function(t) {
+      return typeof t == "number" ? this.orS(t) : this.orM(t);
+    }, i.prototype.orS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) | t);
+      return this;
+    }, i.prototype.orM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) | t.get(s, r));
+      return this;
+    }, i.or = function(t, s) {
+      return new o(t).or(s);
+    }, i.prototype.xor = function(t) {
+      return typeof t == "number" ? this.xorS(t) : this.xorM(t);
+    }, i.prototype.xorS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) ^ t);
+      return this;
+    }, i.prototype.xorM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) ^ t.get(s, r));
+      return this;
+    }, i.xor = function(t, s) {
+      return new o(t).xor(s);
+    }, i.prototype.leftShift = function(t) {
+      return typeof t == "number" ? this.leftShiftS(t) : this.leftShiftM(t);
+    }, i.prototype.leftShiftS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) << t);
+      return this;
+    }, i.prototype.leftShiftM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) << t.get(s, r));
+      return this;
+    }, i.leftShift = function(t, s) {
+      return new o(t).leftShift(s);
+    }, i.prototype.signPropagatingRightShift = function(t) {
+      return typeof t == "number" ? this.signPropagatingRightShiftS(t) : this.signPropagatingRightShiftM(t);
+    }, i.prototype.signPropagatingRightShiftS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) >> t);
+      return this;
+    }, i.prototype.signPropagatingRightShiftM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) >> t.get(s, r));
+      return this;
+    }, i.signPropagatingRightShift = function(t, s) {
+      return new o(t).signPropagatingRightShift(s);
+    }, i.prototype.rightShift = function(t) {
+      return typeof t == "number" ? this.rightShiftS(t) : this.rightShiftM(t);
+    }, i.prototype.rightShiftS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) >>> t);
+      return this;
+    }, i.prototype.rightShiftM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) >>> t.get(s, r));
+      return this;
+    }, i.rightShift = function(t, s) {
+      return new o(t).rightShift(s);
+    }, i.prototype.zeroFillRightShift = i.prototype.rightShift, i.prototype.zeroFillRightShiftS = i.prototype.rightShiftS, i.prototype.zeroFillRightShiftM = i.prototype.rightShiftM, i.zeroFillRightShift = i.rightShift, i.prototype.not = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, ~this.get(t, s));
+      return this;
+    }, i.not = function(t) {
+      return new o(t).not();
+    }, i.prototype.abs = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.abs(this.get(t, s)));
+      return this;
+    }, i.abs = function(t) {
+      return new o(t).abs();
+    }, i.prototype.acos = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.acos(this.get(t, s)));
+      return this;
+    }, i.acos = function(t) {
+      return new o(t).acos();
+    }, i.prototype.acosh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.acosh(this.get(t, s)));
+      return this;
+    }, i.acosh = function(t) {
+      return new o(t).acosh();
+    }, i.prototype.asin = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.asin(this.get(t, s)));
+      return this;
+    }, i.asin = function(t) {
+      return new o(t).asin();
+    }, i.prototype.asinh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.asinh(this.get(t, s)));
+      return this;
+    }, i.asinh = function(t) {
+      return new o(t).asinh();
+    }, i.prototype.atan = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.atan(this.get(t, s)));
+      return this;
+    }, i.atan = function(t) {
+      return new o(t).atan();
+    }, i.prototype.atanh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.atanh(this.get(t, s)));
+      return this;
+    }, i.atanh = function(t) {
+      return new o(t).atanh();
+    }, i.prototype.cbrt = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.cbrt(this.get(t, s)));
+      return this;
+    }, i.cbrt = function(t) {
+      return new o(t).cbrt();
+    }, i.prototype.ceil = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.ceil(this.get(t, s)));
+      return this;
+    }, i.ceil = function(t) {
+      return new o(t).ceil();
+    }, i.prototype.clz32 = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.clz32(this.get(t, s)));
+      return this;
+    }, i.clz32 = function(t) {
+      return new o(t).clz32();
+    }, i.prototype.cos = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.cos(this.get(t, s)));
+      return this;
+    }, i.cos = function(t) {
+      return new o(t).cos();
+    }, i.prototype.cosh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.cosh(this.get(t, s)));
+      return this;
+    }, i.cosh = function(t) {
+      return new o(t).cosh();
+    }, i.prototype.exp = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.exp(this.get(t, s)));
+      return this;
+    }, i.exp = function(t) {
+      return new o(t).exp();
+    }, i.prototype.expm1 = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.expm1(this.get(t, s)));
+      return this;
+    }, i.expm1 = function(t) {
+      return new o(t).expm1();
+    }, i.prototype.floor = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.floor(this.get(t, s)));
+      return this;
+    }, i.floor = function(t) {
+      return new o(t).floor();
+    }, i.prototype.fround = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.fround(this.get(t, s)));
+      return this;
+    }, i.fround = function(t) {
+      return new o(t).fround();
+    }, i.prototype.log = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.log(this.get(t, s)));
+      return this;
+    }, i.log = function(t) {
+      return new o(t).log();
+    }, i.prototype.log1p = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.log1p(this.get(t, s)));
+      return this;
+    }, i.log1p = function(t) {
+      return new o(t).log1p();
+    }, i.prototype.log10 = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.log10(this.get(t, s)));
+      return this;
+    }, i.log10 = function(t) {
+      return new o(t).log10();
+    }, i.prototype.log2 = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.log2(this.get(t, s)));
+      return this;
+    }, i.log2 = function(t) {
+      return new o(t).log2();
+    }, i.prototype.round = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.round(this.get(t, s)));
+      return this;
+    }, i.round = function(t) {
+      return new o(t).round();
+    }, i.prototype.sign = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.sign(this.get(t, s)));
+      return this;
+    }, i.sign = function(t) {
+      return new o(t).sign();
+    }, i.prototype.sin = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.sin(this.get(t, s)));
+      return this;
+    }, i.sin = function(t) {
+      return new o(t).sin();
+    }, i.prototype.sinh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.sinh(this.get(t, s)));
+      return this;
+    }, i.sinh = function(t) {
+      return new o(t).sinh();
+    }, i.prototype.sqrt = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.sqrt(this.get(t, s)));
+      return this;
+    }, i.sqrt = function(t) {
+      return new o(t).sqrt();
+    }, i.prototype.tan = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.tan(this.get(t, s)));
+      return this;
+    }, i.tan = function(t) {
+      return new o(t).tan();
+    }, i.prototype.tanh = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.tanh(this.get(t, s)));
+      return this;
+    }, i.tanh = function(t) {
+      return new o(t).tanh();
+    }, i.prototype.trunc = function() {
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.set(t, s, Math.trunc(this.get(t, s)));
+      return this;
+    }, i.trunc = function(t) {
+      return new o(t).trunc();
+    }, i.pow = function(t, s) {
+      return new o(t).pow(s);
+    }, i.prototype.pow = function(t) {
+      return typeof t == "number" ? this.powS(t) : this.powM(t);
+    }, i.prototype.powS = function(t) {
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) ** t);
+      return this;
+    }, i.prototype.powM = function(t) {
+      if (t = o.checkMatrix(t), this.rows !== t.rows || this.columns !== t.columns)
+        throw new RangeError("Matrices dimensions must be equal");
+      for (let s = 0; s < this.rows; s++)
+        for (let r = 0; r < this.columns; r++)
+          this.set(s, r, this.get(s, r) ** t.get(s, r));
+      return this;
+    };
+  }
+  function Z(i, o, e) {
+    let t = e ? i.rows : i.rows - 1;
+    if (o < 0 || o > t)
+      throw new RangeError("Row index out of range");
+  }
+  function _(i, o, e) {
+    let t = e ? i.columns : i.columns - 1;
+    if (o < 0 || o > t)
+      throw new RangeError("Column index out of range");
+  }
+  function rt(i, o) {
+    if (o.to1DArray && (o = o.to1DArray()), o.length !== i.columns)
+      throw new RangeError(
+        "vector size must be the same as the number of columns"
+      );
+    return o;
+  }
+  function it(i, o) {
+    if (o.to1DArray && (o = o.to1DArray()), o.length !== i.rows)
+      throw new RangeError("vector size must be the same as the number of rows");
+    return o;
+  }
+  function jt(i, o) {
+    if (!D.isAnyArray(o))
+      throw new TypeError("row indices must be an array");
+    for (let e = 0; e < o.length; e++)
+      if (o[e] < 0 || o[e] >= i.rows)
+        throw new RangeError("row indices are out of range");
+  }
+  function St(i, o) {
+    if (!D.isAnyArray(o))
+      throw new TypeError("column indices must be an array");
+    for (let e = 0; e < o.length; e++)
+      if (o[e] < 0 || o[e] >= i.columns)
+        throw new RangeError("column indices are out of range");
+  }
+  function Et(i, o, e, t, s) {
+    if (arguments.length !== 5)
+      throw new RangeError("expected 4 arguments");
+    if (ct("startRow", o), ct("endRow", e), ct("startColumn", t), ct("endColumn", s), o > e || t > s || o < 0 || o >= i.rows || e < 0 || e >= i.rows || t < 0 || t >= i.columns || s < 0 || s >= i.columns)
+      throw new RangeError("Submatrix indices are out of range");
+  }
+  function ft(i, o = 0) {
+    let e = [];
+    for (let t = 0; t < i; t++)
+      e.push(o);
+    return e;
+  }
+  function ct(i, o) {
+    if (typeof o != "number")
+      throw new TypeError(`${i} must be a number`);
+  }
+  function nt(i) {
+    if (i.isEmpty())
+      throw new Error("Empty matrix has no elements to index");
+  }
+  function Yt(i) {
+    let o = ft(i.rows);
+    for (let e = 0; e < i.rows; ++e)
+      for (let t = 0; t < i.columns; ++t)
+        o[e] += i.get(e, t);
+    return o;
+  }
+  function Wt(i) {
+    let o = ft(i.columns);
+    for (let e = 0; e < i.rows; ++e)
+      for (let t = 0; t < i.columns; ++t)
+        o[t] += i.get(e, t);
+    return o;
+  }
+  function Jt(i) {
+    let o = 0;
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        o += i.get(e, t);
+    return o;
+  }
+  function Gt(i) {
+    let o = ft(i.rows, 1);
+    for (let e = 0; e < i.rows; ++e)
+      for (let t = 0; t < i.columns; ++t)
+        o[e] *= i.get(e, t);
+    return o;
+  }
+  function Kt(i) {
+    let o = ft(i.columns, 1);
+    for (let e = 0; e < i.rows; ++e)
+      for (let t = 0; t < i.columns; ++t)
+        o[t] *= i.get(e, t);
+    return o;
+  }
+  function Xt(i) {
+    let o = 1;
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        o *= i.get(e, t);
+    return o;
+  }
+  function Zt(i, o, e) {
+    const t = i.rows, s = i.columns, r = [];
+    for (let n = 0; n < t; n++) {
+      let l = 0, h = 0, u = 0;
+      for (let w = 0; w < s; w++)
+        u = i.get(n, w) - e[n], l += u, h += u * u;
+      o ? r.push((h - l * l / s) / (s - 1)) : r.push((h - l * l / s) / s);
+    }
+    return r;
+  }
+  function _t(i, o, e) {
+    const t = i.rows, s = i.columns, r = [];
+    for (let n = 0; n < s; n++) {
+      let l = 0, h = 0, u = 0;
+      for (let w = 0; w < t; w++)
+        u = i.get(w, n) - e[n], l += u, h += u * u;
+      o ? r.push((h - l * l / t) / (t - 1)) : r.push((h - l * l / t) / t);
+    }
+    return r;
+  }
+  function At(i, o, e) {
+    const t = i.rows, s = i.columns, r = t * s;
+    let n = 0, l = 0, h = 0;
+    for (let u = 0; u < t; u++)
+      for (let w = 0; w < s; w++)
+        h = i.get(u, w) - e, n += h, l += h * h;
+    return o ? (l - n * n / r) / (r - 1) : (l - n * n / r) / r;
+  }
+  function xt(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) - o[e]);
+  }
+  function Ht(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) - o[t]);
+  }
+  function te(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) - o);
+  }
+  function ee(i) {
+    const o = [];
+    for (let e = 0; e < i.rows; e++) {
+      let t = 0;
+      for (let s = 0; s < i.columns; s++)
+        t += i.get(e, s) ** 2 / (i.columns - 1);
+      o.push(Math.sqrt(t));
+    }
+    return o;
+  }
+  function se(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) / o[e]);
+  }
+  function oe(i) {
+    const o = [];
+    for (let e = 0; e < i.columns; e++) {
+      let t = 0;
+      for (let s = 0; s < i.rows; s++)
+        t += i.get(s, e) ** 2 / (i.rows - 1);
+      o.push(Math.sqrt(t));
+    }
+    return o;
+  }
+  function re(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) / o[t]);
+  }
+  function ie(i) {
+    const o = i.size - 1;
+    let e = 0;
+    for (let t = 0; t < i.columns; t++)
+      for (let s = 0; s < i.rows; s++)
+        e += i.get(s, t) ** 2 / o;
+    return Math.sqrt(e);
+  }
+  function ne(i, o) {
+    for (let e = 0; e < i.rows; e++)
+      for (let t = 0; t < i.columns; t++)
+        i.set(e, t, i.get(e, t) / o);
+  }
+  class T {
+    static from1DArray(o, e, t) {
+      if (o * e !== t.length)
+        throw new RangeError("data length does not match given dimensions");
+      let r = new S(o, e);
+      for (let n = 0; n < o; n++)
+        for (let l = 0; l < e; l++)
+          r.set(n, l, t[n * e + l]);
+      return r;
+    }
+    static rowVector(o) {
+      let e = new S(1, o.length);
+      for (let t = 0; t < o.length; t++)
+        e.set(0, t, o[t]);
+      return e;
+    }
+    static columnVector(o) {
+      let e = new S(o.length, 1);
+      for (let t = 0; t < o.length; t++)
+        e.set(t, 0, o[t]);
+      return e;
+    }
+    static zeros(o, e) {
+      return new S(o, e);
+    }
+    static ones(o, e) {
+      return new S(o, e).fill(1);
+    }
+    static rand(o, e, t = {}) {
+      if (typeof t != "object")
+        throw new TypeError("options must be an object");
+      const { random: s = Math.random } = t;
+      let r = new S(o, e);
+      for (let n = 0; n < o; n++)
+        for (let l = 0; l < e; l++)
+          r.set(n, l, s());
+      return r;
+    }
+    static randInt(o, e, t = {}) {
+      if (typeof t != "object")
+        throw new TypeError("options must be an object");
+      const { min: s = 0, max: r = 1e3, random: n = Math.random } = t;
+      if (!Number.isInteger(s)) throw new TypeError("min must be an integer");
+      if (!Number.isInteger(r)) throw new TypeError("max must be an integer");
+      if (s >= r) throw new RangeError("min must be smaller than max");
+      let l = r - s, h = new S(o, e);
+      for (let u = 0; u < o; u++)
+        for (let w = 0; w < e; w++) {
+          let f = s + Math.round(n() * l);
+          h.set(u, w, f);
+        }
+      return h;
+    }
+    static eye(o, e, t) {
+      e === void 0 && (e = o), t === void 0 && (t = 1);
+      let s = Math.min(o, e), r = this.zeros(o, e);
+      for (let n = 0; n < s; n++)
+        r.set(n, n, t);
+      return r;
+    }
+    static diag(o, e, t) {
+      let s = o.length;
+      e === void 0 && (e = s), t === void 0 && (t = e);
+      let r = Math.min(s, e, t), n = this.zeros(e, t);
+      for (let l = 0; l < r; l++)
+        n.set(l, l, o[l]);
+      return n;
+    }
+    static min(o, e) {
+      o = this.checkMatrix(o), e = this.checkMatrix(e);
+      let t = o.rows, s = o.columns, r = new S(t, s);
+      for (let n = 0; n < t; n++)
+        for (let l = 0; l < s; l++)
+          r.set(n, l, Math.min(o.get(n, l), e.get(n, l)));
+      return r;
+    }
+    static max(o, e) {
+      o = this.checkMatrix(o), e = this.checkMatrix(e);
+      let t = o.rows, s = o.columns, r = new this(t, s);
+      for (let n = 0; n < t; n++)
+        for (let l = 0; l < s; l++)
+          r.set(n, l, Math.max(o.get(n, l), e.get(n, l)));
+      return r;
+    }
+    static checkMatrix(o) {
+      return T.isMatrix(o) ? o : new S(o);
+    }
+    static isMatrix(o) {
+      return o != null && o.klass === "Matrix";
+    }
+    get size() {
+      return this.rows * this.columns;
+    }
+    apply(o) {
+      if (typeof o != "function")
+        throw new TypeError("callback must be a function");
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          o.call(this, e, t);
+      return this;
+    }
+    to1DArray() {
+      let o = [];
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          o.push(this.get(e, t));
+      return o;
+    }
+    to2DArray() {
+      let o = [];
+      for (let e = 0; e < this.rows; e++) {
+        o.push([]);
+        for (let t = 0; t < this.columns; t++)
+          o[e].push(this.get(e, t));
+      }
+      return o;
+    }
+    toJSON() {
+      return this.to2DArray();
+    }
+    isRowVector() {
+      return this.rows === 1;
+    }
+    isColumnVector() {
+      return this.columns === 1;
+    }
+    isVector() {
+      return this.rows === 1 || this.columns === 1;
+    }
+    isSquare() {
+      return this.rows === this.columns;
+    }
+    isEmpty() {
+      return this.rows === 0 || this.columns === 0;
+    }
+    isSymmetric() {
+      if (this.isSquare()) {
+        for (let o = 0; o < this.rows; o++)
+          for (let e = 0; e <= o; e++)
+            if (this.get(o, e) !== this.get(e, o))
+              return !1;
+        return !0;
+      }
+      return !1;
+    }
+    isDistance() {
+      if (!this.isSymmetric()) return !1;
+      for (let o = 0; o < this.rows; o++)
+        if (this.get(o, o) !== 0) return !1;
+      return !0;
+    }
+    isEchelonForm() {
+      let o = 0, e = 0, t = -1, s = !0, r = !1;
+      for (; o < this.rows && s; ) {
+        for (e = 0, r = !1; e < this.columns && r === !1; )
+          this.get(o, e) === 0 ? e++ : this.get(o, e) === 1 && e > t ? (r = !0, t = e) : (s = !1, r = !0);
+        o++;
+      }
+      return s;
+    }
+    isReducedEchelonForm() {
+      let o = 0, e = 0, t = -1, s = !0, r = !1;
+      for (; o < this.rows && s; ) {
+        for (e = 0, r = !1; e < this.columns && r === !1; )
+          this.get(o, e) === 0 ? e++ : this.get(o, e) === 1 && e > t ? (r = !0, t = e) : (s = !1, r = !0);
+        for (let n = e + 1; n < this.rows; n++)
+          this.get(o, n) !== 0 && (s = !1);
+        o++;
+      }
+      return s;
+    }
+    echelonForm() {
+      let o = this.clone(), e = 0, t = 0;
+      for (; e < o.rows && t < o.columns; ) {
+        let s = e;
+        for (let r = e; r < o.rows; r++)
+          o.get(r, t) > o.get(s, t) && (s = r);
+        if (o.get(s, t) === 0)
+          t++;
+        else {
+          o.swapRows(e, s);
+          let r = o.get(e, t);
+          for (let n = t; n < o.columns; n++)
+            o.set(e, n, o.get(e, n) / r);
+          for (let n = e + 1; n < o.rows; n++) {
+            let l = o.get(n, t) / o.get(e, t);
+            o.set(n, t, 0);
+            for (let h = t + 1; h < o.columns; h++)
+              o.set(n, h, o.get(n, h) - o.get(e, h) * l);
+          }
+          e++, t++;
+        }
+      }
+      return o;
+    }
+    reducedEchelonForm() {
+      let o = this.echelonForm(), e = o.columns, t = o.rows, s = t - 1;
+      for (; s >= 0; )
+        if (o.maxRow(s) === 0)
+          s--;
+        else {
+          let r = 0, n = !1;
+          for (; r < t && n === !1; )
+            o.get(s, r) === 1 ? n = !0 : r++;
+          for (let l = 0; l < s; l++) {
+            let h = o.get(l, r);
+            for (let u = r; u < e; u++) {
+              let w = o.get(l, u) - h * o.get(s, u);
+              o.set(l, u, w);
+            }
+          }
+          s--;
+        }
+      return o;
+    }
+    set() {
+      throw new Error("set method is unimplemented");
+    }
+    get() {
+      throw new Error("get method is unimplemented");
+    }
+    repeat(o = {}) {
+      if (typeof o != "object")
+        throw new TypeError("options must be an object");
+      const { rows: e = 1, columns: t = 1 } = o;
+      if (!Number.isInteger(e) || e <= 0)
+        throw new TypeError("rows must be a positive integer");
+      if (!Number.isInteger(t) || t <= 0)
+        throw new TypeError("columns must be a positive integer");
+      let s = new S(this.rows * e, this.columns * t);
+      for (let r = 0; r < e; r++)
+        for (let n = 0; n < t; n++)
+          s.setSubMatrix(this, this.rows * r, this.columns * n);
+      return s;
+    }
+    fill(o) {
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, o);
+      return this;
+    }
+    neg() {
+      return this.mulS(-1);
+    }
+    getRow(o) {
+      Z(this, o);
+      let e = [];
+      for (let t = 0; t < this.columns; t++)
+        e.push(this.get(o, t));
+      return e;
+    }
+    getRowVector(o) {
+      return S.rowVector(this.getRow(o));
+    }
+    setRow(o, e) {
+      Z(this, o), e = rt(this, e);
+      for (let t = 0; t < this.columns; t++)
+        this.set(o, t, e[t]);
+      return this;
+    }
+    swapRows(o, e) {
+      Z(this, o), Z(this, e);
+      for (let t = 0; t < this.columns; t++) {
+        let s = this.get(o, t);
+        this.set(o, t, this.get(e, t)), this.set(e, t, s);
+      }
+      return this;
+    }
+    getColumn(o) {
+      _(this, o);
+      let e = [];
+      for (let t = 0; t < this.rows; t++)
+        e.push(this.get(t, o));
+      return e;
+    }
+    getColumnVector(o) {
+      return S.columnVector(this.getColumn(o));
+    }
+    setColumn(o, e) {
+      _(this, o), e = it(this, e);
+      for (let t = 0; t < this.rows; t++)
+        this.set(t, o, e[t]);
+      return this;
+    }
+    swapColumns(o, e) {
+      _(this, o), _(this, e);
+      for (let t = 0; t < this.rows; t++) {
+        let s = this.get(t, o);
+        this.set(t, o, this.get(t, e)), this.set(t, e, s);
+      }
+      return this;
+    }
+    addRowVector(o) {
+      o = rt(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) + o[t]);
+      return this;
+    }
+    subRowVector(o) {
+      o = rt(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) - o[t]);
+      return this;
+    }
+    mulRowVector(o) {
+      o = rt(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) * o[t]);
+      return this;
+    }
+    divRowVector(o) {
+      o = rt(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) / o[t]);
+      return this;
+    }
+    addColumnVector(o) {
+      o = it(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) + o[e]);
+      return this;
+    }
+    subColumnVector(o) {
+      o = it(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) - o[e]);
+      return this;
+    }
+    mulColumnVector(o) {
+      o = it(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) * o[e]);
+      return this;
+    }
+    divColumnVector(o) {
+      o = it(this, o);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          this.set(e, t, this.get(e, t) / o[e]);
+      return this;
+    }
+    mulRow(o, e) {
+      Z(this, o);
+      for (let t = 0; t < this.columns; t++)
+        this.set(o, t, this.get(o, t) * e);
+      return this;
+    }
+    mulColumn(o, e) {
+      _(this, o);
+      for (let t = 0; t < this.rows; t++)
+        this.set(t, o, this.get(t, o) * e);
+      return this;
+    }
+    max(o) {
+      if (this.isEmpty())
+        return NaN;
+      switch (o) {
+        case "row": {
+          const e = new Array(this.rows).fill(Number.NEGATIVE_INFINITY);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) > e[t] && (e[t] = this.get(t, s));
+          return e;
+        }
+        case "column": {
+          const e = new Array(this.columns).fill(Number.NEGATIVE_INFINITY);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) > e[s] && (e[s] = this.get(t, s));
+          return e;
+        }
+        case void 0: {
+          let e = this.get(0, 0);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) > e && (e = this.get(t, s));
+          return e;
+        }
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    maxIndex() {
+      nt(this);
+      let o = this.get(0, 0), e = [0, 0];
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.get(t, s) > o && (o = this.get(t, s), e[0] = t, e[1] = s);
+      return e;
+    }
+    min(o) {
+      if (this.isEmpty())
+        return NaN;
+      switch (o) {
+        case "row": {
+          const e = new Array(this.rows).fill(Number.POSITIVE_INFINITY);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) < e[t] && (e[t] = this.get(t, s));
+          return e;
+        }
+        case "column": {
+          const e = new Array(this.columns).fill(Number.POSITIVE_INFINITY);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) < e[s] && (e[s] = this.get(t, s));
+          return e;
+        }
+        case void 0: {
+          let e = this.get(0, 0);
+          for (let t = 0; t < this.rows; t++)
+            for (let s = 0; s < this.columns; s++)
+              this.get(t, s) < e && (e = this.get(t, s));
+          return e;
+        }
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    minIndex() {
+      nt(this);
+      let o = this.get(0, 0), e = [0, 0];
+      for (let t = 0; t < this.rows; t++)
+        for (let s = 0; s < this.columns; s++)
+          this.get(t, s) < o && (o = this.get(t, s), e[0] = t, e[1] = s);
+      return e;
+    }
+    maxRow(o) {
+      if (Z(this, o), this.isEmpty())
+        return NaN;
+      let e = this.get(o, 0);
+      for (let t = 1; t < this.columns; t++)
+        this.get(o, t) > e && (e = this.get(o, t));
+      return e;
+    }
+    maxRowIndex(o) {
+      Z(this, o), nt(this);
+      let e = this.get(o, 0), t = [o, 0];
+      for (let s = 1; s < this.columns; s++)
+        this.get(o, s) > e && (e = this.get(o, s), t[1] = s);
+      return t;
+    }
+    minRow(o) {
+      if (Z(this, o), this.isEmpty())
+        return NaN;
+      let e = this.get(o, 0);
+      for (let t = 1; t < this.columns; t++)
+        this.get(o, t) < e && (e = this.get(o, t));
+      return e;
+    }
+    minRowIndex(o) {
+      Z(this, o), nt(this);
+      let e = this.get(o, 0), t = [o, 0];
+      for (let s = 1; s < this.columns; s++)
+        this.get(o, s) < e && (e = this.get(o, s), t[1] = s);
+      return t;
+    }
+    maxColumn(o) {
+      if (_(this, o), this.isEmpty())
+        return NaN;
+      let e = this.get(0, o);
+      for (let t = 1; t < this.rows; t++)
+        this.get(t, o) > e && (e = this.get(t, o));
+      return e;
+    }
+    maxColumnIndex(o) {
+      _(this, o), nt(this);
+      let e = this.get(0, o), t = [0, o];
+      for (let s = 1; s < this.rows; s++)
+        this.get(s, o) > e && (e = this.get(s, o), t[0] = s);
+      return t;
+    }
+    minColumn(o) {
+      if (_(this, o), this.isEmpty())
+        return NaN;
+      let e = this.get(0, o);
+      for (let t = 1; t < this.rows; t++)
+        this.get(t, o) < e && (e = this.get(t, o));
+      return e;
+    }
+    minColumnIndex(o) {
+      _(this, o), nt(this);
+      let e = this.get(0, o), t = [0, o];
+      for (let s = 1; s < this.rows; s++)
+        this.get(s, o) < e && (e = this.get(s, o), t[0] = s);
+      return t;
+    }
+    diag() {
+      let o = Math.min(this.rows, this.columns), e = [];
+      for (let t = 0; t < o; t++)
+        e.push(this.get(t, t));
+      return e;
+    }
+    norm(o = "frobenius") {
+      switch (o) {
+        case "max":
+          return this.max();
+        case "frobenius":
+          return Math.sqrt(this.dot(this));
+        default:
+          throw new RangeError(`unknown norm type: ${o}`);
+      }
+    }
+    cumulativeSum() {
+      let o = 0;
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          o += this.get(e, t), this.set(e, t, o);
+      return this;
+    }
+    dot(o) {
+      T.isMatrix(o) && (o = o.to1DArray());
+      let e = this.to1DArray();
+      if (e.length !== o.length)
+        throw new RangeError("vectors do not have the same size");
+      let t = 0;
+      for (let s = 0; s < e.length; s++)
+        t += e[s] * o[s];
+      return t;
+    }
+    mmul(o) {
+      o = S.checkMatrix(o);
+      let e = this.rows, t = this.columns, s = o.columns, r = new S(e, s), n = new Float64Array(t);
+      for (let l = 0; l < s; l++) {
+        for (let h = 0; h < t; h++)
+          n[h] = o.get(h, l);
+        for (let h = 0; h < e; h++) {
+          let u = 0;
+          for (let w = 0; w < t; w++)
+            u += this.get(h, w) * n[w];
+          r.set(h, l, u);
+        }
+      }
+      return r;
+    }
+    mpow(o) {
+      if (!this.isSquare())
+        throw new RangeError("Matrix must be square");
+      if (!Number.isInteger(o) || o < 0)
+        throw new RangeError("Exponent must be a non-negative integer");
+      let e = S.eye(this.rows), t = this;
+      for (let s = o; s >= 1; s /= 2)
+        (s & 1) !== 0 && (e = e.mmul(t)), t = t.mmul(t);
+      return e;
+    }
+    strassen2x2(o) {
+      o = S.checkMatrix(o);
+      let e = new S(2, 2);
+      const t = this.get(0, 0), s = o.get(0, 0), r = this.get(0, 1), n = o.get(0, 1), l = this.get(1, 0), h = o.get(1, 0), u = this.get(1, 1), w = o.get(1, 1), f = (t + u) * (s + w), a = (l + u) * s, j = t * (n - w), m = u * (h - s), p = (t + r) * w, E = (l - t) * (s + n), c = (r - u) * (h + w), M = f + m - p + c, k = j + p, N = a + m, q = f - a + j + E;
+      return e.set(0, 0, M), e.set(0, 1, k), e.set(1, 0, N), e.set(1, 1, q), e;
+    }
+    strassen3x3(o) {
+      o = S.checkMatrix(o);
+      let e = new S(3, 3);
+      const t = this.get(0, 0), s = this.get(0, 1), r = this.get(0, 2), n = this.get(1, 0), l = this.get(1, 1), h = this.get(1, 2), u = this.get(2, 0), w = this.get(2, 1), f = this.get(2, 2), a = o.get(0, 0), j = o.get(0, 1), m = o.get(0, 2), p = o.get(1, 0), E = o.get(1, 1), c = o.get(1, 2), M = o.get(2, 0), k = o.get(2, 1), N = o.get(2, 2), q = (t + s + r - n - l - w - f) * E, V = (t - n) * (-j + E), R = l * (-a + j + p - E - c - M + N), v = (-t + n + l) * (a - j + E), z = (n + l) * (-a + j), g = t * a, d = (-t + u + w) * (a - m + c), b = (-t + u) * (m - c), y = (u + w) * (-a + m), L = (t + s + r - l - h - u - w) * c, $ = w * (-a + m + p - E - c - M + k), P = (-r + w + f) * (E + M - k), U = (r - f) * (E - k), Y = r * M, A = (w + f) * (-M + k), O = (-r + l + h) * (c + M - N), H = (r - h) * (c - N), st = (l + h) * (-M + N), F = s * p, W = h * k, K = n * m, X = u * j, Q = f * N, qe = g + Y + F, Te = q + v + z + g + P + Y + A, Ie = g + d + y + L + Y + O + st, De = V + R + v + g + Y + O + H, Fe = V + v + z + g + W, $e = Y + O + H + st + K, ze = g + d + b + $ + P + U + Y, Ce = P + U + Y + A + X, Pe = g + d + b + y + Q;
+      return e.set(0, 0, qe), e.set(0, 1, Te), e.set(0, 2, Ie), e.set(1, 0, De), e.set(1, 1, Fe), e.set(1, 2, $e), e.set(2, 0, ze), e.set(2, 1, Ce), e.set(2, 2, Pe), e;
+    }
+    mmulStrassen(o) {
+      o = S.checkMatrix(o);
+      let e = this.clone(), t = e.rows, s = e.columns, r = o.rows, n = o.columns;
+      s !== r && console.warn(
+        `Multiplying ${t} x ${s} and ${r} x ${n} matrix: dimensions do not match.`
+      );
+      function l(f, a, j) {
+        let m = f.rows, p = f.columns;
+        if (m === a && p === j)
+          return f;
+        {
+          let E = T.zeros(a, j);
+          return E = E.setSubMatrix(f, 0, 0), E;
+        }
+      }
+      let h = Math.max(t, r), u = Math.max(s, n);
+      e = l(e, h, u), o = l(o, h, u);
+      function w(f, a, j, m) {
+        if (j <= 512 || m <= 512)
+          return f.mmul(a);
+        j % 2 === 1 && m % 2 === 1 ? (f = l(f, j + 1, m + 1), a = l(a, j + 1, m + 1)) : j % 2 === 1 ? (f = l(f, j + 1, m), a = l(a, j + 1, m)) : m % 2 === 1 && (f = l(f, j, m + 1), a = l(a, j, m + 1));
+        let p = parseInt(f.rows / 2, 10), E = parseInt(f.columns / 2, 10), c = f.subMatrix(0, p - 1, 0, E - 1), M = a.subMatrix(0, p - 1, 0, E - 1), k = f.subMatrix(0, p - 1, E, f.columns - 1), N = a.subMatrix(0, p - 1, E, a.columns - 1), q = f.subMatrix(p, f.rows - 1, 0, E - 1), V = a.subMatrix(p, a.rows - 1, 0, E - 1), R = f.subMatrix(p, f.rows - 1, E, f.columns - 1), v = a.subMatrix(p, a.rows - 1, E, a.columns - 1), z = w(
+          T.add(c, R),
+          T.add(M, v),
+          p,
+          E
+        ), g = w(T.add(q, R), M, p, E), d = w(c, T.sub(N, v), p, E), b = w(R, T.sub(V, M), p, E), y = w(T.add(c, k), v, p, E), L = w(
+          T.sub(q, c),
+          T.add(M, N),
+          p,
+          E
+        ), $ = w(
+          T.sub(k, R),
+          T.add(V, v),
+          p,
+          E
+        ), P = T.add(z, b);
+        P.sub(y), P.add($);
+        let U = T.add(d, y), Y = T.add(g, b), A = T.sub(z, g);
+        A.add(d), A.add(L);
+        let O = T.zeros(2 * P.rows, 2 * P.columns);
+        return O = O.setSubMatrix(P, 0, 0), O = O.setSubMatrix(U, P.rows, 0), O = O.setSubMatrix(Y, 0, P.columns), O = O.setSubMatrix(A, P.rows, P.columns), O.subMatrix(0, j - 1, 0, m - 1);
+      }
+      return w(e, o, h, u);
+    }
+    scaleRows(o = {}) {
+      if (typeof o != "object")
+        throw new TypeError("options must be an object");
+      const { min: e = 0, max: t = 1 } = o;
+      if (!Number.isFinite(e)) throw new TypeError("min must be a number");
+      if (!Number.isFinite(t)) throw new TypeError("max must be a number");
+      if (e >= t) throw new RangeError("min must be smaller than max");
+      let s = new S(this.rows, this.columns);
+      for (let r = 0; r < this.rows; r++) {
+        const n = this.getRow(r);
+        n.length > 0 && C(n, { min: e, max: t, output: n }), s.setRow(r, n);
+      }
+      return s;
+    }
+    scaleColumns(o = {}) {
+      if (typeof o != "object")
+        throw new TypeError("options must be an object");
+      const { min: e = 0, max: t = 1 } = o;
+      if (!Number.isFinite(e)) throw new TypeError("min must be a number");
+      if (!Number.isFinite(t)) throw new TypeError("max must be a number");
+      if (e >= t) throw new RangeError("min must be smaller than max");
+      let s = new S(this.rows, this.columns);
+      for (let r = 0; r < this.columns; r++) {
+        const n = this.getColumn(r);
+        n.length && C(n, {
+          min: e,
+          max: t,
+          output: n
+        }), s.setColumn(r, n);
+      }
+      return s;
+    }
+    flipRows() {
+      const o = Math.ceil(this.columns / 2);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < o; t++) {
+          let s = this.get(e, t), r = this.get(e, this.columns - 1 - t);
+          this.set(e, t, r), this.set(e, this.columns - 1 - t, s);
+        }
+      return this;
+    }
+    flipColumns() {
+      const o = Math.ceil(this.rows / 2);
+      for (let e = 0; e < this.columns; e++)
+        for (let t = 0; t < o; t++) {
+          let s = this.get(t, e), r = this.get(this.rows - 1 - t, e);
+          this.set(t, e, r), this.set(this.rows - 1 - t, e, s);
+        }
+      return this;
+    }
+    kroneckerProduct(o) {
+      o = S.checkMatrix(o);
+      let e = this.rows, t = this.columns, s = o.rows, r = o.columns, n = new S(e * s, t * r);
+      for (let l = 0; l < e; l++)
+        for (let h = 0; h < t; h++)
+          for (let u = 0; u < s; u++)
+            for (let w = 0; w < r; w++)
+              n.set(s * l + u, r * h + w, this.get(l, h) * o.get(u, w));
+      return n;
+    }
+    kroneckerSum(o) {
+      if (o = S.checkMatrix(o), !this.isSquare() || !o.isSquare())
+        throw new Error("Kronecker Sum needs two Square Matrices");
+      let e = this.rows, t = o.rows, s = this.kroneckerProduct(S.eye(t, t)), r = S.eye(e, e).kroneckerProduct(o);
+      return s.add(r);
+    }
+    transpose() {
+      let o = new S(this.columns, this.rows);
+      for (let e = 0; e < this.rows; e++)
+        for (let t = 0; t < this.columns; t++)
+          o.set(t, e, this.get(e, t));
+      return o;
+    }
+    sortRows(o = It) {
+      for (let e = 0; e < this.rows; e++)
+        this.setRow(e, this.getRow(e).sort(o));
+      return this;
+    }
+    sortColumns(o = It) {
+      for (let e = 0; e < this.columns; e++)
+        this.setColumn(e, this.getColumn(e).sort(o));
+      return this;
+    }
+    subMatrix(o, e, t, s) {
+      Et(this, o, e, t, s);
+      let r = new S(
+        e - o + 1,
+        s - t + 1
+      );
+      for (let n = o; n <= e; n++)
+        for (let l = t; l <= s; l++)
+          r.set(n - o, l - t, this.get(n, l));
+      return r;
+    }
+    subMatrixRow(o, e, t) {
+      if (e === void 0 && (e = 0), t === void 0 && (t = this.columns - 1), e > t || e < 0 || e >= this.columns || t < 0 || t >= this.columns)
+        throw new RangeError("Argument out of range");
+      let s = new S(o.length, t - e + 1);
+      for (let r = 0; r < o.length; r++)
+        for (let n = e; n <= t; n++) {
+          if (o[r] < 0 || o[r] >= this.rows)
+            throw new RangeError(`Row index out of range: ${o[r]}`);
+          s.set(r, n - e, this.get(o[r], n));
+        }
+      return s;
+    }
+    subMatrixColumn(o, e, t) {
+      if (e === void 0 && (e = 0), t === void 0 && (t = this.rows - 1), e > t || e < 0 || e >= this.rows || t < 0 || t >= this.rows)
+        throw new RangeError("Argument out of range");
+      let s = new S(t - e + 1, o.length);
+      for (let r = 0; r < o.length; r++)
+        for (let n = e; n <= t; n++) {
+          if (o[r] < 0 || o[r] >= this.columns)
+            throw new RangeError(`Column index out of range: ${o[r]}`);
+          s.set(n - e, r, this.get(n, o[r]));
+        }
+      return s;
+    }
+    setSubMatrix(o, e, t) {
+      if (o = S.checkMatrix(o), o.isEmpty())
+        return this;
+      let s = e + o.rows - 1, r = t + o.columns - 1;
+      Et(this, e, s, t, r);
+      for (let n = 0; n < o.rows; n++)
+        for (let l = 0; l < o.columns; l++)
+          this.set(e + n, t + l, o.get(n, l));
+      return this;
+    }
+    selection(o, e) {
+      jt(this, o), St(this, e);
+      let t = new S(o.length, e.length);
+      for (let s = 0; s < o.length; s++) {
+        let r = o[s];
+        for (let n = 0; n < e.length; n++) {
+          let l = e[n];
+          t.set(s, n, this.get(r, l));
+        }
+      }
+      return t;
+    }
+    trace() {
+      let o = Math.min(this.rows, this.columns), e = 0;
+      for (let t = 0; t < o; t++)
+        e += this.get(t, t);
+      return e;
+    }
+    clone() {
+      return this.constructor.copy(this, new S(this.rows, this.columns));
+    }
+    /**
+     * @template {AbstractMatrix} M
+     * @param {AbstractMatrix} from
+     * @param {M} to
+     * @return {M}
+     */
+    static copy(o, e) {
+      for (const [t, s, r] of o.entries())
+        e.set(t, s, r);
+      return e;
+    }
+    sum(o) {
+      switch (o) {
+        case "row":
+          return Yt(this);
+        case "column":
+          return Wt(this);
+        case void 0:
+          return Jt(this);
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    product(o) {
+      switch (o) {
+        case "row":
+          return Gt(this);
+        case "column":
+          return Kt(this);
+        case void 0:
+          return Xt(this);
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    mean(o) {
+      const e = this.sum(o);
+      switch (o) {
+        case "row": {
+          for (let t = 0; t < this.rows; t++)
+            e[t] /= this.columns;
+          return e;
+        }
+        case "column": {
+          for (let t = 0; t < this.columns; t++)
+            e[t] /= this.rows;
+          return e;
+        }
+        case void 0:
+          return e / this.size;
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    variance(o, e = {}) {
+      if (typeof o == "object" && (e = o, o = void 0), typeof e != "object")
+        throw new TypeError("options must be an object");
+      const { unbiased: t = !0, mean: s = this.mean(o) } = e;
+      if (typeof t != "boolean")
+        throw new TypeError("unbiased must be a boolean");
+      switch (o) {
+        case "row": {
+          if (!D.isAnyArray(s))
+            throw new TypeError("mean must be an array");
+          return Zt(this, t, s);
+        }
+        case "column": {
+          if (!D.isAnyArray(s))
+            throw new TypeError("mean must be an array");
+          return _t(this, t, s);
+        }
+        case void 0: {
+          if (typeof s != "number")
+            throw new TypeError("mean must be a number");
+          return At(this, t, s);
+        }
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    standardDeviation(o, e) {
+      typeof o == "object" && (e = o, o = void 0);
+      const t = this.variance(o, e);
+      if (o === void 0)
+        return Math.sqrt(t);
+      for (let s = 0; s < t.length; s++)
+        t[s] = Math.sqrt(t[s]);
+      return t;
+    }
+    center(o, e = {}) {
+      if (typeof o == "object" && (e = o, o = void 0), typeof e != "object")
+        throw new TypeError("options must be an object");
+      const { center: t = this.mean(o) } = e;
+      switch (o) {
+        case "row": {
+          if (!D.isAnyArray(t))
+            throw new TypeError("center must be an array");
+          return xt(this, t), this;
+        }
+        case "column": {
+          if (!D.isAnyArray(t))
+            throw new TypeError("center must be an array");
+          return Ht(this, t), this;
+        }
+        case void 0: {
+          if (typeof t != "number")
+            throw new TypeError("center must be a number");
+          return te(this, t), this;
+        }
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    scale(o, e = {}) {
+      if (typeof o == "object" && (e = o, o = void 0), typeof e != "object")
+        throw new TypeError("options must be an object");
+      let t = e.scale;
+      switch (o) {
+        case "row": {
+          if (t === void 0)
+            t = ee(this);
+          else if (!D.isAnyArray(t))
+            throw new TypeError("scale must be an array");
+          return se(this, t), this;
+        }
+        case "column": {
+          if (t === void 0)
+            t = oe(this);
+          else if (!D.isAnyArray(t))
+            throw new TypeError("scale must be an array");
+          return re(this, t), this;
+        }
+        case void 0: {
+          if (t === void 0)
+            t = ie(this);
+          else if (typeof t != "number")
+            throw new TypeError("scale must be a number");
+          return ne(this, t), this;
+        }
+        default:
+          throw new Error(`invalid option: ${o}`);
+      }
+    }
+    toString(o) {
+      return qt(this, o);
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    /**
+     * iterator from left to right, from top to bottom
+     * yield [row, column, value]
+     * @returns {Generator<[number, number, number], void, void>}
+     */
+    *entries() {
+      for (let o = 0; o < this.rows; o++)
+        for (let e = 0; e < this.columns; e++)
+          yield [o, e, this.get(o, e)];
+    }
+    /**
+     * iterator from left to right, from top to bottom
+     * yield value
+     * @returns {Generator<number, void, void>}
+     */
+    *values() {
+      for (let o = 0; o < this.rows; o++)
+        for (let e = 0; e < this.columns; e++)
+          yield this.get(o, e);
+    }
+  }
+  T.prototype.klass = "Matrix", typeof Symbol < "u" && (T.prototype[Symbol.for("nodejs.util.inspect.custom")] = Ut);
+  function It(i, o) {
+    return i - o;
+  }
+  function le(i) {
+    return i.every((o) => typeof o == "number");
+  }
+  T.random = T.rand, T.randomInt = T.randInt, T.diagonal = T.diag, T.prototype.diagonal = T.prototype.diag, T.identity = T.eye, T.prototype.negate = T.prototype.neg, T.prototype.tensorProduct = T.prototype.kroneckerProduct;
+  const dt = class dt extends T {
+    constructor(e, t) {
+      super();
+      Rt(this, ut);
+      /**
+       * @type {Float64Array[]}
+       */
+      Vt(this, "data");
+      if (dt.isMatrix(e))
+        vt(this, ut, Nt).call(this, e.rows, e.columns), dt.copy(e, this);
+      else if (Number.isInteger(e) && e >= 0)
+        vt(this, ut, Nt).call(this, e, t);
+      else if (D.isAnyArray(e)) {
+        const s = e;
+        if (e = s.length, t = e ? s[0].length : 0, typeof t != "number")
+          throw new TypeError(
+            "Data must be a 2D array with at least one element"
+          );
+        this.data = [];
+        for (let r = 0; r < e; r++) {
+          if (s[r].length !== t)
+            throw new RangeError("Inconsistent array dimensions");
+          if (!le(s[r]))
+            throw new TypeError("Input data contains non-numeric values");
+          this.data.push(Float64Array.from(s[r]));
+        }
+        this.rows = e, this.columns = t;
+      } else
+        throw new TypeError(
+          "First argument must be a positive number or an array"
+        );
+    }
+    set(e, t, s) {
+      return this.data[e][t] = s, this;
+    }
+    get(e, t) {
+      return this.data[e][t];
+    }
+    removeRow(e) {
+      return Z(this, e), this.data.splice(e, 1), this.rows -= 1, this;
+    }
+    addRow(e, t) {
+      return t === void 0 && (t = e, e = this.rows), Z(this, e, !0), t = Float64Array.from(rt(this, t)), this.data.splice(e, 0, t), this.rows += 1, this;
+    }
+    removeColumn(e) {
+      _(this, e);
+      for (let t = 0; t < this.rows; t++) {
+        const s = new Float64Array(this.columns - 1);
+        for (let r = 0; r < e; r++)
+          s[r] = this.data[t][r];
+        for (let r = e + 1; r < this.columns; r++)
+          s[r - 1] = this.data[t][r];
+        this.data[t] = s;
+      }
+      return this.columns -= 1, this;
+    }
+    addColumn(e, t) {
+      typeof t > "u" && (t = e, e = this.columns), _(this, e, !0), t = it(this, t);
+      for (let s = 0; s < this.rows; s++) {
+        const r = new Float64Array(this.columns + 1);
+        let n = 0;
+        for (; n < e; n++)
+          r[n] = this.data[s][n];
+        for (r[n++] = t[s]; n < this.columns + 1; n++)
+          r[n] = this.data[s][n - 1];
+        this.data[s] = r;
+      }
+      return this.columns += 1, this;
+    }
+  };
+  ut = new WeakSet(), /**
+   * Init an empty matrix
+   * @param {number} nRows
+   * @param {number} nColumns
+   */
+  Nt = function(e, t) {
+    if (this.data = [], Number.isInteger(t) && t >= 0)
+      for (let s = 0; s < e; s++)
+        this.data.push(new Float64Array(t));
+    else
+      throw new TypeError("nColumns must be a positive integer");
+    this.rows = e, this.columns = t;
+  };
+  let S = dt;
+  Qt(T, S);
+  const yt = class yt extends T {
+    /**
+     * @param {number | AbstractMatrix | ArrayLike<ArrayLike<number>>} diagonalSize
+     * @return {this}
+     */
+    constructor(e) {
+      super();
+      /** @type {Matrix} */
+      Rt(this, J);
+      if (S.isMatrix(e)) {
+        if (!e.isSymmetric())
+          throw new TypeError("not symmetric data");
+        Mt(this, J, S.copy(
+          e,
+          new S(e.rows, e.rows)
+        ));
+      } else if (Number.isInteger(e) && e >= 0)
+        Mt(this, J, new S(e, e));
+      else if (Mt(this, J, new S(e)), !this.isSymmetric())
+        throw new TypeError("not symmetric data");
+    }
+    get size() {
+      return x(this, J).size;
+    }
+    get rows() {
+      return x(this, J).rows;
+    }
+    get columns() {
+      return x(this, J).columns;
+    }
+    get diagonalSize() {
+      return this.rows;
+    }
+    /**
+     * not the same as matrix.isSymmetric()
+     * Here is to check if it's instanceof SymmetricMatrix without bundling issues
+     *
+     * @param value
+     * @returns {boolean}
+     */
+    static isSymmetricMatrix(e) {
+      return S.isMatrix(e) && e.klassType === "SymmetricMatrix";
+    }
+    /**
+     * @param diagonalSize
+     * @return {SymmetricMatrix}
+     */
+    static zeros(e) {
+      return new this(e);
+    }
+    /**
+     * @param diagonalSize
+     * @return {SymmetricMatrix}
+     */
+    static ones(e) {
+      return new this(e).fill(1);
+    }
+    clone() {
+      const e = new yt(this.diagonalSize);
+      for (const [t, s, r] of this.upperRightEntries())
+        e.set(t, s, r);
+      return e;
+    }
+    toMatrix() {
+      return new S(this);
+    }
+    get(e, t) {
+      return x(this, J).get(e, t);
+    }
+    set(e, t, s) {
+      return x(this, J).set(e, t, s), x(this, J).set(t, e, s), this;
+    }
+    removeCross(e) {
+      return x(this, J).removeRow(e), x(this, J).removeColumn(e), this;
+    }
+    addCross(e, t) {
+      t === void 0 && (t = e, e = this.diagonalSize);
+      const s = t.slice();
+      return s.splice(e, 1), x(this, J).addRow(e, s), x(this, J).addColumn(e, t), this;
+    }
+    /**
+     * @param {Mask[]} mask
+     */
+    applyMask(e) {
+      if (e.length !== this.diagonalSize)
+        throw new RangeError("Mask size do not match with matrix size");
+      const t = [];
+      for (const [s, r] of e.entries())
+        r || t.push(s);
+      t.reverse();
+      for (const s of t)
+        this.removeCross(s);
+      return this;
+    }
+    /**
+     * Compact format upper-right corner of matrix
+     * iterate from left to right, from top to bottom.
+     *
+     * ```
+     *   A B C D
+     * A 1 2 3 4
+     * B 2 5 6 7
+     * C 3 6 8 9
+     * D 4 7 9 10
+     * ```
+     *
+     * will return compact 1D array `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+     *
+     * length is S(i=0, n=sideSize) => 10 for a 4 sideSized matrix
+     *
+     * @returns {number[]}
+     */
+    toCompact() {
+      const { diagonalSize: e } = this, t = new Array(e * (e + 1) / 2);
+      for (let s = 0, r = 0, n = 0; n < t.length; n++)
+        t[n] = this.get(r, s), ++s >= e && (s = ++r);
+      return t;
+    }
+    /**
+     * @param {number[]} compact
+     * @return {SymmetricMatrix}
+     */
+    static fromCompact(e) {
+      const t = e.length, s = (Math.sqrt(8 * t + 1) - 1) / 2;
+      if (!Number.isInteger(s))
+        throw new TypeError(
+          `This array is not a compact representation of a Symmetric Matrix, ${JSON.stringify(
+            e
+          )}`
+        );
+      const r = new yt(s);
+      for (let n = 0, l = 0, h = 0; h < t; h++)
+        r.set(n, l, e[h]), ++n >= s && (n = ++l);
+      return r;
+    }
+    /**
+     * half iterator upper-right-corner from left to right, from top to bottom
+     * yield [row, column, value]
+     *
+     * @returns {Generator<[number, number, number], void, void>}
+     */
+    *upperRightEntries() {
+      for (let e = 0, t = 0; e < this.diagonalSize; void 0) {
+        const s = this.get(e, t);
+        yield [e, t, s], ++t >= this.diagonalSize && (t = ++e);
+      }
+    }
+    /**
+     * half iterator upper-right-corner from left to right, from top to bottom
+     * yield value
+     *
+     * @returns {Generator<[number, number, number], void, void>}
+     */
+    *upperRightValues() {
+      for (let e = 0, t = 0; e < this.diagonalSize; void 0)
+        yield this.get(e, t), ++t >= this.diagonalSize && (t = ++e);
+    }
+  };
+  J = new WeakMap();
+  let ot = yt;
+  ot.prototype.klassType = "SymmetricMatrix";
+  class gt extends ot {
+    /**
+     * not the same as matrix.isSymmetric()
+     * Here is to check if it's instanceof SymmetricMatrix without bundling issues
+     *
+     * @param value
+     * @returns {boolean}
+     */
+    static isDistanceMatrix(o) {
+      return ot.isSymmetricMatrix(o) && o.klassSubType === "DistanceMatrix";
+    }
+    constructor(o) {
+      if (super(o), !this.isDistance())
+        throw new TypeError("Provided arguments do no produce a distance matrix");
+    }
+    set(o, e, t) {
+      return o === e && (t = 0), super.set(o, e, t);
+    }
+    addCross(o, e) {
+      return e === void 0 && (e = o, o = this.diagonalSize), e = e.slice(), e[o] = 0, super.addCross(o, e);
+    }
+    toSymmetricMatrix() {
+      return new ot(this);
+    }
+    clone() {
+      const o = new gt(this.diagonalSize);
+      for (const [e, t, s] of this.upperRightEntries())
+        e !== t && o.set(e, t, s);
+      return o;
+    }
+    /**
+     * Compact format upper-right corner of matrix
+     * no diagonal (only zeros)
+     * iterable from left to right, from top to bottom.
+     *
+     * ```
+     *   A B C D
+     * A 0 1 2 3
+     * B 1 0 4 5
+     * C 2 4 0 6
+     * D 3 5 6 0
+     * ```
+     *
+     * will return compact 1D array `[1, 2, 3, 4, 5, 6]`
+     *
+     * length is S(i=0, n=sideSize-1) => 6 for a 4 side sized matrix
+     *
+     * @returns {number[]}
+     */
+    toCompact() {
+      const { diagonalSize: o } = this, e = (o - 1) * o / 2, t = new Array(e);
+      for (let s = 1, r = 0, n = 0; n < t.length; n++)
+        t[n] = this.get(r, s), ++s >= o && (s = ++r + 1);
+      return t;
+    }
+    /**
+     * @param {number[]} compact
+     */
+    static fromCompact(o) {
+      const e = o.length;
+      if (e === 0)
+        return new this(0);
+      const t = (Math.sqrt(8 * e + 1) + 1) / 2;
+      if (!Number.isInteger(t))
+        throw new TypeError(
+          `This array is not a compact representation of a DistanceMatrix, ${JSON.stringify(
+            o
+          )}`
+        );
+      const s = new this(t);
+      for (let r = 1, n = 0, l = 0; l < e; l++)
+        s.set(r, n, o[l]), ++r >= t && (r = ++n + 1);
+      return s;
+    }
+  }
+  gt.prototype.klassSubType = "DistanceMatrix";
+  class tt extends T {
+    constructor(o, e, t) {
+      super(), this.matrix = o, this.rows = e, this.columns = t;
+    }
+  }
+  class he extends tt {
+    constructor(o, e) {
+      _(o, e), super(o, o.rows, 1), this.column = e;
+    }
+    set(o, e, t) {
+      return this.matrix.set(o, this.column, t), this;
+    }
+    get(o) {
+      return this.matrix.get(o, this.column);
+    }
+  }
+  class ue extends tt {
+    constructor(o, e) {
+      St(o, e), super(o, o.rows, e.length), this.columnIndices = e;
+    }
+    set(o, e, t) {
+      return this.matrix.set(o, this.columnIndices[e], t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(o, this.columnIndices[e]);
+    }
+  }
+  class fe extends tt {
+    constructor(o) {
+      super(o, o.rows, o.columns);
+    }
+    set(o, e, t) {
+      return this.matrix.set(o, this.columns - e - 1, t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(o, this.columns - e - 1);
+    }
+  }
+  class ce extends tt {
+    constructor(o) {
+      super(o, o.rows, o.columns);
+    }
+    set(o, e, t) {
+      return this.matrix.set(this.rows - o - 1, e, t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(this.rows - o - 1, e);
+    }
+  }
+  class ge extends tt {
+    constructor(o, e) {
+      Z(o, e), super(o, 1, o.columns), this.row = e;
+    }
+    set(o, e, t) {
+      return this.matrix.set(this.row, e, t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(this.row, e);
+    }
+  }
+  class we extends tt {
+    constructor(o, e) {
+      jt(o, e), super(o, e.length, o.columns), this.rowIndices = e;
+    }
+    set(o, e, t) {
+      return this.matrix.set(this.rowIndices[o], e, t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(this.rowIndices[o], e);
+    }
+  }
+  class wt extends tt {
+    constructor(o, e, t) {
+      jt(o, e), St(o, t), super(o, e.length, t.length), this.rowIndices = e, this.columnIndices = t;
+    }
+    set(o, e, t) {
+      return this.matrix.set(
+        this.rowIndices[o],
+        this.columnIndices[e],
+        t
+      ), this;
+    }
+    get(o, e) {
+      return this.matrix.get(
+        this.rowIndices[o],
+        this.columnIndices[e]
+      );
+    }
+  }
+  class me extends tt {
+    constructor(o, e, t, s, r) {
+      Et(o, e, t, s, r), super(o, t - e + 1, r - s + 1), this.startRow = e, this.startColumn = s;
+    }
+    set(o, e, t) {
+      return this.matrix.set(
+        this.startRow + o,
+        this.startColumn + e,
+        t
+      ), this;
+    }
+    get(o, e) {
+      return this.matrix.get(
+        this.startRow + o,
+        this.startColumn + e
+      );
+    }
+  }
+  class ae extends tt {
+    constructor(o) {
+      super(o, o.columns, o.rows);
+    }
+    set(o, e, t) {
+      return this.matrix.set(e, o, t), this;
+    }
+    get(o, e) {
+      return this.matrix.get(e, o);
+    }
+  }
+  class Dt extends T {
+    constructor(o, e = {}) {
+      const { rows: t = 1 } = e;
+      if (o.length % t !== 0)
+        throw new Error("the data length is not divisible by the number of rows");
+      super(), this.rows = t, this.columns = o.length / t, this.data = o;
+    }
+    set(o, e, t) {
+      let s = this._calculateIndex(o, e);
+      return this.data[s] = t, this;
+    }
+    get(o, e) {
+      let t = this._calculateIndex(o, e);
+      return this.data[t];
+    }
+    _calculateIndex(o, e) {
+      return o * this.columns + e;
+    }
+  }
+  class G extends T {
+    constructor(o) {
+      super(), this.data = o, this.rows = o.length, this.columns = o[0].length;
+    }
+    set(o, e, t) {
+      return this.data[o][e] = t, this;
+    }
+    get(o, e) {
+      return this.data[o][e];
+    }
+  }
+  function pe(i, o) {
+    if (D.isAnyArray(i))
+      return i[0] && D.isAnyArray(i[0]) ? new G(i) : new Dt(i, o);
+    throw new Error("the argument is not an array");
+  }
+  class mt {
+    constructor(o) {
+      o = G.checkMatrix(o);
+      let e = o.clone(), t = e.rows, s = e.columns, r = new Float64Array(t), n = 1, l, h, u, w, f, a, j, m, p;
+      for (l = 0; l < t; l++)
+        r[l] = l;
+      for (m = new Float64Array(t), h = 0; h < s; h++) {
+        for (l = 0; l < t; l++)
+          m[l] = e.get(l, h);
+        for (l = 0; l < t; l++) {
+          for (p = Math.min(l, h), f = 0, u = 0; u < p; u++)
+            f += e.get(l, u) * m[u];
+          m[l] -= f, e.set(l, h, m[l]);
+        }
+        for (w = h, l = h + 1; l < t; l++)
+          Math.abs(m[l]) > Math.abs(m[w]) && (w = l);
+        if (w !== h) {
+          for (u = 0; u < s; u++)
+            a = e.get(w, u), e.set(w, u, e.get(h, u)), e.set(h, u, a);
+          j = r[w], r[w] = r[h], r[h] = j, n = -n;
+        }
+        if (h < t && e.get(h, h) !== 0)
+          for (l = h + 1; l < t; l++)
+            e.set(l, h, e.get(l, h) / e.get(h, h));
+      }
+      this.LU = e, this.pivotVector = r, this.pivotSign = n;
+    }
+    isSingular() {
+      let o = this.LU, e = o.columns;
+      for (let t = 0; t < e; t++)
+        if (o.get(t, t) === 0)
+          return !0;
+      return !1;
+    }
+    solve(o) {
+      o = S.checkMatrix(o);
+      let e = this.LU;
+      if (e.rows !== o.rows)
+        throw new Error("Invalid matrix dimensions");
+      if (this.isSingular())
+        throw new Error("LU matrix is singular");
+      let s = o.columns, r = o.subMatrixRow(this.pivotVector, 0, s - 1), n = e.columns, l, h, u;
+      for (u = 0; u < n; u++)
+        for (l = u + 1; l < n; l++)
+          for (h = 0; h < s; h++)
+            r.set(l, h, r.get(l, h) - r.get(u, h) * e.get(l, u));
+      for (u = n - 1; u >= 0; u--) {
+        for (h = 0; h < s; h++)
+          r.set(u, h, r.get(u, h) / e.get(u, u));
+        for (l = 0; l < u; l++)
+          for (h = 0; h < s; h++)
+            r.set(l, h, r.get(l, h) - r.get(u, h) * e.get(l, u));
+      }
+      return r;
+    }
+    get determinant() {
+      let o = this.LU;
+      if (!o.isSquare())
+        throw new Error("Matrix must be square");
+      let e = this.pivotSign, t = o.columns;
+      for (let s = 0; s < t; s++)
+        e *= o.get(s, s);
+      return e;
+    }
+    get lowerTriangularMatrix() {
+      let o = this.LU, e = o.rows, t = o.columns, s = new S(e, t);
+      for (let r = 0; r < e; r++)
+        for (let n = 0; n < t; n++)
+          r > n ? s.set(r, n, o.get(r, n)) : r === n ? s.set(r, n, 1) : s.set(r, n, 0);
+      return s;
+    }
+    get upperTriangularMatrix() {
+      let o = this.LU, e = o.rows, t = o.columns, s = new S(e, t);
+      for (let r = 0; r < e; r++)
+        for (let n = 0; n < t; n++)
+          r <= n ? s.set(r, n, o.get(r, n)) : s.set(r, n, 0);
+      return s;
+    }
+    get pivotPermutationVector() {
+      return Array.from(this.pivotVector);
+    }
+  }
+  function et(i, o) {
+    let e = 0;
+    return Math.abs(i) > Math.abs(o) ? (e = o / i, Math.abs(i) * Math.sqrt(1 + e * e)) : o !== 0 ? (e = i / o, Math.abs(o) * Math.sqrt(1 + e * e)) : 0;
+  }
+  class bt {
+    constructor(o) {
+      o = G.checkMatrix(o);
+      let e = o.clone(), t = o.rows, s = o.columns, r = new Float64Array(s), n, l, h, u;
+      for (h = 0; h < s; h++) {
+        let w = 0;
+        for (n = h; n < t; n++)
+          w = et(w, e.get(n, h));
+        if (w !== 0) {
+          for (e.get(h, h) < 0 && (w = -w), n = h; n < t; n++)
+            e.set(n, h, e.get(n, h) / w);
+          for (e.set(h, h, e.get(h, h) + 1), l = h + 1; l < s; l++) {
+            for (u = 0, n = h; n < t; n++)
+              u += e.get(n, h) * e.get(n, l);
+            for (u = -u / e.get(h, h), n = h; n < t; n++)
+              e.set(n, l, e.get(n, l) + u * e.get(n, h));
+          }
+        }
+        r[h] = -w;
+      }
+      this.QR = e, this.Rdiag = r;
+    }
+    solve(o) {
+      o = S.checkMatrix(o);
+      let e = this.QR, t = e.rows;
+      if (o.rows !== t)
+        throw new Error("Matrix row dimensions must agree");
+      if (!this.isFullRank())
+        throw new Error("Matrix is rank deficient");
+      let s = o.columns, r = o.clone(), n = e.columns, l, h, u, w;
+      for (u = 0; u < n; u++)
+        for (h = 0; h < s; h++) {
+          for (w = 0, l = u; l < t; l++)
+            w += e.get(l, u) * r.get(l, h);
+          for (w = -w / e.get(u, u), l = u; l < t; l++)
+            r.set(l, h, r.get(l, h) + w * e.get(l, u));
+        }
+      for (u = n - 1; u >= 0; u--) {
+        for (h = 0; h < s; h++)
+          r.set(u, h, r.get(u, h) / this.Rdiag[u]);
+        for (l = 0; l < u; l++)
+          for (h = 0; h < s; h++)
+            r.set(l, h, r.get(l, h) - r.get(u, h) * e.get(l, u));
+      }
+      return r.subMatrix(0, n - 1, 0, s - 1);
+    }
+    isFullRank() {
+      let o = this.QR.columns;
+      for (let e = 0; e < o; e++)
+        if (this.Rdiag[e] === 0)
+          return !1;
+      return !0;
+    }
+    get upperTriangularMatrix() {
+      let o = this.QR, e = o.columns, t = new S(e, e), s, r;
+      for (s = 0; s < e; s++)
+        for (r = 0; r < e; r++)
+          s < r ? t.set(s, r, o.get(s, r)) : s === r ? t.set(s, r, this.Rdiag[s]) : t.set(s, r, 0);
+      return t;
+    }
+    get orthogonalMatrix() {
+      let o = this.QR, e = o.rows, t = o.columns, s = new S(e, t), r, n, l, h;
+      for (l = t - 1; l >= 0; l--) {
+        for (r = 0; r < e; r++)
+          s.set(r, l, 0);
+        for (s.set(l, l, 1), n = l; n < t; n++)
+          if (o.get(l, l) !== 0) {
+            for (h = 0, r = l; r < e; r++)
+              h += o.get(r, l) * s.get(r, n);
+            for (h = -h / o.get(l, l), r = l; r < e; r++)
+              s.set(r, n, s.get(r, n) + h * o.get(r, l));
+          }
+      }
+      return s;
+    }
+  }
+  class lt {
+    constructor(o, e = {}) {
+      if (o = G.checkMatrix(o), o.isEmpty())
+        throw new Error("Matrix must be non-empty");
+      let t = o.rows, s = o.columns;
+      const {
+        computeLeftSingularVectors: r = !0,
+        computeRightSingularVectors: n = !0,
+        autoTranspose: l = !1
+      } = e;
+      let h = !!r, u = !!n, w = !1, f;
+      if (t < s)
+        if (!l)
+          f = o.clone(), console.warn(
+            "Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose"
+          );
+        else {
+          f = o.transpose(), t = f.rows, s = f.columns, w = !0;
+          let g = h;
+          h = u, u = g;
+        }
+      else
+        f = o.clone();
+      let a = Math.min(t, s), j = Math.min(t + 1, s), m = new Float64Array(j), p = new S(t, a), E = new S(s, s), c = new Float64Array(s), M = new Float64Array(t), k = new Float64Array(j);
+      for (let g = 0; g < j; g++) k[g] = g;
+      let N = Math.min(t - 1, s), q = Math.max(0, Math.min(s - 2, t)), V = Math.max(N, q);
+      for (let g = 0; g < V; g++) {
+        if (g < N) {
+          m[g] = 0;
+          for (let d = g; d < t; d++)
+            m[g] = et(m[g], f.get(d, g));
+          if (m[g] !== 0) {
+            f.get(g, g) < 0 && (m[g] = -m[g]);
+            for (let d = g; d < t; d++)
+              f.set(d, g, f.get(d, g) / m[g]);
+            f.set(g, g, f.get(g, g) + 1);
+          }
+          m[g] = -m[g];
+        }
+        for (let d = g + 1; d < s; d++) {
+          if (g < N && m[g] !== 0) {
+            let b = 0;
+            for (let y = g; y < t; y++)
+              b += f.get(y, g) * f.get(y, d);
+            b = -b / f.get(g, g);
+            for (let y = g; y < t; y++)
+              f.set(y, d, f.get(y, d) + b * f.get(y, g));
+          }
+          c[d] = f.get(g, d);
+        }
+        if (h && g < N)
+          for (let d = g; d < t; d++)
+            p.set(d, g, f.get(d, g));
+        if (g < q) {
+          c[g] = 0;
+          for (let d = g + 1; d < s; d++)
+            c[g] = et(c[g], c[d]);
+          if (c[g] !== 0) {
+            c[g + 1] < 0 && (c[g] = 0 - c[g]);
+            for (let d = g + 1; d < s; d++)
+              c[d] /= c[g];
+            c[g + 1] += 1;
+          }
+          if (c[g] = -c[g], g + 1 < t && c[g] !== 0) {
+            for (let d = g + 1; d < t; d++)
+              M[d] = 0;
+            for (let d = g + 1; d < t; d++)
+              for (let b = g + 1; b < s; b++)
+                M[d] += c[b] * f.get(d, b);
+            for (let d = g + 1; d < s; d++) {
+              let b = -c[d] / c[g + 1];
+              for (let y = g + 1; y < t; y++)
+                f.set(y, d, f.get(y, d) + b * M[y]);
+            }
+          }
+          if (u)
+            for (let d = g + 1; d < s; d++)
+              E.set(d, g, c[d]);
+        }
+      }
+      let R = Math.min(s, t + 1);
+      if (N < s && (m[N] = f.get(N, N)), t < R && (m[R - 1] = 0), q + 1 < R && (c[q] = f.get(q, R - 1)), c[R - 1] = 0, h) {
+        for (let g = N; g < a; g++) {
+          for (let d = 0; d < t; d++)
+            p.set(d, g, 0);
+          p.set(g, g, 1);
+        }
+        for (let g = N - 1; g >= 0; g--)
+          if (m[g] !== 0) {
+            for (let d = g + 1; d < a; d++) {
+              let b = 0;
+              for (let y = g; y < t; y++)
+                b += p.get(y, g) * p.get(y, d);
+              b = -b / p.get(g, g);
+              for (let y = g; y < t; y++)
+                p.set(y, d, p.get(y, d) + b * p.get(y, g));
+            }
+            for (let d = g; d < t; d++)
+              p.set(d, g, -p.get(d, g));
+            p.set(g, g, 1 + p.get(g, g));
+            for (let d = 0; d < g - 1; d++)
+              p.set(d, g, 0);
+          } else {
+            for (let d = 0; d < t; d++)
+              p.set(d, g, 0);
+            p.set(g, g, 1);
+          }
+      }
+      if (u)
+        for (let g = s - 1; g >= 0; g--) {
+          if (g < q && c[g] !== 0)
+            for (let d = g + 1; d < s; d++) {
+              let b = 0;
+              for (let y = g + 1; y < s; y++)
+                b += E.get(y, g) * E.get(y, d);
+              b = -b / E.get(g + 1, g);
+              for (let y = g + 1; y < s; y++)
+                E.set(y, d, E.get(y, d) + b * E.get(y, g));
+            }
+          for (let d = 0; d < s; d++)
+            E.set(d, g, 0);
+          E.set(g, g, 1);
+        }
+      let v = R - 1, z = Number.EPSILON;
+      for (; R > 0; ) {
+        let g, d;
+        for (g = R - 2; g >= -1 && g !== -1; g--) {
+          const b = Number.MIN_VALUE + z * Math.abs(m[g] + Math.abs(m[g + 1]));
+          if (Math.abs(c[g]) <= b || Number.isNaN(c[g])) {
+            c[g] = 0;
+            break;
+          }
+        }
+        if (g === R - 2)
+          d = 4;
+        else {
+          let b;
+          for (b = R - 1; b >= g && b !== g; b--) {
+            let y = (b !== R ? Math.abs(c[b]) : 0) + (b !== g + 1 ? Math.abs(c[b - 1]) : 0);
+            if (Math.abs(m[b]) <= z * y) {
+              m[b] = 0;
+              break;
+            }
+          }
+          b === g ? d = 3 : b === R - 1 ? d = 1 : (d = 2, g = b);
+        }
+        switch (g++, d) {
+          case 1: {
+            let b = c[R - 2];
+            c[R - 2] = 0;
+            for (let y = R - 2; y >= g; y--) {
+              let L = et(m[y], b), $ = m[y] / L, P = b / L;
+              if (m[y] = L, y !== g && (b = -P * c[y - 1], c[y - 1] = $ * c[y - 1]), u)
+                for (let U = 0; U < s; U++)
+                  L = $ * E.get(U, y) + P * E.get(U, R - 1), E.set(U, R - 1, -P * E.get(U, y) + $ * E.get(U, R - 1)), E.set(U, y, L);
+            }
+            break;
+          }
+          case 2: {
+            let b = c[g - 1];
+            c[g - 1] = 0;
+            for (let y = g; y < R; y++) {
+              let L = et(m[y], b), $ = m[y] / L, P = b / L;
+              if (m[y] = L, b = -P * c[y], c[y] = $ * c[y], h)
+                for (let U = 0; U < t; U++)
+                  L = $ * p.get(U, y) + P * p.get(U, g - 1), p.set(U, g - 1, -P * p.get(U, y) + $ * p.get(U, g - 1)), p.set(U, y, L);
+            }
+            break;
+          }
+          case 3: {
+            const b = Math.max(
+              Math.abs(m[R - 1]),
+              Math.abs(m[R - 2]),
+              Math.abs(c[R - 2]),
+              Math.abs(m[g]),
+              Math.abs(c[g])
+            ), y = m[R - 1] / b, L = m[R - 2] / b, $ = c[R - 2] / b, P = m[g] / b, U = c[g] / b, Y = ((L + y) * (L - y) + $ * $) / 2, A = y * $ * (y * $);
+            let O = 0;
+            (Y !== 0 || A !== 0) && (Y < 0 ? O = 0 - Math.sqrt(Y * Y + A) : O = Math.sqrt(Y * Y + A), O = A / (Y + O));
+            let H = (P + y) * (P - y) + O, st = P * U;
+            for (let F = g; F < R - 1; F++) {
+              let W = et(H, st);
+              W === 0 && (W = Number.MIN_VALUE);
+              let K = H / W, X = st / W;
+              if (F !== g && (c[F - 1] = W), H = K * m[F] + X * c[F], c[F] = K * c[F] - X * m[F], st = X * m[F + 1], m[F + 1] = K * m[F + 1], u)
+                for (let Q = 0; Q < s; Q++)
+                  W = K * E.get(Q, F) + X * E.get(Q, F + 1), E.set(Q, F + 1, -X * E.get(Q, F) + K * E.get(Q, F + 1)), E.set(Q, F, W);
+              if (W = et(H, st), W === 0 && (W = Number.MIN_VALUE), K = H / W, X = st / W, m[F] = W, H = K * c[F] + X * m[F + 1], m[F + 1] = -X * c[F] + K * m[F + 1], st = X * c[F + 1], c[F + 1] = K * c[F + 1], h && F < t - 1)
+                for (let Q = 0; Q < t; Q++)
+                  W = K * p.get(Q, F) + X * p.get(Q, F + 1), p.set(Q, F + 1, -X * p.get(Q, F) + K * p.get(Q, F + 1)), p.set(Q, F, W);
+            }
+            c[R - 2] = H;
+            break;
+          }
+          case 4: {
+            if (m[g] <= 0 && (m[g] = m[g] < 0 ? -m[g] : 0, u))
+              for (let b = 0; b <= v; b++)
+                E.set(b, g, -E.get(b, g));
+            for (; g < v && !(m[g] >= m[g + 1]); ) {
+              let b = m[g];
+              if (m[g] = m[g + 1], m[g + 1] = b, u && g < s - 1)
+                for (let y = 0; y < s; y++)
+                  b = E.get(y, g + 1), E.set(y, g + 1, E.get(y, g)), E.set(y, g, b);
+              if (h && g < t - 1)
+                for (let y = 0; y < t; y++)
+                  b = p.get(y, g + 1), p.set(y, g + 1, p.get(y, g)), p.set(y, g, b);
+              g++;
+            }
+            R--;
+            break;
+          }
+        }
+      }
+      if (w) {
+        let g = E;
+        E = p, p = g;
+      }
+      this.m = t, this.n = s, this.s = m, this.U = p, this.V = E;
+    }
+    solve(o) {
+      let e = o, t = this.threshold, s = this.s.length, r = S.zeros(s, s);
+      for (let a = 0; a < s; a++)
+        Math.abs(this.s[a]) <= t ? r.set(a, a, 0) : r.set(a, a, 1 / this.s[a]);
+      let n = this.U, l = this.rightSingularVectors, h = l.mmul(r), u = l.rows, w = n.rows, f = S.zeros(u, w);
+      for (let a = 0; a < u; a++)
+        for (let j = 0; j < w; j++) {
+          let m = 0;
+          for (let p = 0; p < s; p++)
+            m += h.get(a, p) * n.get(j, p);
+          f.set(a, j, m);
+        }
+      return f.mmul(e);
+    }
+    solveForDiagonal(o) {
+      return this.solve(S.diag(o));
+    }
+    inverse() {
+      let o = this.V, e = this.threshold, t = o.rows, s = o.columns, r = new S(t, this.s.length);
+      for (let w = 0; w < t; w++)
+        for (let f = 0; f < s; f++)
+          Math.abs(this.s[f]) > e && r.set(w, f, o.get(w, f) / this.s[f]);
+      let n = this.U, l = n.rows, h = n.columns, u = new S(t, l);
+      for (let w = 0; w < t; w++)
+        for (let f = 0; f < l; f++) {
+          let a = 0;
+          for (let j = 0; j < h; j++)
+            a += r.get(w, j) * n.get(f, j);
+          u.set(w, f, a);
+        }
+      return u;
+    }
+    get condition() {
+      return this.s[0] / this.s[Math.min(this.m, this.n) - 1];
+    }
+    get norm2() {
+      return this.s[0];
+    }
+    get rank() {
+      let o = Math.max(this.m, this.n) * this.s[0] * Number.EPSILON, e = 0, t = this.s;
+      for (let s = 0, r = t.length; s < r; s++)
+        t[s] > o && e++;
+      return e;
+    }
+    get diagonal() {
+      return Array.from(this.s);
+    }
+    get threshold() {
+      return Number.EPSILON / 2 * Math.max(this.m, this.n) * this.s[0];
+    }
+    get leftSingularVectors() {
+      return this.U;
+    }
+    get rightSingularVectors() {
+      return this.V;
+    }
+    get diagonalMatrix() {
+      return S.diag(this.s);
+    }
+  }
+  function de(i, o = !1) {
+    return i = G.checkMatrix(i), o ? new lt(i).inverse() : Ft(i, S.eye(i.rows));
+  }
+  function Ft(i, o, e = !1) {
+    return i = G.checkMatrix(i), o = G.checkMatrix(o), e ? new lt(i).solve(o) : i.isSquare() ? new mt(i).solve(o) : new bt(i).solve(o);
+  }
+  function at(i) {
+    if (i = S.checkMatrix(i), i.isSquare()) {
+      if (i.columns === 0)
+        return 1;
+      let o, e, t, s;
+      if (i.columns === 2)
+        return o = i.get(0, 0), e = i.get(0, 1), t = i.get(1, 0), s = i.get(1, 1), o * s - e * t;
+      if (i.columns === 3) {
+        let r, n, l;
+        return r = new wt(i, [1, 2], [1, 2]), n = new wt(i, [1, 2], [0, 2]), l = new wt(i, [1, 2], [0, 1]), o = i.get(0, 0), e = i.get(0, 1), t = i.get(0, 2), o * at(r) - e * at(n) + t * at(l);
+      } else
+        return new mt(i).determinant;
+    } else
+      throw Error("determinant can only be calculated for a square matrix");
+  }
+  function ye(i, o) {
+    let e = [];
+    for (let t = 0; t < i; t++)
+      t !== o && e.push(t);
+    return e;
+  }
+  function Me(i, o, e, t = 1e-9, s = 1e-9) {
+    if (i > s)
+      return new Array(o.rows + 1).fill(0);
+    {
+      let r = o.addRow(e, [0]);
+      for (let n = 0; n < r.rows; n++)
+        Math.abs(r.get(n, 0)) < t && r.set(n, 0, 0);
+      return r.to1DArray();
+    }
+  }
+  function je(i, o = {}) {
+    const { thresholdValue: e = 1e-9, thresholdError: t = 1e-9 } = o;
+    i = S.checkMatrix(i);
+    let s = i.rows, r = new S(s, s);
+    for (let n = 0; n < s; n++) {
+      let l = S.columnVector(i.getRow(n)), h = i.subMatrixRow(ye(s, n)).transpose(), w = new lt(h).solve(l), f = S.sub(l, h.mmul(w)).abs().max();
+      r.setRow(
+        n,
+        Me(f, w, n, e, t)
+      );
+    }
+    return r;
+  }
+  function Se(i, o = Number.EPSILON) {
+    if (i = S.checkMatrix(i), i.isEmpty())
+      return i.transpose();
+    let e = new lt(i, { autoTranspose: !0 }), t = e.leftSingularVectors, s = e.rightSingularVectors, r = e.diagonal;
+    for (let n = 0; n < r.length; n++)
+      Math.abs(r[n]) > o ? r[n] = 1 / r[n] : r[n] = 0;
+    return s.mmul(S.diag(r).mmul(t.transpose()));
+  }
+  function Ee(i, o = i, e = {}) {
+    i = new S(i);
+    let t = !1;
+    if (typeof o == "object" && !S.isMatrix(o) && !D.isAnyArray(o) ? (e = o, o = i, t = !0) : o = new S(o), i.rows !== o.rows)
+      throw new TypeError("Both matrices must have the same number of rows");
+    const { center: s = !0 } = e;
+    s && (i = i.center("column"), t || (o = o.center("column")));
+    const r = i.transpose().mmul(o);
+    for (let n = 0; n < r.rows; n++)
+      for (let l = 0; l < r.columns; l++)
+        r.set(n, l, r.get(n, l) * (1 / (i.rows - 1)));
+    return r;
+  }
+  function be(i, o = i, e = {}) {
+    i = new S(i);
+    let t = !1;
+    if (typeof o == "object" && !S.isMatrix(o) && !D.isAnyArray(o) ? (e = o, o = i, t = !0) : o = new S(o), i.rows !== o.rows)
+      throw new TypeError("Both matrices must have the same number of rows");
+    const { center: s = !0, scale: r = !0 } = e;
+    s && (i.center("column"), t || o.center("column")), r && (i.scale("column"), t || o.scale("column"));
+    const n = i.standardDeviation("column", { unbiased: !0 }), l = t ? n : o.standardDeviation("column", { unbiased: !0 }), h = i.transpose().mmul(o);
+    for (let u = 0; u < h.rows; u++)
+      for (let w = 0; w < h.columns; w++)
+        h.set(
+          u,
+          w,
+          h.get(u, w) * (1 / (n[u] * l[w])) * (1 / (i.rows - 1))
+        );
+    return h;
+  }
+  class $t {
+    constructor(o, e = {}) {
+      const { assumeSymmetric: t = !1 } = e;
+      if (o = G.checkMatrix(o), !o.isSquare())
+        throw new Error("Matrix is not a square matrix");
+      if (o.isEmpty())
+        throw new Error("Matrix must be non-empty");
+      let s = o.columns, r = new S(s, s), n = new Float64Array(s), l = new Float64Array(s), h = o, u, w, f = !1;
+      if (t ? f = !0 : f = o.isSymmetric(), f) {
+        for (u = 0; u < s; u++)
+          for (w = 0; w < s; w++)
+            r.set(u, w, h.get(u, w));
+        ke(s, l, n, r), Re(s, l, n, r);
+      } else {
+        let a = new S(s, s), j = new Float64Array(s);
+        for (w = 0; w < s; w++)
+          for (u = 0; u < s; u++)
+            a.set(u, w, h.get(u, w));
+        ve(s, a, j, r), Ne(s, l, n, r, a);
+      }
+      this.n = s, this.e = l, this.d = n, this.V = r;
+    }
+    get realEigenvalues() {
+      return Array.from(this.d);
+    }
+    get imaginaryEigenvalues() {
+      return Array.from(this.e);
+    }
+    get eigenvectorMatrix() {
+      return this.V;
+    }
+    get diagonalMatrix() {
+      let o = this.n, e = this.e, t = this.d, s = new S(o, o), r, n;
+      for (r = 0; r < o; r++) {
+        for (n = 0; n < o; n++)
+          s.set(r, n, 0);
+        s.set(r, r, t[r]), e[r] > 0 ? s.set(r, r + 1, e[r]) : e[r] < 0 && s.set(r, r - 1, e[r]);
+      }
+      return s;
+    }
+  }
+  function ke(i, o, e, t) {
+    let s, r, n, l, h, u, w, f;
+    for (h = 0; h < i; h++)
+      e[h] = t.get(i - 1, h);
+    for (l = i - 1; l > 0; l--) {
+      for (f = 0, n = 0, u = 0; u < l; u++)
+        f = f + Math.abs(e[u]);
+      if (f === 0)
+        for (o[l] = e[l - 1], h = 0; h < l; h++)
+          e[h] = t.get(l - 1, h), t.set(l, h, 0), t.set(h, l, 0);
+      else {
+        for (u = 0; u < l; u++)
+          e[u] /= f, n += e[u] * e[u];
+        for (s = e[l - 1], r = Math.sqrt(n), s > 0 && (r = -r), o[l] = f * r, n = n - s * r, e[l - 1] = s - r, h = 0; h < l; h++)
+          o[h] = 0;
+        for (h = 0; h < l; h++) {
+          for (s = e[h], t.set(h, l, s), r = o[h] + t.get(h, h) * s, u = h + 1; u <= l - 1; u++)
+            r += t.get(u, h) * e[u], o[u] += t.get(u, h) * s;
+          o[h] = r;
+        }
+        for (s = 0, h = 0; h < l; h++)
+          o[h] /= n, s += o[h] * e[h];
+        for (w = s / (n + n), h = 0; h < l; h++)
+          o[h] -= w * e[h];
+        for (h = 0; h < l; h++) {
+          for (s = e[h], r = o[h], u = h; u <= l - 1; u++)
+            t.set(u, h, t.get(u, h) - (s * o[u] + r * e[u]));
+          e[h] = t.get(l - 1, h), t.set(l, h, 0);
+        }
+      }
+      e[l] = n;
+    }
+    for (l = 0; l < i - 1; l++) {
+      if (t.set(i - 1, l, t.get(l, l)), t.set(l, l, 1), n = e[l + 1], n !== 0) {
+        for (u = 0; u <= l; u++)
+          e[u] = t.get(u, l + 1) / n;
+        for (h = 0; h <= l; h++) {
+          for (r = 0, u = 0; u <= l; u++)
+            r += t.get(u, l + 1) * t.get(u, h);
+          for (u = 0; u <= l; u++)
+            t.set(u, h, t.get(u, h) - r * e[u]);
+        }
+      }
+      for (u = 0; u <= l; u++)
+        t.set(u, l + 1, 0);
+    }
+    for (h = 0; h < i; h++)
+      e[h] = t.get(i - 1, h), t.set(i - 1, h, 0);
+    t.set(i - 1, i - 1, 1), o[0] = 0;
+  }
+  function Re(i, o, e, t) {
+    let s, r, n, l, h, u, w, f, a, j, m, p, E, c, M, k;
+    for (n = 1; n < i; n++)
+      o[n - 1] = o[n];
+    o[i - 1] = 0;
+    let N = 0, q = 0, V = Number.EPSILON;
+    for (u = 0; u < i; u++) {
+      for (q = Math.max(q, Math.abs(e[u]) + Math.abs(o[u])), w = u; w < i && !(Math.abs(o[w]) <= V * q); )
+        w++;
+      if (w > u)
+        do {
+          for (s = e[u], f = (e[u + 1] - s) / (2 * o[u]), a = et(f, 1), f < 0 && (a = -a), e[u] = o[u] / (f + a), e[u + 1] = o[u] * (f + a), j = e[u + 1], r = s - e[u], n = u + 2; n < i; n++)
+            e[n] -= r;
+          for (N = N + r, f = e[w], m = 1, p = m, E = m, c = o[u + 1], M = 0, k = 0, n = w - 1; n >= u; n--)
+            for (E = p, p = m, k = M, s = m * o[n], r = m * f, a = et(f, o[n]), o[n + 1] = M * a, M = o[n] / a, m = f / a, f = m * e[n] - M * s, e[n + 1] = r + M * (m * s + M * e[n]), h = 0; h < i; h++)
+              r = t.get(h, n + 1), t.set(h, n + 1, M * t.get(h, n) + m * r), t.set(h, n, m * t.get(h, n) - M * r);
+          f = -M * k * E * c * o[u] / j, o[u] = M * f, e[u] = m * f;
+        } while (Math.abs(o[u]) > V * q);
+      e[u] = e[u] + N, o[u] = 0;
+    }
+    for (n = 0; n < i - 1; n++) {
+      for (h = n, f = e[n], l = n + 1; l < i; l++)
+        e[l] < f && (h = l, f = e[l]);
+      if (h !== n)
+        for (e[h] = e[n], e[n] = f, l = 0; l < i; l++)
+          f = t.get(l, n), t.set(l, n, t.get(l, h)), t.set(l, h, f);
+    }
+  }
+  function ve(i, o, e, t) {
+    let s = 0, r = i - 1, n, l, h, u, w, f, a;
+    for (f = s + 1; f <= r - 1; f++) {
+      for (a = 0, u = f; u <= r; u++)
+        a = a + Math.abs(o.get(u, f - 1));
+      if (a !== 0) {
+        for (h = 0, u = r; u >= f; u--)
+          e[u] = o.get(u, f - 1) / a, h += e[u] * e[u];
+        for (l = Math.sqrt(h), e[f] > 0 && (l = -l), h = h - e[f] * l, e[f] = e[f] - l, w = f; w < i; w++) {
+          for (n = 0, u = r; u >= f; u--)
+            n += e[u] * o.get(u, w);
+          for (n = n / h, u = f; u <= r; u++)
+            o.set(u, w, o.get(u, w) - n * e[u]);
+        }
+        for (u = 0; u <= r; u++) {
+          for (n = 0, w = r; w >= f; w--)
+            n += e[w] * o.get(u, w);
+          for (n = n / h, w = f; w <= r; w++)
+            o.set(u, w, o.get(u, w) - n * e[w]);
+        }
+        e[f] = a * e[f], o.set(f, f - 1, a * l);
+      }
+    }
+    for (u = 0; u < i; u++)
+      for (w = 0; w < i; w++)
+        t.set(u, w, u === w ? 1 : 0);
+    for (f = r - 1; f >= s + 1; f--)
+      if (o.get(f, f - 1) !== 0) {
+        for (u = f + 1; u <= r; u++)
+          e[u] = o.get(u, f - 1);
+        for (w = f; w <= r; w++) {
+          for (l = 0, u = f; u <= r; u++)
+            l += e[u] * t.get(u, w);
+          for (l = l / e[f] / o.get(f, f - 1), u = f; u <= r; u++)
+            t.set(u, w, t.get(u, w) + l * e[u]);
+        }
+      }
+  }
+  function Ne(i, o, e, t, s) {
+    let r = i - 1, n = 0, l = i - 1, h = Number.EPSILON, u = 0, w = 0, f = 0, a = 0, j = 0, m = 0, p = 0, E = 0, c, M, k, N, q, V, R, v, z, g, d, b, y, L, $;
+    for (c = 0; c < i; c++)
+      for ((c < n || c > l) && (e[c] = s.get(c, c), o[c] = 0), M = Math.max(c - 1, 0); M < i; M++)
+        w = w + Math.abs(s.get(c, M));
+    for (; r >= n; ) {
+      for (N = r; N > n && (m = Math.abs(s.get(N - 1, N - 1)) + Math.abs(s.get(N, N)), m === 0 && (m = w), !(Math.abs(s.get(N, N - 1)) < h * m)); )
+        N--;
+      if (N === r)
+        s.set(r, r, s.get(r, r) + u), e[r] = s.get(r, r), o[r] = 0, r--, E = 0;
+      else if (N === r - 1) {
+        if (R = s.get(r, r - 1) * s.get(r - 1, r), f = (s.get(r - 1, r - 1) - s.get(r, r)) / 2, a = f * f + R, p = Math.sqrt(Math.abs(a)), s.set(r, r, s.get(r, r) + u), s.set(r - 1, r - 1, s.get(r - 1, r - 1) + u), v = s.get(r, r), a >= 0) {
+          for (p = f >= 0 ? f + p : f - p, e[r - 1] = v + p, e[r] = e[r - 1], p !== 0 && (e[r] = v - R / p), o[r - 1] = 0, o[r] = 0, v = s.get(r, r - 1), m = Math.abs(v) + Math.abs(p), f = v / m, a = p / m, j = Math.sqrt(f * f + a * a), f = f / j, a = a / j, M = r - 1; M < i; M++)
+            p = s.get(r - 1, M), s.set(r - 1, M, a * p + f * s.get(r, M)), s.set(r, M, a * s.get(r, M) - f * p);
+          for (c = 0; c <= r; c++)
+            p = s.get(c, r - 1), s.set(c, r - 1, a * p + f * s.get(c, r)), s.set(c, r, a * s.get(c, r) - f * p);
+          for (c = n; c <= l; c++)
+            p = t.get(c, r - 1), t.set(c, r - 1, a * p + f * t.get(c, r)), t.set(c, r, a * t.get(c, r) - f * p);
+        } else
+          e[r - 1] = v + f, e[r] = v + f, o[r - 1] = p, o[r] = -p;
+        r = r - 2, E = 0;
+      } else {
+        if (v = s.get(r, r), z = 0, R = 0, N < r && (z = s.get(r - 1, r - 1), R = s.get(r, r - 1) * s.get(r - 1, r)), E === 10) {
+          for (u += v, c = n; c <= r; c++)
+            s.set(c, c, s.get(c, c) - v);
+          m = Math.abs(s.get(r, r - 1)) + Math.abs(s.get(r - 1, r - 2)), v = z = 0.75 * m, R = -0.4375 * m * m;
+        }
+        if (E === 30 && (m = (z - v) / 2, m = m * m + R, m > 0)) {
+          for (m = Math.sqrt(m), z < v && (m = -m), m = v - R / ((z - v) / 2 + m), c = n; c <= r; c++)
+            s.set(c, c, s.get(c, c) - m);
+          u += m, v = z = R = 0.964;
+        }
+        for (E = E + 1, q = r - 2; q >= N && (p = s.get(q, q), j = v - p, m = z - p, f = (j * m - R) / s.get(q + 1, q) + s.get(q, q + 1), a = s.get(q + 1, q + 1) - p - j - m, j = s.get(q + 2, q + 1), m = Math.abs(f) + Math.abs(a) + Math.abs(j), f = f / m, a = a / m, j = j / m, !(q === N || Math.abs(s.get(q, q - 1)) * (Math.abs(a) + Math.abs(j)) < h * (Math.abs(f) * (Math.abs(s.get(q - 1, q - 1)) + Math.abs(p) + Math.abs(s.get(q + 1, q + 1)))))); )
+          q--;
+        for (c = q + 2; c <= r; c++)
+          s.set(c, c - 2, 0), c > q + 2 && s.set(c, c - 3, 0);
+        for (k = q; k <= r - 1 && (L = k !== r - 1, k !== q && (f = s.get(k, k - 1), a = s.get(k + 1, k - 1), j = L ? s.get(k + 2, k - 1) : 0, v = Math.abs(f) + Math.abs(a) + Math.abs(j), v !== 0 && (f = f / v, a = a / v, j = j / v)), v !== 0); k++)
+          if (m = Math.sqrt(f * f + a * a + j * j), f < 0 && (m = -m), m !== 0) {
+            for (k !== q ? s.set(k, k - 1, -m * v) : N !== q && s.set(k, k - 1, -s.get(k, k - 1)), f = f + m, v = f / m, z = a / m, p = j / m, a = a / f, j = j / f, M = k; M < i; M++)
+              f = s.get(k, M) + a * s.get(k + 1, M), L && (f = f + j * s.get(k + 2, M), s.set(k + 2, M, s.get(k + 2, M) - f * p)), s.set(k, M, s.get(k, M) - f * v), s.set(k + 1, M, s.get(k + 1, M) - f * z);
+            for (c = 0; c <= Math.min(r, k + 3); c++)
+              f = v * s.get(c, k) + z * s.get(c, k + 1), L && (f = f + p * s.get(c, k + 2), s.set(c, k + 2, s.get(c, k + 2) - f * j)), s.set(c, k, s.get(c, k) - f), s.set(c, k + 1, s.get(c, k + 1) - f * a);
+            for (c = n; c <= l; c++)
+              f = v * t.get(c, k) + z * t.get(c, k + 1), L && (f = f + p * t.get(c, k + 2), t.set(c, k + 2, t.get(c, k + 2) - f * j)), t.set(c, k, t.get(c, k) - f), t.set(c, k + 1, t.get(c, k + 1) - f * a);
+          }
+      }
+    }
+    if (w !== 0) {
+      for (r = i - 1; r >= 0; r--)
+        if (f = e[r], a = o[r], a === 0)
+          for (N = r, s.set(r, r, 1), c = r - 1; c >= 0; c--) {
+            for (R = s.get(c, c) - f, j = 0, M = N; M <= r; M++)
+              j = j + s.get(c, M) * s.get(M, r);
+            if (o[c] < 0)
+              p = R, m = j;
+            else if (N = c, o[c] === 0 ? s.set(c, r, R !== 0 ? -j / R : -j / (h * w)) : (v = s.get(c, c + 1), z = s.get(c + 1, c), a = (e[c] - f) * (e[c] - f) + o[c] * o[c], V = (v * m - p * j) / a, s.set(c, r, V), s.set(
+              c + 1,
+              r,
+              Math.abs(v) > Math.abs(p) ? (-j - R * V) / v : (-m - z * V) / p
+            )), V = Math.abs(s.get(c, r)), h * V * V > 1)
+              for (M = c; M <= r; M++)
+                s.set(M, r, s.get(M, r) / V);
+          }
+        else if (a < 0)
+          for (N = r - 1, Math.abs(s.get(r, r - 1)) > Math.abs(s.get(r - 1, r)) ? (s.set(r - 1, r - 1, a / s.get(r, r - 1)), s.set(r - 1, r, -(s.get(r, r) - f) / s.get(r, r - 1))) : ($ = pt(0, -s.get(r - 1, r), s.get(r - 1, r - 1) - f, a), s.set(r - 1, r - 1, $[0]), s.set(r - 1, r, $[1])), s.set(r, r - 1, 0), s.set(r, r, 1), c = r - 2; c >= 0; c--) {
+            for (g = 0, d = 0, M = N; M <= r; M++)
+              g = g + s.get(c, M) * s.get(M, r - 1), d = d + s.get(c, M) * s.get(M, r);
+            if (R = s.get(c, c) - f, o[c] < 0)
+              p = R, j = g, m = d;
+            else if (N = c, o[c] === 0 ? ($ = pt(-g, -d, R, a), s.set(c, r - 1, $[0]), s.set(c, r, $[1])) : (v = s.get(c, c + 1), z = s.get(c + 1, c), b = (e[c] - f) * (e[c] - f) + o[c] * o[c] - a * a, y = (e[c] - f) * 2 * a, b === 0 && y === 0 && (b = h * w * (Math.abs(R) + Math.abs(a) + Math.abs(v) + Math.abs(z) + Math.abs(p))), $ = pt(
+              v * j - p * g + a * d,
+              v * m - p * d - a * g,
+              b,
+              y
+            ), s.set(c, r - 1, $[0]), s.set(c, r, $[1]), Math.abs(v) > Math.abs(p) + Math.abs(a) ? (s.set(
+              c + 1,
+              r - 1,
+              (-g - R * s.get(c, r - 1) + a * s.get(c, r)) / v
+            ), s.set(
+              c + 1,
+              r,
+              (-d - R * s.get(c, r) - a * s.get(c, r - 1)) / v
+            )) : ($ = pt(
+              -j - z * s.get(c, r - 1),
+              -m - z * s.get(c, r),
+              p,
+              a
+            ), s.set(c + 1, r - 1, $[0]), s.set(c + 1, r, $[1]))), V = Math.max(Math.abs(s.get(c, r - 1)), Math.abs(s.get(c, r))), h * V * V > 1)
+              for (M = c; M <= r; M++)
+                s.set(M, r - 1, s.get(M, r - 1) / V), s.set(M, r, s.get(M, r) / V);
+          }
+      for (c = 0; c < i; c++)
+        if (c < n || c > l)
+          for (M = c; M < i; M++)
+            t.set(c, M, s.get(c, M));
+      for (M = i - 1; M >= n; M--)
+        for (c = n; c <= l; c++) {
+          for (p = 0, k = n; k <= Math.min(M, l); k++)
+            p = p + t.get(c, k) * s.get(k, M);
+          t.set(c, M, p);
+        }
+    }
+  }
+  function pt(i, o, e, t) {
+    let s, r;
+    return Math.abs(e) > Math.abs(t) ? (s = t / e, r = e + s * t, [(i + s * o) / r, (o - s * i) / r]) : (s = e / t, r = t + s * e, [(s * i + o) / r, (s * o - i) / r]);
+  }
+  class zt {
+    constructor(o) {
+      if (o = G.checkMatrix(o), !o.isSymmetric())
+        throw new Error("Matrix is not symmetric");
+      let e = o, t = e.rows, s = new S(t, t), r = !0, n, l, h;
+      for (l = 0; l < t; l++) {
+        let u = 0;
+        for (h = 0; h < l; h++) {
+          let w = 0;
+          for (n = 0; n < h; n++)
+            w += s.get(h, n) * s.get(l, n);
+          w = (e.get(l, h) - w) / s.get(h, h), s.set(l, h, w), u = u + w * w;
+        }
+        for (u = e.get(l, l) - u, r && (r = u > 0), s.set(l, l, Math.sqrt(Math.max(u, 0))), h = l + 1; h < t; h++)
+          s.set(l, h, 0);
+      }
+      this.L = s, this.positiveDefinite = r;
+    }
+    isPositiveDefinite() {
+      return this.positiveDefinite;
+    }
+    solve(o) {
+      o = G.checkMatrix(o);
+      let e = this.L, t = e.rows;
+      if (o.rows !== t)
+        throw new Error("Matrix dimensions do not match");
+      if (this.isPositiveDefinite() === !1)
+        throw new Error("Matrix is not positive definite");
+      let s = o.columns, r = o.clone(), n, l, h;
+      for (h = 0; h < t; h++)
+        for (l = 0; l < s; l++) {
+          for (n = 0; n < h; n++)
+            r.set(h, l, r.get(h, l) - r.get(n, l) * e.get(h, n));
+          r.set(h, l, r.get(h, l) / e.get(h, h));
+        }
+      for (h = t - 1; h >= 0; h--)
+        for (l = 0; l < s; l++) {
+          for (n = h + 1; n < t; n++)
+            r.set(h, l, r.get(h, l) - r.get(n, l) * e.get(n, h));
+          r.set(h, l, r.get(h, l) / e.get(h, h));
+        }
+      return r;
+    }
+    get lowerTriangularMatrix() {
+      return this.L;
+    }
+  }
+  class Ct {
+    constructor(o, e = {}) {
+      o = G.checkMatrix(o);
+      let { Y: t } = e;
+      const {
+        scaleScores: s = !1,
+        maxIterations: r = 1e3,
+        terminationCriteria: n = 1e-10
+      } = e;
+      let l;
+      if (t) {
+        if (D.isAnyArray(t) && typeof t[0] == "number" ? t = S.columnVector(t) : t = G.checkMatrix(t), t.rows !== o.rows)
+          throw new Error("Y should have the same number of rows as X");
+        l = t.getColumnVector(0);
+      } else
+        l = o.getColumnVector(0);
+      let h = 1, u, w, f, a;
+      for (let j = 0; j < r && h > n; j++)
+        f = o.transpose().mmul(l).div(l.transpose().mmul(l).get(0, 0)), f = f.div(f.norm()), u = o.mmul(f).div(f.transpose().mmul(f).get(0, 0)), j > 0 && (h = u.clone().sub(a).pow(2).sum()), a = u.clone(), t ? (w = t.transpose().mmul(u).div(u.transpose().mmul(u).get(0, 0)), w = w.div(w.norm()), l = t.mmul(w).div(w.transpose().mmul(w).get(0, 0))) : l = u;
+      if (t) {
+        let j = o.transpose().mmul(u).div(u.transpose().mmul(u).get(0, 0));
+        j = j.div(j.norm());
+        let m = o.clone().sub(u.clone().mmul(j.transpose())), p = l.transpose().mmul(u).div(u.transpose().mmul(u).get(0, 0)), E = t.clone().sub(
+          u.clone().mulS(p.get(0, 0)).mmul(w.transpose())
+        );
+        this.t = u, this.p = j.transpose(), this.w = f.transpose(), this.q = w, this.u = l, this.s = u.transpose().mmul(u), this.xResidual = m, this.yResidual = E, this.betas = p;
+      } else
+        this.w = f.transpose(), this.s = u.transpose().mmul(u).sqrt(), s ? this.t = u.clone().div(this.s.get(0, 0)) : this.t = u, this.xResidual = o.sub(u.mmul(f.transpose()));
+    }
+  }
+  return I.AbstractMatrix = T, I.CHO = zt, I.CholeskyDecomposition = zt, I.DistanceMatrix = gt, I.EVD = $t, I.EigenvalueDecomposition = $t, I.LU = mt, I.LuDecomposition = mt, I.Matrix = S, I.MatrixColumnSelectionView = ue, I.MatrixColumnView = he, I.MatrixFlipColumnView = fe, I.MatrixFlipRowView = ce, I.MatrixRowSelectionView = we, I.MatrixRowView = ge, I.MatrixSelectionView = wt, I.MatrixSubView = me, I.MatrixTransposeView = ae, I.NIPALS = Ct, I.Nipals = Ct, I.QR = bt, I.QrDecomposition = bt, I.SVD = lt, I.SingularValueDecomposition = lt, I.SymmetricMatrix = ot, I.WrapperMatrix1D = Dt, I.WrapperMatrix2D = G, I.correlation = be, I.covariance = Ee, I.default = S, I.determinant = at, I.inverse = de, I.linearDependencies = je, I.pseudoInverse = Se, I.solve = Ft, I.wrap = pe, I;
+}
+export {
+  Je as __require
+};
+//# sourceMappingURL=matrix2.js.map