@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/ImageryTileLayer-7c19b5c4.js

@@ -0,0 +1,2157 @@
+import { hg as vt, j7 as Tt, cZ as te, c8 as ut, s as le, W as O, ex as Le, a$ as A, b3 as z, U as ht, eg as ft, bR as L, gU as _t, e as I, y as v, c as K, bx as Ft, cw as Xe, b0 as kt, c5 as Mt, fS as Ct, aH as Pt, ad as Ot, j8 as $t, dL as mt, j9 as Dt, B as Be, aO as Nt, gX as Bt, ap as Et, cT as Jt, bj as At, k as zt, bO as Lt, c6 as he, o as Ht, ea as Wt, db as Gt, w as jt, a_ as qt } from "./index-4ead5b97.js";
+import { m as Ut } from "./MultiOriginJSONSupport-66a73b5d.js";
+import { l as Vt } from "./ArcGISService-16ef592c.js";
+import { n as Xt } from "./BlendLayer-f24275a8.js";
+import { e as Yt } from "./CustomParametersMixin-949de3be.js";
+import { c as Kt, N as Ee, l as Qt, d as Zt, a as ei, h as ti, K as Ye, B as Ke, S as ii, E as si, V as Qe, t as ni, p as ri, m as ai, b as oi } from "./ImageHistogramParameters-f0a6a74c.js";
+import { d as pt, c as li } from "./commonProperties-c36fc1b2.js";
+import { h as dt, D as yt, i as ci, a as ui, p as He, d as Ze, o as hi, f as et, g as fi } from "./multidimensionalUtils-8762b51c.js";
+import { S as mi, n as ge, m as We, L as pi, r as tt, a as xe, h as di, g as Ge, P as yi, b as gi, F as xi, U as wi, N as Ii, R as bi, c as we, B as Si, d as Ri, D as vi } from "./RasterSymbolizer-f981d3ba.js";
+import { i as it, m as st, x as nt, h as Ti, s as _i } from "./RawBlockCache-f74df003.js";
+import { U as ke, D as gt, R as Fi, a as ki, l as Mi, c as Ci, u as Y, f as Pi, s as Oi, d as $i, E as Di, W as Ni, T as Bi } from "./dataUtils-cb1ddea6.js";
+import { T as Je, D as Ie, j as rt, r as at, o as Ei, V as Me, J as ve, e as Ji, Z as Ai, C as zi, U as Ae } from "./rasterProjectionHelper-29c41430.js";
+import { d as _e } from "./FeatureSet-a2d35655.js";
+import { R as xt, f as Li, i as Hi, y as je, c as Wi, N as Gi } from "./utils-f5731fc4.js";
+import { u as ji } from "./OperationalLayer-2e935984.js";
+import { j as qi } from "./PortalLayer-15420854.js";
+import { f as Ui } from "./RefreshableLayer-f99ea584.js";
+import { t as Vi } from "./ScaleRangeLayer-6b36cfd2.js";
+import { f as Xi } from "./TemporalLayer-52d34fa2.js";
+import { T as Yi } from "./TilemapCache-ae840560.js";
+import { p as Ki } from "./popupUtils-3e3652c3.js";
+import { A as be } from "./interfaces-fac3cfda.js";
+import "vue";
+import "./jsonUtils-2a454e30.js";
+import "./parser-bab9c2ce.js";
+import "./UniqueValueRenderer-cc2c9298.js";
+import "./ColorStop-6fd09765.js";
+import "./diffUtils-f967bb01.js";
+import "./colorRamps-fedcdeb0.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-88773652.js";
+import "./lengthUtils-21f99608.js";
+import "./jsonUtils-0c0893e4.js";
+import "./styleUtils-b62393b9.js";
+import "./utils-8b01c610.js";
+import "./utils-b1ab6c91.js";
+import "./LRUCache-7a6c25d0.js";
+import "./MemCache-cfd09d4d.js";
+import "./ClassBreaksDefinition-a4abcf50.js";
+import "./ElevationInfo-c194d5f5.js";
+import "./unitConversionUtils-c6c847c9.js";
+import "./colorUtils-b3dcdea1.js";
+import "./vec42-689e76ac.js";
+import "./vec4f64-043e974c.js";
+import "./portalItemUtils-9fe0753b.js";
+import "./TimeInfo-8ce5e779.js";
+import "./ByteSizeUnit-90df2840.js";
+const ot = 8, Qi = 256;
+let Zi = 0, G = class extends vt(Ft) {
+  constructor() {
+    super(...arguments), this._tileFetchQueue = new Tt({ concurrency: 32, process: (i, e) => this._fetchRawTile(i.pyramidLevel, i.row, i.col, { ...i.options, signal: e }) }), this.datasetName = null, this.datasetFormat = null, this.hasUniqueSourceStorageInfo = !0, this.rasterInfo = null, this.ioConfig = { sampling: "closest" };
+  }
+  async init() {
+    const i = Je();
+    this.addResolvingPromise(i), await this.when();
+  }
+  normalizeCtorArgs(i) {
+    return i != null && i.ioConfig && (i = { ...i, ioConfig: { resolution: null, bandIds: null, sampling: "closest", tileInfo: te.create(), ...i.ioConfig } }), i;
+  }
+  get _isGlobalWrappableSource() {
+    const { rasterInfo: i } = this, e = Ie(i.spatialReference);
+    return e != null && i.extent.width >= e / 2;
+  }
+  get _hasNoneOrGCSShiftTransform() {
+    const { transform: i } = this.rasterInfo;
+    return i == null || i.type === "gcs-shift";
+  }
+  set rasterJobHandler(i) {
+    var e, n;
+    this._set("rasterJobHandler", i), this.datasetFormat === "Function" && ((n = (e = this.primaryRasters) == null ? void 0 : e.rasters) == null || n.forEach((t) => t.rasterJobHandler = i));
+  }
+  get rasterId() {
+    return this.url || "rasterId-" + Zi++;
+  }
+  set url(i) {
+    this._set("url", ut(i, le.getLogger(this)));
+  }
+  async open(i) {
+    throw new O("BaseRaster:open-not-implemented", "open() is not implemented");
+  }
+  async fetchTile(i, e, n, t = {}) {
+    const s = t.tileInfo || this.rasterInfo.storageInfo.tileInfo, a = this.getTileExtentFromTileInfo(i, e, n, s);
+    return t = { noClip: !0, ...t }, this.fetchPixels(a, s.size[0], s.size[1], t);
+  }
+  async identify(i, e = {}) {
+    var M;
+    i = Le(A, i).clone().normalize();
+    const { multidimensionalDefinition: n, timeExtent: t } = e, { rasterInfo: s } = this, { hasMultidimensionalTranspose: a, multidimensionalInfo: r } = s;
+    let { transposedVariableName: o } = e;
+    const l = r != null && a && (t != null || dt(n));
+    l && !o && (o = n != null && n.length > 0 ? n[0].variableName ?? void 0 : r.variables[0].name, e = { ...e, transposedVariableName: o }), e = this._getRequestOptionsWithSliceId(e);
+    const { spatialReference: c, extent: h } = s, { datumTransformation: u } = e;
+    let m = rt(i, c, u);
+    if (!h.intersects(m))
+      return { location: m, value: null };
+    if (s.transform != null) {
+      const P = s.transform.inverseTransform(m);
+      if (!s.nativeExtent.intersects(P))
+        return { location: P, value: null };
+      m = P;
+    }
+    let f = 0;
+    const d = o != null && r != null && s.hasMultidimensionalTranspose;
+    if (this.datasetFormat === "Function") {
+      const P = this.primaryRasters.rasters[0];
+      if (d)
+        return P.identify(m, e);
+      const { pixelSize: B } = s, C = 3, $ = B.x * C / 2, D = B.y * C / 2, E = new z({ xmin: m.x - $, xmax: m.x + $, ymin: m.y - D, ymax: m.y + D, spatialReference: c }), X = { interpolation: "nearest", multidimensionalDefinition: n, sliceId: e.sliceId }, { pixelBlock: H } = await P.fetchPixels(E, C, C, X), { pixelBlock: W } = await this.fetchPixels(E, C, C, X);
+      if (H == null)
+        return { location: m, value: null };
+      const q = Math.floor(C * C * 0.5), ee = !H.mask || H.mask[q] ? H.pixels.map((N) => N[q]) : null;
+      let U;
+      return W != null && (U = !W.mask || W.mask[q] ? W.pixels.map((N) => N[q]) : void 0), { location: m, value: ee, processedValue: U, pyramidLevel: 0 };
+    }
+    if (!d) {
+      if (e.srcResolution)
+        f = at(e.srcResolution, s, this.ioConfig.sampling).pyramidLevel;
+      else if (f = await this.computeBestPyramidLevelForLocation(i, e), f == null)
+        return { location: m, value: null };
+    }
+    const g = this.identifyPixelLocation(m, f, null, d);
+    if (g === null)
+      return { location: m, value: null };
+    const { row: p, col: y, rowOffset: x, colOffset: w, blockWidth: S } = g, T = o ?? e.sliceId, b = it(this.rasterId, T), _ = `${f}/${p}/${y}`;
+    let F = st(b, null, _);
+    F == null && (F = this.fetchRawTile(f, p, y, e), nt(b, null, _, F));
+    const R = await F;
+    if (!((M = R == null ? void 0 : R.pixels) != null && M.length))
+      return { location: m, value: null };
+    const k = x * S + w;
+    return this._processIdentifyResult(R, { srcLocation: m, position: k, pyramidLevel: f, useTransposedTile: !!d, requestSomeSlices: l, identifyOptions: e });
+  }
+  async fetchPixels(i, e, n, t = {}) {
+    i = Ei(i), t = this._getRequestOptionsWithSliceId(t);
+    const { _hasNoneOrGCSShiftTransform: s } = this;
+    if (t.requestRawData && s)
+      return this._fetchPixels(i, e, n, t);
+    const a = Ie(i.spatialReference), r = Me(i);
+    if (a == null || r === 0 || r === 1 && this._isGlobalWrappableSource && s)
+      return this._fetchPixels(i, e, n, t);
+    if (r >= 3)
+      return { extent: i, pixelBlock: null };
+    const o = [], { xmin: l, xmax: c } = i, h = Math.round(a / (c - l) * e), u = h - Math.round((a / 2 - l) / (c - l) * e);
+    let m = 0;
+    const f = [];
+    for (let y = 0; y <= r; y++) {
+      const x = new z({ xmin: y === 0 ? l : -a / 2, xmax: y === r ? c - a * y : a / 2, ymin: i.ymin, ymax: i.ymax, spatialReference: i.spatialReference }), w = y === 0 ? h - u : y === r ? e - m : h;
+      m += w, f.push(w);
+      const S = t.disableWrapAround && y > 0 ? null : this._fetchPixels(x, w, n, t);
+      o.push(S);
+    }
+    const d = (await Promise.all(o)).map((y) => y == null ? void 0 : y.pixelBlock);
+    let g = null;
+    const p = { width: e, height: n };
+    return this.rasterJobHandler ? g = (await this.rasterJobHandler.mosaicAndTransform({ srcPixelBlocks: d, srcMosaicSize: p, destDimension: null, coefs: null, sampleSpacing: null, interpolation: "nearest", alignmentInfo: null, blockWidths: f }, t)).pixelBlock : g = ke(d, p, { blockWidths: f }), { extent: i, srcExtent: ve(i, this.rasterInfo.spatialReference, t.datumTransformation), pixelBlock: g };
+  }
+  async fetchRawPixels(i, e, n, t = {}) {
+    e = { x: Math.floor(e.x), y: Math.floor(e.y) };
+    const s = await this._fetchRawTiles(i, e, n, t), { nativeExtent: a, nativePixelSize: r, storageInfo: o } = this.rasterInfo, l = 2 ** i, c = r.x * l, h = r.y * l, u = new z({ xmin: a.xmin + c * e.x, xmax: a.xmin + c * (e.x + n.width - 1), ymin: a.ymax - h * (e.y + n.height - 1), ymax: a.ymax - h * e.y, spatialReference: a.spatialReference });
+    if (!s)
+      return { extent: u, srcExtent: u, pixelBlock: null };
+    const { pixelBlocks: m, mosaicSize: f } = s;
+    if (m.length === 1 && m[0] != null && m[0].width === n.width && m[0].height === n.height)
+      return { extent: u, srcExtent: u, pixelBlock: s.pixelBlocks[0] };
+    const d = i > 0 ? o.pyramidBlockWidth : o.blockWidth, g = i > 0 ? o.pyramidBlockHeight : o.blockHeight, p = { x: e.x % d, y: e.y % g };
+    let y;
+    return this.rasterJobHandler ? y = (await this.rasterJobHandler.mosaicAndTransform({ srcPixelBlocks: m, srcMosaicSize: f, destDimension: n, clipOffset: p, clipSize: n, coefs: null, sampleSpacing: null, interpolation: t.interpolation, alignmentInfo: null, blockWidths: null }, t)).pixelBlock : y = ke(m, f, { clipOffset: p, clipSize: n }), { extent: u, srcExtent: u, pixelBlock: y };
+  }
+  fetchRawTile(i, e, n, t) {
+    throw new O("BaseRaster:read-not-implemented", "fetchRawTile() is not implemented");
+  }
+  computeExtent(i) {
+    return ve(this.rasterInfo.extent, i);
+  }
+  decodePixelBlock(i, e) {
+    return !this.rasterJobHandler || e.useCanvas ? mi(i, e) : this.rasterJobHandler.decode({ data: i, options: e });
+  }
+  async request(i, e, n = 0) {
+    const { customFetchParameters: t } = this.ioConfig, { range: s, query: a, headers: r } = e;
+    n = n ?? e.retryCount ?? this.ioConfig.retryCount;
+    const o = s ? { Range: `bytes=${s.from}-${s.to}` } : null;
+    try {
+      return await ht(i, { ...e, query: { ...a, ...t }, headers: { ...r, ...o } });
+    } catch (l) {
+      if (n > 0)
+        return n--, this.request(i, e, n);
+      throw l;
+    }
+  }
+  getSliceIndex(i) {
+    const { multidimensionalInfo: e } = this.rasterInfo;
+    return e == null || i == null || i.length === 0 ? null : yt(i, e);
+  }
+  getTileExtentFromTileInfo(i, e, n, t) {
+    const s = t.lodAt(i);
+    return this.getTileExtent({ x: s.resolution, y: s.resolution }, e, n, t.origin, t.spatialReference, t.size);
+  }
+  updateTileInfo() {
+    const { storageInfo: i, spatialReference: e, extent: n, pixelSize: t } = this.rasterInfo;
+    if (!i.tileInfo) {
+      const s = [], a = i.maximumPyramidLevel || 0;
+      let r = Math.max(t.x, t.y), o = 1 / 0.0254 * 96 * r;
+      for (let c = 0; c <= a; c++)
+        s.unshift(new ft({ level: a - c, resolution: r, scale: o })), r *= 2, o *= 2;
+      const l = new A({ x: n.xmin, y: n.ymax, spatialReference: e });
+      i.tileInfo = new te({ origin: l, size: [i.blockWidth, i.blockHeight], spatialReference: e, lods: s }), i.isVirtualTileInfo = !0;
+    }
+  }
+  createRemoteDatasetStorageInfo(i, e = 512, n = 512, t) {
+    const { width: s, height: a, nativeExtent: r, pixelSize: o, spatialReference: l } = i, c = new A({ x: r.xmin, y: r.ymax, spatialReference: l });
+    t == null && (t = Math.max(0, Math.round(Math.log(Math.max(s, a)) / Math.LN2 - 8)));
+    const h = this.computeBlockBoundary(r, 512, 512, { x: r.xmin, y: r.ymax }, [o], t);
+    i.storageInfo = new ge({ blockWidth: e, blockHeight: n, pyramidBlockWidth: e, pyramidBlockHeight: n, origin: c, firstPyramidLevel: 1, maximumPyramidLevel: t, blockBoundary: h });
+  }
+  async computeBestPyramidLevelForLocation(i, e = {}) {
+    return 0;
+  }
+  computeBlockBoundary(i, e, n, t, s, a = 0, r = 2) {
+    if (s.length === 1 && a > 0) {
+      s = [...s];
+      let { x: h, y: u } = s[0];
+      for (let m = 0; m < a; m++)
+        h *= r, u *= r, s.push({ x: h, y: u });
+    }
+    const o = [], { x: l, y: c } = t;
+    for (let h = 0; h < s.length; h++) {
+      const { x: u, y: m } = s[h];
+      o.push({ minCol: Math.floor((i.xmin - l + 0.1 * u) / e / u), maxCol: Math.floor((i.xmax - l - 0.1 * u) / e / u), minRow: Math.floor((c - i.ymax + 0.1 * m) / n / m), maxRow: Math.floor((c - i.ymin - 0.1 * m) / n / m) });
+    }
+    return o;
+  }
+  getPyramidPixelSize(i) {
+    const { nativePixelSize: e } = this.rasterInfo, { pyramidResolutions: n, pyramidScalingFactor: t } = this.rasterInfo.storageInfo;
+    if (i === 0)
+      return e;
+    if (n != null && n.length)
+      return n[i - 1];
+    const s = t ** i;
+    return { x: e.x * s, y: e.y * s };
+  }
+  identifyPixelLocation(i, e, n, t) {
+    const { spatialReference: s, nativeExtent: a, storageInfo: r } = this.rasterInfo, { maximumPyramidLevel: o, origin: l, transposeInfo: c } = r, h = t && c != null ? c.tileSize[0] : r.blockWidth, u = t && c != null ? c.tileSize[1] : r.blockHeight, m = rt(i, s, n);
+    if (!a.intersects(m) || e < 0 || e > o)
+      return null;
+    const f = this.getPyramidPixelSize(e), { x: d, y: g } = f, p = (l.y - m.y) / g / u, y = (m.x - l.x) / d / h, x = Math.min(u - 1, Math.floor((p - Math.floor(p)) * u)), w = Math.min(h - 1, Math.floor((y - Math.floor(y)) * h));
+    return { pyramidLevel: e, row: Math.floor(p), col: Math.floor(y), rowOffset: x, colOffset: w, blockWidth: h, srcLocation: m };
+  }
+  getTileExtent(i, e, n, t, s, a) {
+    const [r, o] = a, l = t.x + n * r * i.x, c = l + r * i.x, h = t.y - e * o * i.y, u = h - o * i.y;
+    return new z({ xmin: l, xmax: c, ymin: u, ymax: h, spatialReference: s });
+  }
+  getBlockWidthHeight(i) {
+    return { blockWidth: i > 0 ? this.rasterInfo.storageInfo.pyramidBlockWidth : this.rasterInfo.storageInfo.blockWidth, blockHeight: i > 0 ? this.rasterInfo.storageInfo.pyramidBlockHeight : this.rasterInfo.storageInfo.blockHeight };
+  }
+  isBlockOutside(i, e, n) {
+    const t = this.rasterInfo.storageInfo.blockBoundary[i];
+    return !t || t.maxRow < e || t.maxCol < n || t.minRow > e || t.minCol > n;
+  }
+  updateImageSpaceRasterInfo(i) {
+    const { extent: e, pixelSize: n } = i;
+    if (e.xmin === -0.5 && e.ymax === 0.5 && n.x === 1 && n.y === 1 && i.transform == null)
+      return;
+    const { width: t, height: s } = i, a = L.WebMercator;
+    i.spatialReference = a, i.extent = i.nativeExtent = new z({ xmin: -0.5, ymax: 0.5, xmax: t - 0.5, ymin: 0.5 - s, spatialReference: a }), i.isPseudoSpatialReference = !0, i.transform = null, i.pixelSize = new A({ x: 1, y: 1, spatialReference: a });
+    const { extent: r, storageInfo: o } = i;
+    if (o) {
+      o.origin = new A({ x: r.xmin, y: r.ymax, spatialReference: a });
+      const { tileInfo: l } = o;
+      if (l) {
+        l.origin = o.origin;
+        const c = (i.nativePixelSize.x + i.nativePixelSize.y) / 2;
+        l.lods.forEach((h, u) => {
+          h.resolution = c * 2 ** u, h.scale = 96 * h.resolution / 0.0254;
+        });
+      }
+    }
+  }
+  async _fetchPixels(i, e, n, t = {}) {
+    let s = Me(i);
+    if (s >= 2)
+      return { extent: i, pixelBlock: null };
+    const a = this._getSourceDataInfo(i, e, n, t), { pyramidLevel: r, srcResolution: o, srcExtent: l, srcWidth: c, srcHeight: h, ul: u } = a;
+    if (c === 0 || h === 0)
+      return { extent: i, srcExtent: l, pixelBlock: null };
+    const { rasterInfo: m } = this, f = m.transform, d = (f == null ? void 0 : f.type) === "gcs-shift", g = Ie(i.spatialReference) != null;
+    !d && g || (s = Me(a.srcExtent, d));
+    const p = await this._fetchRawTiles(r, u, { width: c, height: h, wrapCount: s }, t);
+    if (!p)
+      return { extent: i, srcExtent: l, pixelBlock: null };
+    const y = m.storageInfo, x = r > 0 ? y.pyramidBlockWidth : y.blockWidth, w = r > 0 ? y.pyramidBlockHeight : y.blockHeight;
+    let { x: S, y: T } = m.pixelSize;
+    if (r > 0) {
+      const { pyramidResolutions: N, pyramidScalingFactor: Rt } = y;
+      if (N != null && N[r - 1])
+        ({ x: S, y: T } = N[r - 1]);
+      else {
+        const Ve = Rt ** r;
+        S *= Ve, T *= Ve;
+      }
+    }
+    const b = m.spatialReference, _ = new A({ x: S, y: T, spatialReference: b }), F = x === c && w === h && u.x % x == 0 && u.y % w == 0, R = new A({ x: (i.xmax - i.xmin) / e, y: (i.ymax - i.ymin) / n, spatialReference: i.spatialReference }), k = !i.spatialReference.equals(b), M = b.isGeographic ? 1e-9 : 1e-4, { datumTransformation: P } = t;
+    if (!k && F && p.pixelBlocks.length === 1 && x === e && w === n && this._isSameResolution(o, R, M))
+      return { extent: i, srcExtent: l, srcTilePixelSize: _, pixelBlock: p.pixelBlocks[0] };
+    const B = g && Ie(l.spatialReference) != null && this._hasNoneOrGCSShiftTransform, C = t.requestProjectedLocalDirections && this.rasterInfo.dataType.startsWith("vector");
+    C && !this.rasterJobHandler && await Je();
+    const $ = this.rasterJobHandler ? await this.rasterJobHandler.getProjectionOffsetGrid({ projectedExtent: i, srcBufferExtent: p.extent, pixelSize: R.toJSON(), datumTransformation: P, rasterTransform: f, hasWrapAround: s > 0 || B, isAdaptive: this.ioConfig.optimizeProjectionAccuracy !== !1, includeGCSGrid: C }, t) : Ji({ projectedExtent: i, srcBufferExtent: p.extent, pixelSize: R, datumTransformation: P, rasterTransform: f, hasWrapAround: s > 0 || B, isAdaptive: !1, includeGCSGrid: C });
+    let D;
+    const E = !t.requestRawData, X = { rows: $.spacing[0], cols: $.spacing[1] }, H = this._hasNoneOrGCSShiftTransform ? this._getRasterTileAlignmentInfo(r, p.extent.xmin) : void 0, { pixelBlocks: W, mosaicSize: q, isPartiallyFilled: ee } = p;
+    let U = null;
+    if (this.rasterJobHandler)
+      ({ pixelBlock: D, localNorthDirections: U } = await this.rasterJobHandler.mosaicAndTransform({ srcPixelBlocks: W, srcMosaicSize: q, destDimension: E ? { width: e, height: n } : null, coefs: E ? $.coefficients : null, sampleSpacing: E ? X : null, projectDirections: C, gcsGrid: C ? $.gcsGrid : null, isUV: this.rasterInfo.dataType === "vector-uv", interpolation: t.interpolation, alignmentInfo: H, blockWidths: null }, t));
+    else {
+      const N = ke(W, q, { alignmentInfo: H });
+      D = E ? gt(N, { width: e, height: n }, $.coefficients, X, t.interpolation) : N, C && $.gcsGrid && (U = Fi({ width: e, height: n }, $.gcsGrid), D = ki(D, this.rasterInfo.dataType, U));
+    }
+    return t.requestRawData || C ? { extent: i, srcExtent: l, srcTilePixelSize: _, pixelBlock: D, transformGrid: $, localNorthDirections: U, isPartiallyFilled: ee } : { extent: i, srcExtent: l, srcTilePixelSize: _, pixelBlock: D };
+  }
+  async _fetchRawTiles(i, e, n, t) {
+    const { origin: s, blockBoundary: a } = this.rasterInfo.storageInfo, { blockWidth: r, blockHeight: o } = this.getBlockWidthHeight(i);
+    let { x: l, y: c } = e, { width: h, height: u, wrapCount: m } = n;
+    const f = this._getRasterTileAlignmentInfo(i, 0);
+    t.buffer && (l -= t.buffer.cols, c -= t.buffer.rows, h += 2 * t.buffer.cols, u += 2 * t.buffer.rows);
+    let d = 0, g = 0, p = 0;
+    m && f != null && ({ worldColumnCountFromOrigin: g, originColumnOffset: p, rightPadding: d } = f, g * f.blockWidth - d >= l + h && (d = 0));
+    const y = Math.floor(l / r), x = Math.floor(c / o), w = Math.floor((l + h + d - 1) / r), S = Math.floor((c + u + d - 1) / o), T = a[i];
+    if (!T)
+      return null;
+    const { minRow: b, minCol: _, maxCol: F, maxRow: R } = T;
+    if (m === 0 && (S < b || w < _ || x > R || y > F))
+      return null;
+    const k = new Array();
+    let M = !1;
+    const P = this.ioConfig.allowPartialFill == null ? t.allowPartialFill : this.ioConfig.allowPartialFill;
+    for (let H = x; H <= S; H++)
+      for (let W = y; W <= w; W++) {
+        let q = W;
+        if (!t.disableWrapAround && m && f != null && g <= W && (q = W - g - p), H >= b && q >= _ && R >= H && F >= q) {
+          const ee = this._tileFetchQueue.push({ pyramidLevel: i, row: H, col: q, options: t }, { signal: t.signal });
+          P ? k.push(new Promise((U) => {
+            ee.then((N) => U(N)).catch(() => {
+              M = !0, U(null);
+            });
+          })) : k.push(ee);
+        } else
+          k.push(Promise.resolve(null));
+      }
+    if (k.length === 0)
+      return null;
+    const B = await Promise.all(k), C = { height: (S - x + 1) * o, width: (w - y + 1) * r }, { spatialReference: $ } = this.rasterInfo, D = this.getPyramidPixelSize(i), { x: E, y: X } = D;
+    return { extent: new z({ xmin: s.x + y * r * E, xmax: s.x + (w + 1) * r * E, ymin: s.y - (S + 1) * o * X, ymax: s.y - x * o * X, spatialReference: $ }), pixelBlocks: B, mosaicSize: C, isPartiallyFilled: M };
+  }
+  _isSameResolution(i, e, n) {
+    return Math.abs(i.x - e.x) < n && Math.abs(i.y - e.y) < n;
+  }
+  _fetchRawTile(i, e, n, t) {
+    const s = this.rasterInfo.storageInfo.blockBoundary[i];
+    if (!s)
+      return Promise.resolve(null);
+    const { minRow: a, minCol: r, maxCol: o, maxRow: l } = s;
+    if (e < a || n < r || e > l || n > o)
+      return Promise.resolve(null);
+    const c = it(this.rasterId, t.sliceId), h = `${i}/${e}/${n}`;
+    let u = st(c, t.registryId, h);
+    if (u == null) {
+      const m = new AbortController();
+      u = this.fetchRawTile(i, e, n, { ...t, signal: m.signal }), nt(c, t.registryId, h, u, m), u.catch(() => Ti(c, t.registryId, h));
+    }
+    return t.signal && _t(t, () => {
+      _i(c, t.registryId, h);
+    }), u;
+  }
+  _computeMagDirValues(i) {
+    var l;
+    const { bandCount: e, dataType: n } = this.rasterInfo;
+    if (!(e === 2 && n === "vector-magdir" || n === "vector-uv") || (i == null ? void 0 : i.length) !== 2 || !((l = i[0]) != null && l.length))
+      return null;
+    const t = i[0].length;
+    if (n === "vector-magdir") {
+      const c = i[1].map((h) => (h + 360) % 360);
+      return [i[0], c];
+    }
+    const [s, a] = i, r = [], o = [];
+    for (let c = 0; c < t; c++) {
+      const [h, u] = Mi([s[c], a[c]]);
+      r.push(h), o.push(u);
+    }
+    return [r, o];
+  }
+  _getRasterTileAlignmentInfo(i, e) {
+    return this._rasterTileAlignmentInfo == null && (this._rasterTileAlignmentInfo = Ai(this.rasterInfo)), this._rasterTileAlignmentInfo.pyramidsInfo == null ? null : { startX: e, halfWorldWidth: this._rasterTileAlignmentInfo.halfWorldWidth, hasGCSSShiftTransform: this._rasterTileAlignmentInfo.hasGCSSShiftTransform, ...this._rasterTileAlignmentInfo.pyramidsInfo[i] };
+  }
+  _getSourceDataInfo(i, e, n, t = {}) {
+    const s = { datumTransformation: t.datumTransformation, pyramidLevel: 0, pyramidResolution: null, srcExtent: null, srcHeight: 0, srcResolution: null, srcWidth: 0, ul: { x: 0, y: 0 } };
+    t.srcResolution && (s.srcResolution = t.srcResolution, this._updateSourceDataInfo(i, s));
+    const a = this.rasterInfo.storageInfo.maximumPyramidLevel || 0, { srcWidth: r, srcHeight: o, pyramidLevel: l } = s, c = r / e, h = o / n, u = l < a && c * h >= 16, m = l === a && this._requireTooManySrcTiles(r, o, e, n);
+    if (u || m || r === 0 || o === 0) {
+      const f = new A({ x: (i.xmax - i.xmin) / e, y: (i.ymax - i.ymin) / n, spatialReference: i.spatialReference });
+      let d = zi(f, this.rasterInfo.spatialReference, i, s.datumTransformation);
+      const g = !d || t.srcResolution && d.x + d.y < t.srcResolution.x + t.srcResolution.y;
+      if (u && t.srcResolution && g) {
+        const p = Math.round(Math.log(Math.max(c, h)) / Math.LN2) - 1;
+        if (a - l + 3 >= p) {
+          const y = 2 ** p;
+          d = { x: t.srcResolution.x * y, y: t.srcResolution.y * y };
+        }
+      }
+      d && (s.srcResolution = d, this._updateSourceDataInfo(i, s));
+    }
+    return this._requireTooManySrcTiles(s.srcWidth, s.srcHeight, e, n) && (s.srcWidth = 0, s.srcHeight = 0), s;
+  }
+  _requireTooManySrcTiles(i, e, n, t) {
+    const { tileInfo: s } = this.rasterInfo.storageInfo, a = Math.ceil(i / s.size[0]) * Math.ceil(e / s.size[1]), r = i / n, o = e / t, l = Math.max(1, (n + t) / 1024);
+    return a >= Qi * l || r > ot || o > ot;
+  }
+  _updateSourceDataInfo(i, e) {
+    e.srcWidth = 0, e.srcHeight = 0;
+    const { rasterInfo: n } = this, t = n.spatialReference, { srcResolution: s, datumTransformation: a } = e, { pyramidLevel: r, pyramidResolution: o, excessiveReading: l } = at(s, n, this.ioConfig.sampling);
+    if (l)
+      return;
+    let c = e.srcExtent || ve(i, t, a);
+    if (c == null)
+      return;
+    const h = n.transform;
+    h && (c = h.inverseTransform(c)), e.srcExtent = c;
+    const { x: u, y: m } = n.storageInfo.origin, f = Math.floor((c.xmin - u) / o.x + 0.1), d = Math.floor((m - c.ymax) / o.y + 0.1), g = Math.floor((c.xmax - u) / o.x - 0.1), p = Math.floor((m - c.ymin) / o.y - 0.1), y = c.width < 0.1 * o.x ? 0 : g - f + 1, x = c.height < 0.1 * o.y ? 0 : p - d + 1;
+    e.pyramidLevel = r, e.pyramidResolution = o, e.srcWidth = y, e.srcHeight = x, e.ul = { x: f, y: d };
+  }
+  _getRequestOptionsWithSliceId(i) {
+    return this.rasterInfo.multidimensionalInfo != null && i.sliceId == null && (i = { ...i, sliceId: this.getSliceIndex(i.multidimensionalDefinition) }), i;
+  }
+  _processIdentifyResult(i, e) {
+    const { srcLocation: n, position: t, pyramidLevel: s, useTransposedTile: a } = e, r = i.pixels[0].length / i.width / i.height;
+    if (!(!i.mask || i.mask[t]))
+      return { location: n, value: null };
+    const { multidimensionalInfo: o } = this.rasterInfo;
+    if (o == null || !a) {
+      const p = i.pixels.map((w) => w[t]), y = { location: n, value: p, pyramidLevel: s }, x = this._computeMagDirValues(p.map((w) => [w]));
+      return x != null && x.length && (y.magdirValue = x.map((w) => w[0])), y;
+    }
+    let l = i.pixels.map((p) => p.slice(t * r, t * r + r)), c = this._computeMagDirValues(l);
+    const { requestSomeSlices: h, identifyOptions: u } = e;
+    let m = ci(o, u.transposedVariableName);
+    if (h) {
+      const p = ui(m, u.multidimensionalDefinition, u.timeExtent);
+      l = l.map((y) => p.map((x) => y[x])), c = c == null ? void 0 : c.map((y) => p.map((x) => y[x])), m = p.map((y) => m[y]);
+    }
+    const f = i.noDataValues || this.rasterInfo.noDataValue, d = { pixels: l, pixelType: i.pixelType };
+    let g;
+    return f != null && (Ci(d, f), g = d.mask), { location: n, value: null, dataSeries: m.map((p, y) => {
+      const x = { value: (g == null ? void 0 : g[y]) === 0 ? null : l.map((w) => w[y]), multidimensionalDefinition: p.multidimensionalDefinition.map((w) => new He({ ...w, isSlice: !0 })) };
+      return c != null && c.length && (x.magdirValue = [c[0][y], c[1][y]]), x;
+    }), pyramidLevel: s };
+  }
+};
+I([v()], G.prototype, "_rasterTileAlignmentInfo", void 0), I([v()], G.prototype, "_tileFetchQueue", void 0), I([v({ readOnly: !0 })], G.prototype, "_isGlobalWrappableSource", null), I([v({ readOnly: !0 })], G.prototype, "_hasNoneOrGCSShiftTransform", null), I([v()], G.prototype, "rasterJobHandler", null), I([v({ readOnly: !0 })], G.prototype, "rasterId", null), I([v(pt)], G.prototype, "url", null), I([v({ type: String, json: { write: !0 } })], G.prototype, "datasetName", void 0), I([v({ type: String, json: { write: !0 } })], G.prototype, "datasetFormat", void 0), I([v()], G.prototype, "hasUniqueSourceStorageInfo", void 0), I([v()], G.prototype, "rasterInfo", void 0), I([v()], G.prototype, "ioConfig", void 0), I([v()], G.prototype, "sourceJSON", void 0), G = I([K("esri.layers.support.rasterDatasets.BaseRaster")], G);
+const se = G;
+function es(i, e) {
+  if (i.spatialReference.equals(e))
+    return i;
+  const n = Xe(i.spatialReference), t = Xe(e);
+  if (n === t)
+    return i;
+  const s = n / t;
+  return { x: i.x * s, y: i.y * s };
+}
+async function ze(i, e, n) {
+  if (n.type === "extent")
+    return is(i, e, n);
+  const { width: t, height: s } = i, a = new Uint8Array(t * s), { contains: r, intersects: o } = await import("./geometryEngine-7390e3b3.js");
+  return o(e, n) ? n.type === "polyline" ? ss(i, e, n) : r(n, e) ? i : ts(i, e, n) : new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, maskIsAlpha: !1, pixels: [...i.pixels] });
+}
+function ts(i, e, n) {
+  if (!i)
+    return i;
+  const { width: t, height: s } = i, a = e.width / t, r = e.height / s, { xmin: o, ymax: l } = e;
+  let c;
+  if (n.type === "extent") {
+    const p = (n.xmin - o) / a, y = (n.xmax - o) / a, x = (l - n.ymax) / r, w = (l - n.ymin) / r;
+    c = [[[p, x], [p, w], [y, w], [y, x], [p, x]]];
+  } else
+    c = n.rings.map((p) => p.map(([y, x]) => [(y - o) / a, (l - x) / r]));
+  const h = document.createElement("canvas");
+  h.width = t, h.height = s;
+  const u = h.getContext("2d");
+  u.fillStyle = "#f00", u.beginPath(), c.forEach((p) => {
+    u.moveTo(p[0][0], p[0][1]);
+    for (let y = 0; y < p.length; y++)
+      u.lineTo(p[y][0], p[y][1]);
+    u.closePath();
+  }), u.fill();
+  const m = u.getImageData(0, 0, t, s).data, f = i.mask, d = t * s, g = new Uint8Array(d);
+  for (let p = 0; p < d; p++)
+    f && !f[p] || (g[p] = m[4 * p + 3] > 127 ? 255 : 0);
+  return new Y({ pixelType: i.pixelType, width: t, height: s, mask: g, maskIsAlpha: !1, pixels: [...i.pixels] });
+}
+function is(i, e, n) {
+  const { width: t, height: s } = i, a = new Uint8Array(t * s), r = e.width / t, o = e.height / s;
+  if (n.width / r < 0.5 || n.height / o < 0.5)
+    return new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, pixels: [...i.pixels] });
+  const { xmin: l, xmax: c, ymin: h, ymax: u } = e, { xmin: m, xmax: f, ymin: d, ymax: g } = n, p = Math.max(l, m), y = Math.min(c, f), x = Math.max(h, d), w = Math.min(u, g), S = 0.5 * r, T = 0.5 * o;
+  if (y - p < S || w - x < T || y < l + S || p > c - S || x > u - T || w < h + T)
+    return new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, pixels: [...i.pixels] });
+  const b = Math.max(0, (p - l) / r), _ = Math.min(t, Math.max(0, (y - l) / r)), F = Math.max(0, (u - w) / o), R = Math.min(s, Math.max(0, (u - x) / o)), k = Math.round(b), M = Math.round(_) - 1, P = Math.round(F), B = Math.round(R) - 1;
+  if (k === M && b % 1 > 0.5 && _ % 1 < 0.5 || P === B && F % 1 > 0.5 && R % 1 < 0.5)
+    return new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, pixels: [...i.pixels] });
+  if (k === 0 && P === 0 && M === t && B === s)
+    return i;
+  const C = i.mask;
+  for (let $ = P; $ <= B; $++)
+    for (let D = k; D <= M; D++) {
+      const E = $ * t + D;
+      a[E] = C ? C[E] : 255;
+    }
+  return new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, pixels: [...i.pixels] });
+}
+function ss(i, e, n) {
+  const { width: t, height: s } = i, a = new Uint8Array(t * s), r = e.width / t, o = e.height / s, { xmin: l, ymax: c } = e, { paths: h } = n, u = i.mask;
+  for (let m = 0; m < h.length; m++) {
+    const f = h[m];
+    for (let d = 0; d < f.length - 1; d++) {
+      const [g, p] = f[d], [y, x] = f[d + 1];
+      let w = Math.floor((c - p) / o), S = Math.floor((c - x) / o);
+      if (S < w) {
+        const b = w;
+        w = S, S = b;
+      }
+      w = Math.max(0, w), S = Math.min(s - 1, S);
+      const T = (y - g) / (x - p);
+      for (let b = w; b <= S; b++) {
+        const _ = b === w ? Math.max(p, x) : (s + 1 - b) * o, F = b === S ? Math.min(p, x) : _ - o;
+        let R = Math.floor(x === p ? (g - l) / r : (T * (_ - p) + g - l) / r), k = Math.floor(x === p ? (y - l) / r : (T * (F - p) + g - l) / r);
+        if (k < R) {
+          const P = R;
+          R = k, k = P;
+        }
+        const M = b * t;
+        R = Math.max(0, R), k = Math.min(t - 1, k);
+        for (let P = M + R; P <= M + k; P++)
+          a[P] = u ? u[P] : 255;
+      }
+    }
+  }
+  return new Y({ pixelType: i.pixelType, width: t, height: s, mask: a, pixels: [...i.pixels] });
+}
+function ns(i, e, n, t = !0) {
+  const { spatialReference: s } = i, { x: a, y: r } = es(n, s);
+  let o, l, c;
+  const h = e.type === "extent" ? e : e.extent;
+  let { xmin: u, xmax: m, ymax: f, ymin: d } = h;
+  const { xmin: g, ymax: p } = i.extent;
+  return t ? (u = g + (u > g ? a * Math.round((u - g) / a) : 0), f = p - (f < p ? r * Math.round((p - f) / r) : 0), m = g + (m > g ? a * Math.round((m - g) / a) : 0), d = p - (d < p ? r * Math.round((p - d) / r) : 0), o = new z({ xmin: u, ymax: f, xmax: m, ymin: d, spatialReference: s }), l = Math.round(o.width / a), c = Math.round(o.height / r)) : (l = Math.floor((m - u) / a + 0.8), c = Math.floor((f - d) / r + 0.8), u = g + (u > g ? a * Math.floor((u - g) / a + 0.1) : 0), f = p - (f < p ? r * Math.floor((p - f) / r + 0.1) : 0), m = u + l * a, d = f - c * r, o = new z({ xmin: u, ymax: f, xmax: m, ymin: d, spatialReference: s })), { extent: o, width: l, height: c };
+}
+const rs = 40;
+let ne = class extends se {
+  constructor() {
+    super(...arguments), this.datasetFormat = "Function", this.tileType = "Raster", this.rasterFunction = null, this._clippingGeometry = /* @__PURE__ */ new Map();
+  }
+  async open(e) {
+    var h, u, m, f;
+    await this.init();
+    const { rasterFunction: n } = this;
+    (u = (h = this.primaryRasters) == null ? void 0 : h.rasters) != null && u.length ? n.sourceRasters = this.primaryRasters.rasters : (this.primaryRasters = n.getPrimaryRasters(), this.rasterJobHandler && ((m = this.primaryRasters.rasters) == null || m.forEach((d) => d.rasterJobHandler = this.rasterJobHandler)));
+    const { rasters: t, rasterIds: s } = this.primaryRasters, a = t.map((d) => d.rasterInfo ? void 0 : d.open(e));
+    await Promise.all(a);
+    const r = t.map(({ rasterInfo: d }) => d), o = n.bind({ rasterInfos: r, rasterIds: s });
+    if (n.rawSourceRasterInfos = r, !o.success || r.length === 0)
+      throw new O("raster-function:open", `cannot bind the function: ${o.error ?? ""}`);
+    const l = n.functionName === "Table" ? n : (f = n.functionArguments) == null ? void 0 : f.raster;
+    (l == null ? void 0 : l.functionName) === "Table" && (n.rasterInfo.attributeTable = _e.fromJSON(l.functionArguments.attributeTableAsRecordSet)), await this.syncJobHandler();
+    const c = r[0];
+    this.hasUniqueSourceStorageInfo = r.length === 1 || r.slice(1).every((d) => this._hasSameStorageInfo(d, c)), this.set("sourceJSON", t[0].sourceJSON), this.set("rasterInfo", n.rasterInfo), await this._updateClipGeometry();
+  }
+  async syncJobHandler() {
+    var e;
+    return (e = this.rasterJobHandler) == null ? void 0 : e.updateRasterFunction(this.rasterFunction);
+  }
+  async fetchPixels(e, n, t, s = {}) {
+    var S, T;
+    const { rasters: a, rasterIds: r } = this.primaryRasters;
+    let o = !1;
+    const { interpolation: l } = s, c = (S = this.rasterFunction.flatWebGLFunctionChain) == null ? void 0 : S.hasFocalFunction;
+    !s.requestRawData && c && (o = a.length === 1 && !s.skipRasterFunction, s = { ...s, interpolation: "bilinear", requestRawData: o });
+    const h = a.map((b) => b.fetchPixels(e, n, t, s)), u = await Promise.all(h), m = u.map((b) => b.pixelBlock), f = o || s.requestRawData ? u.map((b) => b.srcTilePixelSize) : null;
+    if (s.skipRasterFunction || m.every((b) => b == null))
+      return u[0];
+    const d = ((T = u.find((b) => b.pixelBlock != null)) == null ? void 0 : T.extent) ?? e;
+    let g = this.rasterJobHandler ? await this.rasterJobHandler.process({ extent: d, primaryPixelBlocks: m, primaryPixelSizes: f, primaryRasterIds: r }) : this.rasterFunction.process({ extent: d, primaryPixelBlocks: m, primaryPixelSizes: f, primaryRasterIds: r });
+    const { transformGrid: p } = u[0];
+    if (!o || g == null || p == null) {
+      const b = s.noClip ? null : this.getClippingGeometry(d.spatialReference);
+      return s.noClip || s.requestRawData || g == null || !b || (g = await ze(g, d, b)), { ...u[0], pixelBlock: g };
+    }
+    const y = { rows: p.spacing[0], cols: p.spacing[1] };
+    let x;
+    this.rasterJobHandler ? x = (await this.rasterJobHandler.mosaicAndTransform({ srcPixelBlocks: [g], srcMosaicSize: { width: g.width, height: g.height }, destDimension: { width: n, height: t }, coefs: p.coefficients, sampleSpacing: y, projectDirections: !1, gcsGrid: null, isUV: !1, interpolation: l, alignmentInfo: void 0, blockWidths: null }, s)).pixelBlock : x = gt(g, { width: n, height: t }, p.coefficients, y, l);
+    const w = s.noClip ? null : this.getClippingGeometry(e.spatialReference);
+    return s.noClip || s.requestRawData || x == null || w == null || (x = await ze(x, e, w)), { extent: e, srcExtent: u[0].srcExtent, pixelBlock: x };
+  }
+  getClippingGeometry(e) {
+    const n = this._clippingGeometry.get("0");
+    if (!e || !n)
+      return n;
+    const t = this._getSRKey(e);
+    let s = this._clippingGeometry.get(t);
+    return s != null || (s = e.equals(n.spatialReference) ? n : Ae(n, e), this._clippingGeometry.set(t, s)), s;
+  }
+  _hasSameStorageInfo(e, n) {
+    const { storageInfo: t, pixelSize: s, spatialReference: a, extent: r } = e, { storageInfo: o, pixelSize: l, spatialReference: c, extent: h } = n;
+    return s.x === l.x && s.y === l.y && a.equals(c) && r.equals(h) && t.blockHeight === o.blockHeight && t.blockWidth === o.blockWidth && t.maximumPyramidLevel === o.maximumPyramidLevel;
+  }
+  async _updateClipGeometry() {
+    const e = this.rasterFunction.getClippingGeometries()[0];
+    let n = e == null ? void 0 : e.clippingGeometry;
+    if (n && e.clippingType === "inside") {
+      const { extent: t } = this.rasterInfo, { difference: s, densify: a } = await import("./geometryEngine-7390e3b3.js");
+      let r = a(kt.fromExtent(t), 2 * (t.width + t.height) / rs);
+      r = Ae(r, n.spatialReference), n = s(r, n);
+    }
+    this._clippingGeometry.clear(), n && this._clippingGeometry.set("0", n);
+  }
+  _getSRKey(e) {
+    return String(e.wkid ?? e.wkt ?? e.wkt2);
+  }
+};
+I([v({ type: String, json: { write: !0 } })], ne.prototype, "datasetFormat", void 0), I([v()], ne.prototype, "tileType", void 0), I([v()], ne.prototype, "rasterFunction", void 0), I([v()], ne.prototype, "primaryRasters", void 0), ne = I([K("esri.layers.support.rasterDatasets.FunctionRaster")], ne);
+const wt = ne, as = (i) => {
+  let e = class extends i {
+    constructor(...t) {
+      var s, a;
+      super(...t), this._isConstructedFromFunctionRaster = !1, this._rasterJobHandler = { instance: null, refCount: 0, connectionPromise: null }, this.bandIds = null, this.copyright = null, this.interpolation = "nearest", this.multidimensionalSubset = null, this.raster = null, this.serviceRasterInfo = null, this.sourceJSON = null, this.spatialReference = null, this.symbolizer = null, this._isConstructedFromFunctionRaster = ((a = (s = t[0]) == null ? void 0 : s.raster) == null ? void 0 : a.datasetFormat) === "Function";
+    }
+    get fullExtent() {
+      var t;
+      return (t = this.serviceRasterInfo) == null ? void 0 : t.extent;
+    }
+    set multidimensionalDefinition(t) {
+      this._set("multidimensionalDefinition", t), this.updateRenderer();
+    }
+    set rasterFunction(t) {
+      var s;
+      ((s = t == null ? void 0 : t.functionName) == null ? void 0 : s.toLowerCase()) === "none" && (t = void 0), this._set("rasterFunction", t), this.updateRasterFunction();
+    }
+    get rasterInfo() {
+      return Ct(le.getLogger(this), "rasterInfo", { replacement: "serviceRasterInfo", version: "4.29", warnOnce: !0 }), this._get("serviceRasterInfo");
+    }
+    set url(t) {
+      this._set("url", ut(t, le.getLogger(this)));
+    }
+    set renderer(t) {
+      t == null && this.rasterFunction == null ? this._configDefaultRenderer("override") : (this._set("renderer", t), this.updateRenderer());
+    }
+    readRenderer(t, s, a) {
+      var o, l;
+      const r = (l = (o = s == null ? void 0 : s.layerDefinition) == null ? void 0 : o.drawingInfo) == null ? void 0 : l.renderer;
+      return ei(r, a) || void 0;
+    }
+    async convertVectorFieldData(t, s) {
+      const { serviceRasterInfo: a } = this;
+      if (t == null || !a)
+        return null;
+      const r = this._rasterJobHandler.instance, o = a.dataType;
+      return r ? r.convertVectorFieldData({ pixelBlock: t, dataType: o }, s) : Pi(t, o);
+    }
+    async computeStatisticsHistograms(t, s) {
+      t = Le(ti, t).clone();
+      const { serviceRasterInfo: a } = this, { geometry: r } = t;
+      if (r == null)
+        throw new O("imagery-tile-mixin:compute-statistics-histograms", "geometry must be specified");
+      let o = r;
+      const { spatialReference: l } = a;
+      r.spatialReference.equals(l) || (await Je(), o = r.type === "extent" ? ve(r, l) : Ae(r, l));
+      const c = t.pixelSize ?? new A({ x: a.pixelSize.x, y: a.pixelSize.y, spatialReference: l }), { extent: h, width: u, height: m } = ns(a, o, c), f = await this.fetchPixels(h, u, m, { ...s, interpolation: "nearest" });
+      if (f.pixelBlock == null)
+        throw new O("imagery-tile-mixin:compute-statistics-histograms", "failed to fetch pixels");
+      const d = await ze(f.pixelBlock, h, o), g = this._rasterJobHandler.instance;
+      return g ? g.computeStatisticsHistograms({ pixelBlock: d }, s) : We(d);
+    }
+    async createFlowMesh(t, s) {
+      const a = this._rasterJobHandler.instance;
+      return a ? a.createFlowMesh(t, s) : Oi(t.meshType, t.simulationSettings, t.flowData, s.signal != null ? s.signal : new AbortController().signal);
+    }
+    normalizeRasterFetchOptions(t) {
+      var o, l;
+      const { multidimensionalInfo: s } = this.serviceRasterInfo ?? {};
+      if (s == null)
+        return t;
+      let a = t.multidimensionalDefinition || this.multidimensionalDefinition;
+      a != null && a.length || (a = Ze(this.raster.rasterInfo, { multidimensionalSubset: this.multidimensionalSubset }));
+      const r = t.timeExtent || this.timeExtent;
+      if (a != null && r != null && (r.start != null || r.end != null)) {
+        a = a.map((y) => y.clone());
+        const c = (l = (o = s.variables.find(({ name: y }) => y === a[0].variableName)) == null ? void 0 : o.dimensions) == null ? void 0 : l.find(({ name: y }) => y === "StdTime"), h = a.find(({ dimensionName: y }) => y === "StdTime");
+        if (!c || !h)
+          return { ...t, multidimensionalDefinition: null };
+        const { start: u, end: m } = r, f = u == null ? null : u.getTime(), d = m == null ? null : m.getTime(), g = f ?? d, p = d ?? f;
+        if (c.values != null) {
+          const y = c.values.filter((x) => {
+            if (Array.isArray(x)) {
+              if (g === p)
+                return x[0] <= g && x[1] >= g;
+              const w = x[0] <= g && x[1] > g || x[0] < p && x[1] >= p, S = x[0] >= g && x[1] <= p || x[0] < g && x[1] > p;
+              return w || S;
+            }
+            return g === p ? x === g : x >= g && x <= p;
+          });
+          if (y.length) {
+            const x = y.sort((w, S) => {
+              const T = Array.isArray(w) ? w[0] : w, b = Array.isArray(w) ? w[1] : w, _ = Array.isArray(S) ? S[0] : S, F = Array.isArray(S) ? S[1] : S;
+              return g === p ? T - _ : Math.abs(b - p) - Math.abs(F - p);
+            })[0];
+            h.values = [x];
+          } else
+            a = null;
+        } else if (c.hasRegularIntervals && c.extent) {
+          const [y, x] = c.extent;
+          g > x || p < y ? a = null : h.values = g === p ? [g] : [Math.max(y, g), Math.min(x, p)];
+        }
+      }
+      return a != null && hi(a, this.multidimensionalSubset) ? { ...t, multidimensionalDefinition: null } : { ...t, multidimensionalDefinition: a };
+    }
+    async updateRasterFunction() {
+      var h, u, m;
+      if (!this.loaded || this.type !== "imagery-tile" || !this.rasterFunction && !this._cachedRasterFunctionJson || JSON.stringify(this.rasterFunction) === JSON.stringify(this._cachedRasterFunctionJson))
+        return;
+      if (this._isConstructedFromFunctionRaster && this.raster.datasetFormat === "Function") {
+        const f = this.raster.rasterFunction.toJSON();
+        return !this.rasterFunction && f && this._set("rasterFunction", Ee.fromJSON(f)), void (this._cachedRasterFunctionJson = (h = this.rasterFunction) == null ? void 0 : h.toJSON());
+      }
+      let t, s = this.raster, a = !1;
+      s.datasetFormat === "Function" ? (t = s.primaryRasters.rasters, s = t[0], a = !0) : t = [s];
+      const { rasterFunction: r } = this;
+      if (r) {
+        const f = { raster: s };
+        t.length > 1 && t.forEach((p) => f[p.url] = p);
+        const d = xt(((u = r.functionDefinition) == null ? void 0 : u.toJSON()) ?? r.toJSON(), f), g = new wt({ rasterFunction: d });
+        g.rasterJobHandler = this._rasterJobHandler.instance, await g.open(), this._cachedRasterFunctionJson = (m = this.rasterFunction) == null ? void 0 : m.toJSON(), this.raster = g;
+      } else
+        this.raster = s, this._cachedRasterFunctionJson = null, await s.when();
+      if (this._cachedRendererJson = null, !a && !r)
+        return;
+      const { bandIds: o } = this, { bandCount: l } = this.raster.rasterInfo, c = o != null && o.length ? o.some((f) => f >= l) : l >= 3;
+      o && (c || this.renderer && this.renderer.type !== "raster-stretch") && this._set("bandIds", null), this._configDefaultRenderer("auto");
+    }
+    async updateRenderer() {
+      const { loaded: t, symbolizer: s } = this;
+      if (!t || !s || !this.renderer)
+        return;
+      const { rasterInfo: a } = this.raster, r = et(a, { multidimensionalDefinition: this.multidimensionalDefinition, multidimensionalSubset: this.multidimensionalSubset }), o = r == null ? void 0 : r.name, l = Ye({ ...this.renderer.toJSON(), variableName: o });
+      if (JSON.stringify(this._cachedRendererJson) === JSON.stringify(l))
+        return;
+      const c = this._rasterJobHandler.instance;
+      c && (s.rasterInfo = Ke(a, o), s.rendererJSON = l, s.bind(), await c.updateSymbolizer(s), this._cachedRendererJson = l);
+    }
+    async applyRenderer(t, s) {
+      const a = t == null ? void 0 : t.pixelBlock;
+      if (!(a != null && a.pixels && a.pixels.length > 0))
+        return null;
+      let r;
+      await this.updateRenderer();
+      const o = this._rasterJobHandler.instance, l = this.bandIds ?? [];
+      return r = o ? await o.symbolize({ ...t, simpleStretchParams: s, bandIds: l }) : this.symbolizer.symbolize({ ...t, simpleStretchParams: s, bandIds: l }), r;
+    }
+    getTileUrl(t, s, a) {
+      return this.raster.datasetFormat === "RasterTileServer" ? `${this.url}/tile/${t}/${s}/${a}` : "";
+    }
+    getCompatibleTileInfo(t, s, a = !1) {
+      if (!this.loaded || s == null)
+        return null;
+      if (a && t.equals(this.spatialReference))
+        return this.tileInfo;
+      const r = Pt(t);
+      return te.create({ size: 256, spatialReference: t, origin: r ? { x: r.origin[0], y: r.origin[1] } : { x: s.xmin, y: s.ymax } });
+    }
+    getCompatibleFullExtent(t) {
+      return this.loaded ? (this._compatibleFullExtent && this._compatibleFullExtent.spatialReference.equals(t) || (this._compatibleFullExtent = this.raster.computeExtent(t)), this._compatibleFullExtent) : null;
+    }
+    async fetchTile(t, s, a, r = {}) {
+      var l;
+      if (n(this), r.requestAsImageElement) {
+        const c = this.getTileUrl(t, s, a);
+        return ht(c, { responseType: "image", query: { ...this.refreshParameters, ...this.raster.ioConfig.customFetchParameters }, signal: r.signal }).then((h) => h.data);
+      }
+      const { serviceRasterInfo: o } = this;
+      if (o.multidimensionalInfo != null && (r = this.normalizeRasterFetchOptions(r)).multidimensionalDefinition == null) {
+        const c = r.tileInfo || o.storageInfo.tileInfo;
+        return { extent: this.raster.getTileExtentFromTileInfo(t, s, a, c), pixelBlock: null };
+      }
+      return await this._initJobHandler(), await this.updateRasterFunction(), ((l = this.renderer) == null ? void 0 : l.type) === "raster-shaded-relief" && (r = { ...r, buffer: { cols: 1, rows: 1 } }), this.raster.fetchTile(t, s, a, r);
+    }
+    async fetchPixels(t, s, a, r = {}) {
+      return this.serviceRasterInfo.multidimensionalInfo != null && (r = this.normalizeRasterFetchOptions(r)).multidimensionalDefinition == null ? { extent: t, pixelBlock: null } : (await this._initJobHandler(), await this.updateRasterFunction(), s = Math.round(s), a = Math.round(a), this.raster.fetchPixels(t, s, a, r));
+    }
+    async identify(t, s = {}) {
+      var l;
+      const { raster: a, serviceRasterInfo: r } = this;
+      if (r.multidimensionalInfo != null && !(r.hasMultidimensionalTranspose && (dt(s.multidimensionalDefinition) || s.transposedVariableName || s.timeExtent)) && (s = this.normalizeRasterFetchOptions(s)).multidimensionalDefinition == null)
+        return { location: t, value: null };
+      const o = (l = this.multidimensionalSubset) == null ? void 0 : l.areaOfInterest;
+      if (o && !o.contains(t))
+        throw new O("imagery-tile-mixin:identify", "the request cannot be fulfilled when falling outside of the multidimensional subset");
+      return a.identify(t, s);
+    }
+    increaseRasterJobHandlerUsage() {
+      this._rasterJobHandler.refCount++;
+    }
+    decreaseRasterJobHandlerUsage() {
+      this._rasterJobHandler.refCount--, this._rasterJobHandler.refCount <= 0 && this._shutdownJobHandler();
+    }
+    hasStandardTime() {
+      var r, o, l;
+      const t = (r = this.serviceRasterInfo) == null ? void 0 : r.multidimensionalInfo;
+      if (t == null || ((o = this.serviceRasterInfo) == null ? void 0 : o.dataType) !== "standard-time")
+        return !1;
+      const s = this.multidimensionalDefinition, a = (l = s == null ? void 0 : s[0]) == null ? void 0 : l.variableName;
+      return t.variables.some((c) => c.name === a && (!(s != null && s[0].dimensionName) || c.dimensions.some((h) => h.name === "StdTime")));
+    }
+    getStandardTimeValue(t) {
+      return new Date(24 * (t - 25569) * 3600 * 1e3).toString();
+    }
+    getMultidimensionalSubsetVariables(t) {
+      var a;
+      const s = t ?? ((a = this.serviceRasterInfo) == null ? void 0 : a.multidimensionalInfo);
+      return fi(this.multidimensionalSubset, s);
+    }
+    _configDefaultSettings() {
+      this._configDefaultInterpolation(), this.multidimensionalDefinition || (this.multidimensionalDefinition = Ze(this.raster.rasterInfo, { multidimensionalSubset: this.multidimensionalSubset })), this.rasterFunction && this.raster.datasetFormat === "Function" && (this._cachedRasterFunctionJson = this.rasterFunction.toJSON()), this._configDefaultRenderer();
+    }
+    _initJobHandler() {
+      if (this._rasterJobHandler.connectionPromise != null)
+        return this._rasterJobHandler.connectionPromise;
+      const t = new ni();
+      return this._rasterJobHandler.connectionPromise = t.initialize().then(async () => {
+        n(this), this._rasterJobHandler.instance = t, this.raster.rasterJobHandler = t, this.raster.datasetFormat === "Function" && this.raster.syncJobHandler(), this.rasterFunction && await this.updateRasterFunction().catch(() => {
+        }), this.renderer && this.updateRenderer();
+      }).catch(() => {
+      }), this._rasterJobHandler.connectionPromise;
+    }
+    _shutdownJobHandler() {
+      this._rasterJobHandler.instance && this._rasterJobHandler.instance.destroy(), this._rasterJobHandler.instance = null, this._rasterJobHandler.connectionPromise = null, this._rasterJobHandler.refCount = 0, this._cachedRendererJson = null, this.raster && (this.raster.rasterJobHandler = null);
+    }
+    _configDefaultInterpolation() {
+      var t;
+      if (this.interpolation == null) {
+        n(this);
+        const { raster: s } = this, a = ii(s.rasterInfo, s.tileType, (t = this.sourceJSON) == null ? void 0 : t.defaultResamplingMethod);
+        this._set("interpolation", a);
+      }
+    }
+    _configDefaultRenderer(t = "no") {
+      var h, u;
+      n(this);
+      const { rasterInfo: s } = this.raster;
+      !this.bandIds && s.bandCount > 1 && (this.bandIds = si(s));
+      const a = et(s, { multidimensionalDefinition: this.multidimensionalDefinition, multidimensionalSubset: this.multidimensionalSubset }), r = a == null ? void 0 : a.name;
+      if (!this.renderer || t === "override") {
+        const m = Qe(s, { bandIds: this.bandIds, variableName: r }), f = s.statistics, d = f && f.length > 0 ? f[0] : null, g = (d == null ? void 0 : d.max) ?? 0, p = (d == null ? void 0 : d.min) ?? 0;
+        this.raster.datasetFormat === "WCSServer" && m.type === "raster-stretch" && (g > 1e24 || p < -1e24) && (m.dynamicRangeAdjustment = !0, m.statistics = null, m.stretchType === "none" && (m.stretchType = "min-max")), this.renderer = m;
+      }
+      const o = Ye({ ...this.renderer.toJSON(), variableName: r }), l = Ke(s, r);
+      this.symbolizer ? (this.symbolizer.rendererJSON = o, this.symbolizer.rasterInfo = l) : this.symbolizer = new pi({ rendererJSON: o, rasterInfo: l });
+      const c = this.symbolizer.bind();
+      if (c.success) {
+        if (t === "auto") {
+          const { colormap: m } = this.raster.rasterInfo, f = this.renderer;
+          if (m != null && f.type === "raster-colormap") {
+            const d = Qe(this.raster.rasterInfo);
+            JSON.stringify(d) !== JSON.stringify(f) && this._configDefaultRenderer("override");
+          } else if (f.type === "raster-stretch") {
+            const d = (h = this.bandIds) == null ? void 0 : h.length, g = (u = f.statistics) == null ? void 0 : u.length;
+            !f.dynamicRangeAdjustment && g && d && g !== d && this._configDefaultRenderer("override");
+          }
+        }
+      } else
+        le.getLogger(this).warn("imagery-tile-mixin", c.error || "The given renderer is not supported by the layer."), t === "auto" && this._configDefaultRenderer("override");
+    }
+  };
+  function n(t) {
+    if (!t.raster || !t.serviceRasterInfo)
+      throw new O("imagery-tile", "no raster");
+  }
+  return I([v({ clonable: !1 })], e.prototype, "_cachedRendererJson", void 0), I([v({ clonable: !1 })], e.prototype, "_cachedRasterFunctionJson", void 0), I([v({ clonable: !1 })], e.prototype, "_compatibleFullExtent", void 0), I([v({ clonable: !1 })], e.prototype, "_isConstructedFromFunctionRaster", void 0), I([v({ clonable: !1 })], e.prototype, "_rasterJobHandler", void 0), I([v()], e.prototype, "bandIds", void 0), I([v({ json: { origins: { service: { read: { source: "copyrightText" } } } } })], e.prototype, "copyright", void 0), I([v({ json: { read: !1 } })], e.prototype, "fullExtent", null), I([v()], e.prototype, "interpolation", void 0), I([v()], e.prototype, "ioConfig", void 0), I([v({ type: [He], json: { write: !0 } })], e.prototype, "multidimensionalDefinition", null), I([v({ type: Kt, json: { write: !0 } })], e.prototype, "multidimensionalSubset", void 0), I([v()], e.prototype, "raster", void 0), I([v({ type: Ee, json: { name: "renderingRule", write: !0 } })], e.prototype, "rasterFunction", null), I([v({ readOnly: !0 })], e.prototype, "rasterInfo", null), I([v()], e.prototype, "serviceRasterInfo", void 0), I([v()], e.prototype, "sourceJSON", void 0), I([v({ readOnly: !0, type: L, json: { read: !1 } })], e.prototype, "spatialReference", void 0), I([v({ type: te })], e.prototype, "tileInfo", void 0), I([v(pt)], e.prototype, "url", null), I([v({ types: Qt, json: { name: "layerDefinition.drawingInfo.renderer", write: { overridePolicy() {
+    var s;
+    const t = ((s = this.renderer) == null ? void 0 : s.type) === "raster-stretch" && this.renderer.stretchType === "none" && !this.renderer.useGamma;
+    return { enabled: !this.loaded || this.raster.tileType === "Raster" || !t };
+  } }, origins: { "web-scene": { types: Zt, name: "layerDefinition.drawingInfo.renderer", write: { overridePolicy: (t) => ({ enabled: t && t.type !== "vector-field" && t.type !== "flow" }) } } } } })], e.prototype, "renderer", null), I([Mt("renderer")], e.prototype, "readRenderer", null), I([v({ clonable: !1 })], e.prototype, "symbolizer", void 0), e = I([K("esri.layers.ImageryTileMixin")], e), e;
+};
+function os(i) {
+  const e = i.fields, n = i.records, t = e.some((c) => c.name.toLowerCase() === "oid") ? "OBJECTID" : "OID", s = [{ name: t, type: "esriFieldTypeOID", alias: "OID" }].concat(e.map((c) => ({ name: c.name, type: "esriFieldType" + c.typeName, alias: c.name }))), a = s.map((c) => c.name), r = [];
+  let o = 0, l = 0;
+  return n.forEach((c) => {
+    const h = {};
+    for (h[t] = o++, l = 1; l < a.length; l++)
+      h[a[l]] = c[l - 1];
+    r.push({ attributes: h });
+  }), { displayFieldName: "", fields: s, features: r };
+}
+let It = class {
+  static get supportedVersions() {
+    return [5];
+  }
+  static parse(e) {
+    const n = new DataView(e), t = 3 & n.getUint8(0);
+    if (t !== 3)
+      return { header: { version: t }, recordSet: null };
+    const s = n.getUint32(4, !0), a = n.getUint16(8, !0), r = n.getUint16(10, !0), o = { version: t, recordCount: s, headerByteCount: a, recordByteCount: r };
+    let l = 32;
+    const c = [], h = [];
+    let u;
+    if (t === 3) {
+      for (; n.getUint8(l) !== 13; )
+        u = String.fromCharCode(n.getUint8(l + 11)).trim(), c.push({ name: tt(new Uint8Array(e, l, 11)), type: u, typeName: ["String", "Date", "Double", "Boolean", "String", "Integer"][["C", "D", "F", "L", "M", "N"].indexOf(u)], length: n.getUint8(l + 16) }), l += 32;
+      if (l += 1, c.length > 0)
+        for (; h.length < s && e.byteLength - l > r; ) {
+          const m = [];
+          n.getUint8(l) === 32 ? (l += 1, c.forEach((f) => {
+            if (f.type === "C")
+              m.push(tt(new Uint8Array(e, l, f.length)).trim());
+            else if (f.type === "N")
+              m.push(parseInt(String.fromCharCode.apply(null, new Uint8Array(e, l, f.length)).trim(), 10));
+            else if (f.type === "F")
+              m.push(parseFloat(String.fromCharCode.apply(null, new Uint8Array(e, l, f.length)).trim()));
+            else if (f.type === "D") {
+              const d = String.fromCharCode.apply(null, new Uint8Array(e, l, f.length)).trim();
+              m.push(new Date(parseInt(d.substring(0, 4), 10), parseInt(d.substring(4, 6), 10) - 1, parseInt(d.substring(6, 8), 10)));
+            }
+            l += f.length;
+          }), h.push(m)) : l += r;
+        }
+    }
+    return { header: o, fields: c, records: h, recordSet: os({ fields: c, records: h }) };
+  }
+};
+const re = /* @__PURE__ */ new Map();
+re.set("int16", "esriFieldTypeSmallInteger"), re.set("int32", "esriFieldTypeInteger"), re.set("int64", "esriFieldTypeInteger"), re.set("float32", "esriFieldTypeSingle"), re.set("float64", "esriFieldTypeDouble"), re.set("text", "esriFieldTypeString");
+const lt = 8;
+let pe = class extends se {
+  constructor() {
+    super(...arguments), this.storageInfo = null, this.datasetFormat = "CRF";
+  }
+  async open(e) {
+    await this.init();
+    const { data: n } = await this.request(this.url + "/conf.json", { signal: e == null ? void 0 : e.signal });
+    if (!this._validateHeader(n))
+      throw new O("cloudraster:open", "Invalid or unsupported conf.json.");
+    this.datasetName = this.url.slice(this.url.lastIndexOf("/") + 1);
+    const { storageInfo: t, rasterInfo: s } = this._parseHeader(n);
+    if (s.dataType === "thematic") {
+      const a = await this._fetchAuxiliaryInformation();
+      s.attributeTable = a;
+    }
+    this._set("storageInfo", t), this._set("rasterInfo", s), this.ioConfig.retryCount = this.ioConfig.retryCount || 0;
+  }
+  async fetchRawTile(e, n, t, s = {}) {
+    const { transposeInfo: a } = this.rasterInfo.storageInfo, { transposedVariableName: r } = s, o = !(!a || !r), l = o ? 0 : this.rasterInfo.storageInfo.maximumPyramidLevel - e;
+    if (l < 0)
+      return null;
+    const c = this._buildCacheFilePath(l, n, t, s.multidimensionalDefinition, r), h = this._getIndexRecordFromBundle(n, t, o), u = await this.request(c, { range: { from: 0, to: this.storageInfo.headerSize - 1 }, responseType: "array-buffer", signal: s.signal });
+    if (!u)
+      return null;
+    const m = new Uint8Array(u.data), f = this._getTileEndAndContentType(m, h);
+    if (f.recordSize === 0)
+      return null;
+    const d = await this.request(c, { range: { from: f.position, to: f.position + f.recordSize }, responseType: "array-buffer", signal: s.signal });
+    if (!d)
+      return null;
+    const [g, p] = this._getTileSize(o);
+    return this.decodePixelBlock(d.data, { width: g, height: p, planes: null, pixelType: null, returnInterleaved: o });
+  }
+  _validateHeader(e) {
+    const n = ["origin", "extent", "geodataXform", "LODInfos", "blockWidth", "blockHeight", "bandCount", "pixelType", "pixelSizeX", "pixelSizeY", "format", "packetSize"];
+    return e && e.type === "RasterInfo" && !n.some((t) => !e[t]);
+  }
+  _parseHeader(e) {
+    var H, W, q, ee, U;
+    const n = ["u1", "u2", "u4", "u8", "s8", "u16", "s16", "u32", "s32", "f32", "f64"][e.pixelType], { bandCount: t, colormap: s, blockWidth: a, blockHeight: r, firstPyramidLevel: o, maximumPyramidLevel: l } = e, c = (H = e.statistics) == null ? void 0 : H.map((N) => ({ min: N.min, max: N.max, avg: N.mean, stddev: N.standardDeviation, median: N.median, mode: N.mode })), h = (ee = (q = (W = e.histograms) == null ? void 0 : W[0]) == null ? void 0 : q.counts) != null && ee.length ? e.histograms : null, u = e.extent.spatialReference, m = (U = e.geodataXform) == null ? void 0 : U.spatialReference, f = new L(u != null && u.wkid || u != null && u.wkt || u != null && u.wkt2 ? u : m);
+    let d = new z({ xmin: e.extent.xmin, ymin: e.extent.ymin, xmax: e.extent.xmax, ymax: e.extent.ymax, spatialReference: f });
+    const g = new A({ x: e.pixelSizeX, y: e.pixelSizeY, spatialReference: f }), p = Math.round((d.xmax - d.xmin) / g.x), y = Math.round((d.ymax - d.ymin) / g.y), x = this._parseTransform(e.geodataXform), w = x ? d : null;
+    x && (d = x.forwardTransform(d), g.x = (d.xmax - d.xmin) / p, g.y = (d.ymax - d.ymin) / y);
+    const S = e.properties ?? {}, T = e.format.toLowerCase().replace("cache/", ""), b = new A(e.origin.x, e.origin.y, f);
+    let _, F, R, k;
+    if (s != null && s.colors)
+      for (_ = [], F = 0; F < s.colors.length; F++)
+        R = s.colors[F], k = s.values ? s.values[F] : F, _.push([k, 255 & R, R << 16 >>> 24, R << 8 >>> 24, R >>> 24]);
+    const M = e.LODInfos, P = [];
+    for (F = 0; F < M.levels.length; F++)
+      P.push(new ft({ level: M.levels[F], resolution: M.resolutions[F], scale: 96 / 0.0254 * M.resolutions[F] }));
+    const B = new te({ dpi: 96, lods: P, format: T, origin: b, size: [a, r], spatialReference: f }), C = { recordSize: lt, packetSize: e.packetSize, headerSize: e.packetSize * e.packetSize * lt + 64 }, $ = [{ maxCol: Math.ceil(p / a) - 1, maxRow: Math.ceil(y / r) - 1, minCol: 0, minRow: 0 }];
+    let D = 2;
+    if (l > 0)
+      for (F = 0; F < l; F++)
+        $.push({ maxCol: Math.ceil(p / D / a) - 1, maxRow: Math.ceil(y / D / r) - 1, minCol: 0, minRow: 0 }), D *= 2;
+    const E = e.mdInfo;
+    let X = null;
+    if (E && S._yxs) {
+      const N = S._yxs;
+      X = { packetSize: N.PacketSize, tileSize: [N.TileXSize, N.TileYSize] };
+    }
+    return { storageInfo: C, rasterInfo: new xe({ width: p, height: y, pixelType: n, bandCount: t, extent: d, nativeExtent: w, transform: x, spatialReference: f, pixelSize: g, keyProperties: S, statistics: c, histograms: h, multidimensionalInfo: E, colormap: _, storageInfo: new ge({ blockWidth: a, blockHeight: r, pyramidBlockWidth: a, pyramidBlockHeight: r, origin: b, tileInfo: B, transposeInfo: X, firstPyramidLevel: o, maximumPyramidLevel: l, blockBoundary: $ }) }) };
+  }
+  _parseTransform(e) {
+    var t, s;
+    if (!Li(e))
+      throw new O("cloudraster:open", "the data contains unsupported geodata transform types");
+    const n = Hi(e);
+    if (n.type === "identity")
+      return null;
+    if (n.type !== "polynomial" || !((t = n.forwardCoefficients) != null && t.length) || !((s = n.inverseCoefficients) != null && s.length))
+      throw new O("cloudraster:open", "the data contains unsupported geodata transforms - both forward and inverse coefficients are required currently");
+    return n;
+  }
+  async _fetchAuxiliaryInformation(e) {
+    const n = this.request(this.url + "/conf.vat.json", { signal: e }).then((r) => r.data).catch(() => null), t = this.request(this.url + "/conf.vat.dbf", { responseType: "array-buffer", signal: e }).then((r) => r.data).catch(() => null), s = await Promise.all([n, t]);
+    let a;
+    if (s[0]) {
+      let r = s[0].fields;
+      const o = s[0].values;
+      if (r && o) {
+        r = r.map((c) => ({ type: c.name === "OID" ? "esriFieldTypeOID" : re.get(c.type), name: c.name, alias: c.alias || c.name }));
+        const l = o.map((c) => ({ attributes: c }));
+        r && o && (a = { fields: r, features: l });
+      }
+    }
+    return !a && s[1] && (a = It.parse(s[1]).recordSet), _e.fromJSON(a);
+  }
+  _buildCacheFilePath(e, n, t, s, a) {
+    const r = this._getPackageSize(!!a), o = Math.floor(n / r) * r, l = Math.floor(t / r) * r, c = "R" + this._toHexString4(o) + "C" + this._toHexString4(l);
+    let h = "L";
+    h += e >= 10 ? e.toString() : "0" + e.toString();
+    const { multidimensionalInfo: u } = this.rasterInfo, m = s == null ? void 0 : s[0];
+    if (u == null || !m)
+      return `${this.url}/_alllayers/${h}/${c}.bundle`;
+    let f = "_yxs";
+    if (!a) {
+      f = u.variables.find((p) => p.name === m.variableName).dimensions[0].values.indexOf(m.values[0]).toString(16);
+      const g = 4 - f.length;
+      for (let p = 0; p < g; p++)
+        f = "0" + f;
+      f = "S" + f;
+    }
+    const d = this._getVariableFolderName(a || m.variableName);
+    return `${this.url}/_alllayers/${d}/${f}/${h}/${c}.bundle`;
+  }
+  _getPackageSize(e = !1) {
+    const { transposeInfo: n } = this.rasterInfo.storageInfo;
+    return e && n != null ? n.packetSize ?? 0 : this.storageInfo.packetSize;
+  }
+  _getTileSize(e = !1) {
+    const { storageInfo: n } = this.rasterInfo, { transposeInfo: t } = n;
+    return e && t != null ? t.tileSize : n.tileInfo.size;
+  }
+  _getVariableFolderName(e) {
+    return (e = e.trim()) === "" ? "_v" : e.replaceAll(/[\{|\}\-]/g, "_").replace("\\*", "_v");
+  }
+  _getIndexRecordFromBundle(e, n, t = !1) {
+    const s = this._getPackageSize(t), a = s * (e % s) + n % s;
+    if (a < 0)
+      throw new Error("Invalid level / row / col");
+    return 20 + a * this.storageInfo.recordSize + 44;
+  }
+  _getTileEndAndContentType(e, n) {
+    const t = e.subarray(n, n + 8);
+    let s, a = 0;
+    for (s = 0; s < 5; s++)
+      a |= (255 & t[s]) << 8 * s;
+    const r = 1099511627775 & a;
+    for (a = 0, s = 5; s < 8; s++)
+      a |= (255 & t[s]) << 8 * (s - 5);
+    return { position: r, recordSize: 1099511627775 & a };
+  }
+  _toHexString4(e) {
+    let n = e.toString(16);
+    if (n.length !== 4) {
+      let t = 4 - n.length;
+      for (; t-- > 0; )
+        n = "0" + n;
+    }
+    return n;
+  }
+};
+I([v({ readOnly: !0 })], pe.prototype, "storageInfo", void 0), I([v({ type: String, json: { write: !0 } })], pe.prototype, "datasetFormat", void 0), pe = I([K("esri.layers.support.rasterDatasets.CloudRaster")], pe);
+const ls = pe;
+function bt(i) {
+  return ["x", "e", "east", "long", "longitude"].includes(i.toLowerCase());
+}
+function St(i) {
+  return ["y", "n", "west", "lat", "latitude"].includes(i.toLowerCase());
+}
+function cs(i) {
+  const { axes: e } = i.domain, n = Object.keys(e), t = [], s = [];
+  let a = -1, r = -1, o = [];
+  for (let x = 0; x < n.length; x++) {
+    const w = n[x];
+    bt(w) ? a = x : St(w) && (r = x);
+    const S = e[w], T = [];
+    if ("values" in S) {
+      S.values.forEach((_) => T.push(typeof _ == "string" ? new Date(_).getTime() : _));
+      const b = T[1] - T[0];
+      t.push([T[0] - 0.5 * b, T[T.length - 1] + 0.5 * b]), s.push(b);
+    } else {
+      const { start: b, stop: _, num: F } = S, R = (_ - b) / (F - 1);
+      t.push([b - 0.5 * R, _ + 0.5 * R]), s.push(R);
+      for (let k = 0; k < F; k++)
+        T.push(b + R * k);
+    }
+    o.push({ name: w, values: T, extent: [T[0], T[T.length - 1]] });
+  }
+  a > -1 && r === -1 ? r = a === 0 ? 1 : 0 : r > -1 && a === -1 ? a = r === 0 ? 1 : 0 : r === -1 && a === -1 && (a = 0, r = 1), o = o.filter((x, w) => !(w === a || w === r));
+  const { referencing: l } = i.domain, c = l.find((x) => x.coordinates.includes(n[a])).system.id, h = c == null ? void 0 : c.slice(c.lastIndexOf("/") + 1), u = h == null || h === "CRS84" ? 4326 : Number(h), m = new L({ wkid: u }), [f, d] = t[a], [g, p] = t[r], y = new z({ xmin: f, xmax: d, ymin: g, ymax: p, spatialReference: m });
+  return { width: Math.round(y.width / s[a]), height: Math.round(y.height / s[r]), extent: y, dimensions: o };
+}
+function Ce(i) {
+  const e = $t();
+  return e ? i[e] ?? Object.values(i)[0] : Object.values(i)[0];
+}
+function Pe() {
+  return Math.round(255 * Math.random());
+}
+function us(i) {
+  var t, s;
+  const e = {}, { parameters: n } = i;
+  if (!n)
+    return e;
+  for (const [a, r] of Object.entries(n)) {
+    const { type: o, description: l, unit: c, categoryEncoding: h, observedProperty: u } = r;
+    if (o === "Parameter" && (e[a] = {}, l && (e[a].description = Ce(l)), c && (e[a].unit = c.label ? Ce(c.label) : null, e[a].symbol = (t = c.symbol) == null ? void 0 : t.value), h)) {
+      const m = Object.entries(h).map((g, p) => ({ OID: p, Value: Number(g[1]), ClassName: g[0].slice(g[0].lastIndexOf("/") + 1), Count: 1 }));
+      let f = !1;
+      (s = u == null ? void 0 : u.categories) != null && s.length && (u.categories.forEach((g) => {
+        if (!g.id)
+          return;
+        const p = g.id.slice(g.id.lastIndexOf("/") + 1), y = m.find((w) => w.ClassName === p);
+        if (!y)
+          return;
+        const x = g.label ? Ce(g.label) : null;
+        if (y.Label = x, g.preferredColor) {
+          const w = Ot.fromHex(g.preferredColor);
+          w && (f = !0, y.Red = w.r, y.Green = w.g, y.Blue = w.b);
+        }
+      }), f && m.forEach((g) => {
+        g.Red == null && (g.Red = Pe(), g.Green = Pe(), g.Blue = Pe());
+      }));
+      const d = { objectIdFieldName: "", fields: [{ name: "OID", type: "esriFieldTypeOID", alias: "OID", domain: null }, { name: "Value", type: "esriFieldTypeInteger", alias: "Value", domain: null }, { name: "Count", type: "esriFieldTypeDouble", alias: "Count", domain: null }, { name: "ClassName", type: "esriFieldTypeString", alias: "ClassName", domain: null, length: 50 }, { name: "Label", type: "esriFieldTypeString", alias: "Label", domain: null, length: 50 }], features: m.map((g) => ({ attributes: g })) };
+      f && d.fields.push({ name: "Red", type: "esriFieldTypeInteger", alias: "Red", domain: null }, { name: "Green", type: "esriFieldTypeInteger", alias: "Green", domain: null }, { name: "Blue", type: "esriFieldTypeInteger", alias: "Blue", domain: null }), e[a].attributeTable = d;
+    }
+  }
+  return e;
+}
+function hs(i) {
+  let e = Number.MAX_VALUE, n = -Number.MAX_VALUE;
+  for (let t = 0; t < i.length; t++) {
+    const s = i[t];
+    s != null && (s < e && (e = s), s > n && (n = s));
+  }
+  return $i(e, n);
+}
+function fs(i, e, n) {
+  const t = i.map((l, c) => ({ name: l, count: e[c] })).sort((l, c) => l.name > c.name ? -1 : 1), s = (a = 1, (l) => a *= l.count);
+  var a;
+  const r = [...t.slice(1), { name: "", count: 1 }].reverse().map(s).reverse();
+  let o = 0;
+  for (let l = i.length - 1; l >= 0; l--)
+    o += r[t.findIndex(({ name: c }) => c === i[l])] * (n % e[l]), n = Math.floor(n / e[l]);
+  return o;
+}
+function ms(i) {
+  var m;
+  const { width: e, height: n, extent: t, dimensions: s } = cs(i), { ranges: a } = i, r = Object.keys(a).sort((f, d) => f < d ? -1 : 1), o = [];
+  for (let f = 0; f < r.length; f++) {
+    const d = r[f];
+    s != null && s.length && o.push({ name: d, dimensions: s });
+  }
+  const l = us(i);
+  o.forEach((f) => l[f.name] && Object.assign(f, l[f.name]));
+  const c = o.length ? { variables: o } : void 0, h = [];
+  for (let f = 0; f < r.length; f++) {
+    const d = r[f], { values: g, dataType: p, axisNames: y, shape: x } = a[d], w = x.length > 2 ? f * x.slice(0, -2).reduce((R, k) => R * k) : 0, S = y.slice(0, -2), T = x.slice(0, -2), b = p === "float" ? "f32" : hs(g), _ = e * n, F = g.length / _;
+    for (let R = 0; R < F; R++) {
+      const k = Y.createEmptyBand(b, _), M = new Uint8Array(_).fill(255);
+      let P = !1;
+      const B = R * _;
+      for (let C = 0; C < _; C++) {
+        const $ = g[B + C];
+        $ == null ? (M[C] = 0, P = !0) : k[C] = $;
+      }
+      if (f === 0 || s != null && s.length) {
+        const C = new Y({ width: e, height: n, mask: P ? M : null, pixels: [k], pixelType: b });
+        C.updateStatistics(), (s == null ? void 0 : s.length) ? h[fs(S, T, R) + w] = C : h.push(C);
+      } else {
+        const C = h[R];
+        C.pixels.push(k), P ? C.mask && (C.mask = Y.combineBandMasks([C.mask, M])) : C.mask = P ? M : null;
+      }
+    }
+  }
+  const u = (m = Object.values(l).find((f) => f.attributeTable)) == null ? void 0 : m.attributeTable;
+  return { extent: t, pixelBlocks: h, multidimensionalInfo: c, attributeTable: u, bandNames: c ? void 0 : r };
+}
+let ce = class extends se {
+  constructor() {
+    super(...arguments), this.datasetFormat = "MEMORY", this.source = null;
+  }
+  get url() {
+    return "";
+  }
+  async open(i) {
+    await this.init();
+    const e = this.source, { pixelBlocks: n, attributeTable: t, statistics: s, histograms: a, name: r, nativeExtent: o, transform: l } = e, c = n[0], { width: h, height: u, pixelType: m } = c, f = e.extent ?? new z({ xmin: -0.5, ymin: 0.5, xmax: h - 0.5, ymax: u - 0.5, spatialReference: new L({ wkid: 3857 }) }), d = e.isPseudoSpatialReference ?? !e.extent, g = { x: f.width / h, y: f.height / u }, p = { ...e.keyProperties };
+    t && (p.DataType = "Thematic");
+    const y = new xe({ width: h, height: u, pixelType: m, extent: f, nativeExtent: o, attributeTable: t, transform: l, pixelSize: g, spatialReference: f.spatialReference, bandCount: c.pixels.length, keyProperties: p, multidimensionalInfo: e.multidimensionalInfo, statistics: s, isPseudoSpatialReference: d, histograms: a });
+    this.ioConfig.skipMapInfo && this.updateImageSpaceRasterInfo(y), this.createRemoteDatasetStorageInfo(y, 512, 512), this._set("rasterInfo", y), this.updateTileInfo(), y.multidimensionalInfo ? await this._buildMDimStats(e.pixelBlocks, y.multidimensionalInfo) : await this._buildInMemoryRaster(c, { width: 512, height: 512 }, i), y.multidimensionalInfo || (this.source = null), this.datasetName = r;
+  }
+  fetchRawTile(i, e, n, t = {}) {
+    if (!this._pixelBlockTiles) {
+      const { rasterInfo: a } = this, [r, o] = a.storageInfo.tileInfo.size, { sliceId: l } = t, { pixelBlocks: c } = this.source, h = { pixelBlock: l == null ? c[0] : c[l], useBilinear: a.dataType !== "thematic", tileSize: { width: r, height: o }, level: i, row: e, col: n }, u = this.rasterJobHandler ? this.rasterJobHandler.clipTile(h, t) : Di(h);
+      return Promise.resolve(u);
+    }
+    const s = this._pixelBlockTiles.get(`${i}/${e}/${n}`);
+    return Promise.resolve(s);
+  }
+  async _buildInMemoryRaster(i, e, n) {
+    var u, m;
+    const { rasterInfo: t } = this, s = t.storageInfo.maximumPyramidLevel ?? 0, a = t.dataType !== "thematic", r = this.rasterJobHandler ? this.rasterJobHandler.split({ pixelBlock: i, tileSize: e, maximumPyramidLevel: s, useBilinear: a }, n) : Promise.resolve(Ni(i, e, s, a)), o = t.statistics != null, l = t.histograms != null, c = this.ioConfig.skipStatistics || o ? Promise.resolve({ statistics: null, histograms: null }) : this.rasterJobHandler ? this.rasterJobHandler.estimateStatisticsHistograms({ pixelBlock: i }, n) : Promise.resolve(di(i)), h = await mt([r, c]);
+    if (!h[0].value && h[1].value)
+      throw new O("inmemory-raster:open", "failed to build in memory raster");
+    this._pixelBlockTiles = h[0].value, o || (t.statistics = (u = h[1].value) == null ? void 0 : u.statistics), l || (t.histograms = (m = h[1].value) == null ? void 0 : m.histograms);
+  }
+  async _buildMDimStats(i, e, n) {
+    for (let t = 0; t < e.variables.length; t++) {
+      const s = e.variables[t];
+      if (s.statistics)
+        continue;
+      const a = s.dimensions.map((c) => {
+        var h, u;
+        return new He({ variableName: s.name, dimensionName: c.name, values: [((h = c.values) == null ? void 0 : h[0]) ?? ((u = c.extent) == null ? void 0 : u[0])], isSlice: !0 });
+      }), r = yt(a, e), o = r == null ? null : i[r];
+      if (o == null)
+        continue;
+      const l = this.rasterJobHandler ? await this.rasterJobHandler.computeStatisticsHistograms({ pixelBlock: o }, n) : We(o);
+      s.statistics = l.statistics, s.histograms || (s.histograms = l.histograms);
+    }
+  }
+};
+I([v({ type: String, json: { write: !0 } })], ce.prototype, "datasetFormat", void 0), I([v()], ce.prototype, "source", void 0), I([v()], ce.prototype, "url", null), ce = I([K("esri.layers.support.rasterDatasets.InMemoryRaster")], ce);
+const qe = ce;
+let de = class extends se {
+  constructor() {
+    super(...arguments), this.datasetFormat = "CovJSON";
+  }
+  async open(e) {
+    await this.init();
+    const { extent: n, pixelBlocks: t, multidimensionalInfo: s, attributeTable: a, bandNames: r } = await this._fetchData(e), { statistics: o, histograms: l } = We(t[0]), c = r == null ? void 0 : r.map((f) => ({ BandName: f })), h = { DataType: a ? "Thematic" : s ? "Scientific" : "Generic", BandProperties: c }, u = new qe({ source: { extent: n, pixelBlocks: t, attributeTable: a ? _e.fromJSON(a) : null, multidimensionalInfo: s, statistics: o, histograms: l, keyProperties: h, isPseudoSpatialReference: !1 } });
+    await u.open(), this._inMemoryRaster = u;
+    const m = this.source ? "" : this.url.slice(this.url.lastIndexOf("/") + 1);
+    this._set("datasetName", m.slice(0, m.indexOf("."))), this._set("rasterInfo", u.rasterInfo);
+  }
+  fetchRawTile(e, n, t, s = {}) {
+    return this._inMemoryRaster.fetchRawTile(e, n, t, s);
+  }
+  async _fetchData(e) {
+    var a, r, o, l;
+    const n = this.source ?? (await this.request(this.url, { signal: e == null ? void 0 : e.signal })).data, t = "imagery-tile-layer:open-coverage-json";
+    if (((a = n.type) == null ? void 0 : a.toLowerCase()) !== "coverage" || ((o = (r = n.domain) == null ? void 0 : r.domainType) == null ? void 0 : o.toLowerCase()) !== "grid")
+      throw new O(t, "Only coverage with Grid domain type is supported");
+    if (!n.ranges)
+      throw new O(t, "Missing ranges in the grid coverage data");
+    if (!((l = n.domain.referencing) != null && l.length))
+      throw new O(t, "Missing domain referencing in the grid coverage data");
+    const s = Object.values(n.ranges);
+    for (let c = 0; c < s.length; c++) {
+      const { axisNames: h, shape: u, type: m, values: f } = s[c];
+      if (!(m.toLowerCase() === "ndarray" && (f != null && f.length) && (h != null && h.length) && (u != null && u.length)))
+        throw new O(t, "Only ranges with valid NdArray, axisNames, shape, and inline values are supported");
+      if (!(bt(h[h.length - 1]) && St(h[h.length - 2])))
+        throw new O(t, "Only row-major ordered pixel values are supported. X axis must be the last axis.");
+    }
+    return ms(n);
+  }
+};
+I([v({ type: String, json: { write: !0 } })], de.prototype, "datasetFormat", void 0), I([v({ constructOnly: !0 })], de.prototype, "source", void 0), de = I([K("esri.layers.support.rasterDatasets.CovJSONRaster")], de);
+const ps = de;
+function fe(i, e) {
+  if (!i || !e)
+    return [];
+  let n = e;
+  e.includes("/") ? (n = e.slice(0, e.indexOf("/")), e = e.slice(e.indexOf("/") + 1)) : e = "";
+  const t = [];
+  if (e) {
+    const a = fe(i, n);
+    for (let r = 0; r < a.length; r++)
+      fe(a[r], e).forEach((o) => t.push(o));
+    return t;
+  }
+  const s = i.getElementsByTagNameNS("*", n);
+  if (!s || s.length === 0)
+    return [];
+  for (let a = 0; a < s.length; a++)
+    t.push(s[a] || s.item(a));
+  return t;
+}
+function V(i, e) {
+  if (!i || !e)
+    return null;
+  let n = e;
+  e.includes("/") ? (n = e.slice(0, e.indexOf("/")), e = e.slice(e.indexOf("/") + 1)) : e = "";
+  const t = fe(i, n);
+  return t.length > 0 ? e ? V(t[0], e) : t[0] : null;
+}
+function Z(i, e = null) {
+  const n = e ? V(i, e) : i;
+  let t;
+  return n ? (t = n.textContent || n.nodeValue, t ? t.trim() : null) : null;
+}
+function ds(i, e) {
+  const n = fe(i, e), t = [];
+  let s;
+  for (let a = 0; a < n.length; a++)
+    s = n[a].textContent || n[a].nodeValue, s && (s = s.trim(), s !== "" && t.push(s));
+  return t;
+}
+function Se(i, e) {
+  return ds(i, e).map((n) => Number(n));
+}
+function oe(i, e) {
+  const n = Z(i, e);
+  return Number(n);
+}
+function Oe(i, e) {
+  var s;
+  const n = (s = i == null ? void 0 : i.nodeName) == null ? void 0 : s.toLowerCase(), t = e.toLowerCase();
+  return n.slice(n.lastIndexOf(":") + 1) === t;
+}
+function ct(i, e) {
+  if (!i || !e)
+    return null;
+  const n = [];
+  for (let t = 0; t < i.length; t++)
+    n.push(i[t]), n.push(e[t]);
+  return n;
+}
+function ys(i) {
+  const e = V(i, "GeodataXform"), n = Fe(oe(e, "SpatialReference/WKID") || Z(e, "SpatialReference/WKT"));
+  if (e.getAttribute("xsi:type") !== "typens:PolynomialXform")
+    return { spatialReference: n, transform: null };
+  const t = oe(e, "PolynomialOrder") ?? 1, s = Se(e, "CoeffX/Double"), a = Se(e, "CoeffY/Double"), r = Se(e, "InverseCoeffX/Double"), o = Se(e, "InverseCoeffY/Double"), l = ct(s, a), c = ct(r, o);
+  return { spatialReference: n, transform: l && c && l.length && c.length ? new je({ spatialReference: n, polynomialOrder: t, forwardCoefficients: l, inverseCoefficients: c }) : null };
+}
+function gs(i) {
+  var m;
+  const e = oe(i, "NoDataValue"), n = V(i, "Histograms/HistItem"), t = oe(n, "HistMin"), s = oe(n, "HistMax"), a = oe(n, "BucketCount"), r = (m = Z(n, "HistCounts")) == null ? void 0 : m.split("|").map((f) => Number(f));
+  let o, l, c, h;
+  fe(i, "Metadata/MDI").forEach((f) => {
+    const d = Number(f.textContent ?? f.nodeValue);
+    switch (f.getAttribute("key").toUpperCase()) {
+      case "STATISTICS_MINIMUM":
+        o = d;
+        break;
+      case "STATISTICS_MAXIMUM":
+        l = d;
+        break;
+      case "STATISTICS_MEAN":
+        c = d;
+        break;
+      case "STATISTICS_STDDEV":
+        h = d;
+    }
+  });
+  const u = oe(i, "Metadata/SourceBandIndex");
+  return { noDataValue: e, histogram: r != null && r.length && t != null && s != null ? { min: t, max: s, size: a || r.length, counts: r } : null, sourceBandIndex: u, statistics: o != null && l != null ? { min: o, max: l, avg: c, stddev: h } : null };
+}
+function Fe(i) {
+  if (!i)
+    return null;
+  let e = Number(i);
+  if (!isNaN(e) && e !== 0)
+    return new L({ wkid: e });
+  if (i = String(i).trim(), Dt(i))
+    return new L({ wkt2: i });
+  const n = i.toUpperCase();
+  if (n.startsWith("COMPD_CS")) {
+    if (!n.includes("VERTCS") || !n.includes("GEOGCS") && !n.startsWith("PROJCS"))
+      return null;
+    const t = n.indexOf("VERTCS"), s = n.indexOf("PROJCS"), a = s > -1 ? s : n.indexOf("GEOGCS");
+    if (a === -1)
+      return null;
+    const r = i.slice(a, i.lastIndexOf("]", t) + 1).trim(), o = i.slice(t, i.lastIndexOf("]")).trim();
+    e = $e(r);
+    const l = new L(e ? { wkid: e } : { wkt: r }), c = $e(o);
+    return c && (l.vcsWkid = c), l;
+  }
+  return n.startsWith("GEOGCS") || n.startsWith("PROJCS") ? (e = $e(i), new L(e !== 0 ? { wkid: e } : { wkt: i })) : null;
+}
+function $e(i) {
+  var s;
+  const e = i.replaceAll("]", "[").replaceAll('"', "").split("[").map((a) => a.trim()).filter((a) => a !== ""), n = e[e.length - 1].split(","), t = (s = n[0]) == null ? void 0 : s.toLowerCase();
+  if ((t === "epsg" || t === "esri") && i.endsWith('"]]')) {
+    const a = Number(n[1]);
+    if (!isNaN(a) && a !== 0)
+      return a;
+  }
+  return 0;
+}
+function Ue(i) {
+  var t;
+  if (((t = i == null ? void 0 : i.documentElement.tagName) == null ? void 0 : t.toLowerCase()) !== "pamdataset")
+    return {};
+  const e = { spatialReference: null, transform: null, metadata: {}, rasterBands: [], statistics: null, histograms: null };
+  i.documentElement.childNodes.forEach((s) => {
+    if (s.nodeType === 1) {
+      if (Oe(s, "SRS")) {
+        if (!e.spatialReference) {
+          const a = Z(s);
+          e.spatialReference = Fe(a);
+        }
+      } else if (Oe(s, "Metadata"))
+        if (s.getAttribute("domain") === "xml:ESRI") {
+          const { spatialReference: a, transform: r } = ys(s);
+          e.transform = r, e.spatialReference || (e.spatialReference = a);
+        } else
+          fe(s, "MDI").forEach((a) => e.metadata[a.getAttribute("key")] = Z(a));
+      else if (Oe(s, "PAMRasterBand")) {
+        const a = gs(s);
+        a.sourceBandIndex != null && e.rasterBands[a.sourceBandIndex] == null ? e.rasterBands[a.sourceBandIndex] = a : e.rasterBands.push(a);
+      }
+    }
+  });
+  const n = e.rasterBands;
+  if (n.length) {
+    const s = !!n[0].statistics;
+    e.statistics = s ? n.map((r) => r.statistics).filter(Be) : null;
+    const a = !!n[0].histogram;
+    e.histograms = a ? n.map((r) => r.histogram).filter(Be) : null;
+  }
+  return e;
+}
+let Te = class extends se {
+  async open(i) {
+    await this.init();
+    const e = await this._fetchData(i);
+    let { spatialReference: n, statistics: t, histograms: s, transform: a } = await this._fetchAuxiliaryData(i);
+    const r = !n;
+    r && (n = new L({ wkid: 3857 })), s != null && s.length && t == null && (t = Ge(s));
+    const { width: o, height: l } = e;
+    let c = new z({ xmin: -0.5, ymin: 0.5 - l, xmax: o - 0.5, ymax: 0.5, spatialReference: n });
+    const h = a ? a.forwardTransform(c) : c;
+    let u = !0;
+    if (a) {
+      const f = a.forwardCoefficients;
+      u = f && f[1] === 0 && f[2] === 0, u && (a = null, c = h);
+    }
+    const m = new qe({ source: { extent: h, nativeExtent: c, transform: a, pixelBlocks: [e], statistics: t, histograms: s, keyProperties: { DateType: "Processed" }, isPseudoSpatialReference: r }, ioConfig: { sampling: "closest", skipStatistics: !0 } });
+    this.ioConfig.skipMapInfo && (m.ioConfig.skipMapInfo = !0), await m.open(), m.source = null, this._set("rasterInfo", m.rasterInfo), this._inMemoryRaster = m;
+  }
+  fetchRawTile(i, e, n, t = {}) {
+    return this._inMemoryRaster.fetchRawTile(i, e, n, t);
+  }
+  async _fetchData(i) {
+    const { data: e } = await this.request(this.url, { responseType: "array-buffer", signal: i == null ? void 0 : i.signal }), n = yi(e).toUpperCase();
+    if (n !== "JPG" && n !== "PNG" && n !== "GIF" && n !== "BMP")
+      throw new O("image-aux-raster:open", "the data is not a supported format");
+    this._set("datasetFormat", n);
+    const t = n.toLowerCase(), s = t === "gif" || t === "bmp" || !Nt("ios"), a = await this.decodePixelBlock(e, { format: t, useCanvas: s, hasNoZlibMask: !0 });
+    if (a == null)
+      throw new O("image-aux-raster:open", "the data cannot be decoded");
+    return a;
+  }
+  async _fetchAuxiliaryData(i) {
+    var h;
+    const e = i == null ? void 0 : i.signal, { skipExtensions: n = [], skipMapInfo: t } = this.ioConfig, s = t || n.includes("aux.xml") ? null : this.request(this.url + ".aux.xml", { responseType: "xml", signal: e }), a = this.datasetFormat, r = a === "JPG" ? "jgw" : a === "PNG" ? "pgw" : a === "BMP" ? "bpw" : null, o = r && n.includes(r) ? null : this.request(this.url.slice(0, this.url.lastIndexOf(".")) + "." + r, { responseType: "text", signal: e }), l = await mt([s, o]);
+    if (e != null && e.aborted)
+      throw Bt();
+    const c = Ue((h = l[0].value) == null ? void 0 : h.data);
+    if (!c.transform) {
+      const u = l[1].value ? l[1].value.data.split(`
+`).slice(0, 6).map((m) => Number(m)) : null;
+      c.transform = (u == null ? void 0 : u.length) === 6 ? new je({ forwardCoefficients: [u[4], u[5], u[0], -u[1], u[2], -u[3]] }) : null;
+    }
+    return c;
+  }
+};
+I([v({ type: String, json: { write: !0 } })], Te.prototype, "datasetFormat", void 0), Te = I([K("esri.layers.support.rasterDatasets.ImageAuxRaster")], Te);
+const Re = Te;
+let ye = class extends se {
+  constructor() {
+    super(...arguments), this._levelOffset = 0, this._tilemapCache = null, this._slices = null, this.datasetFormat = "RasterTileServer", this.tileType = null;
+  }
+  async open(i) {
+    var _, F;
+    await this.init();
+    const e = i == null ? void 0 : i.signal, n = this.sourceJSON ? { data: this.sourceJSON } : await this.request(this.url, { query: { f: "json" }, signal: e });
+    n.ssl && (this.url = this.url.replace(/^http:/i, "https:"));
+    const t = n.data;
+    if (this.sourceJSON = t, !t)
+      throw new O("imageserverraster:open", "cannot initialize tiled image service, missing service info");
+    if (!t.tileInfo)
+      throw new O("imageserverraster:open", "use ImageryLayer to open non-tiled image services");
+    this._fixScaleInServiceInfo();
+    const s = ["jpg", "jpeg", "png", "png8", "png24", "png32", "mixed"];
+    this.tileType = t.cacheType, this.tileType == null && (s.includes(t.tileInfo.format.toLowerCase()) ? this.tileType = "Map" : t.tileInfo.format.toLowerCase() === "lerc" ? this.tileType = "Elevation" : this.tileType = "Raster"), this.datasetName = ((_ = t.name) == null ? void 0 : _.slice(t.name.indexOf("/") + 1)) ?? "";
+    const a = await this._fetchRasterInfo({ signal: e });
+    if (a == null)
+      throw new O("image-server-raster:open", "cannot initialize image service");
+    ri(a, t);
+    const r = this.tileType === "Map" ? xs(t.tileInfo, t) : te.fromJSON(t.tileInfo);
+    Et(r);
+    const [o, l] = this._computeMinMaxLOD(a, r), { extent: c, pixelSize: h } = a, u = 0.5 / a.width * h.x, m = Math.max(h.x, h.y), { lods: f } = r;
+    (this.tileType !== "Map" && t.maxScale !== 0 || Math.abs(h.x - h.y) > u || !f.some((R) => Math.abs(R.resolution - m) < u)) && (h.x = h.y = o.resolution, a.width = Math.ceil((c.xmax - c.xmin) / h.x - 0.1), a.height = Math.ceil((c.ymax - c.ymin) / h.y - 0.1));
+    const d = o.level - l.level, [g, p] = r.size, y = [], x = [];
+    f.forEach((R, k) => {
+      R.level >= l.level && R.level <= o.level && y.push({ x: R.resolution, y: R.resolution }), k < f.length - 1 && x.push(Math.round(10 * R.resolution / f[k + 1].resolution) / 10);
+    }), y.sort((R, k) => R.x - k.x);
+    const w = this.computeBlockBoundary(c, g, p, r.origin, y, d), S = y.length > 1 ? y.slice(1) : null;
+    let T;
+    t.transposeInfo && (T = { tileSize: [t.transposeInfo.rows, t.transposeInfo.cols], packetSize: ((F = a.keyProperties) == null ? void 0 : F._yxs.PacketSize) ?? 0 });
+    const b = x.length <= 1 || x.length >= 3 && x.slice(0, -1).every((R) => R === x[0]) ? x[0] ?? 2 : Math.round(10 / (l.resolution / o.resolution) ** (-1 / d)) / 10;
+    if (a.storageInfo = new ge({ blockWidth: r.size[0], blockHeight: r.size[1], pyramidBlockWidth: r.size[0], pyramidBlockHeight: r.size[1], pyramidResolutions: S, pyramidScalingFactor: b, compression: r.format, origin: r.origin, firstPyramidLevel: 1, maximumPyramidLevel: d, tileInfo: r, transposeInfo: T, blockBoundary: w }), this._fixGCSShift(a), this._set("rasterInfo", a), t.capabilities.toLowerCase().includes("tilemap")) {
+      const R = { tileInfo: a.storageInfo.tileInfo, parsedUrl: Jt(this.url), url: this.url, tileServers: [] };
+      this._tilemapCache = new Yi({ layer: R });
+    }
+  }
+  async fetchRawTile(i, e, n, t = {}) {
+    const { storageInfo: s, extent: a } = this.rasterInfo, { transposeInfo: r } = s, o = r != null && !!t.transposedVariableName;
+    if (this._slices && !o && t.sliceId == null)
+      return null;
+    const l = o ? 0 : s.maximumPyramidLevel - i + this._levelOffset, c = `${this.url}/tile/${l}/${e}/${n}`, h = this._slices ? o ? { variable: t.transposedVariableName } : { sliceId: t.sliceId || 0 } : null, { data: u } = await this.request(c, { query: h, responseType: "array-buffer", signal: t.signal });
+    if (!u)
+      return null;
+    const m = o ? r.tileSize : s.tileInfo.size, f = await this.decodePixelBlock(u, { width: m[0], height: m[1], planes: null, pixelType: null, isPoint: this.tileType === "Elevation", returnInterleaved: o, noDataValue: this.rasterInfo.noDataValue });
+    if (f == null)
+      return null;
+    const d = s.blockBoundary[i];
+    if (s.compression !== "jpg" || n > d.minCol && n < d.maxCol && e > d.minRow && e < d.maxRow)
+      return f;
+    const { origin: g, blockWidth: p, blockHeight: y } = s, { x, y: w } = this.getPyramidPixelSize(i), S = Math.round((a.xmin - g.x) / x) % p, T = Math.round((a.xmax - g.x) / x) % p || p, b = Math.round((g.y - a.ymax) / w) % y, _ = Math.round((g.y - a.ymin) / w) % y || y, F = n === d.minCol ? S : 0, R = e === d.minRow ? b : 0, k = n === d.maxCol ? T : p, M = e === d.maxRow ? _ : y;
+    return Bi(f, { x: F, y: R }, { width: k - F, height: M - R }), f;
+  }
+  getSliceIndex(i) {
+    if (!this._slices || i == null || i.length === 0)
+      return null;
+    const e = i;
+    for (let n = 0; n < this._slices.length; n++) {
+      const t = this._slices[n].multidimensionalDefinition;
+      if (t.length === e.length && !t.some((s) => {
+        const a = e.find((r) => s.variableName === r.variableName && r.dimensionName === s.dimensionName);
+        return a ? (Array.isArray(s.values[0]) ? `${s.values[0][0]}-${s.values[0][1]}` : s.values[0]) !== (Array.isArray(a.values[0]) ? `${a.values[0][0]}-${a.values[0][1]}` : a.values[0]) : !0;
+      }))
+        return n;
+    }
+    return null;
+  }
+  async fetchVariableStatisticsHistograms(i, e) {
+    var a, r, o;
+    const n = this.request(this.url + "/statistics", { query: { variable: i, f: "json" }, signal: e }).then((l) => {
+      var c;
+      return (c = l.data) == null ? void 0 : c.statistics;
+    }), t = this.request(this.url + "/histograms", { query: { variable: i, f: "json" }, signal: e }).then((l) => {
+      var c;
+      return (c = l.data) == null ? void 0 : c.histograms;
+    }), s = await Promise.all([n, t]);
+    return s[0] && s[0].forEach((l) => {
+      l.avg = l.mean, l.stddev = l.standardDeviation;
+    }), (o = (r = (a = s[1]) == null ? void 0 : a[0]) == null ? void 0 : r.counts) != null && o.length || (s[1] = null), { statistics: s[0] || null, histograms: s[1] || null };
+  }
+  async computeBestPyramidLevelForLocation(i, e = {}) {
+    if (!this._tilemapCache)
+      return 0;
+    let n = this.identifyPixelLocation(i, 0, e.datumTransformation);
+    if (n === null)
+      return null;
+    let t = 0;
+    const { maximumPyramidLevel: s } = this.rasterInfo.storageInfo;
+    let a = s - t + this._levelOffset;
+    const r = n.srcLocation;
+    for (; a >= 0; ) {
+      try {
+        if (await this._tilemapCache.fetchAvailability(a, n.row, n.col, e) === "available")
+          break;
+      } catch {
+      }
+      if (a--, t++, n = this.identifyPixelLocation(r, t, e.datumTransformation), n === null)
+        return null;
+    }
+    return a === -1 || n == null ? null : t;
+  }
+  async _fetchRasterInfo(i) {
+    const e = this.sourceJSON;
+    if (this.tileType === "Map") {
+      const r = e.fullExtent || e.extent, o = Math.ceil((r.xmax - r.xmin) / e.pixelSizeX - 0.1), l = Math.ceil((r.ymax - r.ymin) / e.pixelSizeY - 0.1), c = L.fromJSON(e.spatialReference || r.spatialReference), h = new A({ x: e.pixelSizeX, y: e.pixelSizeY, spatialReference: c });
+      return new xe({ width: o, height: l, bandCount: 3, extent: z.fromJSON(r), spatialReference: c, pixelSize: h, pixelType: "u8", statistics: null, keyProperties: { DataType: "processed" } });
+    }
+    const { signal: n } = i, t = ai(this.url, this.sourceJSON, { signal: n, query: this.ioConfig.customFetchParameters }), s = e.hasMultidimensions ? this.request(`${this.url}/slices`, { query: { f: "json" }, signal: n }).then((r) => {
+      var o;
+      return (o = r.data) == null ? void 0 : o.slices;
+    }).catch(() => null) : null, a = await Promise.all([t, s]);
+    return this._slices = a[1], a[0];
+  }
+  _fixScaleInServiceInfo() {
+    const { sourceJSON: i } = this;
+    i.minScale && i.minScale < 0 && (i.minScale = 0), i.maxScale && i.maxScale < 0 && (i.maxScale = 0);
+  }
+  _fixGCSShift(i) {
+    const { extent: e, spatialReference: n } = i;
+    e.xmin > -1 && e.xmax > 181 && (n != null && n.wkid) && n.isGeographic && (i.nativeExtent = i.extent, i.transform = new Wi(), i.extent = i.transform.forwardTransform(e));
+  }
+  _computeMinMaxLOD(i, e) {
+    const { pixelSize: n } = i, t = 0.5 / i.width * n.x, { lods: s } = e, a = e.lodAt(Math.max.apply(null, s.map((m) => m.level))), r = e.lodAt(Math.min.apply(null, s.map((m) => m.level))), { tileType: o } = this;
+    if (o === "Map")
+      return this._levelOffset = s[0].level, [a, r];
+    if (o === "Raster")
+      return [s.find((m) => m.resolution === n.x) ?? a, r];
+    const { minScale: l, maxScale: c } = this.sourceJSON;
+    let h = a;
+    c > 0 && (h = s.find((m) => Math.abs(m.scale - c) < t), h || (h = s.filter((m) => m.scale > c).sort((m, f) => m.scale > f.scale ? 1 : -1)[0] ?? a));
+    let u = r;
+    return l > 0 && (u = s.find((m) => Math.abs(m.scale - l) < t) ?? r, this._levelOffset = u.level - r.level), [h, u];
+  }
+};
+function xs(i, e) {
+  if (!i)
+    return null;
+  const { minScale: n, maxScale: t, minLOD: s, maxLOD: a } = e;
+  if (s != null && a != null)
+    return te.fromJSON({ ...i, lods: i.lods.filter(({ level: r }) => r != null && r >= s && r <= a) });
+  if (n !== 0 && t !== 0) {
+    const r = (c) => Math.round(1e4 * c) / 1e4, o = n ? r(n) : 1 / 0, l = t ? r(t) : -1 / 0;
+    return te.fromJSON({ ...i, lods: i.lods.filter((c) => {
+      const h = r(c.scale);
+      return h <= o && h >= l;
+    }) });
+  }
+  return te.fromJSON(i);
+}
+I([v({ type: String, json: { write: !0 } })], ye.prototype, "datasetFormat", void 0), I([v()], ye.prototype, "tileType", void 0), ye = I([K("esri.layers.support.rasterDatasets.ImageServerRaster")], ye);
+const ws = ye, Q = /* @__PURE__ */ new Map();
+Q.set("Int8", "s8"), Q.set("UInt8", "u8"), Q.set("Int16", "s16"), Q.set("UInt16", "u16"), Q.set("Int32", "s32"), Q.set("UInt32", "u32"), Q.set("Float32", "f32"), Q.set("Float64", "f32"), Q.set("Double64", "f32");
+const ie = /* @__PURE__ */ new Map();
+ie.set("none", { blobExtension: ".til", isOneSegment: !0, decoderFormat: "bip" }), ie.set("lerc", { blobExtension: ".lrc", isOneSegment: !1, decoderFormat: "lerc" }), ie.set("deflate", { blobExtension: ".pzp", isOneSegment: !0, decoderFormat: "deflate" }), ie.set("jpeg", { blobExtension: ".pjg", isOneSegment: !0, decoderFormat: "jpg" });
+let ue = class extends se {
+  constructor() {
+    super(...arguments), this._files = null, this._storageIndex = null, this.datasetFormat = "MRF";
+  }
+  async open(i) {
+    await this.init(), this.datasetName = this.url.slice(this.url.lastIndexOf("/") + 1);
+    const e = i ? i.signal : null, n = await this.request(this.url, { responseType: "xml", signal: e }), { rasterInfo: t, files: s } = this._parseHeader(n.data), { skipMapInfo: a, skipExtensions: r = [] } = this.ioConfig;
+    if (!r.includes("aux.xml") && !a) {
+      const y = await this._fetchAuxiliaryData(i);
+      y != null && (t.statistics = y.statistics ?? t.statistics, t.histograms = y.histograms, y.histograms && t.statistics == null && (t.statistics = Ge(y.histograms)));
+    }
+    a && this.updateImageSpaceRasterInfo(t), this._set("rasterInfo", t), this._files = s;
+    const o = await this.request(s.index, { responseType: "array-buffer", signal: e });
+    this._storageIndex = this._parseIndex(o.data);
+    const { blockWidth: l, blockHeight: c } = this.rasterInfo.storageInfo, h = this.rasterInfo.storageInfo.pyramidScalingFactor, { width: u, height: m } = this.rasterInfo, f = [], d = this._getBandSegmentCount();
+    let g = 0, p = -1;
+    for (; g < this._storageIndex.length; ) {
+      p++;
+      const y = Math.ceil(u / l / h ** p) - 1, x = Math.ceil(m / c / h ** p) - 1;
+      g += (y + 1) * (x + 1) * d * 4, f.push({ maxRow: x, maxCol: y, minCol: 0, minRow: 0 });
+    }
+    this.rasterInfo.storageInfo.blockBoundary = f, p > 0 && (this.rasterInfo.storageInfo.firstPyramidLevel = 1, this.rasterInfo.storageInfo.maximumPyramidLevel = p), this.updateTileInfo();
+  }
+  async fetchRawTile(i, e, n, t = {}) {
+    const { blockWidth: s, blockHeight: a, blockBoundary: r } = this.rasterInfo.storageInfo, o = r[i];
+    if (!o || o.maxRow < e || o.maxCol < n || o.minRow > e || o.minCol > n)
+      return null;
+    const { bandCount: l, pixelType: c } = this.rasterInfo, { ranges: h, actualTileWidth: u, actualTileHeight: m } = this._getTileLocation(i, e, n);
+    if (!h || h.length === 0)
+      return null;
+    if (h[0].from === 0 && h[0].to === 0) {
+      const M = new Uint8Array(s * a);
+      return new Y({ width: s, height: a, pixels: null, mask: M, validPixelCount: 0 });
+    }
+    const { bandIds: f } = this.ioConfig, d = this._getBandSegmentCount(), g = [];
+    let p = 0;
+    for (p = 0; p < d; p++)
+      f && !f.includes(p) || g.push(this.request(this._files.data, { range: { from: h[p].from, to: h[p].to }, responseType: "array-buffer", signal: t.signal }));
+    const y = await Promise.all(g), x = y.map((M) => M.data.byteLength).reduce((M, P) => M + P), w = new Uint8Array(x), S = [];
+    let T = 0;
+    for (p = 0; p < d; p++)
+      S.push(T), w.set(new Uint8Array(y[p].data), T), T += y[p].data.byteLength;
+    const b = ie.get(this.rasterInfo.storageInfo.compression).decoderFormat, _ = await this.decodePixelBlock(w.buffer, { width: s, height: a, format: b, planes: (f == null ? void 0 : f.length) || l, offsets: S, pixelType: c });
+    if (_ == null)
+      return null;
+    let { noDataValue: F } = this.rasterInfo;
+    if (F != null && b !== "lerc" && !_.mask && (F = F[0], F != null)) {
+      const M = _.width * _.height, P = new Uint8Array(M);
+      if (Math.abs(F) > 1e24)
+        for (p = 0; p < M; p++)
+          Math.abs((_.pixels[0][p] - F) / F) > 1e-6 && (P[p] = 1);
+      else
+        for (p = 0; p < M; p++)
+          _.pixels[0][p] !== F && (P[p] = 1);
+      _.mask = P;
+    }
+    let R = 0, k = 0;
+    if (u !== s || m !== a) {
+      let M = _.mask;
+      if (M)
+        for (p = 0; p < a; p++)
+          if (k = p * s, p < m)
+            for (R = u; R < s; R++)
+              M[k + R] = 0;
+          else
+            for (R = 0; R < s; R++)
+              M[k + R] = 0;
+      else
+        for (M = new Uint8Array(s * a), _.mask = M, p = 0; p < m; p++)
+          for (k = p * s, R = 0; R < u; R++)
+            M[k + R] = 1;
+    }
+    return _;
+  }
+  _parseIndex(i) {
+    if (i.byteLength % 16 > 0)
+      throw new Error("invalid array buffer must be multiples of 16");
+    let e, n, t, s, a, r;
+    if (gi) {
+      for (n = new Uint8Array(i), s = new ArrayBuffer(i.byteLength), t = new Uint8Array(s), a = 0; a < i.byteLength / 4; a++)
+        for (r = 0; r < 4; r++)
+          t[4 * a + r] = n[4 * a + 3 - r];
+      e = new Uint32Array(s);
+    } else
+      e = new Uint32Array(i);
+    return e;
+  }
+  _getBandSegmentCount() {
+    return ie.get(this.rasterInfo.storageInfo.compression).isOneSegment ? 1 : this.rasterInfo.bandCount;
+  }
+  _getTileLocation(i, e, n) {
+    const { blockWidth: t, blockHeight: s, pyramidScalingFactor: a } = this.rasterInfo.storageInfo, { width: r, height: o } = this.rasterInfo, l = this._getBandSegmentCount();
+    let c, h, u, m = 0, f = 0;
+    for (u = 0; u < i; u++)
+      f = a ** u, c = Math.ceil(r / t / f), h = Math.ceil(o / s / f), m += c * h;
+    f = a ** i, c = Math.ceil(r / t / f), h = Math.ceil(o / s / f), m += e * c + n, m *= 4 * l;
+    const d = this._storageIndex.subarray(m, m + 4 * l);
+    let g = 0, p = 0;
+    const y = [];
+    for (let x = 0; x < l; x++)
+      g = d[4 * x] * 2 ** 32 + d[4 * x + 1], p = g + d[4 * x + 2] * 2 ** 32 + d[4 * x + 3], y.push({ from: g, to: p });
+    return { ranges: y, actualTileWidth: n < c - 1 ? t : Math.ceil(r / f) - t * (c - 1), actualTileHeight: e < h - 1 ? s : Math.ceil(o / f) - s * (h - 1) };
+  }
+  _parseHeader(i) {
+    const e = V(i, "MRF_META/Raster");
+    if (!e)
+      throw new O("mrf:open", "not a valid MRF format");
+    const n = V(e, "Size"), t = parseInt(n.getAttribute("x"), 10), s = parseInt(n.getAttribute("y"), 10), a = parseInt(n.getAttribute("c"), 10), r = (Z(e, "Compression") || "none").toLowerCase();
+    if (!ie.has(r))
+      throw new O("mrf:open", "currently does not support compression " + r);
+    const o = Z(e, "DataType") || "UInt8", l = Q.get(o);
+    if (l == null)
+      throw new O("mrf:open", "currently does not support pixel type " + o);
+    const c = V(e, "PageSize"), h = parseInt(c.getAttribute("x"), 10), u = parseInt(c.getAttribute("y"), 10), m = V(e, "DataValues");
+    let f, d;
+    if (m && (d = m.getAttribute("NoData"), d != null && (f = d.trim().split(" ").map((M) => parseFloat(M)))), V(i, "MRF_META/CachedSource"))
+      throw new O("mrf:open", "currently does not support MRF referencing other data files");
+    const g = V(i, "MRF_META/GeoTags"), p = V(g, "BoundingBox");
+    let y, x = !1;
+    if (p != null) {
+      const M = parseFloat(p.getAttribute("minx")), P = parseFloat(p.getAttribute("miny")), B = parseFloat(p.getAttribute("maxx")), C = parseFloat(p.getAttribute("maxy")), $ = Z(g, "Projection") || "";
+      let D = L.WGS84;
+      if ($ !== "LOCAL_CS[]")
+        if ($.toLowerCase().startsWith("epsg:")) {
+          const E = Number($.slice(5));
+          isNaN(E) || E === 0 || (D = new L({ wkid: E }));
+        } else
+          D = Fe($) ?? L.WGS84;
+      else
+        x = !0, D = new L({ wkid: 3857 });
+      y = new z(M, P, B, C), y.spatialReference = D;
+    } else
+      x = !0, y = new z({ xmin: -0.5, ymin: 0.5 - s, xmax: t - 0.5, ymax: 0.5, spatialReference: new L({ wkid: 3857 }) });
+    const w = V(i, "MRF_META/Rsets"), S = parseInt((w == null ? void 0 : w.getAttribute("scale")) || "2", 10), T = y.spatialReference, b = new ge({ origin: new A({ x: y.xmin, y: y.ymax, spatialReference: T }), blockWidth: h, blockHeight: u, pyramidBlockWidth: h, pyramidBlockHeight: u, compression: r, pyramidScalingFactor: S }), _ = new A({ x: y.width / t, y: y.height / s, spatialReference: T }), F = new xe({ width: t, height: s, extent: y, isPseudoSpatialReference: x, spatialReference: T, bandCount: a, pixelType: l, pixelSize: _, noDataValue: f, storageInfo: b }), R = Z(i, "datafile"), k = Z(i, "IndexFile");
+    return { rasterInfo: F, files: { mrf: this.url, index: k || this.url.replace(".mrf", ".idx"), data: R || this.url.replace(".mrf", ie.get(r).blobExtension) } };
+  }
+  async _fetchAuxiliaryData(i) {
+    try {
+      const { data: e } = await this.request(this.url + ".aux.xml", { responseType: "xml", signal: i == null ? void 0 : i.signal });
+      return Ue(e);
+    } catch {
+      return null;
+    }
+  }
+};
+I([v()], ue.prototype, "_files", void 0), I([v()], ue.prototype, "_storageIndex", void 0), I([v({ type: String, json: { write: !0 } })], ue.prototype, "datasetFormat", void 0), ue = I([K("esri.layers.support.rasterIO.MRFRaster")], ue);
+const Is = ue, De = (i, e) => {
+  var n;
+  return (n = i.get(e)) == null ? void 0 : n.values;
+}, me = (i, e) => {
+  var n, t;
+  return (t = (n = i.get(e)) == null ? void 0 : n.values) == null ? void 0 : t[0];
+};
+let ae = class extends se {
+  constructor() {
+    super(...arguments), this._files = null, this._headerInfo = null, this._bufferSize = 1048576, this.datasetFormat = "TIFF";
+  }
+  async open(i) {
+    var g, p, y, x;
+    await this.init();
+    const e = i ? i.signal : null, { data: n } = await this.request(this.url, { range: { from: 0, to: this._bufferSize }, responseType: "array-buffer", signal: e });
+    if (!n)
+      throw new O("tiffraster:open", "failed to open url " + this.url);
+    this.datasetName = this.url.slice(this.url.lastIndexOf("/") + 1, this.url.lastIndexOf("."));
+    const { littleEndian: t, firstIFDPos: s, isBigTiff: a } = xi(n), r = [];
+    await this._readIFDs(r, n, t, s, 0, a ? 8 : 4, e);
+    const { imageInfo: o, rasterInfo: l } = this._parseIFDs(r), c = wi(r), h = Ii(r);
+    if (this._headerInfo = { littleEndian: t, isBigTiff: a, ifds: r, pyramidIFDs: c, maskIFDs: h, ...o }, this._set("rasterInfo", l), !o.isSupported)
+      throw new O("tiffraster:open", "this tiff is not supported: " + o.message);
+    if (!o.tileWidth)
+      throw new O("tiffraster:open", "none-tiled tiff is not optimized for access, convert to COG and retry.");
+    l.isPseudoSpatialReference && le.getLogger(this).warn("The spatial reference for this tiff is unsupported. Only EPSG spatial reference codes and Esri WKTs are supported.");
+    const u = (p = (g = r[0].get("PREDICTOR")) == null ? void 0 : g.values) == null ? void 0 : p[0];
+    if (((x = (y = r[0].get("SAMPLEFORMAT")) == null ? void 0 : y.values) == null ? void 0 : x[0]) === 3 && u === 2)
+      throw new O("tiffraster:open", "unsupported horizontal difference encoding. Predictor=3 is supported for floating point data");
+    const { skipMapInfo: f, skipExtensions: d = [] } = this.ioConfig;
+    if (!d.includes("aux.xml") && !f) {
+      const w = await this._fetchAuxiliaryMetaData(i);
+      w != null && this._processPAMInfo(w, l);
+    }
+    d.includes("vat.dbf") || l.bandCount !== 1 || l.pixelType !== "u8" || f || (l.attributeTable = await this._fetchAuxiliaryTable(i), l.attributeTable != null && (l.keyProperties.DataType = "thematic")), f && this.updateImageSpaceRasterInfo(l), this.updateTileInfo();
+  }
+  async fetchRawTile(i, e, n, t = {}) {
+    var a;
+    if (!((a = this._headerInfo) != null && a.isSupported) || this.isBlockOutside(i, e, n))
+      return null;
+    const s = await this._fetchRawTiffTile(i, e, n, !1, t);
+    if (s != null && this._headerInfo.hasMaskBand) {
+      const r = await this._fetchRawTiffTile(i, e, n, !0, t);
+      r != null && r.pixels[0] instanceof Uint8Array && (s.mask = r.pixels[0]);
+    }
+    return s;
+  }
+  _parseIFDs(i) {
+    var P, B;
+    const e = bi(i), { width: n, height: t, tileWidth: s, tileHeight: a, planes: r, pixelType: o, compression: l, firstPyramidLevel: c, maximumPyramidLevel: h, pyramidBlockWidth: u, pyramidBlockHeight: m, tileBoundary: f, affine: d, metadata: g } = e, p = ((P = e.extent.spatialReference) == null ? void 0 : P.wkt) || ((B = e.extent.spatialReference) == null ? void 0 : B.wkid);
+    let y = Fe(p), x = !!e.isPseudoGeographic;
+    y == null && (x = !0, y = new L({ wkid: 3857 }));
+    const w = new z({ ...e.extent, spatialReference: y }), S = new A(w ? { x: w.xmin, y: w.ymax, spatialReference: y } : { x: 0, y: 0 }), T = new ge({ blockWidth: s, blockHeight: a, pyramidBlockWidth: u, pyramidBlockHeight: m, compression: l, origin: S, firstPyramidLevel: c, maximumPyramidLevel: h, blockBoundary: f }), b = new A({ x: (w.xmax - w.xmin) / n, y: (w.ymax - w.ymin) / t, spatialReference: y }), _ = g ? { BandProperties: g.bandProperties, DataType: g.dataType } : {};
+    let F = null;
+    const R = me(i[0], "PHOTOMETRICINTERPRETATION"), k = De(i[0], "COLORMAP");
+    if (R <= 3 && (k == null ? void 0 : k.length) > 3 && k.length % 3 == 0) {
+      F = [];
+      const C = k.length / 3;
+      for (let $ = 0; $ < C; $++)
+        F.push([$, k[$] >>> 8, k[$ + C] >>> 8, k[$ + 2 * C] >>> 8]);
+    }
+    const M = new xe({ width: n, height: t, bandCount: r, pixelType: o, pixelSize: b, storageInfo: T, spatialReference: y, isPseudoSpatialReference: x, keyProperties: _, extent: w, colormap: F, statistics: g ? g.statistics : null });
+    return d != null && d.length && (M.nativeExtent = new z({ xmin: -0.5, ymin: 0.5 - t, xmax: n - 0.5, ymax: 0.5, spatialReference: y }), M.transform = new je({ polynomialOrder: 1, forwardCoefficients: [d[2] + d[0] / 2, d[5] - d[3] / 2, d[0], d[3], -d[1], -d[4]] }), M.extent = M.transform.forwardTransform(M.nativeExtent), M.pixelSize = new A({ x: (w.xmax - w.xmin) / n, y: (w.ymax - w.ymin) / t, spatialReference: y }), T.origin.x = -0.5, T.origin.y = 0.5), { imageInfo: e, rasterInfo: M };
+  }
+  _processPAMInfo(i, e) {
+    if (e.statistics = i.statistics ?? e.statistics, e.histograms = i.histograms, i.histograms && e.statistics == null && (e.statistics = Ge(i.histograms)), i.transform && e.transform == null) {
+      e.transform = i.transform, e.nativeExtent = e.extent;
+      const n = e.transform.forwardTransform(e.nativeExtent);
+      e.pixelSize = new A({ x: (n.xmax - n.xmin) / e.width, y: (n.ymax - n.ymin) / e.height, spatialReference: e.spatialReference }), e.extent = n;
+    }
+    e.isPseudoSpatialReference && i.spatialReference && (e.spatialReference = i.spatialReference, e.extent.spatialReference = e.nativeExtent.spatialReference = e.storageInfo.origin.spatialReference = e.spatialReference);
+  }
+  async _readIFDs(i, e, n, t, s, a = 4, r) {
+    if (!t)
+      return null;
+    (t >= e.byteLength || t < 0) && (e = (await this.request(this.url, { range: { from: t + s, to: t + s + this._bufferSize }, responseType: "array-buffer", signal: r })).data, s = t + s, t = 0);
+    const o = await this._readIFD(e, n, t, s, we.tiffTags, a, r);
+    if (i.push(o.ifd), !o.nextIFD)
+      return null;
+    await this._readIFDs(i, e, n, o.nextIFD - s, s, a, r);
+  }
+  async _readIFD(i, e, n, t, s = we.tiffTags, a = 4, r) {
+    var l, c;
+    if (!i)
+      return null;
+    const o = Si(i, e, n, t, s, a);
+    if (o.success) {
+      const h = [];
+      if ((l = o.ifd) == null || l.forEach((u) => {
+        u.values || h.push(u);
+      }), h.length > 0) {
+        const u = h.map((f) => f.offlineOffsetSize).filter(Be), m = Math.min.apply(null, u.map((f) => f[0]));
+        if (Math.min.apply(null, u.map((f) => f[0] + f[1])) - m <= this._bufferSize) {
+          const { data: f } = await this.request(this.url, { range: { from: m, to: m + this._bufferSize }, responseType: "array-buffer", signal: r });
+          i = f, t = m, h.forEach((d) => Ri(i, e, d, t));
+        }
+      }
+      if ((c = o.ifd) != null && c.has("GEOKEYDIRECTORY")) {
+        const u = o.ifd.get("GEOKEYDIRECTORY"), m = u == null ? void 0 : u.values;
+        if (m && m.length > 4) {
+          const f = m[0] + "." + m[1] + "." + m[2], d = await this._readIFD(i, e, u.valueOffset + 6 - t, t, we.geoKeys, 2, r);
+          u.data = d.ifd, u.data && u.data.set("GEOTIFFVersion", { id: 0, type: 2, valueCount: 1, valueOffset: null, values: [f] });
+        }
+      }
+      return o;
+    }
+    if (o.requiredBufferSize && o.requiredBufferSize !== i.byteLength)
+      return (i = (await this.request(this.url, { range: { from: t, to: t + o.requiredBufferSize + 4 }, responseType: "array-buffer", signal: r })).data).byteLength < o.requiredBufferSize ? null : this._readIFD(i, e, 0, t, we.tiffTags, 4, r);
+  }
+  async _fetchRawTiffTile(i, e, n, t, s = {}) {
+    const a = this._getTileLocation(i, e, n, t);
+    if (!a)
+      return null;
+    const { ranges: r, actualTileWidth: o, actualTileHeight: l, ifd: c } = a, h = r.map((b) => this.request(this.url, { range: b, responseType: "array-buffer", signal: s.signal })), u = await Promise.all(h), m = u.map((b) => b.data.byteLength).reduce((b, _) => b + _), f = u.length === 1 ? u[0].data : new ArrayBuffer(m), d = [0], g = [0];
+    if (u.length > 1) {
+      const b = new Uint8Array(f);
+      for (let _ = 0, F = 0; _ < u.length; _++) {
+        const R = u[_].data;
+        b.set(new Uint8Array(R), F), d[_] = F, F += R.byteLength, g[_] = R.byteLength;
+      }
+    }
+    const { blockWidth: p, blockHeight: y } = this.getBlockWidthHeight(i), x = await this.decodePixelBlock(f, { format: "tiff", customOptions: { headerInfo: this._headerInfo, ifd: c, offsets: d, sizes: g }, width: p, height: y, planes: null, pixelType: null });
+    if (x == null)
+      return null;
+    let w, S, T;
+    if (o !== p || l !== y) {
+      let b = x.mask;
+      if (b)
+        for (w = 0; w < y; w++)
+          if (T = w * p, w < l)
+            for (S = o; S < p; S++)
+              b[T + S] = 0;
+          else
+            for (S = 0; S < p; S++)
+              b[T + S] = 0;
+      else
+        for (b = new Uint8Array(p * y), x.mask = b, w = 0; w < l; w++)
+          for (T = w * p, S = 0; S < o; S++)
+            b[T + S] = 1;
+    }
+    return x;
+  }
+  _getTileLocation(i, e, n, t = !1) {
+    const { firstPyramidLevel: s, blockBoundary: a } = this.rasterInfo.storageInfo, r = i === 0 ? 0 : i - (s - 1), { _headerInfo: o } = this;
+    if (!o)
+      return null;
+    const l = t ? o.maskIFDs[r] : r === 0 ? o == null ? void 0 : o.ifds[0] : o == null ? void 0 : o.pyramidIFDs[r - 1];
+    if (!l)
+      return null;
+    const c = vi(l, o), h = De(l, "TILEOFFSETS");
+    if (h === void 0)
+      return null;
+    const u = De(l, "TILEBYTECOUNTS"), { minRow: m, minCol: f, maxRow: d, maxCol: g } = a[r];
+    if (e > d || n > g || e < m || n < f)
+      return null;
+    const p = me(l, "IMAGEWIDTH"), y = me(l, "IMAGELENGTH"), x = me(l, "TILEWIDTH"), w = me(l, "TILELENGTH"), S = [];
+    if (c) {
+      const { bandCount: T } = this.rasterInfo;
+      for (let b = 0; b < T; b++) {
+        const _ = b * (d + 1) * (g + 1) + e * (g + 1) + n;
+        S[b] = { from: h[_], to: h[_] + u[_] - 1 };
+      }
+    } else {
+      const T = e * (g + 1) + n;
+      S.push({ from: h[T], to: h[T] + u[T] - 1 });
+    }
+    for (let T = 0; T < S.length; T++)
+      if (S[T].from == null || !S[T].to || S[T].to < 0)
+        return null;
+    return { ranges: S, ifd: l, actualTileWidth: n === g && p % x || x, actualTileHeight: e === d && y % w || w };
+  }
+  async _fetchAuxiliaryMetaData(i) {
+    try {
+      const { data: e } = await this.request(this.url + ".aux.xml", { responseType: "xml", signal: i == null ? void 0 : i.signal });
+      return Ue(e);
+    } catch {
+      return null;
+    }
+  }
+  async _fetchAuxiliaryTable(i) {
+    try {
+      const { data: e } = await this.request(this.url + ".vat.dbf", { responseType: "array-buffer", signal: i == null ? void 0 : i.signal }), n = It.parse(e);
+      return n != null && n.recordSet ? _e.fromJSON(n.recordSet) : null;
+    } catch {
+      return null;
+    }
+  }
+};
+I([v()], ae.prototype, "_files", void 0), I([v()], ae.prototype, "_headerInfo", void 0), I([v()], ae.prototype, "_bufferSize", void 0), I([v({ type: String, json: { write: !0 } })], ae.prototype, "datasetFormat", void 0), ae = I([K("esri.layers.support.rasterDatasets.TIFFRaster")], ae);
+const bs = ae, j = /* @__PURE__ */ new Map();
+j.set("CRF", { desc: "Cloud Raster Format", constructor: ls }), j.set("MRF", { desc: "Meta Raster Format", constructor: Is }), j.set("TIFF", { desc: "GeoTIFF", constructor: bs }), j.set("RasterTileServer", { desc: "Raster Tile Server", constructor: ws }), j.set("JPG", { desc: "JPG Raster Format", constructor: Re }), j.set("PNG", { desc: "PNG Raster Format", constructor: Re }), j.set("GIF", { desc: "GIF Raster Format", constructor: Re }), j.set("BMP", { desc: "BMP Raster Format", constructor: Re }), j.set("CovJSON", { desc: "COVJSON Raster Format", constructor: ps }), j.set("MEMORY", { desc: "In Memory Raster Format", constructor: qe });
+class Ne {
+  static get supportedFormats() {
+    const e = /* @__PURE__ */ new Set();
+    return j.forEach((n, t) => e.add(t)), e;
+  }
+  static async open(e) {
+    var u;
+    const { url: n, ioConfig: t, source: s, sourceJSON: a } = e;
+    let r = e.datasetFormat ?? (t == null ? void 0 : t.datasetFormat);
+    r == null && (n.includes(".") ? r = n.slice(n.lastIndexOf(".") + 1).toUpperCase() : ((u = s == null ? void 0 : s.type) == null ? void 0 : u.toLowerCase()) === "coverage" ? r = "CovJSON" : s != null && s.extent && s.pixelblocks && (r = "MEMORY")), r === "OVR" || r === "TIF" ? r = "TIFF" : r === "JPG" || r === "JPEG" || r === "JFIF" ? r = "JPG" : r === "COVJSON" && (r = "CovJSON"), n.toLowerCase().includes("/imageserver") && !n.toLowerCase().includes("/wcsserver") && (r = "RasterTileServer");
+    const o = { url: n, source: s, sourceJSON: a, datasetFormat: r, ioConfig: t ?? { bandIds: null, sampling: null } };
+    if (Object.keys(o).forEach((m) => {
+      o[m] == null && delete o[m];
+    }), r) {
+      if (!this.supportedFormats.has(r))
+        throw new O("rasterfactory:open", "not a supported format " + r);
+      if (r === "CRF" && !(t != null && t.enableCRF))
+        throw new O("rasterfactory:open", `cannot open raster: ${n}`);
+      const m = new (j.get(r)).constructor(o);
+      return await m.open({ signal: e.signal }), m;
+    }
+    const l = Array.from(j.keys()).filter((m) => m !== "CovJSON" && m !== "Memory");
+    let c = 0;
+    const h = () => {
+      if (r = l[c++], !r || r === "CRF" && !(t != null && t.enableCRF))
+        return null;
+      const m = new (j.get(r)).constructor(o);
+      return m.open({ signal: e.signal }).then(() => m).catch(() => h());
+    };
+    return h();
+  }
+  static register(e, n, t) {
+    j.has(e.toUpperCase()) || j.set(e.toUpperCase(), { desc: n, constructor: t });
+  }
+}
+let J = class extends Xt(Vi(ji(qi(Yt(as(Xi(Vt(Ui(Ut(At(qt))))))))))) {
+  constructor(...i) {
+    super(...i), this._primaryRasters = [], this.bandIds = null, this.interpolation = null, this.legendEnabled = !0, this.isReference = null, this.listMode = "show", this.sourceJSON = null, this.version = null, this.type = "imagery-tile", this.operationalLayerType = "ArcGISTiledImageServiceLayer", this.popupEnabled = !0, this.popupTemplate = null, this.fields = null, this.source = void 0, this._debouncedSaveOperations = zt(async (e, n, t) => {
+      const { save: s, saveAs: a } = await import("./imageryUtils-04032523.js");
+      switch (e) {
+        case be.SAVE:
+          return s(this, n);
+        case be.SAVE_AS:
+          return a(this, t, n);
+      }
+    });
+  }
+  normalizeCtorArgs(i, e) {
+    return typeof i == "string" ? { url: i, ...e } : i;
+  }
+  load(i) {
+    const e = i != null ? i.signal : null;
+    return this.addResolvingPromise(this.loadFromPortal({ supportedTypes: ["Image Service"] }, i).catch(Lt).then(() => this._openRaster(e))), Promise.resolve(this);
+  }
+  get defaultPopupTemplate() {
+    return this.createPopupTemplate();
+  }
+  get rasterFields() {
+    var o;
+    const i = [new he({ name: "Raster.ServicePixelValue", alias: "Pixel Value", domain: null, editable: !1, length: 50, type: "string" }), new he({ name: "Raster.ServicePixelValue.Raw", alias: "Raw Pixel Value", domain: null, editable: !1, length: 50, type: "string" })], { serviceRasterInfo: e } = this, n = e == null ? void 0 : e.attributeTable, t = n != null ? n.fields : null, s = "Raster.";
+    if (t) {
+      const l = t.filter((c) => c.type !== "oid" && c.name.toLowerCase() !== "value").map((c) => {
+        const h = c.clone();
+        return h.name = s + c.name, h;
+      });
+      i.push(...l);
+    }
+    const a = e == null ? void 0 : e.dataType, r = e == null ? void 0 : e.multidimensionalInfo;
+    if ((a === "vector-magdir" || a === "vector-uv") && r != null) {
+      const l = (o = r.variables[0].unit) == null ? void 0 : o.trim(), c = "Magnitude" + (l ? ` (${l})` : "");
+      i.push(new he({ name: "Raster.Magnitude", alias: c, domain: null, editable: !1, type: "double" })), i.push(new he({ name: "Raster.Direction", alias: "Direction (°)", domain: null, editable: !1, type: "double" }));
+    }
+    return i;
+  }
+  createPopupTemplate(i) {
+    const { rasterFields: e } = this, n = new Set(e.map(({ name: t }) => t).filter((t) => t.toLowerCase() !== "raster.servicepixelvalue.raw"));
+    return Ki({ fields: e, title: this.title }, { ...i, visibleFieldNames: n });
+  }
+  async generateRasterInfo(i, e) {
+    if (!(i = Le(Ee, i)))
+      return this.serviceRasterInfo;
+    try {
+      const { rasterInfo: n } = await this._openFunctionRaster(i, e);
+      return n;
+    } catch (n) {
+      throw n instanceof O ? n : new O("imagery-tile-layer", "the given raster function is not supported");
+    }
+  }
+  async save(i) {
+    return this._debouncedSaveOperations(be.SAVE, i);
+  }
+  async saveAs(i, e) {
+    return this._debouncedSaveOperations(be.SAVE_AS, e, i);
+  }
+  write(i, e) {
+    const n = this._primaryRasters[0] ?? this.raster;
+    if (this.loaded ? n.datasetFormat === "RasterTileServer" && (n.tileType === "Raster" || n.tileType === "Map") : this.url && /\/ImageServer(\/|\/?$)/i.test(this.url))
+      return super.write(i, e);
+    if (e != null && e.messages) {
+      const t = `${e.origin}/${e.layerContainerType || "operational-layers"}`;
+      e.messages.push(new O("layer:unsupported", `Layers (${this.title}, ${this.id}) of type '${this.declaredClass}' are not supported in the context of '${t}'`, { layer: this }));
+    }
+    return null;
+  }
+  async _openRaster(i) {
+    let e = !1;
+    if (this.raster)
+      await this._openFromRaster(this.raster, i), e = this.raster.datasetFormat === "Function";
+    else {
+      const { url: t, rasterFunction: s, source: a } = this;
+      if (!t && !a)
+        throw new O("imagery-tile-layer:open", "missing url or source parameter");
+      a ? await this._openFromSource(a, i) : s ? await this._openFromUrlWithRasterFunction(t, s, i) : await this._openFromUrl(t, i);
+    }
+    const n = this.raster.rasterInfo;
+    if (!n)
+      throw new O("imagery-tile-layer:load", "cannot load resources on " + this.url);
+    if (this._set("serviceRasterInfo", e ? n : this._primaryRasters[0].rasterInfo), this._set("spatialReference", n.spatialReference), this.sourceJSON = this.sourceJSON || this.raster.sourceJSON, this.sourceJSON != null) {
+      const t = this.raster.tileType === "Map" && this.sourceJSON.minLOD != null && this.sourceJSON.maxLOD != null ? this.sourceJSON : { ...this.sourceJSON, minScale: 0, maxScale: 0 };
+      this.read(t, { origin: "service" });
+    } else
+      this.read({ tileInfo: this.serviceRasterInfo.storageInfo.tileInfo.toJSON() }, { origin: "service" });
+    this.title || (this.title = this.raster.datasetName), this.raster.tileType === "Map" && (this.popupEnabled = !1), this._configDefaultSettings(), this.addHandles(Ht(() => this.customParameters, (t) => {
+      this.raster && (this.raster.ioConfig.customFetchParameters = t);
+    }));
+  }
+  async _openFromRaster(i, e) {
+    i.rasterInfo || await i.open({ signal: e }), this._primaryRasters = i.datasetFormat === "Function" ? i.primaryRasters.rasters : [i], this.url || (this.url = this._primaryRasters[0].url);
+  }
+  async _openFromUrlWithRasterFunction(i, e, n) {
+    const t = [i];
+    e && Gi(e.toJSON(), t);
+    const s = await Promise.all(t.map((r) => Ne.open({ url: r, sourceJSON: this.sourceJSON, ioConfig: { sampling: "closest", ...this.ioConfig, customFetchParameters: this.customParameters }, signal: n }))), a = s.findIndex((r) => r == null);
+    if (a > -1)
+      throw new O("imagery-tile-layer:open", `cannot open raster: ${t[a]}`);
+    return this._primaryRasters = s, this._initializeWithFunctionRaster(e);
+  }
+  async _openFromUrl(i, e) {
+    const n = await Ne.open({ url: i, sourceJSON: this.sourceJSON, ioConfig: { sampling: "closest", ...this.ioConfig, customFetchParameters: this.customParameters }, signal: e });
+    if (n == null)
+      throw new O("imagery-tile-layer:open", `cannot open raster: ${i}`);
+    this._primaryRasters = [n], this.raster = n;
+  }
+  async _openFromSource(i, e) {
+    var a;
+    const n = "the tiled imagery data source is not supported", t = ((a = i.type) == null ? void 0 : a.toLowerCase()) === "coverage" ? "CovJSON" : i.extent && i.pixelBlock ? "MEMORY" : null;
+    if (!t)
+      throw new O("imagery-tile-layer:open", n);
+    t === "MEMORY" && (i = { extent: i.extent, pixelBlocks: [i.pixelBlock] });
+    const s = await Ne.open({ url: "", source: i, datasetFormat: t, ioConfig: { sampling: "closest", ...this.ioConfig, customFetchParameters: this.customParameters }, signal: e });
+    if (s == null)
+      throw new O("imagery-tile-layer:open", n);
+    this._primaryRasters = [s], this.rasterFunction ? await this._initializeWithFunctionRaster(this.rasterFunction) : this.raster = s;
+  }
+  async _openFunctionRaster(i, e) {
+    var a;
+    const n = { raster: this._primaryRasters[0] };
+    this._primaryRasters.length > 1 && this._primaryRasters.forEach((r) => n[r.url] = r);
+    const t = xt(((a = i.functionDefinition) == null ? void 0 : a.toJSON()) ?? i.toJSON(), n), s = new wt({ rasterFunction: t });
+    return await s.open(e), s;
+  }
+  async _initializeWithFunctionRaster(i, e) {
+    try {
+      this.raster = await this._openFunctionRaster(i, e);
+    } catch (n) {
+      n instanceof O && le.getLogger(this).error("imagery-tile-layer:open", n.message), le.getLogger(this).warn("imagery-tile-layer:open", "the raster function cannot be applied and is removed"), this._set("rasterFunction", null), this.raster = this._primaryRasters[0];
+    }
+  }
+};
+I([v({ clonable: !1 })], J.prototype, "_primaryRasters", void 0), I([v({ type: [Wt], json: { write: { overridePolicy() {
+  var i;
+  return { enabled: !this.loaded || this.raster.tileType === "Raster" || ((i = this.bandIds) == null ? void 0 : i.join(",")) !== "0,1,2" };
+} } } })], J.prototype, "bandIds", void 0), I([v({ json: { write: { overridePolicy() {
+  return { enabled: !this.loaded || this.raster.tileType === "Raster" || this.interpolation !== "bilinear" };
+} } } }), Gt(oi)], J.prototype, "interpolation", void 0), I([v(li)], J.prototype, "legendEnabled", void 0), I([v({ type: Boolean, json: { read: !1, write: { enabled: !0, overridePolicy: () => ({ enabled: !1 }) } } })], J.prototype, "isReference", void 0), I([v({ type: ["show", "hide"] })], J.prototype, "listMode", void 0), I([v({ json: { read: !0, write: !0 } })], J.prototype, "blendMode", void 0), I([v()], J.prototype, "sourceJSON", void 0), I([v({ readOnly: !0, json: { origins: { service: { read: { source: "currentVersion" } } } } })], J.prototype, "version", void 0), I([v({ readOnly: !0, json: { read: !1 } })], J.prototype, "type", void 0), I([v({ type: ["ArcGISTiledImageServiceLayer"] })], J.prototype, "operationalLayerType", void 0), I([v({ type: Boolean, value: !0, json: { read: { source: "disablePopup", reader: (i, e) => !e.disablePopup }, write: { target: "disablePopup", overridePolicy() {
+  return { enabled: !this.loaded || this.raster.tileType === "Raster" };
+}, writer(i, e, n) {
+  e[n] = !i;
+} } } })], J.prototype, "popupEnabled", void 0), I([v({ type: jt, json: { read: { source: "popupInfo" }, write: { target: "popupInfo", overridePolicy() {
+  return { enabled: !this.loaded || this.raster.tileType === "Raster" };
+} } } })], J.prototype, "popupTemplate", void 0), I([v({ readOnly: !0 })], J.prototype, "defaultPopupTemplate", null), I([v({ readOnly: !0, type: [he] })], J.prototype, "fields", void 0), I([v({ readOnly: !0, type: [he] })], J.prototype, "rasterFields", null), I([v({ constructOnly: !0 })], J.prototype, "source", void 0), J = I([K("esri.layers.ImageryTileLayer")], J);
+const In = J;
+export {
+  In as default
+};