@agrotools1/at-components 0.2.1 → 0.2.3

package/dist/dataUtils-7c276b73.js

@@ -0,0 +1,1421 @@
+import { e as q, y as X, ei as Dt, c as Rt, bx as Lt, W as Nt, bz as Et, s as Z, bu as jt, aO as nt, bJ as Ot, aH as Gt, b3 as Wt, hN as Ut, bF as qt } from "./index-01c737ed.js";
+let gt = class {
+  constructor(e = null, n = null, r = null) {
+    this.minValue = e, this.maxValue = n, this.noDataValue = r;
+  }
+};
+const zt = 9999999e31, Xt = 2e-7, Jt = { u1: [0, 1], u2: [0, 3], u4: [0, 15], u8: [0, 255], s8: [-128, 127], u16: [0, 65535], s16: [-32768, 32767], u32: [0, 4294967295], s32: [-2147483648, 2147483647], f32: [-34028234663852886e22, 34028234663852886e22], f64: [-Number.MAX_VALUE, Number.MAX_VALUE], unknown: void 0, c64: void 0, c128: void 0 };
+function ht(t) {
+  return Jt[t] ?? [-34028234663852886e22, 34028234663852886e22];
+}
+function xe(t, e) {
+  return t == null || e == null ? "s32" : t < 0 ? t >= -128 && e < 128 ? "s8" : t >= -32768 && e < 32768 ? "s16" : "s32" : e < 256 ? "u8" : e < 65536 ? "u16" : "u32";
+}
+function we(t) {
+  return ((t == null ? void 0 : t.startsWith("s")) || (t == null ? void 0 : t.startsWith("u"))) ?? !1;
+}
+function ye(t, e, n) {
+  var p, f;
+  if (t.depthCount && t.depthCount > 1)
+    return;
+  const { pixels: r, statistics: a, pixelType: i } = t, o = r[0].length, u = t.bandMasks ?? [], h = t.mask ?? new Uint8Array(o).fill(255), s = i === "f32" || i === "f64", l = ht(i);
+  let c = !1;
+  for (let d = 0; d < r.length; d++) {
+    const m = typeof e == "number" ? e : e[d];
+    if (m == null)
+      continue;
+    const x = ((p = a == null ? void 0 : a[d]) == null ? void 0 : p.minValue) ?? l[0], w = ((f = a == null ? void 0 : a[d]) == null ? void 0 : f.maxValue) ?? l[1];
+    if (x > m + Number.EPSILON || w < m - Number.EPSILON)
+      continue;
+    const A = u[d] || h.slice(), k = r[d], M = n == null ? void 0 : n.customFloatTolerance;
+    if (s && M !== 0) {
+      let g = M;
+      g || (g = Math.abs(m) >= zt ? Xt * Math.abs(m) : i === "f32" ? 2 ** -23 : Number.EPSILON);
+      for (let y = 0; y < k.length; y++)
+        A[y] && Math.abs(k[y] - m) < g && (k[y] = 0, A[y] = 0, h[y] = 0, c = !0);
+    } else
+      for (let g = 0; g < k.length; g++)
+        A[g] && k[g] === m && (k[g] = 0, A[g] = 0, h[g] = 0, c = !0);
+    u[d] = A;
+  }
+  c && (t.bandMasks = t.bandMasks || t.pixels.length > 1 ? u : null, t.mask = h), c && "updateStatistics" in t && t.updateStatistics();
+}
+var K;
+let O = K = class extends Lt {
+  static createEmptyBand(t, e) {
+    return new (K.getPixelArrayConstructor(t))(e);
+  }
+  static combineBandMasks(t) {
+    if (t.length < 2)
+      return t[0];
+    const e = t[0].length, n = new Uint8Array(e).fill(255);
+    for (let r = 0; r < t.length; r++) {
+      const a = t[r];
+      for (let i = 0; i < e; i++)
+        a[i] || (n[i] = 0);
+    }
+    return n;
+  }
+  static getPixelArrayConstructor(t) {
+    let e;
+    switch (t) {
+      case "u1":
+      case "u2":
+      case "u4":
+      case "u8":
+        e = Uint8Array;
+        break;
+      case "u16":
+        e = Uint16Array;
+        break;
+      case "u32":
+        e = Uint32Array;
+        break;
+      case "s8":
+        e = Int8Array;
+        break;
+      case "s16":
+        e = Int16Array;
+        break;
+      case "s32":
+        e = Int32Array;
+        break;
+      case "f32":
+      case "c64":
+      case "c128":
+      case "unknown":
+        e = Float32Array;
+        break;
+      case "f64":
+        e = Float64Array;
+    }
+    return e;
+  }
+  constructor(t) {
+    super(t), this.width = null, this.height = null, this.pixelType = "f32", this.validPixelCount = null, this.mask = null, this.maskIsAlpha = !1, this.premultiplyAlpha = !1, this.statistics = null, this.depthCount = 1;
+  }
+  castPixelType(t) {
+    if (!t)
+      return "f32";
+    let e = t.toLowerCase();
+    return ["u1", "u2", "u4"].includes(e) ? e = "u8" : ["unknown", "u8", "s8", "u16", "s16", "u32", "s32", "f32", "f64"].includes(e) || (e = "f32"), e;
+  }
+  getPlaneCount() {
+    var t;
+    return (t = this.pixels) == null ? void 0 : t.length;
+  }
+  addData(t) {
+    if (!t.pixels || t.pixels.length !== this.width * this.height)
+      throw new Nt("pixelblock:invalid-or-missing-pixels", "add data requires valid pixels array that has same length defined by pixel block width * height");
+    this.pixels || (this.pixels = []), this.statistics || (this.statistics = []), this.pixels.push(t.pixels), this.statistics.push(t.statistics ?? new gt());
+  }
+  getAsRGBA() {
+    const t = new ArrayBuffer(this.width * this.height * 4);
+    switch (this.pixelType) {
+      case "s8":
+      case "s16":
+      case "u16":
+      case "s32":
+      case "u32":
+      case "f32":
+      case "f64":
+        this._fillFromNon8Bit(t);
+        break;
+      default:
+        this._fillFrom8Bit(t);
+    }
+    return new Uint8ClampedArray(t);
+  }
+  getAsRGBAFloat() {
+    const t = new Float32Array(this.width * this.height * 4);
+    return this._fillFrom32Bit(t), t;
+  }
+  updateStatistics() {
+    if (!this.pixels)
+      return;
+    this.statistics = this.pixels.map((n) => this._calculateBandStatistics(n, this.mask));
+    const t = this.mask;
+    let e = 0;
+    if (t != null)
+      for (let n = 0; n < t.length; n++)
+        t[n] && e++;
+    else
+      e = this.width * this.height;
+    this.validPixelCount = e;
+  }
+  clamp(t) {
+    if (!t || t === "f64" || t === "f32" || !this.pixels)
+      return;
+    const [e, n] = ht(t), r = this.pixels, a = this.width * this.height, i = r.length;
+    let o, u, h;
+    const s = [];
+    for (let l = 0; l < i; l++) {
+      h = K.createEmptyBand(t, a), o = r[l];
+      for (let c = 0; c < a; c++)
+        u = o[c], h[c] = u > n ? n : u < e ? e : u;
+      s.push(h);
+    }
+    this.pixels = s, this.pixelType = t;
+  }
+  extractBands(t) {
+    var c;
+    const { pixels: e, statistics: n } = this;
+    if (t == null || t.length === 0 || !e || e.length === 0)
+      return this;
+    const r = e.length, a = t.some((p) => p >= e.length), i = r === t.length && !t.some((p, f) => p !== f);
+    if (a || i)
+      return this;
+    const o = ((c = this.bandMasks) == null ? void 0 : c.length) === r ? t.map((p) => this.bandMasks[p]) : void 0;
+    let { mask: u, validPixelCount: h } = this;
+    const { width: s, height: l } = this;
+    return o != null && o.length && (u = K.combineBandMasks(o), h = u.filter((p) => !!p).length), new K({ pixelType: this.pixelType, width: s, height: l, mask: u, bandMasks: o, validPixelCount: h, maskIsAlpha: this.maskIsAlpha, pixels: t.map((p) => e[p]), statistics: n && t.map((p) => n[p]) });
+  }
+  clone() {
+    const t = new K({ width: this.width, height: this.height, pixelType: this.pixelType, maskIsAlpha: this.maskIsAlpha, validPixelCount: this.validPixelCount });
+    let e;
+    this.mask != null && (this.mask instanceof Uint8Array ? t.mask = new Uint8Array(this.mask) : t.mask = this.mask.slice(0)), this.bandMasks && (t.bandMasks = this.bandMasks.map((r) => new Uint8Array(r)));
+    const n = K.getPixelArrayConstructor(this.pixelType);
+    if (this.pixels && this.pixels.length > 0) {
+      t.pixels = [];
+      const r = !!this.pixels[0].slice;
+      for (e = 0; e < this.pixels.length; e++)
+        t.pixels[e] = r ? this.pixels[e].slice(0, this.pixels[e].length) : new n(this.pixels[e]);
+    }
+    if (this.statistics)
+      for (t.statistics = [], e = 0; e < this.statistics.length; e++)
+        t.statistics[e] = Et(this.statistics[e]);
+    return t.premultiplyAlpha = this.premultiplyAlpha, t;
+  }
+  _fillFrom8Bit(t) {
+    const { mask: e, maskIsAlpha: n, premultiplyAlpha: r, pixels: a } = this;
+    if (!t || !(a != null && a.length))
+      return void Z.getLogger(this).error("getAsRGBA()", "Unable to convert to RGBA. The input pixel block is empty.");
+    let i, o, u, h;
+    i = o = u = a[0], a.length >= 3 ? (o = a[1], u = a[2]) : a.length === 2 && (o = a[1]);
+    const s = new Uint32Array(t), l = this.width * this.height;
+    if (i.length === l)
+      if (e != null && e.length === l)
+        if (n)
+          for (h = 0; h < l; h++) {
+            const c = e[h];
+            if (c) {
+              const p = c / 255;
+              s[h] = r ? c << 24 | u[h] * p << 16 | o[h] * p << 8 | i[h] * p : c << 24 | u[h] << 16 | o[h] << 8 | i[h];
+            }
+          }
+        else
+          for (h = 0; h < l; h++)
+            e[h] && (s[h] = 255 << 24 | u[h] << 16 | o[h] << 8 | i[h]);
+      else
+        for (h = 0; h < l; h++)
+          s[h] = 255 << 24 | u[h] << 16 | o[h] << 8 | i[h];
+    else
+      Z.getLogger(this).error("getAsRGBA()", "Unable to convert to RGBA. The pixelblock is invalid.");
+  }
+  _fillFromNon8Bit(t) {
+    const { pixels: e, mask: n, statistics: r } = this;
+    if (!t || !(e != null && e.length))
+      return void Z.getLogger(this).error("getAsRGBA()", "Unable to convert to RGBA. The input pixel block is empty.");
+    const a = this.pixelType;
+    let i = 1, o = 0, u = 1;
+    if (r && r.length > 0) {
+      for (const m of r)
+        if (m.minValue != null && (o = Math.min(o, m.minValue)), m.maxValue != null && m.minValue != null) {
+          const x = m.maxValue - m.minValue;
+          u = Math.max(u, x);
+        }
+      i = 255 / u;
+    } else {
+      let m = 255;
+      a === "s8" ? (o = -128, m = 127) : a === "u16" ? m = 65535 : a === "s16" ? (o = -32768, m = 32767) : a === "u32" ? m = 4294967295 : a === "s32" ? (o = -2147483648, m = 2147483647) : a === "f32" ? (o = -34e38, m = 34e38) : a === "f64" && (o = -Number.MAX_VALUE, m = Number.MAX_VALUE), i = 255 / (m - o);
+    }
+    const h = new Uint32Array(t), s = this.width * this.height;
+    let l, c, p, f, d;
+    if (l = c = p = e[0], l.length !== s)
+      return Z.getLogger(this).error("getAsRGBA()", "Unable to convert to RGBA. The pixelblock is invalid.");
+    if (e.length >= 2)
+      if (c = e[1], e.length >= 3 && (p = e[2]), n != null && n.length === s)
+        for (f = 0; f < s; f++)
+          n[f] && (h[f] = 255 << 24 | (p[f] - o) * i << 16 | (c[f] - o) * i << 8 | (l[f] - o) * i);
+      else
+        for (f = 0; f < s; f++)
+          h[f] = 255 << 24 | (p[f] - o) * i << 16 | (c[f] - o) * i << 8 | (l[f] - o) * i;
+    else if (n != null && n.length === s)
+      for (f = 0; f < s; f++)
+        d = (l[f] - o) * i, n[f] && (h[f] = 255 << 24 | d << 16 | d << 8 | d);
+    else
+      for (f = 0; f < s; f++)
+        d = (l[f] - o) * i, h[f] = 255 << 24 | d << 16 | d << 8 | d;
+  }
+  _fillFrom32Bit(t) {
+    const { pixels: e, mask: n } = this;
+    if (!t || !(e != null && e.length))
+      return Z.getLogger(this).error("getAsRGBAFloat()", "Unable to convert to RGBA. The input pixel block is empty.");
+    let r, a, i, o;
+    r = a = i = e[0], e.length >= 3 ? (a = e[1], i = e[2]) : e.length === 2 && (a = e[1]);
+    const u = this.width * this.height;
+    if (r.length !== u)
+      return Z.getLogger(this).error("getAsRGBAFloat()", "Unable to convert to RGBA. The pixelblock is invalid.");
+    let h = 0;
+    if (n != null && n.length === u)
+      for (o = 0; o < u; o++)
+        t[h++] = r[o], t[h++] = a[o], t[h++] = i[o], t[h++] = 1 & n[o];
+    else
+      for (o = 0; o < u; o++)
+        t[h++] = r[o], t[h++] = a[o], t[h++] = i[o], t[h++] = 1;
+  }
+  _calculateBandStatistics(t, e) {
+    let n = 1 / 0, r = -1 / 0;
+    const a = t.length;
+    let i, o = 0;
+    if (e != null)
+      for (i = 0; i < a; i++)
+        e[i] && (o = t[i], n = o < n ? o : n, r = o > r ? o : r);
+    else
+      for (i = 0; i < a; i++)
+        o = t[i], n = o < n ? o : n, r = o > r ? o : r;
+    return new gt(n, r);
+  }
+};
+q([X({ json: { write: !0 } })], O.prototype, "width", void 0), q([X({ json: { write: !0 } })], O.prototype, "height", void 0), q([X({ json: { write: !0 } })], O.prototype, "pixelType", void 0), q([Dt("pixelType")], O.prototype, "castPixelType", null), q([X({ json: { write: !0 } })], O.prototype, "validPixelCount", void 0), q([X({ json: { write: !0 } })], O.prototype, "mask", void 0), q([X({ json: { write: !0 } })], O.prototype, "maskIsAlpha", void 0), q([X({ json: { write: !0 } })], O.prototype, "pixels", void 0), q([X()], O.prototype, "premultiplyAlpha", void 0), q([X({ json: { write: !0 } })], O.prototype, "statistics", void 0), q([X({ json: { write: !0 } })], O.prototype, "depthCount", void 0), q([X({ json: { write: !0 } })], O.prototype, "noDataValues", void 0), q([X({ json: { write: !0 } })], O.prototype, "bandMasks", void 0), O = K = q([Rt("esri.layers.support.PixelBlock")], O);
+const _ = O;
+var xt, wt;
+(function(t) {
+  t[t.matchAny = 0] = "matchAny", t[t.matchAll = 1] = "matchAll";
+})(xt || (xt = {})), function(t) {
+  t[t.bestMatch = 0] = "bestMatch", t[t.fail = 1] = "fail";
+}(wt || (wt = {}));
+const ke = 6;
+function R(t) {
+  return t != null && t.declaredClass === "esri.layers.support.PixelBlock" && t.pixels && t.pixels.length > 0;
+}
+function Me(t) {
+  var l;
+  if (!(t != null && t.length) || t.some((c) => !R(c)))
+    return null;
+  if (t.length === 1)
+    return ((l = t[0]) == null ? void 0 : l.clone()) ?? null;
+  const e = t, { width: n, height: r, pixelType: a } = e[0];
+  if (e.some((c) => c.width !== n || c.height !== r))
+    return null;
+  const i = e.map(({ mask: c }) => c).filter((c) => c != null);
+  let o = null;
+  i.length && (o = new Uint8Array(n * r), o.set(i[0]), i.length > 1 && $t(i.slice(1), o));
+  const u = [];
+  e.forEach(({ pixels: c }) => u.push(...c));
+  const h = e.map(({ statistics: c }) => c).filter((c) => c == null ? void 0 : c.length), s = [];
+  return h.forEach((c) => s.push(...c)), new _({ pixelType: a, width: n, height: r, mask: o, pixels: u, statistics: s.length ? s : null });
+}
+function Ae(t) {
+  if (!t)
+    return;
+  const e = t.colormap;
+  if (!e || e.length === 0)
+    return;
+  const n = e.sort((c, p) => c[0] - p[0]);
+  let r = 0;
+  n[0][0] < 0 && (r = n[0][0]);
+  const a = Math.max(256, n[n.length - 1][0] - r + 1), i = new Uint8Array(4 * a), o = [];
+  let u, h = 0, s = 0;
+  const l = n[0].length === 5;
+  if (a > 65536)
+    return n.forEach((c) => {
+      o[c[0] - r] = l ? c.slice(1) : c.slice(1).concat([255]);
+    }), { indexed2DColormap: o, offset: r, alphaSpecified: l };
+  if (t.fillUnspecified)
+    for (u = n[s], h = u[0] - r; h < a; h++)
+      i[4 * h] = u[1], i[4 * h + 1] = u[2], i[4 * h + 2] = u[3], i[4 * h + 3] = l ? u[4] : 255, h === u[0] - r && (u = s === n.length - 1 ? u : n[++s]);
+  else
+    for (h = 0; h < n.length; h++)
+      u = n[h], s = 4 * (u[0] - r), i[s] = u[1], i[s + 1] = u[2], i[s + 2] = u[3], i[s + 3] = l ? u[4] : 255;
+  return { indexedColormap: i, offset: r, alphaSpecified: l };
+}
+function be(t, e) {
+  if (!R(t) || !e || !e.indexedColormap && !e.indexed2DColormap)
+    return t;
+  const n = t.clone(), r = n.pixels;
+  let a = n.mask;
+  const i = n.width * n.height;
+  if (r.length !== 1)
+    return t;
+  const { indexedColormap: o, indexed2DColormap: u, offset: h, alphaSpecified: s } = e;
+  let l = 0;
+  const c = r[0], p = new Uint8Array(c.length), f = new Uint8Array(c.length), d = new Uint8Array(c.length);
+  let m, x = 0;
+  if (o) {
+    const w = o.length - 1;
+    if (a != null)
+      for (l = 0; l < i; l++)
+        a[l] && (x = 4 * (c[l] - h), x < h || x > w ? a[l] = 0 : (p[l] = o[x], f[l] = o[x + 1], d[l] = o[x + 2], a[l] = o[x + 3]));
+    else {
+      for (a = new Uint8Array(i), l = 0; l < i; l++)
+        x = 4 * (c[l] - h), x < h || x > w ? a[l] = 0 : (p[l] = o[x], f[l] = o[x + 1], d[l] = o[x + 2], a[l] = o[x + 3]);
+      n.mask = a;
+    }
+  } else if (u)
+    if (a != null)
+      for (l = 0; l < i; l++)
+        a[l] && (m = u[c[l]], p[l] = m[0], f[l] = m[1], d[l] = m[2], a[l] = m[3]);
+    else {
+      for (a = new Uint8Array(i), l = 0; l < i; l++)
+        m = u[c[l]], p[l] = m[0], f[l] = m[1], d[l] = m[2], a[l] = m[3];
+      n.mask = a;
+    }
+  return n.pixels = [p, f, d], n.statistics = null, n.pixelType = "u8", n.maskIsAlpha = s, n;
+}
+function ve(t, e) {
+  if (!R(t))
+    return null;
+  const { pixels: n, mask: r } = t, a = n.length;
+  let i = e.lut;
+  const { offset: o } = e;
+  i && i[0].length === 1 && (i = n.map(() => i));
+  const u = [], h = e.outputPixelType || "u8";
+  for (let l = 0; l < a; l++) {
+    const c = Pt(n[l], r, i[l], o || 0, h);
+    u.push(c);
+  }
+  const s = new _({ width: t.width, height: t.height, pixels: u, mask: r, pixelType: h });
+  return s.updateStatistics(), s;
+}
+function Pt(t, e, n, r, a) {
+  const i = t.length, o = _.createEmptyBand(a, i);
+  if (e)
+    for (let u = 0; u < i; u++)
+      e[u] && (o[u] = n[t[u] - r]);
+  else
+    for (let u = 0; u < i; u++)
+      o[u] = n[t[u] - r];
+  return o;
+}
+function Ue(t, e) {
+  if (!R(t))
+    return null;
+  const n = t.clone(), { pixels: r } = n, a = n.width * n.height, i = e.length, o = Math.floor(i / 2), u = e[Math.floor(o)], h = r[0];
+  let s, l, c, p, f, d, m = !1;
+  const x = new Uint8Array(a), w = new Uint8Array(a), A = new Uint8Array(a);
+  let k = n.mask;
+  const M = e[0].mappedColor.length === 4;
+  for (k || (k = new Uint8Array(a), k.fill(M ? 255 : 1), n.mask = k), f = 0; f < a; f++)
+    if (k[f]) {
+      for (s = h[f], m = !1, d = o, l = u, c = 0, p = i - 1; p - c > 1; ) {
+        if (s === l.value) {
+          m = !0;
+          break;
+        }
+        s > l.value ? c = d : p = d, d = Math.floor((c + p) / 2), l = e[Math.floor(d)];
+      }
+      m || (s === e[c].value ? (l = e[c], m = !0) : s === e[p].value ? (l = e[p], m = !0) : s < e[c].value ? (m = !1, l = null) : s > e[c].value && (s < e[p].value ? (l = e[c], m = !0) : p === i - 1 ? (m = !1, l = null) : (l = e[p], m = !0))), m ? (x[f] = l.mappedColor[0], w[f] = l.mappedColor[1], A[f] = l.mappedColor[2], k[f] = l.mappedColor[3]) : x[f] = w[f] = A[f] = k[f] = 0;
+    }
+  return n.pixels = [x, w, A], n.mask = k, n.pixelType = "u8", n.maskIsAlpha = M, n;
+}
+function Pe(t, e) {
+  if (!R(t))
+    return null;
+  const { width: n, height: r } = t, { inputRanges: a, outputValues: i, outputPixelType: o, noDataRanges: u, allowUnmatched: h, isLastInputRangeInclusive: s } = e, l = t.pixels[0], c = _.createEmptyBand(o, l.length), p = t.mask, f = new Uint8Array(n * r);
+  p ? f.set(p) : f.fill(255);
+  const d = t.pixelType.startsWith("f") ? 1e-6 : 0, m = a.map((M) => M - d);
+  m[0] = a[0], m[m.length - 1] = a[a.length - 1] + (s ? 1e-6 : 0);
+  const x = a.length / 2, [w, A] = ht(o);
+  for (let M = 0; M < r; M++)
+    for (let g = 0; g < n; g++) {
+      const y = M * n + g;
+      if (f[y]) {
+        const v = l[y];
+        let b = !1;
+        for (let $ = x - 1; $ >= 0; $--)
+          if (v === m[2 * $] || v > m[2 * $] && v < m[2 * $ + 1]) {
+            c[y] = i[$], b = !0;
+            break;
+          }
+        b || (h ? c[y] = v > A ? A : v < w ? w : v : f[y] = 0);
+      }
+    }
+  const k = u == null ? void 0 : u.length;
+  if (k)
+    for (let M = 0; M < r; M++)
+      for (let g = 0; g < n; g++) {
+        const y = M * n + g;
+        if (!p || p[y]) {
+          const v = l[y];
+          for (let b = 0; b < k; b += 2)
+            if (v >= u[b] && v <= u[b + 1]) {
+              c[y] = 0, f[y] = 0;
+              break;
+            }
+        }
+      }
+  return new _({ width: n, height: r, pixelType: o, pixels: [c], mask: f });
+}
+function yt(t, e, n, r) {
+  const a = n != null && n.length >= 2 ? new Set(n) : null, i = (n == null ? void 0 : n.length) === 1 ? n[0] : null, o = !!(e != null && e.length);
+  for (let u = 0; u < t.length; u++)
+    if (r[u]) {
+      const h = t[u];
+      if (o) {
+        let s = !1;
+        for (let l = 0; l < e.length; l += 2)
+          if (h >= e[l] && h <= e[l + 1]) {
+            s = !0;
+            break;
+          }
+        s || (r[u] = 0);
+      }
+      r[u] && (h === i || a != null && a.has(h)) && (r[u] = 0);
+    }
+}
+function kt(t, e) {
+  const n = t[0].length;
+  for (let r = 0; r < n; r++)
+    if (e[r]) {
+      let a = !1;
+      for (let i = 0; i < t.length; i++)
+        if (t[i][r]) {
+          a = !0;
+          break;
+        }
+      a || (e[r] = 0);
+    }
+}
+function $t(t, e) {
+  const n = t[0].length;
+  for (let r = 0; r < n; r++)
+    if (e[r]) {
+      let a = !1;
+      for (let i = 0; i < t.length; i++)
+        if (t[i][r] === 0) {
+          a = !0;
+          break;
+        }
+      a && (e[r] = 0);
+    }
+}
+function $e(t, e) {
+  if (!R(t))
+    return null;
+  const { width: n, height: r, pixels: a } = t, i = n * r, o = new Uint8Array(i);
+  t.mask ? o.set(t.mask) : o.fill(255);
+  const u = a.length, { includedRanges: h, noDataValues: s, outputPixelType: l, matchAll: c, lookups: p } = e;
+  if (p) {
+    const f = [];
+    for (let d = 0; d < u; d++) {
+      const m = p[d], x = Pt(a[d], o, m.lut, m.offset || 0, "u8");
+      f.push(x);
+    }
+    f.length === 1 ? o.set(f[0]) : c ? kt(f, o) : $t(f, o);
+  } else if (c) {
+    const f = [];
+    for (let d = 0; d < u; d++) {
+      const m = new Uint8Array(i);
+      m.set(o), yt(a[d], h == null ? void 0 : h.slice(2 * d, 2 * d + 2), s == null ? void 0 : s[d], m), f.push(m);
+    }
+    f.length === 1 ? o.set(f[0]) : kt(f, o);
+  } else
+    for (let f = 0; f < u; f++)
+      yt(a[f], h == null ? void 0 : h.slice(2 * f, 2 * f + 2), s == null ? void 0 : s[f], o);
+  return new _({ width: n, height: r, pixelType: l, pixels: a, mask: o });
+}
+function Te(t) {
+  const { srcPixelType: e, inputRanges: n, outputValues: r, allowUnmatched: a, noDataRanges: i, isLastInputRangeInclusive: o, outputPixelType: u } = t;
+  if (e !== "u8" && e !== "s8" && e !== "u16" && e !== "s16")
+    return null;
+  const h = e.includes("16") ? 65536 : 256, s = e.includes("s") ? -h / 2 : 0, l = _.createEmptyBand(u, h), c = new Uint8Array(h);
+  a && c.fill(255);
+  const [p, f] = ht(u);
+  if (n != null && n.length && (r != null && r.length)) {
+    const m = n.map((x) => x - 1e-6);
+    m[0] = n[0], o && (m[m.length - 1] = n[n.length - 1]);
+    for (let x = 0; x < m.length; x++) {
+      const w = r[x] > f ? f : r[x] < p ? p : r[x], A = Math.ceil(m[2 * x] - s), k = Math.floor(m[2 * x + 1] - s);
+      for (let M = A; M <= k; M++)
+        l[M] = w, c[M] = 255;
+    }
+  }
+  if (i != null && i.length)
+    for (let d = 0; d < i.length; d++) {
+      const m = Math.ceil(i[2 * d] - s), x = Math.floor(i[2 * d + 1] - s);
+      for (let w = m; w <= x; w++)
+        c[w] = 0;
+    }
+  return { lut: l, offset: s, mask: c };
+}
+function Ie(t, e, n) {
+  if (t !== "u8" && t !== "s8" && t !== "u16" && t !== "s16")
+    return null;
+  const r = t.includes("16") ? 65536 : 256, a = t.includes("s") ? -r / 2 : 0, i = new Uint8Array(r);
+  if (e)
+    for (let o = 0; o < e.length; o++) {
+      const u = Math.ceil(e[2 * o] - a), h = Math.floor(e[2 * o + 1] - a);
+      for (let s = u; s <= h; s++)
+        i[s] = 255;
+    }
+  else
+    i.fill(255);
+  if (n)
+    for (let o = 0; o < n.length; o++)
+      i[n[o] - a] = 0;
+  return { lut: i, offset: a };
+}
+function Ht(t, e, n, r, a, i, o, u) {
+  return { xmin: a <= n * t ? 0 : a < n * t + t ? a - n * t : t, ymin: i <= r * e ? 0 : i < r * e + e ? i - r * e : e, xmax: a + o <= n * t ? 0 : a + o < n * t + t ? a + o - n * t : t, ymax: i + u <= r * e ? 0 : i + u < r * e + e ? i + u - r * e : e };
+}
+function Be(t, e) {
+  if (!t || t.length === 0)
+    return null;
+  const n = t.find((d) => d.pixelBlock);
+  if ((n == null ? void 0 : n.pixelBlock) == null)
+    return null;
+  const r = (n.extent.xmax - n.extent.xmin) / n.pixelBlock.width, a = (n.extent.ymax - n.extent.ymin) / n.pixelBlock.height, i = 0.01 * Math.min(r, a), o = t.sort((d, m) => Math.abs(d.extent.ymax - m.extent.ymax) > i ? m.extent.ymax - d.extent.ymax : Math.abs(d.extent.xmin - m.extent.xmin) > i ? d.extent.xmin - m.extent.xmin : 0), u = Math.min.apply(null, o.map((d) => d.extent.xmin)), h = Math.min.apply(null, o.map((d) => d.extent.ymin)), s = Math.max.apply(null, o.map((d) => d.extent.xmax)), l = Math.max.apply(null, o.map((d) => d.extent.ymax)), c = { x: Math.round((e.xmin - u) / r), y: Math.round((l - e.ymax) / a) }, p = { width: Math.round((s - u) / r), height: Math.round((l - h) / a) }, f = { width: Math.round((e.xmax - e.xmin) / r), height: Math.round((e.ymax - e.ymin) / a) };
+  return Math.round(p.width / n.pixelBlock.width) * Math.round(p.height / n.pixelBlock.height) !== o.length || c.x < 0 || c.y < 0 || p.width < f.width || p.height < f.height ? null : { extent: e, pixelBlock: Kt(o.map((d) => d.pixelBlock), p, { clipOffset: c, clipSize: f }) };
+}
+function ut(t, e, n, r, a, i) {
+  const { width: o, height: u } = n.block, { x: h, y: s } = n.offset, { width: l, height: c } = n.mosaic, p = Ht(o, u, r, a, h, s, l, c);
+  let f = 0, d = 0;
+  if (i) {
+    const m = i.hasGCSSShiftTransform ? 360 : i.halfWorldWidth ?? 0, x = o * i.resolutionX, w = i.startX + r * x;
+    w < m && w + x > m ? d = i.rightPadding : w >= m && (f = i.leftMargin - i.rightPadding, d = 0);
+  }
+  if (p.xmax -= d, typeof e != "number")
+    for (let m = p.ymin; m < p.ymax; m++) {
+      const x = (a * u + m - s) * l + (r * o - h) + f, w = m * o;
+      for (let A = p.xmin; A < p.xmax; A++)
+        t[x + A] = e[w + A];
+    }
+  else
+    for (let m = p.ymin; m < p.ymax; m++) {
+      const x = (a * u + m - s) * l + (r * o - h) + f;
+      for (let w = p.xmin; w < p.xmax; w++)
+        t[x + w] = e;
+    }
+}
+function Kt(t, e, n = {}) {
+  var T;
+  const { clipOffset: r, clipSize: a, alignmentInfo: i, blockWidths: o } = n;
+  if (o)
+    return Qt(t, e, { blockWidths: o });
+  const u = t.find((P) => R(P));
+  if (u == null)
+    return null;
+  const h = a ? a.width : e.width, s = a ? a.height : e.height, l = u.width, c = u.height, p = e.width / l, f = e.height / c, d = { offset: r || { x: 0, y: 0 }, mosaic: a || e, block: { width: l, height: c } }, m = u.pixelType, x = _.getPixelArrayConstructor(m), w = u.pixels.length, A = [];
+  let k, M;
+  for (let P = 0; P < w; P++) {
+    M = new x(h * s);
+    for (let U = 0; U < f; U++)
+      for (let I = 0; I < p; I++) {
+        const C = t[U * p + I];
+        R(C) && (k = C.pixels[P], ut(M, k, d, I, U, i));
+      }
+    A.push(M);
+  }
+  const g = t.some((P) => P == null || P.mask != null && P.mask.length > 0), y = t.some((P) => (P == null ? void 0 : P.bandMasks) && P.bandMasks.length > 1), v = g ? new Uint8Array(h * s) : void 0, b = y ? [] : void 0;
+  if (v) {
+    for (let P = 0; P < f; P++)
+      for (let U = 0; U < p; U++) {
+        const I = t[P * p + U], C = I != null ? I.mask : null;
+        ut(v, C ?? (I ? 255 : 0), d, U, P, i);
+      }
+    if (b)
+      for (let P = 0; P < w; P++) {
+        const U = new Uint8Array(h * s);
+        for (let I = 0; I < f; I++)
+          for (let C = 0; C < p; C++) {
+            const S = t[I * p + C], B = ((T = S == null ? void 0 : S.bandMasks) == null ? void 0 : T[P]) ?? (S == null ? void 0 : S.mask);
+            ut(U, B ?? (S ? 255 : 0), d, C, I, i);
+          }
+        b.push(U);
+      }
+  }
+  const $ = new _({ width: h, height: s, pixels: A, pixelType: m, bandMasks: b, mask: v });
+  return $.updateStatistics(), $;
+}
+function Qt(t, e, n) {
+  var x;
+  const r = t.find((w) => w != null);
+  if (r == null)
+    return null;
+  const a = t.some((w) => w == null || !!w.mask), { width: i, height: o } = e, u = a ? new Uint8Array(i * o) : null, { blockWidths: h } = n, s = [], l = r.getPlaneCount(), c = _.getPixelArrayConstructor(r.pixelType);
+  if (a)
+    for (let w = 0, A = 0; w < t.length; A += h[w], w++) {
+      const k = t[w];
+      if (!R(k))
+        continue;
+      const M = k.mask;
+      for (let g = 0; g < o; g++)
+        for (let y = 0; y < h[w]; y++)
+          u[g * i + y + A] = M == null ? 255 : M[g * k.width + y];
+    }
+  const p = t.some((w) => (w == null ? void 0 : w.bandMasks) && w.bandMasks.length > 1), f = p ? [] : void 0, d = i * o;
+  for (let w = 0; w < l; w++) {
+    const A = new c(d), k = p ? new Uint8Array(d) : void 0;
+    for (let M = 0, g = 0; M < t.length; g += h[M], M++) {
+      const y = t[M];
+      if (!R(y))
+        continue;
+      const v = y.pixels[w];
+      if (v != null) {
+        for (let b = 0; b < o; b++)
+          for (let $ = 0; $ < h[M]; $++)
+            A[b * i + $ + g] = v[b * y.width + $];
+        if (k) {
+          const b = ((x = y.bandMasks) == null ? void 0 : x[w]) ?? y.mask;
+          for (let $ = 0; $ < o; $++)
+            for (let T = 0; T < h[M]; T++)
+              k[$ * i + T + g] = b ? b[$ * y.width + T] : 255;
+        }
+      }
+    }
+    s.push(A), f && k && f.push(k);
+  }
+  const m = new _({ width: i, height: o, mask: u, bandMasks: f, pixels: s, pixelType: r.pixelType });
+  return m.updateStatistics(), m;
+}
+function Se(t, e, n) {
+  if (!R(t))
+    return null;
+  const { width: r, height: a } = t, i = e.x, o = e.y, u = n.width + i, h = n.height + o;
+  if (i < 0 || o < 0 || u > r || h > a || i === 0 && o === 0 && u === r && h === a)
+    return t;
+  t.mask || (t.mask = new Uint8Array(r * a));
+  const s = t.mask;
+  for (let l = 0; l < a; l++) {
+    const c = l * r;
+    for (let p = 0; p < r; p++)
+      s[c + p] = l < o || l >= h || p < i || p >= u ? 0 : 1;
+  }
+  return t.updateStatistics(), t;
+}
+function Yt(t) {
+  if (!R(t))
+    return null;
+  const e = t.clone(), { width: n, height: r, pixels: a } = t, i = a[0], o = e.pixels[0], u = t.mask;
+  for (let h = 2; h < r - 1; h++) {
+    const s = /* @__PURE__ */ new Map();
+    for (let c = h - 2; c < h + 2; c++)
+      for (let p = 0; p < 4; p++) {
+        const f = c * n + p;
+        lt(s, i[f], u ? u[f] : 1);
+      }
+    o[h * n] = Mt(s), o[h * n + 1] = o[h * n + 2] = o[h * n];
+    let l = 3;
+    for (; l < n - 1; l++) {
+      let c = (h - 2) * n + l + 1;
+      lt(s, i[c], u ? u[c] : 1), c = (h - 1) * n + l + 1, lt(s, i[c], u ? u[c] : 1), c = h * n + l + 1, lt(s, i[c], u ? u[c] : 1), c = (h + 1) * n + l + 1, lt(s, i[c], u ? u[c] : 1), c = (h - 2) * n + l - 3, rt(s, i[c], u ? u[c] : 1), c = (h - 1) * n + l - 3, rt(s, i[c], u ? u[c] : 1), c = h * n + l - 3, rt(s, i[c], u ? u[c] : 1), c = (h + 1) * n + l - 3, rt(s, i[c], u ? u[c] : 1), o[h * n + l] = Mt(s);
+    }
+    o[h * n + l + 1] = o[h * n + l];
+  }
+  for (let h = 0; h < n; h++)
+    o[h] = o[n + h] = o[2 * n + h], o[(r - 1) * n + h] = o[(r - 2) * n + h];
+  return e.updateStatistics(), e;
+}
+function Mt(t) {
+  if (t.size === 0)
+    return 0;
+  let e = 0, n = -1, r = 0;
+  const a = t.keys();
+  let i = a.next();
+  for (; !i.done; )
+    r = t.get(i.value), r > e && (n = i.value, e = r), i = a.next();
+  return n;
+}
+function rt(t, e, n) {
+  if (n === 0)
+    return;
+  const r = t.get(e);
+  r === 1 ? t.delete(e) : t.set(e, r - 1);
+}
+function lt(t, e, n) {
+  n !== 0 && t.set(e, t.has(e) ? t.get(e) + 1 : 1);
+}
+function Tt(t, e, n) {
+  let { x: r, y: a } = e;
+  const { width: i, height: o } = n;
+  if (r === 0 && a === 0 && o === t.height && i === t.width)
+    return t;
+  const { width: u, height: h } = t, s = Math.max(0, a), l = Math.max(0, r), c = Math.min(r + i, u), p = Math.min(a + o, h);
+  if (c < 0 || p < 0 || !R(t))
+    return null;
+  r = Math.max(0, -r), a = Math.max(0, -a);
+  const { pixels: f } = t, d = i * o, m = f.length, x = [];
+  for (let M = 0; M < m; M++) {
+    const g = f[M], y = _.createEmptyBand(t.pixelType, d);
+    for (let v = s; v < p; v++) {
+      const b = v * u;
+      let $ = (v + a - s) * i + r;
+      for (let T = l; T < c; T++)
+        y[$++] = g[b + T];
+    }
+    x.push(y);
+  }
+  const w = new Uint8Array(d), A = t.mask;
+  for (let M = s; M < p; M++) {
+    const g = M * u;
+    let y = (M + a - s) * i + r;
+    for (let v = l; v < c; v++)
+      w[y++] = A ? A[g + v] : 1;
+  }
+  const k = new _({ width: n.width, height: n.height, pixelType: t.pixelType, pixels: x, mask: w });
+  return k.updateStatistics(), k;
+}
+function It(t, e = !0) {
+  if (!R(t))
+    return null;
+  const { pixels: n, width: r, height: a, mask: i, pixelType: o } = t, u = [], h = Math.round(r / 2), s = Math.round(a / 2), l = a - 1, c = r - 1;
+  for (let f = 0; f < n.length; f++) {
+    const d = n[f], m = _.createEmptyBand(o, h * s);
+    let x = 0;
+    for (let w = 0; w < a; w += 2)
+      for (let A = 0; A < r; A += 2) {
+        const k = d[w * r + A];
+        if (e) {
+          const M = A === c ? k : d[w * r + A + 1], g = w === l ? k : d[w * r + A + r], y = A === c ? g : w === l ? M : d[w * r + A + r + 1];
+          m[x++] = (k + M + g + y) / 4;
+        } else
+          m[x++] = k;
+      }
+    u.push(m);
+  }
+  let p = null;
+  if (i != null) {
+    p = new Uint8Array(h * s);
+    let f = 0;
+    for (let d = 0; d < a; d += 2)
+      for (let m = 0; m < r; m += 2) {
+        const x = i[d * r + m];
+        if (e) {
+          const w = m === c ? x : i[d * r + m + 1], A = d === l ? x : i[d * r + m + r], k = m === c ? A : d === l ? w : i[d * r + m + r + 1];
+          p[f++] = x * w * A * k ? 1 : 0;
+        } else
+          p[f++] = x;
+      }
+  }
+  return new _({ width: h, height: s, pixelType: o, pixels: u, mask: p });
+}
+function Ce(t, e, n = 0, r = !0) {
+  if (!R(t))
+    return null;
+  const { width: a, height: i } = e;
+  let { width: o, height: u } = t;
+  const h = /* @__PURE__ */ new Map(), s = { x: 0, y: 0 }, l = 1 + n;
+  let c = t;
+  for (let p = 0; p < l; p++) {
+    const f = Math.ceil(o / a), d = Math.ceil(u / i);
+    for (let m = 0; m < d; m++) {
+      s.y = m * i;
+      for (let x = 0; x < f; x++) {
+        s.x = x * a;
+        const w = Tt(c, s, e);
+        h.set(`${p}/${m}/${x}`, w);
+      }
+    }
+    p < l - 1 && (c = It(c, r)), o = Math.round(o / 2), u = Math.round(u / 2);
+  }
+  return h;
+}
+function Fe(t) {
+  const { pixelBlock: e, tileSize: n, level: r, row: a, col: i, useBilinear: o } = t;
+  if (!R(e))
+    return null;
+  const { width: u, height: h } = n, s = 2 ** r, l = s * u, c = s * h;
+  let p = Tt(e, { y: a * c, x: i * l }, { width: l, height: c });
+  if (!p)
+    return null;
+  for (let f = r; f > 0; f--)
+    p = It(p, o);
+  return p;
+}
+function Bt(t, e, n, r, a = 0) {
+  const { width: i, height: o } = t, { width: u, height: h } = e, s = r.cols, l = r.rows, c = Math.ceil(u / s - 0.1 / s), p = Math.ceil(h / l - 0.1 / l);
+  let f, d, m, x, w, A, k;
+  const M = c * s, g = M * p * l, y = new Float32Array(g), v = new Float32Array(g), b = new Uint32Array(g), $ = new Uint32Array(g);
+  let T, P, U = 0;
+  for (let I = 0; I < p; I++)
+    for (let C = 0; C < c; C++) {
+      f = 12 * (I * c + C), d = n[f], m = n[f + 1], x = n[f + 2], w = n[f + 3], A = n[f + 4], k = n[f + 5];
+      for (let S = 0; S < l; S++) {
+        U = (I * l + S) * M + C * s, P = (S + 0.5) / l;
+        for (let B = 0; B < S; B++)
+          T = (B + 0.5) / s, y[U + B] = (d * T + m * P + x) * i + a, v[U + B] = (w * T + A * P + k) * o + a, b[U + B] = Math.floor(y[U + B]), $[U + B] = Math.floor(v[U + B]);
+      }
+      f += 6, d = n[f], m = n[f + 1], x = n[f + 2], w = n[f + 3], A = n[f + 4], k = n[f + 5];
+      for (let S = 0; S < l; S++) {
+        U = (I * l + S) * M + C * s, P = (S + 0.5) / l;
+        for (let B = S; B < s; B++)
+          T = (B + 0.5) / s, y[U + B] = (d * T + m * P + x) * i + a, v[U + B] = (w * T + A * P + k) * o + a, b[U + B] = Math.floor(y[U + B]), $[U + B] = Math.floor(v[U + B]);
+      }
+    }
+  return { offsets_x: y, offsets_y: v, offsets_xi: b, offsets_yi: $, gridWidth: M };
+}
+function Ve(t, e) {
+  const { coefficients: n, spacing: r } = e, { offsets_x: a, offsets_y: i, gridWidth: o } = Bt(t, t, n, { rows: r[0], cols: r[1] }), { width: u, height: h } = t, s = new Float32Array(u * h), l = 180 / Math.PI;
+  for (let c = 0; c < h; c++)
+    for (let p = 0; p < u; p++) {
+      const f = c * o + p, d = c === 0 ? f : f - o, m = c === h - 1 ? f : f + o, x = a[d] - a[m], w = i[m] - i[d];
+      if (isNaN(x) || isNaN(w))
+        s[c * u + p] = 90;
+      else {
+        let A = Math.atan2(w, x) * l;
+        A = (360 + A) % 360, s[c * u + p] = A;
+      }
+    }
+  return s;
+}
+function _e(t, e, n, r, a = "nearest") {
+  if (!R(t))
+    return null;
+  a === "majority" && (t = Yt(t));
+  const { pixels: i, mask: o, bandMasks: u, pixelType: h } = t, s = t.width, l = t.height, c = _.getPixelArrayConstructor(h), p = i.length, { width: f, height: d } = e;
+  let m = !1;
+  for (let U = 0; U < n.length; U += 3)
+    n[U] === -1 && n[U + 1] === -1 && n[U + 2] === -1 && (m = !0);
+  const { offsets_x: x, offsets_y: w, offsets_xi: A, offsets_yi: k, gridWidth: M } = Bt({ width: s, height: l }, e, n, r, a === "majority" ? 0.5 : 0);
+  let g;
+  const y = (U, I, C, S) => {
+    const B = U instanceof Float32Array || U instanceof Float64Array ? 0 : 0.5;
+    for (let F = 0; F < d; F++) {
+      g = F * M;
+      for (let V = 0; V < f; V++) {
+        if (x[g] < 0 || w[g] < 0)
+          U[F * f + V] = 0;
+        else if (S)
+          U[F * f + V] = I[A[g] + k[g] * s];
+        else {
+          const E = Math.floor(x[g]), W = Math.floor(w[g]), L = Math.ceil(x[g]), G = Math.ceil(w[g]), z = x[g] - E, H = w[g] - W;
+          if (!C || C[E + W * s] && C[L + W * s] && C[E + G * s] && C[L + G * s]) {
+            const et = (1 - z) * I[E + W * s] + z * I[L + W * s], Q = (1 - z) * I[E + G * s] + z * I[L + G * s];
+            U[F * f + V] = (1 - H) * et + H * Q + B;
+          } else
+            U[F * f + V] = I[A[g] + k[g] * s];
+        }
+        g++;
+      }
+    }
+  }, v = [];
+  let b;
+  const $ = (u == null ? void 0 : u.length) === p, T = [];
+  for (let U = 0; U < p; U++) {
+    if ($) {
+      const I = new Uint8Array(f * d);
+      y(I, u[U], u[U], !0), T.push(I);
+    }
+    b = new c(f * d), y(b, i[U], $ ? u[U] : o, a === "nearest" || a === "majority"), v.push(b);
+  }
+  const P = new _({ width: f, height: d, pixelType: h, pixels: v, bandMasks: $ ? T : void 0 });
+  if (o != null)
+    P.mask = new Uint8Array(f * d), y(P.mask, o, o, !0);
+  else if (m) {
+    P.mask = new Uint8Array(f * d);
+    for (let U = 0; U < f * d; U++)
+      P.mask[U] = x[U] < 0 || w[U] < 0 ? 0 : 1;
+  }
+  return P.updateStatistics(), P;
+}
+const tt = /* @__PURE__ */ new Map();
+tt.set("meter-per-second", 1), tt.set("kilometer-per-hour", 0.277778), tt.set("knots", 0.514444), tt.set("feet-per-second", 0.3048), tt.set("mile-per-hour", 0.44704);
+const pt = 180 / Math.PI, dt = 5, at = new jt({ esriMetersPerSecond: "meter-per-second", esriKilometersPerHour: "kilometer-per-hour", esriKnots: "knots", esriFeetPerSecond: "feet-per-second", esriMilesPerHour: "mile-per-hour" });
+function mt(t, e) {
+  return tt.get(t) / tt.get(e) || 1;
+}
+function St(t) {
+  return (450 - t) % 360;
+}
+function Ct(t, e = "geographic") {
+  const [n, r] = t, a = Math.sqrt(n * n + r * r);
+  let i = Math.atan2(r, n) * pt;
+  return i = (360 + i) % 360, e === "geographic" && (i = St(i)), [a, i];
+}
+function Ft(t, e = "geographic") {
+  let n = t[1];
+  e === "geographic" && (n = St(n)), n %= 360;
+  const r = t[0];
+  return [r * Math.cos(n / pt), r * Math.sin(n / pt)];
+}
+function De(t, e, n, r = "geographic") {
+  if (!R(t) || n == null)
+    return t;
+  const a = e === "vector-magdir" ? t.clone() : At(t, e), i = a.pixels[1];
+  for (let o = 0; o < i.length; o++)
+    i[o] = r === "geographic" ? (i[o] + n[o] + 270) % 360 : (i[o] + 360 - n[o]) % 360;
+  return e === "vector-magdir" ? a : At(a, "vector-magdir");
+}
+function At(t, e, n = "geographic", r = 1) {
+  if (!R(t))
+    return t;
+  const { pixels: a, width: i, height: o } = t, u = i * o, h = a[0], s = a[1], l = t.pixelType.startsWith("f") ? t.pixelType : "f32", c = _.createEmptyBand(l, u), p = _.createEmptyBand(l, u);
+  let f = 0;
+  for (let m = 0; m < o; m++)
+    for (let x = 0; x < i; x++)
+      e === "vector-uv" ? ([c[f], p[f]] = Ct([h[f], s[f]], n), c[f] *= r) : ([c[f], p[f]] = Ft([h[f], s[f]], n), c[f] *= r, p[f] *= r), f++;
+  const d = new _({ pixelType: l, width: t.width, height: t.height, mask: t.mask, validPixelCount: t.validPixelCount, maskIsAlpha: t.maskIsAlpha, pixels: [c, p] });
+  return d.updateStatistics(), d;
+}
+function Re(t, e, n = 1) {
+  if (n === 1 || !R(t))
+    return t;
+  const r = t.clone(), { pixels: a, width: i, height: o } = r, u = a[0], h = a[1];
+  let s = 0;
+  for (let l = 0; l < o; l++)
+    for (let c = 0; c < i; c++)
+      e === "vector-uv" ? (u[s] *= n, h[s] *= n) : u[s] *= n, s++;
+  return r.updateStatistics(), r;
+}
+function Le(t, e, n, r, a) {
+  if (a == null || !a.spatialReference.equals(t.spatialReference))
+    return { extent: t, width: Math.round(e / r), height: Math.round(n / r), resolution: t.width / e };
+  const i = a.xmin, o = a.ymax, u = (t.xmax - t.xmin) / e * r, h = (t.ymax - t.ymin) / n * r, s = (u + h) / 2;
+  return t.xmin = i + Math.floor((t.xmin - i) / u) * u, t.xmax = i + Math.ceil((t.xmax - i) / u) * u, t.ymin = o + Math.floor((t.ymin - o) / h) * h, t.ymax = o + Math.ceil((t.ymax - o) / h) * h, { extent: t, width: Math.round(t.width / u), height: Math.round(t.height / h), resolution: s };
+}
+const Zt = Vt(0, 0, 0);
+function Vt(t = 0, e = 0, n = Math.PI, r = !0) {
+  r && (n = (2 * Math.PI - n) % (2 * Math.PI));
+  const a = r ? -1 : 1, i = 13 * a, o = -7 * a, u = -2 * a, h = -16 * a, s = 21.75, [l, c] = j(0, e + i, n, s), [p, f] = j(t - 5.5, e + o, n, s), [d, m] = j(t + 5.5, e + o, n, s), [x, w] = j(t - 1.5, e + u, n, s), [A, k] = j(t + 1.5, e + u, n, s), [M, g] = j(t - 1.5, e + h, n, s), [y, v] = j(t + 1.5, e + h, n, s);
+  return [l, c, p, f, x, w, A, k, d, m, M, g, y, v];
+}
+function te(t = 0, e = Math.PI, n = !0) {
+  n && (e = (2 * Math.PI - e) % (2 * Math.PI));
+  const r = 10, a = n ? -1 : 1, i = 5 * a, o = 20 * a, u = 25 * a, h = 45, s = 0, l = 0, c = 2, p = 0, f = c * a, d = n ? 1 : -1, m = r / 2 * d;
+  let [x, w] = [s + m, l - o], [A, k] = [x + c * d, w], [M, g] = [A - p * d, k + f], [y, v] = [s - m, l - u], [b, $] = [y + p * d, v - f], T = Math.ceil(t / dt), P = Math.floor(T / 10);
+  T -= 8 * P;
+  const U = [], I = [];
+  for (let z = 0; z < T / 2; z++, P--) {
+    P <= 0 && T % 2 == 1 && z === (T - 1) / 2 && (y = s, b = y + p * d, v = (v + w) / 2, $ = v - f);
+    const [H, et] = j(y, v, e, h);
+    if (P > 0) {
+      const [Q, it] = j(A, v, e, h), [st, D] = j(x, w, e, h);
+      U.push(Q), U.push(it), U.push(H), U.push(et), U.push(st), U.push(D);
+    } else {
+      const [Q, it] = j(A, k, e, h), [st, D] = j(M, g, e, h), [N, ct] = j(b, $, e, h);
+      I.push(H), I.push(et), I.push(N), I.push(ct), I.push(st), I.push(D), I.push(Q), I.push(it);
+    }
+    v += i, w += i, k += i, g += i, $ += i;
+  }
+  const [C, S] = j(s + m, l + o, e, h), B = (r / 2 + c) * d, [F, V] = j(s + B, l + o, e, h), [E, W] = j(s + m, l - u, e, h), [L, G] = j(s + B, l - u, e, h);
+  return { pennants: U, barbs: I, shaft: [C, S, F, V, E, W, L, G] };
+}
+function j(t, e, n, r = 1) {
+  const a = Math.sqrt(t * t + e * e) / r, i = (2 * Math.PI + Math.atan2(e, t)) % (2 * Math.PI);
+  return [a, (2 * Math.PI + i - n) % (2 * Math.PI)];
+}
+const ot = [0, 1, 3, 6, 10, 16, 21, 27, 33, 40, 47, 55, 63], ee = [0, 0.5, 1, 1.5, 2], ne = [0, 0.25, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4];
+function Y(t, e, n, r) {
+  const a = mt(r || "knots", n);
+  let i;
+  for (i = 1; i < e.length; i++)
+    if (i === e.length - 1) {
+      if (t < e[i] * a)
+        break;
+    } else if (t <= e[i] * a)
+      break;
+  return Math.min(i - 1, e.length - 2);
+}
+function ie(t, e, n, r, a) {
+  let i = 0;
+  switch (e) {
+    case "beaufort_kn":
+      i = Y(t, ot, "knots", n);
+      break;
+    case "beaufort_km":
+      i = Y(t, ot, "kilometer-per-hour", n);
+      break;
+    case "beaufort_ft":
+      i = Y(t, ot, "feet-per-second", n);
+      break;
+    case "beaufort_m":
+      i = Y(t, ot, "meter-per-second", n);
+      break;
+    case "classified_arrow":
+      i = Y(t, a ?? [], r, n);
+      break;
+    case "ocean_current_m":
+      i = Y(t, ee, "meter-per-second", n);
+      break;
+    case "ocean_current_kn":
+      i = Y(t, ne, "knots", n);
+  }
+  return i;
+}
+function se(t, e) {
+  const { style: n, inputUnit: r, outputUnit: a, breakValues: i } = e, o = at.fromJSON(r), u = at.fromJSON(a), h = 7 * 6, s = 15;
+  let l = 0, c = 0;
+  const { width: p, height: f, mask: d } = t, m = t.pixels[0], x = t.pixels[1], w = d != null ? d.filter((g) => g > 0).length : p * f, A = new Float32Array(w * h), k = new Uint32Array(s * w), M = e.invertDirection ? Vt(0, 0, 0, !1) : Zt;
+  for (let g = 0; g < f; g++)
+    for (let y = 0; y < p; y++) {
+      const v = g * p + y;
+      if (!d || d[g * p + y]) {
+        const b = (x[v] + 360) % 360 / 180 * Math.PI, $ = ie(m[v], n, o, u, i);
+        for (let P = 0; P < M.length; P += 2)
+          A[l++] = (y + 0.5) / p, A[l++] = (g + 0.5) / f, A[l++] = M[P], A[l++] = M[P + 1] + b, A[l++] = $, A[l++] = m[v];
+        const T = 7 * (l / h - 1);
+        k[c++] = T, k[c++] = T + 1, k[c++] = T + 2, k[c++] = T + 0, k[c++] = T + 4, k[c++] = T + 3, k[c++] = T + 0, k[c++] = T + 2, k[c++] = T + 3, k[c++] = T + 2, k[c++] = T + 5, k[c++] = T + 3, k[c++] = T + 5, k[c++] = T + 6, k[c++] = T + 3;
+      }
+    }
+  return { vertexData: A, indexData: k };
+}
+const ft = [];
+function le(t, e) {
+  if (ft.length === 0)
+    for (let f = 0; f < 30; f++)
+      ft.push(te(5 * f, 0, !e.invertDirection));
+  const n = mt(at.fromJSON(e.inputUnit), "knots"), { width: r, height: a, mask: i } = t, o = t.pixels[0], u = t.pixels[1], h = 6, s = [], l = [];
+  let c = 0, p = 0;
+  for (let f = 0; f < a; f++)
+    for (let d = 0; d < r; d++) {
+      const m = f * r + d, x = o[m] * n;
+      if ((!i || i[f * r + d]) && x >= dt) {
+        const w = (u[m] + 360) % 360 / 180 * Math.PI, { pennants: A, barbs: k, shaft: M } = ft[Math.min(Math.floor(x / 5), 29)];
+        if (A.length + k.length === 0)
+          continue;
+        let g = s.length / h;
+        const y = (d + 0.5) / r, v = (f + 0.5) / a;
+        for (let b = 0; b < A.length; b += 2)
+          s[c++] = y, s[c++] = v, s[c++] = A[b], s[c++] = A[b + 1] + w, s[c++] = 0, s[c++] = x;
+        for (let b = 0; b < k.length; b += 2)
+          s[c++] = y, s[c++] = v, s[c++] = k[b], s[c++] = k[b + 1] + w, s[c++] = 0, s[c++] = x;
+        for (let b = 0; b < M.length; b += 2)
+          s[c++] = y, s[c++] = v, s[c++] = M[b], s[c++] = M[b + 1] + w, s[c++] = 0, s[c++] = x;
+        for (let b = 0; b < A.length / 6; b++)
+          l[p++] = g, l[p++] = g + 1, l[p++] = g + 2, g += 3;
+        for (let b = 0; b < k.length / 8; b++)
+          l[p++] = g, l[p++] = g + 1, l[p++] = g + 2, l[p++] = g + 1, l[p++] = g + 2, l[p++] = g + 3, g += 4;
+        l[p++] = g + 0, l[p++] = g + 1, l[p++] = g + 2, l[p++] = g + 1, l[p++] = g + 3, l[p++] = g + 2, g += 4;
+      }
+    }
+  return { vertexData: new Float32Array(s), indexData: new Uint32Array(l) };
+}
+function re(t, e) {
+  let r = 0, a = 0;
+  const { width: i, height: o, mask: u } = t, h = t.pixels[0], s = [], l = [], c = mt(at.fromJSON(e.inputUnit), "knots"), p = e.style === "wind_speed" ? dt : Number.MAX_VALUE;
+  for (let f = 0; f < o; f++)
+    for (let d = 0; d < i; d++) {
+      const m = h[f * i + d] * c;
+      if ((!u || u[f * i + d]) && m < p) {
+        for (let w = 0; w < 4; w++)
+          s[r++] = (d + 0.5) / i, s[r++] = (f + 0.5) / o, s[r++] = w < 2 ? -0.5 : 0.5, s[r++] = w % 2 == 0 ? -0.5 : 0.5, s[r++] = 0, s[r++] = m;
+        const x = 4 * (r / 24 - 1);
+        l[a++] = x, l[a++] = x + 1, l[a++] = x + 2, l[a++] = x + 1, l[a++] = x + 2, l[a++] = x + 3;
+      }
+    }
+  return { vertexData: new Float32Array(s), indexData: new Uint32Array(l) };
+}
+function Ne(t, e) {
+  return e.style === "simple_scalar" ? re(t, e) : e.style === "wind_speed" ? le(t, e) : se(t, e);
+}
+function Ee(t, e, n, r = [0, 0], a = 0.5) {
+  const { width: i, height: o, mask: u } = t, [h, s] = t.pixels, [l, c] = r, p = Math.round((i - l) / n), f = Math.round((o - c) / n), d = p * f, m = new Float32Array(d), x = new Float32Array(d), w = new Uint8Array(d), A = e === "vector-uv";
+  for (let M = 0; M < f; M++)
+    for (let g = 0; g < p; g++) {
+      let y = 0;
+      const v = M * p + g, b = Math.max(0, M * n + c), $ = Math.max(0, g * n + l), T = Math.min(o, b + n), P = Math.min(i, $ + n);
+      for (let U = b; U < T; U++)
+        for (let I = $; I < P; I++) {
+          const C = U * i + I;
+          if (!u || u[C]) {
+            y++;
+            const S = A ? [h[C], s[C]] : [h[C], (360 + s[C]) % 360], [B, F] = A ? S : Ft(S);
+            m[v] += B, x[v] += F;
+          }
+        }
+      if (y >= (T - b) * (P - $) * (1 - a)) {
+        w[v] = 1;
+        const [U, I] = Ct([m[v] / y, x[v] / y]);
+        m[v] = U, x[v] = I;
+      } else
+        w[v] = 0, m[v] = 0, x[v] = 0;
+    }
+  const k = new _({ width: p, height: f, pixels: [m, x], mask: w });
+  return k.updateStatistics(), k;
+}
+const J = () => Z.getLogger("esri.views.2d.engine.flow.dataUtils"), oe = 10;
+async function je(t, e, n, r) {
+  const a = performance.now(), i = ae(e, n), o = performance.now(), u = ce(e, i, n.width, n.height), h = performance.now(), s = fe(u, !0), l = performance.now(), c = t === "Streamlines" ? pe(s, oe) : de(s), p = performance.now();
+  return nt("esri-2d-profiler") && (J().info("I.1", "_createFlowFieldFromData (ms)", Math.round(o - a)), J().info("I.2", "_getStreamlines (ms)", Math.round(h - o)), J().info("I.3", "createAnimatedLinesData (ms)", Math.round(l - h)), J().info("I.4", "create{Streamlines|Particles}Mesh (ms)", Math.round(p - l)), J().info("I.5", "createFlowMesh (ms)", Math.round(p - a)), J().info("I.6", "Mesh size (bytes)", c.vertexData.buffer.byteLength + c.indexData.buffer.byteLength)), await Promise.resolve(), Ot(r), c;
+}
+function ae(t, e) {
+  const n = ue(e.data, e.width, e.height, t.smoothing);
+  return t.interpolate ? (r, a) => {
+    const i = Math.floor(r), o = Math.floor(a);
+    if (i < 0 || i >= e.width)
+      return [0, 0];
+    if (o < 0 || o >= e.height)
+      return [0, 0];
+    const u = r - i, h = a - o, s = i, l = o, c = i < e.width - 1 ? i + 1 : i, p = o < e.height - 1 ? o + 1 : o, f = n[2 * (l * e.width + s)], d = n[2 * (l * e.width + c)], m = n[2 * (p * e.width + s)], x = n[2 * (p * e.width + c)], w = n[2 * (l * e.width + s) + 1], A = n[2 * (l * e.width + c) + 1];
+    return [(f * (1 - h) + m * h) * (1 - u) + (d * (1 - h) + x * h) * u, (w * (1 - h) + n[2 * (p * e.width + s) + 1] * h) * (1 - u) + (A * (1 - h) + n[2 * (p * e.width + c) + 1] * h) * u];
+  } : (r, a) => {
+    const i = Math.round(r), o = Math.round(a);
+    return i < 0 || i >= e.width || o < 0 || o >= e.height ? [0, 0] : [n[2 * (o * e.width + i)], n[2 * (o * e.width + i) + 1]];
+  };
+}
+function he(t, e, n, r, a, i, o, u, h) {
+  const s = [];
+  let l = n, c = r, p = 0, [f, d] = e(l, c);
+  f *= t.velocityScale, d *= t.velocityScale;
+  const m = Math.sqrt(f * f + d * d);
+  let x, w;
+  s.push({ x: l, y: c, t: p, speed: m });
+  for (let A = 0; A < t.verticesPerLine; A++) {
+    let [k, M] = e(l, c);
+    k *= t.velocityScale, M *= t.velocityScale;
+    const g = Math.sqrt(k * k + M * M);
+    if (g < t.minSpeedThreshold)
+      return s;
+    const y = k / g, v = M / g;
+    if (l += y * t.segmentLength, c += v * t.segmentLength, p += t.segmentLength / g, Math.acos(y * x + v * w) > t.maxTurnAngle)
+      return s;
+    if (t.collisions) {
+      const b = Math.round(l * h), $ = Math.round(c * h);
+      if (b < 0 || b > o - 1 || $ < 0 || $ > u - 1)
+        return s;
+      const T = i[$ * o + b];
+      if (T !== -1 && T !== a)
+        return s;
+      i[$ * o + b] = a;
+    }
+    s.push({ x: l, y: c, t: p, speed: g }), x = y, w = v;
+  }
+  return s;
+}
+function ce(t, e, n, r) {
+  const a = [], i = new Ut(), o = 1 / Math.max(t.lineCollisionWidth, 1), u = Math.round(n * o), h = Math.round(r * o), s = new Int32Array(u * h);
+  for (let c = 0; c < s.length; c++)
+    s[c] = -1;
+  const l = [];
+  for (let c = 0; c < r; c += t.lineSpacing)
+    for (let p = 0; p < n; p += t.lineSpacing)
+      l.push({ x: p, y: c, sort: i.getFloat() });
+  l.sort((c, p) => c.sort - p.sort);
+  for (const { x: c, y: p } of l)
+    if (i.getFloat() < t.density) {
+      const f = he(t, e, c, p, a.length, s, u, h, o);
+      if (f.length < 2)
+        continue;
+      a.push(f);
+    }
+  return a;
+}
+function ue(t, e, n, r) {
+  if (r === 0)
+    return t;
+  const a = Math.round(3 * r), i = new Array(2 * a + 1);
+  let o = 0;
+  for (let s = -a; s <= a; s++) {
+    const l = Math.exp(-s * s / (r * r));
+    i[s + a] = l, o += l;
+  }
+  for (let s = -a; s <= a; s++)
+    i[s + a] /= o;
+  const u = new Float32Array(t.length);
+  for (let s = 0; s < n; s++)
+    for (let l = 0; l < e; l++) {
+      let c = 0, p = 0;
+      for (let f = -a; f <= a; f++) {
+        if (l + f < 0 || l + f >= e)
+          continue;
+        const d = i[f + a];
+        c += d * t[2 * (s * e + (l + f))], p += d * t[2 * (s * e + (l + f)) + 1];
+      }
+      u[2 * (s * e + l)] = c, u[2 * (s * e + l) + 1] = p;
+    }
+  const h = new Float32Array(t.length);
+  for (let s = 0; s < e; s++)
+    for (let l = 0; l < n; l++) {
+      let c = 0, p = 0;
+      for (let f = -a; f <= a; f++) {
+        if (l + f < 0 || l + f >= n)
+          continue;
+        const d = i[f + a];
+        c += d * u[2 * ((l + f) * e + s)], p += d * u[2 * ((l + f) * e + s) + 1];
+      }
+      h[2 * (l * e + s)] = c, h[2 * (l * e + s) + 1] = p;
+    }
+  return h;
+}
+function fe(t, e) {
+  const n = new Ut(), r = t.reduce((h, s) => h + s.length, 0), a = new Float32Array(4 * r), i = new Array(t.length);
+  let o = 0, u = 0;
+  for (const h of t) {
+    const s = o;
+    for (const l of h)
+      a[4 * o] = l.x, a[4 * o + 1] = l.y, a[4 * o + 2] = l.t, a[4 * o + 3] = l.speed, o++;
+    i[u++] = { startVertex: s, numberOfVertices: h.length, totalTime: h[h.length - 1].t, timeSeed: e ? n.getFloat() : 0 };
+  }
+  return { lineVertices: a, lineDescriptors: i };
+}
+function pe(t, e) {
+  const { lineVertices: r, lineDescriptors: a } = t;
+  let i = 0, o = 0;
+  for (const f of a)
+    i += 2 * f.numberOfVertices, o += 6 * (f.numberOfVertices - 1);
+  const u = new Float32Array(i * 9), h = new Uint32Array(o);
+  let s = 0, l = 0;
+  function c() {
+    h[l++] = s - 2, h[l++] = s, h[l++] = s - 1, h[l++] = s, h[l++] = s + 1, h[l++] = s - 1;
+  }
+  function p(f, d, m, x, w, A, k, M) {
+    const g = s * 9;
+    let y = 0;
+    u[g + y++] = f, u[g + y++] = d, u[g + y++] = 1, u[g + y++] = m, u[g + y++] = A, u[g + y++] = k, u[g + y++] = x / 2, u[g + y++] = w / 2, u[g + y++] = M, s++, u[g + y++] = f, u[g + y++] = d, u[g + y++] = -1, u[g + y++] = m, u[g + y++] = A, u[g + y++] = k, u[g + y++] = -x / 2, u[g + y++] = -w / 2, u[g + y++] = M, s++;
+  }
+  for (const f of a) {
+    const { totalTime: d, timeSeed: m } = f;
+    let x = null, w = null, A = null, k = null, M = null, g = null;
+    for (let y = 0; y < f.numberOfVertices; y++) {
+      const v = r[4 * (f.startVertex + y)], b = r[4 * (f.startVertex + y) + 1], $ = r[4 * (f.startVertex + y) + 2], T = r[4 * (f.startVertex + y) + 3];
+      let P = null, U = null, I = null, C = null;
+      if (y > 0) {
+        P = v - x, U = b - w;
+        const S = Math.sqrt(P * P + U * U);
+        if (P /= S, U /= S, y > 1) {
+          let B = P + M, F = U + g;
+          const V = Math.sqrt(B * B + F * F);
+          B /= V, F /= V;
+          const E = Math.min(1 / (B * P + F * U), e);
+          B *= E, F *= E, I = -F, C = B;
+        } else
+          I = -U, C = P;
+        I !== null && C !== null && (p(x, w, A, I, C, d, m, T), c());
+      }
+      x = v, w = b, A = $, M = P, g = U, k = T;
+    }
+    p(x, w, A, -g, M, d, m, k);
+  }
+  return { vertexData: u, indexData: h };
+}
+function de(t) {
+  const { lineVertices: a, lineDescriptors: i } = t;
+  let o = 0, u = 0;
+  for (const S of i) {
+    const B = S.numberOfVertices - 1;
+    o += 4 * B * 2, u += 6 * B * 2;
+  }
+  const h = new Float32Array(o * 16), s = new Uint32Array(u);
+  let l, c, p, f, d, m, x, w, A, k, M, g, y, v, b = 0, $ = 0;
+  function T() {
+    s[$++] = b - 8, s[$++] = b - 7, s[$++] = b - 6, s[$++] = b - 7, s[$++] = b - 5, s[$++] = b - 6, s[$++] = b - 4, s[$++] = b - 3, s[$++] = b - 2, s[$++] = b - 3, s[$++] = b - 1, s[$++] = b - 2;
+  }
+  function P(S, B, F, V, E, W, L, G, z, H, et, Q, it, st) {
+    const D = b * 16;
+    let N = 0;
+    for (const ct of [1, 2])
+      for (const _t of [1, 2, 3, 4])
+        h[D + N++] = S, h[D + N++] = B, h[D + N++] = F, h[D + N++] = V, h[D + N++] = L, h[D + N++] = G, h[D + N++] = z, h[D + N++] = H, h[D + N++] = ct, h[D + N++] = _t, h[D + N++] = it, h[D + N++] = st, h[D + N++] = E / 2, h[D + N++] = W / 2, h[D + N++] = et / 2, h[D + N++] = Q / 2, b++;
+  }
+  function U(S, B) {
+    let F = A + M, V = k + g;
+    const E = Math.sqrt(F * F + V * V);
+    F /= E, V /= E;
+    const W = A * F + k * V;
+    F /= W, V /= W;
+    let L = M + y, G = g + v;
+    const z = Math.sqrt(L * L + G * G);
+    L /= z, G /= z;
+    const H = M * L + g * G;
+    L /= H, G /= H, P(l, c, p, f, -V, F, d, m, x, w, -G, L, S, B), T();
+  }
+  function I(S, B, F, V, E, W) {
+    if (A = M, k = g, M = y, g = v, A == null && k == null && (A = M, k = g), d != null && m != null) {
+      y = S - d, v = B - m;
+      const L = Math.sqrt(y * y + v * v);
+      y /= L, v /= L;
+    }
+    A != null && k != null && U(E, W), l = d, c = m, p = x, f = w, d = S, m = B, x = F, w = V;
+  }
+  function C(S, B) {
+    A = M, k = g, M = y, g = v, A == null && k == null && (A = M, k = g), A != null && k != null && U(S, B);
+  }
+  for (const S of i) {
+    l = null, c = null, p = null, f = null, d = null, m = null, x = null, w = null, A = null, k = null, M = null, g = null, y = null, v = null;
+    const { totalTime: B, timeSeed: F } = S;
+    for (let V = 0; V < S.numberOfVertices; V++)
+      I(a[4 * (S.startVertex + V)], a[4 * (S.startVertex + V) + 1], a[4 * (S.startVertex + V) + 2], a[4 * (S.startVertex + V) + 3], B, F);
+    C(B, F);
+  }
+  return { vertexData: h, indexData: s };
+}
+function bt(t, e) {
+  const n = e.pixels, { width: r, height: a } = e, i = new Float32Array(r * a * 2), o = e.mask || new Uint8Array(r * a * 2);
+  if (e.mask || o.fill(255), t === "vector-uv")
+    for (let u = 0; u < r * a; u++)
+      i[2 * u] = n[0][u], i[2 * u + 1] = -n[1][u];
+  else if (t === "vector-magdir")
+    for (let u = 0; u < r * a; u++) {
+      const h = n[0][u], s = qt(n[1][u]), l = Math.cos(s - Math.PI / 2), c = Math.sin(s - Math.PI / 2);
+      i[2 * u] = l * h, i[2 * u + 1] = c * h;
+    }
+  return { data: i, mask: o, width: r, height: a };
+}
+async function Oe(t, e, n, r, a, i) {
+  const o = performance.now(), u = Gt(e.spatialReference);
+  if (!u) {
+    const M = await vt(t, e, n, r, a, i);
+    return nt("esri-2d-profiler") && J().info("I.7", "loadImagery, early exit (ms)", Math.round(performance.now() - o)), nt("esri-2d-profiler") && J().info("I.9", "Number of parts", 1), M;
+  }
+  const [h, s] = u.valid, l = s - h, c = Math.ceil(e.width / l), p = e.width / c, f = Math.round(n / c);
+  let d = e.xmin;
+  const m = [], x = performance.now();
+  for (let M = 0; M < c; M++) {
+    const g = new Wt({ xmin: d, xmax: d + p, ymin: e.ymin, ymax: e.ymax, spatialReference: e.spatialReference });
+    m.push(vt(t, g, f, r, a, i)), d += p;
+  }
+  const w = await Promise.all(m);
+  nt("esri-2d-profiler") && J().info("I.8", "All calls to _fetchPart (ms)", Math.round(performance.now() - x)), nt("esri-2d-profiler") && J().info("I.9", "Number of parts", w.length);
+  const A = { data: new Float32Array(n * r * 2), mask: new Uint8Array(n * r), width: n, height: r };
+  let k = 0;
+  for (const M of w) {
+    for (let g = 0; g < M.height; g++)
+      for (let y = 0; y < M.width; y++)
+        k + y >= n || (A.data[2 * (g * n + k + y)] = M.data[2 * (g * M.width + y)], A.data[2 * (g * n + k + y) + 1] = M.data[2 * (g * M.width + y) + 1], A.mask[g * n + k + y] = M.mask[g * M.width + y]);
+    k += M.width;
+  }
+  return nt("esri-2d-profiler") && J().info("I.10", "loadImagery, general exit (ms)", Math.round(performance.now() - o)), A;
+}
+async function vt(t, e, n, r, a, i) {
+  var s;
+  const o = { requestProjectedLocalDirections: !0, signal: i };
+  if (a != null && (o.timeExtent = a), t.type === "imagery") {
+    await t.load({ signal: i });
+    const l = t.rasterInfo.dataType, c = await t.fetchImage(e, n, r, o);
+    return ((s = c == null ? void 0 : c.pixelData) == null ? void 0 : s.pixelBlock) == null ? { data: new Float32Array(n * r * 2), mask: new Uint8Array(n * r), width: n, height: r } : bt(l, c.pixelData.pixelBlock);
+  }
+  await t.load({ signal: i });
+  const u = t.serviceRasterInfo.dataType, h = await t.fetchPixels(e, n, r, o);
+  return (h == null ? void 0 : h.pixelBlock) == null ? { data: new Float32Array(n * r * 2), mask: new Uint8Array(n * r), width: n, height: r } : bt(u, h.pixelBlock);
+}
+export {
+  Te as A,
+  Pt as B,
+  Pe as C,
+  _e as D,
+  Fe as E,
+  Be as M,
+  Ve as R,
+  Ee as S,
+  Se as T,
+  Kt as U,
+  Ce as W,
+  re as _,
+  De as a,
+  Ne as b,
+  ye as c,
+  xe as d,
+  at as e,
+  At as f,
+  Oe as g,
+  mt as h,
+  ht as i,
+  be as j,
+  Ue as k,
+  Ct as l,
+  Le as m,
+  ve as n,
+  R as o,
+  Re as p,
+  Ae as q,
+  we as r,
+  je as s,
+  Me as t,
+  _ as u,
+  wt as v,
+  xt as w,
+  Ie as x,
+  ke as y,
+  $e as z
+};