web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/echarts/lib/core/impl.js

@@ -0,0 +1,11 @@
+var t = {};
+function n(r, e) {
+  t[r] = e;
+}
+function i(r) {
+  return t[r];
+}
+export {
+  i as getImpl,
+  n as registerImpl
+};

package/dist/node_modules/echarts/lib/core/lifecycle.js

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

package/dist/node_modules/echarts/lib/core/locale.js

@@ -0,0 +1,37 @@
+import m from "../model/Model.js";
+import p from "../../../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/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/dist/node_modules/echarts/lib/core/task.js

@@ -0,0 +1,91 @@
+import { isArray as v } from "../../../zrender/lib/core/util.js";
+function I(i) {
+  return new E(i);
+}
+var E = (
+  /** @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 u;
+      this._plan && !e && (u = this._plan(this.context));
+      var p = a(this._modBy), l = this._modDataCount || 0, r = a(t && t.modBy), o = t && t.modDataCount || 0;
+      (p !== r || l !== o) && (u = "reset");
+      function a(f) {
+        return !(f >= 1) && (f = 1), f;
+      }
+      var d;
+      (this._dirty || u === "reset") && (this._dirty = !1, d = this._doReset(e)), this._modBy = r, this._modDataCount = o;
+      var m = t && t.step;
+      if (s ? this._dueEnd = s._outputDueEnd : this._dueEnd = this._count ? this._count(this.context) : 1 / 0, this._progress) {
+        var c = this._dueIndex, h = Math.min(m != null ? this._dueIndex + m : 1 / 0, this._dueEnd);
+        if (!e && (d || c < h)) {
+          var _ = this._progress;
+          if (v(_))
+            for (var y = 0; y < _.length; y++)
+              this._doProgress(_[y], c, h, r, o);
+          else
+            this._doProgress(_, c, h, r, o);
+        }
+        this._dueIndex = h;
+        var D = this._settedOutputEnd != null ? this._settedOutputEnd : h;
+        this._outputDueEnd = D;
+      } 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, u) {
+      x.reset(s, e, n, u), 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), v(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) {
+      (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, u = {
+    reset: function(r, o, a, d) {
+      t = r, i = o, s = a, e = d, n = Math.ceil(e / s), u.next = s > 1 && e > 0 ? l : p;
+    }
+  };
+  return u;
+  function p() {
+    return t < i ? t++ : null;
+  }
+  function l() {
+    var r = t % n * s + Math.ceil(t / n), o = t >= i ? null : r < e ? r : t;
+    return t++, o;
+  }
+})();
+export {
+  E as Task,
+  I as createTask
+};

package/dist/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/dist/node_modules/echarts/lib/data/DataStore.js

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