@milaboratories/graph-maker 1.1.132 → 1.1.133

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/ms/index.js

@@ -0,0 +1,73 @@
+var e = 1e3, r = e * 60, c = r * 60, t = c * 24, u = t * 365.25, l = function(s, a) {
+  a = a || {};
+  var n = typeof s;
+  if (n === "string" && s.length > 0)
+    return m(s);
+  if (n === "number" && isNaN(s) === !1)
+    return a.long ? h(s) : d(s);
+  throw new Error(
+    "val is not a non-empty string or a valid number. val=" + JSON.stringify(s)
+  );
+};
+function m(s) {
+  if (s = String(s), !(s.length > 100)) {
+    var a = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
+      s
+    );
+    if (a) {
+      var n = parseFloat(a[1]), o = (a[2] || "ms").toLowerCase();
+      switch (o) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * u;
+        case "days":
+        case "day":
+        case "d":
+          return n * t;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * c;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * r;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * e;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return;
+      }
+    }
+  }
+}
+function d(s) {
+  return s >= t ? Math.round(s / t) + "d" : s >= c ? Math.round(s / c) + "h" : s >= r ? Math.round(s / r) + "m" : s >= e ? Math.round(s / e) + "s" : s + "ms";
+}
+function h(s) {
+  return i(s, t, "day") || i(s, c, "hour") || i(s, r, "minute") || i(s, e, "second") || s + " ms";
+}
+function i(s, a, n) {
+  if (!(s < a))
+    return s < a * 1.5 ? Math.floor(s / a) + " " + n : Math.ceil(s / a) + " " + n + "s";
+}
+export {
+  l as m
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/ms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@milaboratories/miplots4/node_modules/ms/index.js"],"sourcesContent":["/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return;\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name;\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n"],"names":["s","m","h","d","y","ms","val","options","type","parse","fmtLong","fmtShort","str","match","n","plural","name"],"mappings":"AAIA,IAAIA,IAAI,KACJC,IAAID,IAAI,IACRE,IAAID,IAAI,IACRE,IAAID,IAAI,IACRE,IAAID,IAAI,QAgBZE,IAAiB,SAASC,GAAKC,GAAS;AACtCA,EAAAA,IAAUA,KAAW,CAAA;AACrB,MAAIC,IAAO,OAAOF;AAClB,MAAIE,MAAS,YAAYF,EAAI,SAAS;AACpC,WAAOG,EAAMH,CAAG;AACX,MAAIE,MAAS,YAAY,MAAMF,CAAG,MAAM;AAC7C,WAAOC,EAAQ,OAAOG,EAAQJ,CAAG,IAAIK,EAASL,CAAG;AAEnD,QAAM,IAAI;AAAA,IACR,0DACE,KAAK,UAAUA,CAAG;AAAA,EAAA;AAExB;AAUA,SAASG,EAAMG,GAAK;AAElB,MADAA,IAAM,OAAOA,CAAG,GACZ,EAAAA,EAAI,SAAS,MAGjB;AAAA,QAAIC,IAAQ,wHAAwH;AAAA,MAClID;AAAAA,IAAA;AAEF,QAAKC,GAGL;AAAA,UAAIC,IAAI,WAAWD,EAAM,CAAC,CAAC,GACvBL,KAAQK,EAAM,CAAC,KAAK,MAAM,YAAA;AAC9B,cAAQL,GAAAA;AAAAA,QACN,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOM,IAAIV;AAAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOU,IAAIX;AAAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOW,IAAIZ;AAAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOY,IAAIb;AAAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOa,IAAId;AAAAA,QACb,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AACH,iBAAOc;AAAAA,QACT;AACE;AAAA,MAAA;AAAA,IACN;AAAA,EAAA;AACA;AAUA,SAASH,EAASN,GAAI;AACpB,SAAIA,KAAMF,IACD,KAAK,MAAME,IAAKF,CAAC,IAAI,MAE1BE,KAAMH,IACD,KAAK,MAAMG,IAAKH,CAAC,IAAI,MAE1BG,KAAMJ,IACD,KAAK,MAAMI,IAAKJ,CAAC,IAAI,MAE1BI,KAAML,IACD,KAAK,MAAMK,IAAKL,CAAC,IAAI,MAEvBK,IAAK;AACd;AAUA,SAASK,EAAQL,GAAI;AACnB,SAAOU,EAAOV,GAAIF,GAAG,KAAK,KACxBY,EAAOV,GAAIH,GAAG,MAAM,KACpBa,EAAOV,GAAIJ,GAAG,QAAQ,KACtBc,EAAOV,GAAIL,GAAG,QAAQ,KACtBK,IAAK;AACT;AAMA,SAASU,EAAOV,GAAIS,GAAGE,GAAM;AAC3B,MAAI,EAAAX,IAAKS;AAGT,WAAIT,IAAKS,IAAI,MACJ,KAAK,MAAMT,IAAKS,CAAC,IAAI,MAAME,IAE7B,KAAK,KAAKX,IAAKS,CAAC,IAAI,MAAME,IAAO;AAC1C;","x_google_ignoreList":[0]}

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/quickselect/index.js

@@ -0,0 +1,26 @@
+function u(t, f, a = 0, h = t.length - 1, e = w) {
+  for (; h > a; ) {
+    if (h - a > 600) {
+      const M = h - a + 1, m = f - a + 1, p = Math.log(M), x = 0.5 * Math.exp(2 * p / 3), d = 0.5 * Math.sqrt(p * x * (M - x) / M) * (m - M / 2 < 0 ? -1 : 1), g = Math.max(a, Math.floor(f - m * x / M + d)), q = Math.min(h, Math.floor(f + (M - m) * x / M + d));
+      u(t, f, g, q, e);
+    }
+    const o = t[f];
+    let l = a, r = h;
+    for (i(t, a, f), e(t[h], o) > 0 && i(t, a, h); l < r; ) {
+      for (i(t, l, r), l++, r--; e(t[l], o) < 0; ) l++;
+      for (; e(t[r], o) > 0; ) r--;
+    }
+    e(t[a], o) === 0 ? i(t, a, r) : (r++, i(t, r, h)), r <= f && (a = r + 1), f <= r && (h = r - 1);
+  }
+}
+function i(t, f, a) {
+  const h = t[f];
+  t[f] = t[a], t[a] = h;
+}
+function w(t, f) {
+  return t < f ? -1 : t > f ? 1 : 0;
+}
+export {
+  u as default
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/quickselect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@milaboratories/miplots4/node_modules/quickselect/index.js"],"sourcesContent":["\n/**\n * Rearranges items so that all items in the [left, k] are the smallest.\n * The k-th element will have the (k - left + 1)-th smallest value in [left, right].\n *\n * @template T\n * @param {T[]} arr the array to partially sort (in place)\n * @param {number} k middle index for partial sorting (as defined above)\n * @param {number} [left=0] left index of the range to sort\n * @param {number} [right=arr.length-1] right index\n * @param {(a: T, b: T) => number} [compare = (a, b) => a - b] compare function\n */\nexport default function quickselect(arr, k, left = 0, right = arr.length - 1, compare = defaultCompare) {\n\n    while (right > left) {\n        if (right - left > 600) {\n            const n = right - left + 1;\n            const m = k - left + 1;\n            const z = Math.log(n);\n            const s = 0.5 * Math.exp(2 * z / 3);\n            const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n            const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n            const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n            quickselect(arr, k, newLeft, newRight, compare);\n        }\n\n        const t = arr[k];\n        let i = left;\n        /** @type {number} */\n        let j = right;\n\n        swap(arr, left, k);\n        if (compare(arr[right], t) > 0) swap(arr, left, right);\n\n        while (i < j) {\n            swap(arr, i, j);\n            i++;\n            j--;\n            while (compare(arr[i], t) < 0) i++;\n            while (compare(arr[j], t) > 0) j--;\n        }\n\n        if (compare(arr[left], t) === 0) swap(arr, left, j);\n        else {\n            j++;\n            swap(arr, j, right);\n        }\n\n        if (j <= k) left = j + 1;\n        if (k <= j) right = j - 1;\n    }\n}\n\n/**\n * @template T\n * @param {T[]} arr\n * @param {number} i\n * @param {number} j\n */\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\n/**\n * @template T\n * @param {T} a\n * @param {T} b\n * @returns {number}\n */\nfunction defaultCompare(a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n}\n"],"names":["quickselect","arr","k","left","right","compare","defaultCompare","n","m","z","s","sd","newLeft","newRight","t","i","j","swap","tmp","a","b"],"mappings":"AAYe,SAASA,EAAYC,GAAKC,GAAGC,IAAO,GAAGC,IAAQH,EAAI,SAAS,GAAGI,IAAUC,GAAgB;AAEpG,SAAOF,IAAQD,KAAM;AACjB,QAAIC,IAAQD,IAAO,KAAK;AACpB,YAAMI,IAAIH,IAAQD,IAAO,GACnBK,IAAIN,IAAIC,IAAO,GACfM,IAAI,KAAK,IAAIF,CAAC,GACdG,IAAI,MAAM,KAAK,IAAI,IAAID,IAAI,CAAC,GAC5BE,IAAK,MAAM,KAAK,KAAKF,IAAIC,KAAKH,IAAIG,KAAKH,CAAC,KAAKC,IAAID,IAAI,IAAI,IAAI,KAAK,IAClEK,IAAU,KAAK,IAAIT,GAAM,KAAK,MAAMD,IAAIM,IAAIE,IAAIH,IAAII,CAAE,CAAC,GACvDE,IAAW,KAAK,IAAIT,GAAO,KAAK,MAAMF,KAAKK,IAAIC,KAAKE,IAAIH,IAAII,CAAE,CAAC;AACrEX,MAAAA,EAAYC,GAAKC,GAAGU,GAASC,GAAUR,CAAO;AAAA,IAClD;AAEA,UAAMS,IAAIb,EAAIC,CAAC;AACf,QAAIa,IAAIZ,GAEJa,IAAIZ;AAKR,SAHAa,EAAKhB,GAAKE,GAAMD,CAAC,GACbG,EAAQJ,EAAIG,CAAK,GAAGU,CAAC,IAAI,KAAGG,EAAKhB,GAAKE,GAAMC,CAAK,GAE9CW,IAAIC,KAAG;AAIV,WAHAC,EAAKhB,GAAKc,GAAGC,CAAC,GACdD,KACAC,KACOX,EAAQJ,EAAIc,CAAC,GAAGD,CAAC,IAAI,IAAGC,CAAAA;AAC/B,aAAOV,EAAQJ,EAAIe,CAAC,GAAGF,CAAC,IAAI,IAAGE,CAAAA;AAAAA,IACnC;AAEIX,IAAAA,EAAQJ,EAAIE,CAAI,GAAGW,CAAC,MAAM,IAAGG,EAAKhB,GAAKE,GAAMa,CAAC,KAE9CA,KACAC,EAAKhB,GAAKe,GAAGZ,CAAK,IAGlBY,KAAKd,MAAGC,IAAOa,IAAI,IACnBd,KAAKc,MAAGZ,IAAQY,IAAI;AAAA,EAC5B;AACJ;AAQA,SAASC,EAAKhB,GAAKc,GAAGC,GAAG;AACrB,QAAME,IAAMjB,EAAIc,CAAC;AACjBd,EAAAA,EAAIc,CAAC,IAAId,EAAIe,CAAC,GACdf,EAAIe,CAAC,IAAIE;AACb;AAQA,SAASZ,EAAea,GAAGC,GAAG;AAC1B,SAAOD,IAAIC,IAAI,KAAKD,IAAIC,IAAI,IAAI;AACpC;","x_google_ignoreList":[0]}

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/rbush/index.js

@@ -0,0 +1,251 @@
+import S from "../quickselect/index.js";
+class j {
+  constructor(t = 9) {
+    this._maxEntries = Math.max(4, t), this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)), this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(t) {
+    let n = this.data;
+    const i = [];
+    if (!M(t, n)) return i;
+    const r = this.toBBox, e = [];
+    for (; n; ) {
+      for (let s = 0; s < n.children.length; s++) {
+        const a = n.children[s], o = n.leaf ? r(a) : a;
+        M(t, o) && (n.leaf ? i.push(a) : Y(t, o) ? this._all(a, i) : e.push(a));
+      }
+      n = e.pop();
+    }
+    return i;
+  }
+  collides(t) {
+    let n = this.data;
+    if (!M(t, n)) return !1;
+    const i = [];
+    for (; n; ) {
+      for (let r = 0; r < n.children.length; r++) {
+        const e = n.children[r], s = n.leaf ? this.toBBox(e) : e;
+        if (M(t, s)) {
+          if (n.leaf || Y(t, s)) return !0;
+          i.push(e);
+        }
+      }
+      n = i.pop();
+    }
+    return !1;
+  }
+  load(t) {
+    if (!(t && t.length)) return this;
+    if (t.length < this._minEntries) {
+      for (let i = 0; i < t.length; i++)
+        this.insert(t[i]);
+      return this;
+    }
+    let n = this._build(t.slice(), 0, t.length - 1, 0);
+    if (!this.data.children.length)
+      this.data = n;
+    else if (this.data.height === n.height)
+      this._splitRoot(this.data, n);
+    else {
+      if (this.data.height < n.height) {
+        const i = this.data;
+        this.data = n, n = i;
+      }
+      this._insert(n, this.data.height - n.height - 1, !0);
+    }
+    return this;
+  }
+  insert(t) {
+    return t && this._insert(t, this.data.height - 1), this;
+  }
+  clear() {
+    return this.data = f([]), this;
+  }
+  remove(t, n) {
+    if (!t) return this;
+    let i = this.data;
+    const r = this.toBBox(t), e = [], s = [];
+    let a, o, c;
+    for (; i || e.length; ) {
+      if (i || (i = e.pop(), o = e[e.length - 1], a = s.pop(), c = !0), i.leaf) {
+        const l = E(t, i.children, n);
+        if (l !== -1)
+          return i.children.splice(l, 1), e.push(i), this._condense(e), this;
+      }
+      !c && !i.leaf && Y(i, r) ? (e.push(i), s.push(a), a = 0, o = i, i = i.children[0]) : o ? (a++, i = o.children[a], c = !1) : i = null;
+    }
+    return this;
+  }
+  toBBox(t) {
+    return t;
+  }
+  compareMinX(t, n) {
+    return t.minX - n.minX;
+  }
+  compareMinY(t, n) {
+    return t.minY - n.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(t) {
+    return this.data = t, this;
+  }
+  _all(t, n) {
+    const i = [];
+    for (; t; )
+      t.leaf ? n.push(...t.children) : i.push(...t.children), t = i.pop();
+    return n;
+  }
+  _build(t, n, i, r) {
+    const e = i - n + 1;
+    let s = this._maxEntries, a;
+    if (e <= s)
+      return a = f(t.slice(n, i + 1)), u(a, this.toBBox), a;
+    r || (r = Math.ceil(Math.log(e) / Math.log(s)), s = Math.ceil(e / Math.pow(s, r - 1))), a = f([]), a.leaf = !1, a.height = r;
+    const o = Math.ceil(e / s), c = o * Math.ceil(Math.sqrt(s));
+    _(t, n, i, c, this.compareMinX);
+    for (let l = n; l <= i; l += c) {
+      const m = Math.min(l + c - 1, i);
+      _(t, l, m, o, this.compareMinY);
+      for (let p = l; p <= m; p += o) {
+        const B = Math.min(p + o - 1, m);
+        a.children.push(this._build(t, p, B, r - 1));
+      }
+    }
+    return u(a, this.toBBox), a;
+  }
+  _chooseSubtree(t, n, i, r) {
+    for (; r.push(n), !(n.leaf || r.length - 1 === i); ) {
+      let e = 1 / 0, s = 1 / 0, a;
+      for (let o = 0; o < n.children.length; o++) {
+        const c = n.children[o], l = X(c), m = A(t, c) - l;
+        m < s ? (s = m, e = l < e ? l : e, a = c) : m === s && l < e && (e = l, a = c);
+      }
+      n = a || n.children[0];
+    }
+    return n;
+  }
+  _insert(t, n, i) {
+    const r = i ? t : this.toBBox(t), e = [], s = this._chooseSubtree(r, this.data, n, e);
+    for (s.children.push(t), d(s, r); n >= 0 && e[n].children.length > this._maxEntries; )
+      this._split(e, n), n--;
+    this._adjustParentBBoxes(r, e, n);
+  }
+  // split overflowed node into two
+  _split(t, n) {
+    const i = t[n], r = i.children.length, e = this._minEntries;
+    this._chooseSplitAxis(i, e, r);
+    const s = this._chooseSplitIndex(i, e, r), a = f(i.children.splice(s, i.children.length - s));
+    a.height = i.height, a.leaf = i.leaf, u(i, this.toBBox), u(a, this.toBBox), n ? t[n - 1].children.push(a) : this._splitRoot(i, a);
+  }
+  _splitRoot(t, n) {
+    this.data = f([t, n]), this.data.height = t.height + 1, this.data.leaf = !1, u(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(t, n, i) {
+    let r, e = 1 / 0, s = 1 / 0;
+    for (let a = n; a <= i - n; a++) {
+      const o = x(t, 0, a, this.toBBox), c = x(t, a, i, this.toBBox), l = D(o, c), m = X(o) + X(c);
+      l < e ? (e = l, r = a, s = m < s ? m : s) : l === e && m < s && (s = m, r = a);
+    }
+    return r || i - n;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(t, n, i) {
+    const r = t.leaf ? this.compareMinX : b, e = t.leaf ? this.compareMinY : O, s = this._allDistMargin(t, n, i, r), a = this._allDistMargin(t, n, i, e);
+    s < a && t.children.sort(r);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(t, n, i, r) {
+    t.children.sort(r);
+    const e = this.toBBox, s = x(t, 0, n, e), a = x(t, i - n, i, e);
+    let o = g(s) + g(a);
+    for (let c = n; c < i - n; c++) {
+      const l = t.children[c];
+      d(s, t.leaf ? e(l) : l), o += g(s);
+    }
+    for (let c = i - n - 1; c >= n; c--) {
+      const l = t.children[c];
+      d(a, t.leaf ? e(l) : l), o += g(a);
+    }
+    return o;
+  }
+  _adjustParentBBoxes(t, n, i) {
+    for (let r = i; r >= 0; r--)
+      d(n[r], t);
+  }
+  _condense(t) {
+    for (let n = t.length - 1, i; n >= 0; n--)
+      t[n].children.length === 0 ? n > 0 ? (i = t[n - 1].children, i.splice(i.indexOf(t[n]), 1)) : this.clear() : u(t[n], this.toBBox);
+  }
+}
+function E(h, t, n) {
+  if (!n) return t.indexOf(h);
+  for (let i = 0; i < t.length; i++)
+    if (n(h, t[i])) return i;
+  return -1;
+}
+function u(h, t) {
+  x(h, 0, h.children.length, t, h);
+}
+function x(h, t, n, i, r) {
+  r || (r = f(null)), r.minX = 1 / 0, r.minY = 1 / 0, r.maxX = -1 / 0, r.maxY = -1 / 0;
+  for (let e = t; e < n; e++) {
+    const s = h.children[e];
+    d(r, h.leaf ? i(s) : s);
+  }
+  return r;
+}
+function d(h, t) {
+  return h.minX = Math.min(h.minX, t.minX), h.minY = Math.min(h.minY, t.minY), h.maxX = Math.max(h.maxX, t.maxX), h.maxY = Math.max(h.maxY, t.maxY), h;
+}
+function b(h, t) {
+  return h.minX - t.minX;
+}
+function O(h, t) {
+  return h.minY - t.minY;
+}
+function X(h) {
+  return (h.maxX - h.minX) * (h.maxY - h.minY);
+}
+function g(h) {
+  return h.maxX - h.minX + (h.maxY - h.minY);
+}
+function A(h, t) {
+  return (Math.max(t.maxX, h.maxX) - Math.min(t.minX, h.minX)) * (Math.max(t.maxY, h.maxY) - Math.min(t.minY, h.minY));
+}
+function D(h, t) {
+  const n = Math.max(h.minX, t.minX), i = Math.max(h.minY, t.minY), r = Math.min(h.maxX, t.maxX), e = Math.min(h.maxY, t.maxY);
+  return Math.max(0, r - n) * Math.max(0, e - i);
+}
+function Y(h, t) {
+  return h.minX <= t.minX && h.minY <= t.minY && t.maxX <= h.maxX && t.maxY <= h.maxY;
+}
+function M(h, t) {
+  return t.minX <= h.maxX && t.minY <= h.maxY && t.maxX >= h.minX && t.maxY >= h.minY;
+}
+function f(h) {
+  return {
+    children: h,
+    height: 1,
+    leaf: !0,
+    minX: 1 / 0,
+    minY: 1 / 0,
+    maxX: -1 / 0,
+    maxY: -1 / 0
+  };
+}
+function _(h, t, n, i, r) {
+  const e = [t, n];
+  for (; e.length; ) {
+    if (n = e.pop(), t = e.pop(), n - t <= i) continue;
+    const s = t + Math.ceil((n - t) / i / 2) * i;
+    S(h, s, t, n, r), e.push(t, s, s, n);
+  }
+}
+export {
+  j as default
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@milaboratories/miplots4/dist/node_modules/rbush/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@milaboratories/miplots4/node_modules/rbush/index.js"],"sourcesContent":["import quickselect from 'quickselect';\n\nexport default class RBush {\n    constructor(maxEntries = 9) {\n        // max entries in a node is 9 by default; min node fill is 40% for best performance\n        this._maxEntries = Math.max(4, maxEntries);\n        this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));\n        this.clear();\n    }\n\n    all() {\n        return this._all(this.data, []);\n    }\n\n    search(bbox) {\n        let node = this.data;\n        const result = [];\n\n        if (!intersects(bbox, node)) return result;\n\n        const toBBox = this.toBBox;\n        const nodesToSearch = [];\n\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf) result.push(child);\n                    else if (contains(bbox, childBBox)) this._all(child, result);\n                    else nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return result;\n    }\n\n    collides(bbox) {\n        let node = this.data;\n\n        if (!intersects(bbox, node)) return false;\n\n        const nodesToSearch = [];\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? this.toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf || contains(bbox, childBBox)) return true;\n                    nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return false;\n    }\n\n    load(data) {\n        if (!(data && data.length)) return this;\n\n        if (data.length < this._minEntries) {\n            for (let i = 0; i < data.length; i++) {\n                this.insert(data[i]);\n            }\n            return this;\n        }\n\n        // recursively build the tree with the given data from scratch using OMT algorithm\n        let node = this._build(data.slice(), 0, data.length - 1, 0);\n\n        if (!this.data.children.length) {\n            // save as is if tree is empty\n            this.data = node;\n\n        } else if (this.data.height === node.height) {\n            // split root if trees have the same height\n            this._splitRoot(this.data, node);\n\n        } else {\n            if (this.data.height < node.height) {\n                // swap trees if inserted one is bigger\n                const tmpNode = this.data;\n                this.data = node;\n                node = tmpNode;\n            }\n\n            // insert the small tree into the large tree at appropriate level\n            this._insert(node, this.data.height - node.height - 1, true);\n        }\n\n        return this;\n    }\n\n    insert(item) {\n        if (item) this._insert(item, this.data.height - 1);\n        return this;\n    }\n\n    clear() {\n        this.data = createNode([]);\n        return this;\n    }\n\n    remove(item, equalsFn) {\n        if (!item) return this;\n\n        let node = this.data;\n        const bbox = this.toBBox(item);\n        const path = [];\n        const indexes = [];\n        let i, parent, goingUp;\n\n        // depth-first iterative tree traversal\n        while (node || path.length) {\n\n            if (!node) { // go up\n                node = path.pop();\n                parent = path[path.length - 1];\n                i = indexes.pop();\n                goingUp = true;\n            }\n\n            if (node.leaf) { // check current node\n                const index = findItem(item, node.children, equalsFn);\n\n                if (index !== -1) {\n                    // item found, remove the item and condense tree upwards\n                    node.children.splice(index, 1);\n                    path.push(node);\n                    this._condense(path);\n                    return this;\n                }\n            }\n\n            if (!goingUp && !node.leaf && contains(node, bbox)) { // go down\n                path.push(node);\n                indexes.push(i);\n                i = 0;\n                parent = node;\n                node = node.children[0];\n\n            } else if (parent) { // go right\n                i++;\n                node = parent.children[i];\n                goingUp = false;\n\n            } else node = null; // nothing found\n        }\n\n        return this;\n    }\n\n    toBBox(item) { return item; }\n\n    compareMinX(a, b) { return a.minX - b.minX; }\n    compareMinY(a, b) { return a.minY - b.minY; }\n\n    toJSON() { return this.data; }\n\n    fromJSON(data) {\n        this.data = data;\n        return this;\n    }\n\n    _all(node, result) {\n        const nodesToSearch = [];\n        while (node) {\n            if (node.leaf) result.push(...node.children);\n            else nodesToSearch.push(...node.children);\n\n            node = nodesToSearch.pop();\n        }\n        return result;\n    }\n\n    _build(items, left, right, height) {\n\n        const N = right - left + 1;\n        let M = this._maxEntries;\n        let node;\n\n        if (N <= M) {\n            // reached leaf level; return leaf\n            node = createNode(items.slice(left, right + 1));\n            calcBBox(node, this.toBBox);\n            return node;\n        }\n\n        if (!height) {\n            // target height of the bulk-loaded tree\n            height = Math.ceil(Math.log(N) / Math.log(M));\n\n            // target number of root entries to maximize storage utilization\n            M = Math.ceil(N / Math.pow(M, height - 1));\n        }\n\n        node = createNode([]);\n        node.leaf = false;\n        node.height = height;\n\n        // split the items into M mostly square tiles\n\n        const N2 = Math.ceil(N / M);\n        const N1 = N2 * Math.ceil(Math.sqrt(M));\n\n        multiSelect(items, left, right, N1, this.compareMinX);\n\n        for (let i = left; i <= right; i += N1) {\n\n            const right2 = Math.min(i + N1 - 1, right);\n\n            multiSelect(items, i, right2, N2, this.compareMinY);\n\n            for (let j = i; j <= right2; j += N2) {\n\n                const right3 = Math.min(j + N2 - 1, right2);\n\n                // pack each entry recursively\n                node.children.push(this._build(items, j, right3, height - 1));\n            }\n        }\n\n        calcBBox(node, this.toBBox);\n\n        return node;\n    }\n\n    _chooseSubtree(bbox, node, level, path) {\n        while (true) {\n            path.push(node);\n\n            if (node.leaf || path.length - 1 === level) break;\n\n            let minArea = Infinity;\n            let minEnlargement = Infinity;\n            let targetNode;\n\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const area = bboxArea(child);\n                const enlargement = enlargedArea(bbox, child) - area;\n\n                // choose entry with the least area enlargement\n                if (enlargement < minEnlargement) {\n                    minEnlargement = enlargement;\n                    minArea = area < minArea ? area : minArea;\n                    targetNode = child;\n\n                } else if (enlargement === minEnlargement) {\n                    // otherwise choose one with the smallest area\n                    if (area < minArea) {\n                        minArea = area;\n                        targetNode = child;\n                    }\n                }\n            }\n\n            node = targetNode || node.children[0];\n        }\n\n        return node;\n    }\n\n    _insert(item, level, isNode) {\n        const bbox = isNode ? item : this.toBBox(item);\n        const insertPath = [];\n\n        // find the best node for accommodating the item, saving all nodes along the path too\n        const node = this._chooseSubtree(bbox, this.data, level, insertPath);\n\n        // put the item into the node\n        node.children.push(item);\n        extend(node, bbox);\n\n        // split on node overflow; propagate upwards if necessary\n        while (level >= 0) {\n            if (insertPath[level].children.length > this._maxEntries) {\n                this._split(insertPath, level);\n                level--;\n            } else break;\n        }\n\n        // adjust bboxes along the insertion path\n        this._adjustParentBBoxes(bbox, insertPath, level);\n    }\n\n    // split overflowed node into two\n    _split(insertPath, level) {\n        const node = insertPath[level];\n        const M = node.children.length;\n        const m = this._minEntries;\n\n        this._chooseSplitAxis(node, m, M);\n\n        const splitIndex = this._chooseSplitIndex(node, m, M);\n\n        const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));\n        newNode.height = node.height;\n        newNode.leaf = node.leaf;\n\n        calcBBox(node, this.toBBox);\n        calcBBox(newNode, this.toBBox);\n\n        if (level) insertPath[level - 1].children.push(newNode);\n        else this._splitRoot(node, newNode);\n    }\n\n    _splitRoot(node, newNode) {\n        // split root node\n        this.data = createNode([node, newNode]);\n        this.data.height = node.height + 1;\n        this.data.leaf = false;\n        calcBBox(this.data, this.toBBox);\n    }\n\n    _chooseSplitIndex(node, m, M) {\n        let index;\n        let minOverlap = Infinity;\n        let minArea = Infinity;\n\n        for (let i = m; i <= M - m; i++) {\n            const bbox1 = distBBox(node, 0, i, this.toBBox);\n            const bbox2 = distBBox(node, i, M, this.toBBox);\n\n            const overlap = intersectionArea(bbox1, bbox2);\n            const area = bboxArea(bbox1) + bboxArea(bbox2);\n\n            // choose distribution with minimum overlap\n            if (overlap < minOverlap) {\n                minOverlap = overlap;\n                index = i;\n\n                minArea = area < minArea ? area : minArea;\n\n            } else if (overlap === minOverlap) {\n                // otherwise choose distribution with minimum area\n                if (area < minArea) {\n                    minArea = area;\n                    index = i;\n                }\n            }\n        }\n\n        return index || M - m;\n    }\n\n    // sorts node children by the best axis for split\n    _chooseSplitAxis(node, m, M) {\n        const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;\n        const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;\n        const xMargin = this._allDistMargin(node, m, M, compareMinX);\n        const yMargin = this._allDistMargin(node, m, M, compareMinY);\n\n        // if total distributions margin value is minimal for x, sort by minX,\n        // otherwise it's already sorted by minY\n        if (xMargin < yMargin) node.children.sort(compareMinX);\n    }\n\n    // total margin of all possible split distributions where each node is at least m full\n    _allDistMargin(node, m, M, compare) {\n        node.children.sort(compare);\n\n        const toBBox = this.toBBox;\n        const leftBBox = distBBox(node, 0, m, toBBox);\n        const rightBBox = distBBox(node, M - m, M, toBBox);\n        let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);\n\n        for (let i = m; i < M - m; i++) {\n            const child = node.children[i];\n            extend(leftBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(leftBBox);\n        }\n\n        for (let i = M - m - 1; i >= m; i--) {\n            const child = node.children[i];\n            extend(rightBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(rightBBox);\n        }\n\n        return margin;\n    }\n\n    _adjustParentBBoxes(bbox, path, level) {\n        // adjust bboxes along the given tree path\n        for (let i = level; i >= 0; i--) {\n            extend(path[i], bbox);\n        }\n    }\n\n    _condense(path) {\n        // go through the path, removing empty nodes and updating bboxes\n        for (let i = path.length - 1, siblings; i >= 0; i--) {\n            if (path[i].children.length === 0) {\n                if (i > 0) {\n                    siblings = path[i - 1].children;\n                    siblings.splice(siblings.indexOf(path[i]), 1);\n\n                } else this.clear();\n\n            } else calcBBox(path[i], this.toBBox);\n        }\n    }\n}\n\nfunction findItem(item, items, equalsFn) {\n    if (!equalsFn) return items.indexOf(item);\n\n    for (let i = 0; i < items.length; i++) {\n        if (equalsFn(item, items[i])) return i;\n    }\n    return -1;\n}\n\n// calculate node's bbox from bboxes of its children\nfunction calcBBox(node, toBBox) {\n    distBBox(node, 0, node.children.length, toBBox, node);\n}\n\n// min bounding rectangle of node children from k to p-1\nfunction distBBox(node, k, p, toBBox, destNode) {\n    if (!destNode) destNode = createNode(null);\n    destNode.minX = Infinity;\n    destNode.minY = Infinity;\n    destNode.maxX = -Infinity;\n    destNode.maxY = -Infinity;\n\n    for (let i = k; i < p; i++) {\n        const child = node.children[i];\n        extend(destNode, node.leaf ? toBBox(child) : child);\n    }\n\n    return destNode;\n}\n\nfunction extend(a, b) {\n    a.minX = Math.min(a.minX, b.minX);\n    a.minY = Math.min(a.minY, b.minY);\n    a.maxX = Math.max(a.maxX, b.maxX);\n    a.maxY = Math.max(a.maxY, b.maxY);\n    return a;\n}\n\nfunction compareNodeMinX(a, b) { return a.minX - b.minX; }\nfunction compareNodeMinY(a, b) { return a.minY - b.minY; }\n\nfunction bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }\nfunction bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }\n\nfunction enlargedArea(a, b) {\n    return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *\n           (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));\n}\n\nfunction intersectionArea(a, b) {\n    const minX = Math.max(a.minX, b.minX);\n    const minY = Math.max(a.minY, b.minY);\n    const maxX = Math.min(a.maxX, b.maxX);\n    const maxY = Math.min(a.maxY, b.maxY);\n\n    return Math.max(0, maxX - minX) *\n           Math.max(0, maxY - minY);\n}\n\nfunction contains(a, b) {\n    return a.minX <= b.minX &&\n           a.minY <= b.minY &&\n           b.maxX <= a.maxX &&\n           b.maxY <= a.maxY;\n}\n\nfunction intersects(a, b) {\n    return b.minX <= a.maxX &&\n           b.minY <= a.maxY &&\n           b.maxX >= a.minX &&\n           b.maxY >= a.minY;\n}\n\nfunction createNode(children) {\n    return {\n        children,\n        height: 1,\n        leaf: true,\n        minX: Infinity,\n        minY: Infinity,\n        maxX: -Infinity,\n        maxY: -Infinity\n    };\n}\n\n// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;\n// combines selection algorithm with binary divide & conquer approach\n\nfunction multiSelect(arr, left, right, n, compare) {\n    const stack = [left, right];\n\n    while (stack.length) {\n        right = stack.pop();\n        left = stack.pop();\n\n        if (right - left <= n) continue;\n\n        const mid = left + Math.ceil((right - left) / n / 2) * n;\n        quickselect(arr, mid, left, right, compare);\n\n        stack.push(left, mid, mid, right);\n    }\n}\n"],"names":["RBush","maxEntries","bbox","node","result","intersects","toBBox","nodesToSearch","i","child","childBBox","contains","data","tmpNode","item","createNode","equalsFn","path","indexes","parent","goingUp","index","findItem","a","b","items","left","right","height","N","M","calcBBox","N2","N1","multiSelect","right2","j","right3","level","minArea","minEnlargement","targetNode","area","bboxArea","enlargement","enlargedArea","isNode","insertPath","extend","m","splitIndex","newNode","minOverlap","bbox1","distBBox","bbox2","overlap","intersectionArea","compareMinX","compareNodeMinX","compareMinY","compareNodeMinY","xMargin","yMargin","compare","leftBBox","rightBBox","margin","bboxMargin","siblings","k","p","destNode","minX","minY","maxX","maxY","children","arr","n","stack","mid","quickselect"],"mappings":"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","x_google_ignoreList":[0]}