yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/impl.js

@@ -0,0 +1,12 @@
+import { error as t } from "../util/log.js";
+var r = {};
+function n(o, i) {
+  process.env.NODE_ENV !== "production" && r[o] && t("Already has an implementation of " + o + "."), r[o] = i;
+}
+function p(o) {
+  return process.env.NODE_ENV !== "production" && (r[o] || t("Implementation of " + o + " doesn't exists.")), r[o];
+}
+export {
+  p as getImpl,
+  n as registerImpl
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/lifecycle.js

@@ -0,0 +1,5 @@
+import e from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Eventful.js";
+var l = new e();
+export {
+  l as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/locale.js

@@ -0,0 +1,37 @@
+import m from "../model/Model.js";
+import p from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/env.js";
+import L from "../i18n/langEN.js";
+import s from "../i18n/langZH.js";
+import { isString as v, clone as n, merge as f } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+var a = "ZH", i = "EN", e = i, o = {}, u = {}, S = p.domSupported ? function() {
+  var r = (
+    /* eslint-disable-next-line */
+    (document.documentElement.lang || navigator.language || navigator.browserLanguage || e).toUpperCase()
+  );
+  return r.indexOf(a) > -1 ? a : e;
+}() : e;
+function g(r, t) {
+  r = r.toUpperCase(), u[r] = new m(t), o[r] = t;
+}
+function A(r) {
+  if (v(r)) {
+    var t = o[r.toUpperCase()] || {};
+    return r === a || r === i ? n(t) : f(n(t), n(o[e]), !1);
+  } else
+    return f(n(r), n(o[e]), !1);
+}
+function M(r) {
+  return u[r];
+}
+function N() {
+  return u[e];
+}
+g(i, L);
+g(a, s);
+export {
+  S as SYSTEM_LANG,
+  A as createLocaleObject,
+  N as getDefaultLocaleModel,
+  M as getLocaleModel,
+  g as registerLocale
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/task.js

@@ -0,0 +1,91 @@
+import { assert as p, isArray as D } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+function N(i) {
+  return new g(i);
+}
+var g = (
+  /** @class */
+  function() {
+    function i(t) {
+      t = t || {}, this._reset = t.reset, this._plan = t.plan, this._count = t.count, this._onDirty = t.onDirty, this._dirty = !0;
+    }
+    return i.prototype.perform = function(t) {
+      var s = this._upstream, e = t && t.skip;
+      if (this._dirty && s) {
+        var n = this.context;
+        n.data = n.outputData = s.context.outputData;
+      }
+      this.__pipeline && (this.__pipeline.currentTask = this);
+      var o;
+      this._plan && !e && (o = this._plan(this.context));
+      var c = _(this._modBy), l = this._modDataCount || 0, r = _(t && t.modBy), u = t && t.modDataCount || 0;
+      (c !== r || l !== u) && (o = "reset");
+      function _(v) {
+        return !(v >= 1) && (v = 1), v;
+      }
+      var d;
+      (this._dirty || o === "reset") && (this._dirty = !1, d = this._doReset(e)), this._modBy = r, this._modDataCount = u;
+      var m = t && t.step;
+      if (s ? (process.env.NODE_ENV !== "production" && p(s._outputDueEnd != null), this._dueEnd = s._outputDueEnd) : (process.env.NODE_ENV !== "production" && p(!this._progress || this._count), this._dueEnd = this._count ? this._count(this.context) : 1 / 0), this._progress) {
+        var f = this._dueIndex, h = Math.min(m != null ? this._dueIndex + m : 1 / 0, this._dueEnd);
+        if (!e && (d || f < h)) {
+          var a = this._progress;
+          if (D(a))
+            for (var y = 0; y < a.length; y++)
+              this._doProgress(a[y], f, h, r, u);
+          else
+            this._doProgress(a, f, h, r, u);
+        }
+        this._dueIndex = h;
+        var E = this._settedOutputEnd != null ? this._settedOutputEnd : h;
+        process.env.NODE_ENV !== "production" && p(E >= this._outputDueEnd), this._outputDueEnd = E;
+      } else
+        this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;
+      return this.unfinished();
+    }, i.prototype.dirty = function() {
+      this._dirty = !0, this._onDirty && this._onDirty(this.context);
+    }, i.prototype._doProgress = function(t, s, e, n, o) {
+      x.reset(s, e, n, o), this._callingProgress = t, this._callingProgress({
+        start: s,
+        end: e,
+        count: e - s,
+        next: x.next
+      }, this.context);
+    }, i.prototype._doReset = function(t) {
+      this._dueIndex = this._outputDueEnd = this._dueEnd = 0, this._settedOutputEnd = null;
+      var s, e;
+      !t && this._reset && (s = this._reset(this.context), s && s.progress && (e = s.forceFirstProgress, s = s.progress), D(s) && !s.length && (s = null)), this._progress = s, this._modBy = this._modDataCount = null;
+      var n = this._downstream;
+      return n && n.dirty(), e;
+    }, i.prototype.unfinished = function() {
+      return this._progress && this._dueIndex < this._dueEnd;
+    }, i.prototype.pipe = function(t) {
+      process.env.NODE_ENV !== "production" && p(t && !t._disposed && t !== this), (this._downstream !== t || this._dirty) && (this._downstream = t, t._upstream = this, t.dirty());
+    }, i.prototype.dispose = function() {
+      this._disposed || (this._upstream && (this._upstream._downstream = null), this._downstream && (this._downstream._upstream = null), this._dirty = !1, this._disposed = !0);
+    }, i.prototype.getUpstream = function() {
+      return this._upstream;
+    }, i.prototype.getDownstream = function() {
+      return this._downstream;
+    }, i.prototype.setOutputEnd = function(t) {
+      this._outputDueEnd = this._settedOutputEnd = t;
+    }, i;
+  }()
+), x = /* @__PURE__ */ function() {
+  var i, t, s, e, n, o = {
+    reset: function(r, u, _, d) {
+      t = r, i = u, s = _, e = d, n = Math.ceil(e / s), o.next = s > 1 && e > 0 ? l : c;
+    }
+  };
+  return o;
+  function c() {
+    return t < i ? t++ : null;
+  }
+  function l() {
+    var r = t % n * s + Math.ceil(t / n), u = t >= i ? null : r < e ? r : t;
+    return t++, u;
+  }
+}();
+export {
+  g as Task,
+  N as createTask
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/DataDiffer.js

@@ -0,0 +1,80 @@
+function a(r) {
+  return r == null ? 0 : r.length || 1;
+}
+function c(r) {
+  return r;
+}
+var d = (
+  /** @class */
+  function() {
+    function r(t, h, i, n, o, e) {
+      this._old = t, this._new = h, this._oldKeyGetter = i || c, this._newKeyGetter = n || c, this.context = o, this._diffModeMultiple = e === "multiple";
+    }
+    return r.prototype.add = function(t) {
+      return this._add = t, this;
+    }, r.prototype.update = function(t) {
+      return this._update = t, this;
+    }, r.prototype.updateManyToOne = function(t) {
+      return this._updateManyToOne = t, this;
+    }, r.prototype.updateOneToMany = function(t) {
+      return this._updateOneToMany = t, this;
+    }, r.prototype.updateManyToMany = function(t) {
+      return this._updateManyToMany = t, this;
+    }, r.prototype.remove = function(t) {
+      return this._remove = t, this;
+    }, r.prototype.execute = function() {
+      this[this._diffModeMultiple ? "_executeMultiple" : "_executeOneToOne"]();
+    }, r.prototype._executeOneToOne = function() {
+      var t = this._old, h = this._new, i = {}, n = new Array(t.length), o = new Array(h.length);
+      this._initIndexMap(t, null, n, "_oldKeyGetter"), this._initIndexMap(h, i, o, "_newKeyGetter");
+      for (var e = 0; e < t.length; e++) {
+        var s = n[e], u = i[s], _ = a(u);
+        if (_ > 1) {
+          var f = u.shift();
+          u.length === 1 && (i[s] = u[0]), this._update && this._update(f, e);
+        } else _ === 1 ? (i[s] = null, this._update && this._update(u, e)) : this._remove && this._remove(e);
+      }
+      this._performRestAdd(o, i);
+    }, r.prototype._executeMultiple = function() {
+      var t = this._old, h = this._new, i = {}, n = {}, o = [], e = [];
+      this._initIndexMap(t, i, o, "_oldKeyGetter"), this._initIndexMap(h, n, e, "_newKeyGetter");
+      for (var s = 0; s < o.length; s++) {
+        var u = o[s], _ = i[u], f = n[u], v = a(_), p = a(f);
+        if (v > 1 && p === 1)
+          this._updateManyToOne && this._updateManyToOne(f, _), n[u] = null;
+        else if (v === 1 && p > 1)
+          this._updateOneToMany && this._updateOneToMany(f, _), n[u] = null;
+        else if (v === 1 && p === 1)
+          this._update && this._update(f, _), n[u] = null;
+        else if (v > 1 && p > 1)
+          this._updateManyToMany && this._updateManyToMany(f, _), n[u] = null;
+        else if (v > 1)
+          for (var y = 0; y < v; y++)
+            this._remove && this._remove(_[y]);
+        else
+          this._remove && this._remove(_);
+      }
+      this._performRestAdd(e, n);
+    }, r.prototype._performRestAdd = function(t, h) {
+      for (var i = 0; i < t.length; i++) {
+        var n = t[i], o = h[n], e = a(o);
+        if (e > 1)
+          for (var s = 0; s < e; s++)
+            this._add && this._add(o[s]);
+        else e === 1 && this._add && this._add(o);
+        h[n] = null;
+      }
+    }, r.prototype._initIndexMap = function(t, h, i, n) {
+      for (var o = this._diffModeMultiple, e = 0; e < t.length; e++) {
+        var s = "_ec_" + this[n](t[e], e);
+        if (o || (i[e] = s), !!h) {
+          var u = h[s], _ = a(u);
+          _ === 0 ? (h[s] = e, o && i.push(s)) : _ === 1 ? h[s] = [u, e] : u.push(e);
+        }
+      }
+    }, r;
+  }()
+);
+export {
+  d as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/DataStore.js

@@ -0,0 +1,420 @@
+import { createHashMap as B, assert as x, isFunction as k, map as z, keys as T, reduce as q, clone as O } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { parseDataValue as P } from "./helper/dataValueHelper.js";
+import { shouldRetrieveDataByName as H } from "./Source.js";
+var E = "undefined", L = typeof Uint32Array === E ? Array : Uint32Array, J = typeof Uint16Array === E ? Array : Uint16Array, K = typeof Int32Array === E ? Array : Int32Array, V = typeof Float64Array === E ? Array : Float64Array, b = {
+  float: V,
+  int: K,
+  // Ordinal data type can be string or int
+  ordinal: Array,
+  number: Array,
+  time: V
+}, U;
+function I(h) {
+  return h > 65535 ? L : J;
+}
+function M() {
+  return [1 / 0, -1 / 0];
+}
+function Q(h) {
+  var t = h.constructor;
+  return t === Array ? h.slice() : new t(h);
+}
+function F(h, t, r, e, a) {
+  var n = b[r || "float"];
+  if (a) {
+    var o = h[t], s = o && o.length;
+    if (s !== e) {
+      for (var i = new n(e), u = 0; u < s; u++)
+        i[u] = o[u];
+      h[t] = i;
+    }
+  } else
+    h[t] = new n(e);
+}
+var X = (
+  /** @class */
+  function() {
+    function h() {
+      this._chunks = [], this._rawExtent = [], this._extent = [], this._count = 0, this._rawCount = 0, this._calcDimNameToIdx = B();
+    }
+    return h.prototype.initData = function(t, r, e) {
+      process.env.NODE_ENV !== "production" && x(k(t.getItem) && k(t.count), "Invalid data provider."), this._provider = t, this._chunks = [], this._indices = null, this.getRawIndex = this._getRawIdxIdentity;
+      var a = t.getSource(), n = this.defaultDimValueGetter = U[a.sourceFormat];
+      this._dimValueGetter = e || n, this._rawExtent = [];
+      var o = H(a);
+      this._dimensions = z(r, function(s) {
+        return process.env.NODE_ENV !== "production" && o && x(s.property != null), {
+          // Only pick these two props. Not leak other properties like orderMeta.
+          type: s.type,
+          property: s.property
+        };
+      }), this._initDataFromProvider(0, t.count());
+    }, h.prototype.getProvider = function() {
+      return this._provider;
+    }, h.prototype.getSource = function() {
+      return this._provider.getSource();
+    }, h.prototype.ensureCalculationDimension = function(t, r) {
+      var e = this._calcDimNameToIdx, a = this._dimensions, n = e.get(t);
+      if (n != null) {
+        if (a[n].type === r)
+          return n;
+      } else
+        n = a.length;
+      return a[n] = {
+        type: r
+      }, e.set(t, n), this._chunks[n] = new b[r || "float"](this._rawCount), this._rawExtent[n] = M(), n;
+    }, h.prototype.collectOrdinalMeta = function(t, r) {
+      var e = this._chunks[t], a = this._dimensions[t], n = this._rawExtent, o = a.ordinalOffset || 0, s = e.length;
+      o === 0 && (n[t] = M());
+      for (var i = n[t], u = o; u < s; u++) {
+        var v = e[u] = r.parseAndCollect(e[u]);
+        isNaN(v) || (i[0] = Math.min(v, i[0]), i[1] = Math.max(v, i[1]));
+      }
+      a.ordinalMeta = r, a.ordinalOffset = s, a.type = "ordinal";
+    }, h.prototype.getOrdinalMeta = function(t) {
+      var r = this._dimensions[t], e = r.ordinalMeta;
+      return e;
+    }, h.prototype.getDimensionProperty = function(t) {
+      var r = this._dimensions[t];
+      return r && r.property;
+    }, h.prototype.appendData = function(t) {
+      process.env.NODE_ENV !== "production" && x(!this._indices, "appendData can only be called on raw data.");
+      var r = this._provider, e = this.count();
+      r.appendData(t);
+      var a = r.count();
+      return r.persistent || (a += e), e < a && this._initDataFromProvider(e, a, !0), [e, a];
+    }, h.prototype.appendValues = function(t, r) {
+      for (var e = this._chunks, a = this._dimensions, n = a.length, o = this._rawExtent, s = this.count(), i = s + Math.max(t.length, r || 0), u = 0; u < n; u++) {
+        var v = a[u];
+        F(e, u, v.type, i, !0);
+      }
+      for (var y = [], l = s; l < i; l++)
+        for (var c = l - s, f = 0; f < n; f++) {
+          var v = a[f], g = U.arrayRows.call(this, t[c] || y, v.property, c, f);
+          e[f][l] = g;
+          var p = o[f];
+          g < p[0] && (p[0] = g), g > p[1] && (p[1] = g);
+        }
+      return this._rawCount = this._count = i, {
+        start: s,
+        end: i
+      };
+    }, h.prototype._initDataFromProvider = function(t, r, e) {
+      for (var a = this._provider, n = this._chunks, o = this._dimensions, s = o.length, i = this._rawExtent, u = z(o, function(w) {
+        return w.property;
+      }), v = 0; v < s; v++) {
+        var y = o[v];
+        i[v] || (i[v] = M()), F(n, v, y.type, r, e);
+      }
+      if (a.fillStorage)
+        a.fillStorage(t, r, n, i);
+      else
+        for (var l = [], c = t; c < r; c++) {
+          l = a.getItem(c, l);
+          for (var f = 0; f < s; f++) {
+            var g = n[f], p = this._dimValueGetter(l, u[f], c, f);
+            g[c] = p;
+            var _ = i[f];
+            p < _[0] && (_[0] = p), p > _[1] && (_[1] = p);
+          }
+        }
+      !a.persistent && a.clean && a.clean(), this._rawCount = this._count = r, this._extent = [];
+    }, h.prototype.count = function() {
+      return this._count;
+    }, h.prototype.get = function(t, r) {
+      if (!(r >= 0 && r < this._count))
+        return NaN;
+      var e = this._chunks[t];
+      return e ? e[this.getRawIndex(r)] : NaN;
+    }, h.prototype.getValues = function(t, r) {
+      var e = [], a = [];
+      if (r == null) {
+        r = t, t = [];
+        for (var n = 0; n < this._dimensions.length; n++)
+          a.push(n);
+      } else
+        a = t;
+      for (var n = 0, o = a.length; n < o; n++)
+        e.push(this.get(a[n], r));
+      return e;
+    }, h.prototype.getByRawIndex = function(t, r) {
+      if (!(r >= 0 && r < this._rawCount))
+        return NaN;
+      var e = this._chunks[t];
+      return e ? e[r] : NaN;
+    }, h.prototype.getSum = function(t) {
+      var r = this._chunks[t], e = 0;
+      if (r)
+        for (var a = 0, n = this.count(); a < n; a++) {
+          var o = this.get(t, a);
+          isNaN(o) || (e += o);
+        }
+      return e;
+    }, h.prototype.getMedian = function(t) {
+      var r = [];
+      this.each([t], function(n) {
+        isNaN(n) || r.push(n);
+      });
+      var e = r.sort(function(n, o) {
+        return n - o;
+      }), a = this.count();
+      return a === 0 ? 0 : a % 2 === 1 ? e[(a - 1) / 2] : (e[a / 2] + e[a / 2 - 1]) / 2;
+    }, h.prototype.indexOfRawIndex = function(t) {
+      if (t >= this._rawCount || t < 0)
+        return -1;
+      if (!this._indices)
+        return t;
+      var r = this._indices, e = r[t];
+      if (e != null && e < this._count && e === t)
+        return t;
+      for (var a = 0, n = this._count - 1; a <= n; ) {
+        var o = (a + n) / 2 | 0;
+        if (r[o] < t)
+          a = o + 1;
+        else if (r[o] > t)
+          n = o - 1;
+        else
+          return o;
+      }
+      return -1;
+    }, h.prototype.getIndices = function() {
+      var t, r = this._indices;
+      if (r) {
+        var e = r.constructor, a = this._count;
+        if (e === Array) {
+          t = new e(a);
+          for (var n = 0; n < a; n++)
+            t[n] = r[n];
+        } else
+          t = new e(r.buffer, 0, a);
+      } else {
+        var e = I(this._rawCount);
+        t = new e(this.count());
+        for (var n = 0; n < t.length; n++)
+          t[n] = n;
+      }
+      return t;
+    }, h.prototype.filter = function(t, r) {
+      if (!this._count)
+        return this;
+      for (var e = this.clone(), a = e.count(), n = I(e._rawCount), o = new n(a), s = [], i = t.length, u = 0, v = t[0], y = e._chunks, l = 0; l < a; l++) {
+        var c = void 0, f = e.getRawIndex(l);
+        if (i === 0)
+          c = r(l);
+        else if (i === 1) {
+          var g = y[v][f];
+          c = r(g, l);
+        } else {
+          for (var p = 0; p < i; p++)
+            s[p] = y[t[p]][f];
+          s[p] = l, c = r.apply(null, s);
+        }
+        c && (o[u++] = f);
+      }
+      return u < a && (e._indices = o), e._count = u, e._extent = [], e._updateGetRawIdx(), e;
+    }, h.prototype.selectRange = function(t) {
+      var r = this.clone(), e = r._count;
+      if (!e)
+        return this;
+      var a = T(t), n = a.length;
+      if (!n)
+        return this;
+      var o = r.count(), s = I(r._rawCount), i = new s(o), u = 0, v = a[0], y = t[v][0], l = t[v][1], c = r._chunks, f = !1;
+      if (!r._indices) {
+        var g = 0;
+        if (n === 1) {
+          for (var p = c[a[0]], _ = 0; _ < e; _++) {
+            var w = p[_];
+            (w >= y && w <= l || isNaN(w)) && (i[u++] = g), g++;
+          }
+          f = !0;
+        } else if (n === 2) {
+          for (var p = c[a[0]], d = c[a[1]], R = t[a[1]][0], D = t[a[1]][1], _ = 0; _ < e; _++) {
+            var w = p[_], N = d[_];
+            (w >= y && w <= l || isNaN(w)) && (N >= R && N <= D || isNaN(N)) && (i[u++] = g), g++;
+          }
+          f = !0;
+        }
+      }
+      if (!f)
+        if (n === 1)
+          for (var _ = 0; _ < o; _++) {
+            var A = r.getRawIndex(_), w = c[a[0]][A];
+            (w >= y && w <= l || isNaN(w)) && (i[u++] = A);
+          }
+        else
+          for (var _ = 0; _ < o; _++) {
+            for (var S = !0, A = r.getRawIndex(_), C = 0; C < n; C++) {
+              var m = a[C], w = c[m][A];
+              (w < t[m][0] || w > t[m][1]) && (S = !1);
+            }
+            S && (i[u++] = r.getRawIndex(_));
+          }
+      return u < o && (r._indices = i), r._count = u, r._extent = [], r._updateGetRawIdx(), r;
+    }, h.prototype.map = function(t, r) {
+      var e = this.clone(t);
+      return this._updateDims(e, t, r), e;
+    }, h.prototype.modify = function(t, r) {
+      this._updateDims(this, t, r);
+    }, h.prototype._updateDims = function(t, r, e) {
+      for (var a = t._chunks, n = [], o = r.length, s = t.count(), i = [], u = t._rawExtent, v = 0; v < r.length; v++)
+        u[r[v]] = M();
+      for (var y = 0; y < s; y++) {
+        for (var l = t.getRawIndex(y), c = 0; c < o; c++)
+          i[c] = a[r[c]][l];
+        i[o] = y;
+        var f = e && e.apply(null, i);
+        if (f != null) {
+          typeof f != "object" && (n[0] = f, f = n);
+          for (var v = 0; v < f.length; v++) {
+            var g = r[v], p = f[v], _ = u[g], w = a[g];
+            w && (w[l] = p), p < _[0] && (_[0] = p), p > _[1] && (_[1] = p);
+          }
+        }
+      }
+    }, h.prototype.lttbDownSample = function(t, r) {
+      var e = this.clone([t], !0), a = e._chunks, n = a[t], o = this.count(), s = 0, i = Math.floor(1 / r), u = this.getRawIndex(0), v, y, l, c = new (I(this._rawCount))(Math.min((Math.ceil(o / i) + 2) * 2, o));
+      c[s++] = u;
+      for (var f = 1; f < o - 1; f += i) {
+        for (var g = Math.min(f + i, o - 1), p = Math.min(f + i * 2, o), _ = (p + g) / 2, w = 0, d = g; d < p; d++) {
+          var R = this.getRawIndex(d), D = n[R];
+          isNaN(D) || (w += D);
+        }
+        w /= p - g;
+        var N = f, A = Math.min(f + i, o), S = f - 1, C = n[u];
+        v = -1, l = N;
+        for (var m = -1, G = 0, d = N; d < A; d++) {
+          var R = this.getRawIndex(d), D = n[R];
+          if (isNaN(D)) {
+            G++, m < 0 && (m = R);
+            continue;
+          }
+          y = Math.abs((S - _) * (D - C) - (S - d) * (w - C)), y > v && (v = y, l = R);
+        }
+        G > 0 && G < A - N && (c[s++] = Math.min(m, l), l = Math.max(m, l)), c[s++] = l, u = l;
+      }
+      return c[s++] = this.getRawIndex(o - 1), e._count = s, e._indices = c, e.getRawIndex = this._getRawIdx, e;
+    }, h.prototype.minmaxDownSample = function(t, r) {
+      for (var e = this.clone([t], !0), a = e._chunks, n = Math.floor(1 / r), o = a[t], s = this.count(), i = new (I(this._rawCount))(Math.ceil(s / n) * 2), u = 0, v = 0; v < s; v += n) {
+        var y = v, l = o[this.getRawIndex(y)], c = v, f = o[this.getRawIndex(c)], g = n;
+        v + n > s && (g = s - v);
+        for (var p = 0; p < g; p++) {
+          var _ = this.getRawIndex(v + p), w = o[_];
+          w < l && (l = w, y = v + p), w > f && (f = w, c = v + p);
+        }
+        var d = this.getRawIndex(y), R = this.getRawIndex(c);
+        y < c ? (i[u++] = d, i[u++] = R) : (i[u++] = R, i[u++] = d);
+      }
+      return e._count = u, e._indices = i, e._updateGetRawIdx(), e;
+    }, h.prototype.downSample = function(t, r, e, a) {
+      for (var n = this.clone([t], !0), o = n._chunks, s = [], i = Math.floor(1 / r), u = o[t], v = this.count(), y = n._rawExtent[t] = M(), l = new (I(this._rawCount))(Math.ceil(v / i)), c = 0, f = 0; f < v; f += i) {
+        i > v - f && (i = v - f, s.length = i);
+        for (var g = 0; g < i; g++) {
+          var p = this.getRawIndex(f + g);
+          s[g] = u[p];
+        }
+        var _ = e(s), w = this.getRawIndex(Math.min(f + a(s, _) || 0, v - 1));
+        u[w] = _, _ < y[0] && (y[0] = _), _ > y[1] && (y[1] = _), l[c++] = w;
+      }
+      return n._count = c, n._indices = l, n._updateGetRawIdx(), n;
+    }, h.prototype.each = function(t, r) {
+      if (this._count)
+        for (var e = t.length, a = this._chunks, n = 0, o = this.count(); n < o; n++) {
+          var s = this.getRawIndex(n);
+          switch (e) {
+            case 0:
+              r(n);
+              break;
+            case 1:
+              r(a[t[0]][s], n);
+              break;
+            case 2:
+              r(a[t[0]][s], a[t[1]][s], n);
+              break;
+            default:
+              for (var i = 0, u = []; i < e; i++)
+                u[i] = a[t[i]][s];
+              u[i] = n, r.apply(null, u);
+          }
+        }
+    }, h.prototype.getDataExtent = function(t) {
+      var r = this._chunks[t], e = M();
+      if (!r)
+        return e;
+      var a = this.count(), n = !this._indices, o;
+      if (n)
+        return this._rawExtent[t].slice();
+      if (o = this._extent[t], o)
+        return o.slice();
+      o = e;
+      for (var s = o[0], i = o[1], u = 0; u < a; u++) {
+        var v = this.getRawIndex(u), y = r[v];
+        y < s && (s = y), y > i && (i = y);
+      }
+      return o = [s, i], this._extent[t] = o, o;
+    }, h.prototype.getRawDataItem = function(t) {
+      var r = this.getRawIndex(t);
+      if (this._provider.persistent)
+        return this._provider.getItem(r);
+      for (var e = [], a = this._chunks, n = 0; n < a.length; n++)
+        e.push(a[n][r]);
+      return e;
+    }, h.prototype.clone = function(t, r) {
+      var e = new h(), a = this._chunks, n = t && q(t, function(s, i) {
+        return s[i] = !0, s;
+      }, {});
+      if (n)
+        for (var o = 0; o < a.length; o++)
+          e._chunks[o] = n[o] ? Q(a[o]) : a[o];
+      else
+        e._chunks = a;
+      return this._copyCommonProps(e), r || (e._indices = this._cloneIndices()), e._updateGetRawIdx(), e;
+    }, h.prototype._copyCommonProps = function(t) {
+      t._count = this._count, t._rawCount = this._rawCount, t._provider = this._provider, t._dimensions = this._dimensions, t._extent = O(this._extent), t._rawExtent = O(this._rawExtent);
+    }, h.prototype._cloneIndices = function() {
+      if (this._indices) {
+        var t = this._indices.constructor, r = void 0;
+        if (t === Array) {
+          var e = this._indices.length;
+          r = new t(e);
+          for (var a = 0; a < e; a++)
+            r[a] = this._indices[a];
+        } else
+          r = new t(this._indices);
+        return r;
+      }
+      return null;
+    }, h.prototype._getRawIdxIdentity = function(t) {
+      return t;
+    }, h.prototype._getRawIdx = function(t) {
+      return t < this._count && t >= 0 ? this._indices[t] : -1;
+    }, h.prototype._updateGetRawIdx = function() {
+      this.getRawIndex = this._indices ? this._getRawIdx : this._getRawIdxIdentity;
+    }, h.internalField = function() {
+      function t(r, e, a, n) {
+        return P(r[n], this._dimensions[n]);
+      }
+      U = {
+        arrayRows: t,
+        objectRows: function(r, e, a, n) {
+          return P(r[e], this._dimensions[n]);
+        },
+        keyedColumns: t,
+        original: function(r, e, a, n) {
+          var o = r && (r.value == null ? r : r.value);
+          return P(o instanceof Array ? o[n] : o, this._dimensions[n]);
+        },
+        typedArray: function(r, e, a, n) {
+          return r[n];
+        }
+      };
+    }(), h;
+  }()
+);
+export {
+  V as CtorFloat64Array,
+  K as CtorInt32Array,
+  J as CtorUint16Array,
+  L as CtorUint32Array,
+  X as default
+};