@performant-software/geospatial 3.1.25-beta.1 → 3.1.25-beta.2

package/dist/index.es564.js

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