@agrotools1/at-components 0.3.4 → 0.3.5

package/dist/ImageryLayer-89c92097.js

@@ -0,0 +1,1799 @@
+import { bz as Q, e as i, y as o, c2 as T, c as b, bx as j, a$ as A, bR as se, hM as be, hL as ot, kc as lt, c5 as V, b0 as Ze, b3 as ze, bv as oe, c7 as te, c4 as M, ew as z, ev as U, U as D, dS as Ne, e7 as wt, bj as Se, ea as Be, bu as kt, dk as re, db as Wt, kd as Zt, bw as jt, fS as Ve, s as we, b2 as Kt, c6 as Fe, cT as Xt, W as I, ex as $, by as mt, o as Yt, z as er, ke as tr, hD as rr, k as ir, bO as sr, w as nr, a_ as ar } from "./index-a8d87ec0.js";
+import { m as or } from "./MultiOriginJSONSupport-ec8788e6.js";
+import { N as S, b as ve, i as Ue, j as k, c as lr, l as ur, d as pr, n as dt, a as cr, h as yt, f as mr, m as dr, p as yr, k as hr, E as gr, V as fr, K as wr, t as Rr } from "./ImageHistogramParameters-47cf0f1b.js";
+import { g as vr, d as br, c as Sr, y as xr } from "./commonProperties-3f86f534.js";
+import { m as ht, g as Ir, p as Fr, d as Dr } from "./multidimensionalUtils-705f0902.js";
+import { i as Tr, u as gt, s as jr, l as Pr } from "./dataUtils-ebb55aab.js";
+import { G as Mt, e as Jt, f as Nr, q as Or, A as _r, n as Cr, a as Et, L as $r, S as _t, P as Ar } from "./RasterSymbolizer-1644d7a7.js";
+import { b as Vr } from "./UniqueValueRenderer-56a91680.js";
+import { Z as Mr } from "./FieldsIndex-7d8f3589.js";
+import { t as Ct } from "./imageBitmapUtils-d56cd963.js";
+import { d as qt } from "./FeatureSet-29d82bc9.js";
+import { s as Jr } from "./executeQueryJSON-c5616d7b.js";
+import "./pbf-b0a9807c.js";
+import "./AttachmentInfo-1b2ece0a.js";
+import "./AttachmentQuery-470d5a03.js";
+import { s as Er, n as qr } from "./executeForIds-6a55aa95.js";
+import "./RelationshipQuery-8a39148b.js";
+import "./TopFeaturesQuery-77f00fe7.js";
+import { l as Gr } from "./ArcGISService-1e7483eb.js";
+import { n as Lr } from "./BlendLayer-ced1717f.js";
+import { e as zr } from "./CustomParametersMixin-fa9fc8f5.js";
+import { u as Ur } from "./OperationalLayer-d43d80b1.js";
+import { j as Hr } from "./PortalLayer-daca6a23.js";
+import { f as Br } from "./RefreshableLayer-a0708abb.js";
+import { t as Qr } from "./ScaleRangeLayer-dc6d9c0e.js";
+import { f as kr } from "./TemporalLayer-011ac13a.js";
+import { e as Wr } from "./versionUtils-2a4f90d3.js";
+import { p as Zr } from "./popupUtils-4b2bd688.js";
+import { A as We } from "./interfaces-fac3cfda.js";
+import "vue";
+import "./ColorStop-81b2ebbf.js";
+import "./colorRamps-4ea8b8f7.js";
+import "./visualVariableUtils-d45d2e59.js";
+import "./lengthUtils-7339106c.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./utils-7202e24d.js";
+import "./parser-65ddb097.js";
+import "./utils-a7d5b733.js";
+import "./LRUCache-948c7d75.js";
+import "./MemCache-1532e921.js";
+import "./ClassBreaksDefinition-0f6902fe.js";
+import "./ElevationInfo-a456026a.js";
+import "./unitConversionUtils-df3ffd70.js";
+import "./colorUtils-611a3fa1.js";
+import "./vec42-d5675dd5.js";
+import "./vec4f64-043e974c.js";
+import "./diffUtils-b887dbbc.js";
+import "./jsonUtils-980c608d.js";
+import "./styleUtils-52e000d6.js";
+import "./UnknownTimeZone-e62caf07.js";
+import "./query-2ab99d18.js";
+import "./pbfQueryUtils-3cd28b30.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./queryZScale-62422052.js";
+import "./jsonUtils-34961e68.js";
+import "./portalItemUtils-052627b4.js";
+import "./TimeInfo-68d2df8b.js";
+const Kr = { StretchFunction: { arguments: { ComputeGamma: { isDataset: !1, isPublic: !1, name: "ComputeGamma", type: "RasterFunctionVariable", value: !1 }, DRA: { isDataset: !1, isPublic: !1, name: "DRA", type: "RasterFunctionVariable", value: !1 }, EstimateStatsHistogram: { isDataset: !1, isPublic: !1, name: "EstimateStatsHistogram", type: "RasterFunctionVariable", value: !1 }, Gamma: { displayName: "Gamma", isDataset: !1, isPublic: !1, name: "Gamma", type: "RasterFunctionVariable" }, Histograms: { isDataset: !1, isPublic: !1, name: "Histograms", type: "RasterFunctionVariable" }, Max: { isDataset: !1, isPublic: !1, name: "Max", type: "RasterFunctionVariable", value: 255 }, MaxPercent: { isDataset: !1, isPublic: !1, name: "MaxPercent", type: "RasterFunctionVariable", value: 0.5 }, Min: { isDataset: !1, isPublic: !1, name: "Min", type: "RasterFunctionVariable", value: 0 }, MinPercent: { isDataset: !1, isPublic: !1, name: "MinPercent", type: "RasterFunctionVariable", value: 0.25 }, NumberOfStandardDeviations: { isDataset: !1, isPublic: !1, name: "NumberOfStandardDeviation", type: "RasterFunctionVariable", value: 2 }, Raster: { isDataset: !0, isPublic: !1, name: "Raster", type: "RasterFunctionVariable" }, SigmoidStrengthLevel: { isDataset: !1, isPublic: !1, name: "SigmoidStrengthLevel", type: "RasterFunctionVariable", value: 2 }, Statistics: { isDataset: !1, isPublic: !1, name: "Statistics", type: "RasterFunctionVariable" }, StretchType: { isDataset: !1, isPublic: !1, name: "StretchType", type: "RasterFunctionVariable", value: 0 }, type: "StretchFunctionArguments", UseGamma: { isDataset: !1, isPublic: !1, name: "UseGamma", type: "RasterFunctionVariable", value: !1 } }, description: "Enhances an image by adjusting the range of values displayed. This does not alter the underlying pixel values. If a pixel has a value outside of the specified range, it will appear as either the minimum or maximum value.", function: { description: "Enhances an image by adjusting the range of values displayed. This does not alter the underlying pixel values. If a pixel has a value outside of the specified range, it will appear as either the minimum or maximum value.", name: "Stretch", pixelType: "UNKNOWN", type: "StretchFunction" }, functionType: 0, name: "Stretch", thumbnail: "" }, RemapFunction: { name: "Remap", description: "Changes pixel values by assigning new values to ranges of pixel values or using an external table.", function: { type: "RemapFunction", pixelType: "UNKNOWN", name: "Remap", description: "Changes pixel values by assigning new values to ranges of pixel values or using an external table." }, arguments: { Raster: { name: "Raster", isPublic: !1, isDataset: !0, type: "RasterFunctionVariable" }, UseTable: { name: "UseTable", isPublic: !1, isDataset: !1, value: !1, type: "RasterFunctionVariable" }, InputRanges: { name: "InputRanges", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable", displayName: "Input Ranges" }, OutputValues: { name: "OutputValues", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable", displayName: "Output Values" }, NoDataRanges: { name: "NoDataRanges", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable", displayName: "NoData Ranges" }, Table: { name: "Table", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, InputField: { name: "InputField", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, OutputField: { name: "OutputField", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, InputMaxField: { name: "InputMaxField", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, RemapTableType: { name: "RemapTableType", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, AllowUnmatched: { name: "AllowUnmatched", isPublic: !1, isDataset: !1, value: !0, type: "RasterFunctionVariable" }, type: "RemapFunctionArguments" }, functionType: 0, thumbnail: "" }, ColormapFunction: { name: "Colormap", description: "Changes pixel values to display the raster data as either a grayscale or a red, green, blue (RGB) image, based on a colormap or a color ramp.", function: { type: "ColormapFunction", pixelType: "UNKNOWN", name: "Colormap", description: "Changes pixel values to display the raster data as either a grayscale or a red, green, blue (RGB) image, based on a colormap or a color ramp." }, arguments: { Raster: { name: "Raster", isPublic: !1, isDataset: !0, type: "RasterFunctionVariable" }, ColorSchemeType: { name: "ColorSchemeType", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, Colormap: { name: "Colormap", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, ColormapName: { name: "ColormapName", isPublic: !1, isDataset: !1, value: "Gray", type: "RasterFunctionVariable" }, ColorRamp: { name: "ColorRamp", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, type: "ColormapFunctionArguments" }, functionType: 0, thumbnail: "" }, ShadedReliefFunction: { name: "Shaded Relief", description: "Creates a multiband, color coded, 3D representation of the surface, with the sun's relative position taken into account for shading the image.", function: { type: "ShadedReliefFunction", pixelType: "UNKNOWN", name: "Shaded Relief", description: "Creates a multiband, color coded, 3D representation of the surface, with the sun's relative position taken into account for shading the image." }, arguments: { Raster: { name: "Raster", isPublic: !1, isDataset: !0, type: "RasterFunctionVariable" }, ColorSchemeType: { name: "ColorSchemeType", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, ColorRamp: { name: "ColorRamp", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, HillshadeType: { name: "HillshadeType", isPublic: !1, isDataset: !1, value: 0, type: "RasterFunctionVariable" }, Colormap: { name: "Colormap", isPublic: !1, isDataset: !1, type: "RasterFunctionVariable" }, Azimuth: { name: "Azimuth", isPublic: !1, isDataset: !1, value: 315, type: "RasterFunctionVariable" }, Altitude: { name: "Altitude", isPublic: !1, isDataset: !1, value: 45, type: "RasterFunctionVariable" }, SlopeType: { name: "SlopeType", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, ZFactor: { name: "ZFactor", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, PSPower: { name: "PSPower", isPublic: !1, isDataset: !1, value: 0.664, type: "RasterFunctionVariable" }, PSZFactor: { name: "PSZFactor", isPublic: !1, isDataset: !1, value: 0.024, type: "RasterFunctionVariable" }, RemoveEdgeEffect: { name: "RemoveEdgeEffect", isPublic: !1, isDataset: !1, value: !1, type: "RasterFunctionVariable" }, type: "ShadedReliefFunctionArguments" }, functionType: 0, thumbnail: "" }, HillshadeFunction: { name: "Hillshade", description: "Creates a 3D representation of the surface, with the sun's relative position taken into account for shading the image", function: { type: "HillshadeFunction", pixelType: "UNKNOWN", name: "Hillshade", description: "Creates a 3D representation of the surface, with the sun's relative position taken into account for shading the image" }, arguments: { DEM: { name: "DEM", isPublic: !1, isDataset: !0, type: "RasterFunctionVariable" }, HillshadeType: { name: "HillshadeType", isPublic: !1, isDataset: !1, value: 0, type: "RasterFunctionVariable" }, Azimuth: { name: "Azimuth", isPublic: !1, isDataset: !1, value: 315, type: "RasterFunctionVariable" }, Altitude: { name: "Altitude", isPublic: !1, isDataset: !1, value: 45, type: "RasterFunctionVariable" }, SlopeType: { name: "SlopeType", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, ZFactor: { name: "ZFactor", isPublic: !1, isDataset: !1, value: 1, type: "RasterFunctionVariable" }, PSPower: { name: "PSPower", isPublic: !1, isDataset: !1, value: 0.664, type: "RasterFunctionVariable" }, PSZFactor: { name: "PSZFactor", isPublic: !1, isDataset: !1, value: 0.024, type: "RasterFunctionVariable" }, RemoveEdgeEffect: { name: "RemoveEdgeEffect", isPublic: !1, isDataset: !1, value: !1, type: "RasterFunctionVariable" }, type: "HillshadeFunctionArguments" }, functionType: 0, thumbnail: "" }, ResampleFunction: { name: "Resample", description: "Changes the cell size of a raster.", function: { type: "ResampleFunction", pixelType: "UNKNOWN", name: "Resample", description: "Changes the cell size of a raster." }, arguments: { Raster: { name: "Raster", isPublic: !1, isDataset: !0, type: "RasterFunctionVariable" }, ResamplingType: { name: "ResamplingType", isPublic: !1, isDataset: !1, value: 0, type: "RasterFunctionVariable" }, InputCellSize: { name: "InputCellsize", isPublic: !1, isDataset: !1, value: { x: 0, y: 0 }, type: "RasterFunctionVariable" }, OutputCellSize: { name: "OutputCellsize", isPublic: !1, isDataset: !1, value: { x: 0, y: 0 }, type: "RasterFunctionVariable" }, type: "ResampleFunctionArguments" }, functionType: 0, thumbnail: "" } }, Xr = /* @__PURE__ */ new Set(["u1", "u2", "u4", "u8", "s8", "u16", "s16"]), Yr = { simple_scalar: "Simple Scalar", wind_barb: "Wind Barb", single_arrow: "Single Arrow", beaufort_kn: "Beaufort Wind (Knots)", beaufort_m: "Beaufort Wind (MetersPerSecond)", ocean_current_m: "Ocean Current (MetersPerSecond)", ocean_current_kn: "Ocean Current (Knots)" }, ei = /* @__PURE__ */ new Set(["raster-stretch", "unique-value", "class-breaks", "raster-shaded-relief", "vector-field", "raster-colormap"]);
+function Gt(s) {
+  return ei.has(s.type);
+}
+function ft(s, r) {
+  var e;
+  if (!s || !r)
+    return Q(s || r);
+  const a = Q(s);
+  if (a.functionDefinition && r.rasterFunctionDefinition) {
+    const t = r.rasterFunctionDefinition;
+    (t.thumbnail || t.thumbnailEx) && (t.thumbnail = t.thumbnailEx = void 0), Lt(a.functionDefinition.arguments, r), a.rasterFunctionDefinition = a.functionDefinition.toJSON();
+  } else
+    ((e = r.functionName) == null ? void 0 : e.toLowerCase()) !== "none" && (zt(a.functionArguments).Raster = r);
+  return a;
+}
+function Lt(s, r) {
+  for (const a in s)
+    a.toLowerCase() === "raster" && (s[a].type === "RasterFunctionVariable" ? (s[a] = r.rasterFunctionDefinition, s[a].type = "RasterFunctionTemplate") : s[a].type === "RasterFunctionTemplate" && Lt(s[a].arguments, r));
+}
+function ne(s) {
+  const r = Q(Kr[s.functionName + "Function"]), a = s.functionArguments;
+  for (const e in a)
+    e.toLowerCase() === "raster" ? (r.arguments[e] = ne(a[e]), r.arguments[e].type = "RasterFunctionTemplate") : e.toLowerCase() === "colormap" ? (r.arguments[e].value = ui(a[e]), r.arguments.ColorSchemeType.value = 0) : r.arguments[e].value = a[e];
+  return r;
+}
+function ti(s, r) {
+  switch (r = r || {}, s.type) {
+    case "raster-stretch":
+      return si(s, r);
+    case "class-breaks":
+      return ni(s, r);
+    case "unique-value":
+      return ai(s, r);
+    case "raster-colormap":
+      return oi(s, r);
+    case "vector-field":
+      return ri(s, r);
+    case "raster-shaded-relief":
+      return ii(s, r);
+    case "flow":
+      throw new Error("Unsupported rendering rule.");
+  }
+}
+function zt(s) {
+  const r = (s == null ? void 0 : s.Raster) ?? (s == null ? void 0 : s.raster);
+  return r && r.declaredClass === "esri.layers.support.RasterFunction" ? zt(r.functionArguments) : s;
+}
+const Ee = { none: 0, standardDeviation: 3, histogramEqualization: 4, minMax: 5, percentClip: 6, sigmoid: 9 };
+function ri(s, r) {
+  const a = new S();
+  a.functionName = "VectorFieldRenderer";
+  const { dataType: e, bandNames: t } = r, n = e === "vector-uv";
+  let l, u;
+  if (t && t.length === 2) {
+    const R = t.map((f) => f.toLowerCase());
+    l = R.indexOf("magnitude"), u = R.indexOf("direction");
+  }
+  l !== -1 && l !== null || (l = 0, u = 1);
+  const p = s.rotationType === "arithmetic" ? 1 : 2, m = s.flowRepresentation === "flow-from" ? 0 : 1, c = s.visualVariables ? s.visualVariables.find((R) => R.field === "Magnitude") : new Vr(), d = { magnitudeBandID: l, directionBandID: u, isUVComponents: n, referenceSystem: p, massFlowAngleRepresentation: m, symbolTileSize: 50, symbolTileSizeUnits: 100, calculationMethod: "Vector Average", symbologyName: Yr[s.style.toLowerCase().replace("-", "_")], minimumMagnitude: c.minDataValue, maximumMagnitude: c.maxDataValue, minimumSymbolSize: c.minSize, maximumSymbolSize: c.maxSize };
+  a.functionArguments = d;
+  const h = ne(a);
+  return r.convertToRFT ? S.fromJSON({ rasterFunctionDefinition: h }) : a;
+}
+function ii(s, r) {
+  const a = r.convertToRFT;
+  if (r.dataType !== "elevation" && (r.dataType !== "generic" || r.bandCount !== 1 || r.pixelType !== "s16" && r.pixelType !== "s32" && r.pixelType !== "f32" && r.pixelType !== "f64"))
+    return new S();
+  const e = new S();
+  e.functionName = "Hillshade";
+  const t = s.hillshadeType === "traditional" ? 0 : 1, n = s.scalingType === "none" ? 1 : 3, l = { HillshadeType: t, SlopeType: n, ZFactor: s.zFactor };
+  return t === 0 && (l.Azimuth = s.azimuth, l.Altitude = s.altitude), n === 3 && (l.PSPower = s.pixelSizePower, l.PSZFactor = s.pixelSizeFactor), e.functionArguments = l, e.variableName = "Raster", s.colorRamp && (e.functionName = "ShadedRelief", a ? l.ColorRamp = Mt(s.colorRamp) : l.Colormap = Jt(s.colorRamp)), a ? new S({ rasterFunctionDefinition: ne(e) }) : e;
+}
+function si(s, r) {
+  var u;
+  const a = r.convertToRFT, e = new S();
+  e.functionName = "Stretch";
+  const t = Ee[Nr.toJSON(s.stretchType)], n = "u8", l = { StretchType: t, Statistics: li(s.statistics ?? []), DRA: s.dynamicRangeAdjustment, UseGamma: s.useGamma, Gamma: s.gamma, ComputeGamma: s.computeGamma };
+  if (s.outputMin != null && (l.Min = s.outputMin), s.outputMax != null && (l.Max = s.outputMax), t === Ee.standardDeviation ? (l.NumberOfStandardDeviations = s.numberOfStandardDeviations, e.outputPixelType = n) : t === Ee.percentClip ? (l.MinPercent = s.minPercent, l.MaxPercent = s.maxPercent, e.outputPixelType = n) : t === Ee.minMax ? e.outputPixelType = n : t === Ee.sigmoid && (l.SigmoidStrengthLevel = s.sigmoidStrengthLevel), e.functionArguments = l, e.variableName = "Raster", s.colorRamp) {
+    const p = s.colorRamp, m = new S();
+    if (a)
+      m.functionArguments = { ColorRamp: Mt(p) };
+    else {
+      const c = Or(p, !0);
+      if (c)
+        m.functionArguments = { colorRampName: c };
+      else if (!r.convertColorRampToColormap || p.type !== "algorithmic" && p.type !== "multipart") {
+        const d = s.colorRamp.toJSON();
+        d.type === "algorithmic" ? d.algorithm = d.algorithm || "esriCIELabAlgorithm" : d.type === "multipart" && ((u = d.colorRamps) != null && u.length) && d.colorRamps.forEach((h) => h.algorithm = h.algorithm || "esriCIELabAlgorithm"), m.functionArguments = { colorRamp: d };
+      } else
+        m.functionArguments = { Colormap: Jt(p) };
+    }
+    return m.variableName = "Raster", m.functionName = "Colormap", m.functionArguments.Raster = e, a ? new S({ rasterFunctionDefinition: ne(m) }) : m;
+  }
+  return a ? new S({ rasterFunctionDefinition: ne(e) }) : e;
+}
+function ni(s, r) {
+  const a = [], e = [], t = [], n = [], { pixelType: u, rasterAttributeTable: p } = r, m = p == null ? null : p.features, c = Ut(p);
+  if (c && m && Array.isArray(m) && s.classBreakInfos) {
+    s.classBreakInfos.forEach((y, g) => {
+      var G;
+      const v = (G = y.symbol) == null ? void 0 : G.color;
+      let O;
+      v != null && v.a && y.minValue != null && y.maxValue != null && m.forEach((J) => {
+        y.minValue != null && y.maxValue != null && (O = J.attributes[s.field], (O >= y.minValue && O < y.maxValue || g === s.classBreakInfos.length - 1 && O >= y.minValue) && n.push([J.attributes[c], v.r, v.g, v.b]));
+      });
+    });
+    const f = u ? ut(n, u) : n, w = new S();
+    return w.functionName = "Colormap", w.functionArguments = {}, w.functionArguments.Colormap = f, w.variableName = "Raster", r.convertToRFT ? new S({ rasterFunctionDefinition: ne(w) }) : w;
+  }
+  s.classBreakInfos.forEach((f, w) => {
+    if (f.minValue == null || f.maxValue == null)
+      return;
+    const y = f.symbol && f.symbol.color;
+    y != null && y.a ? (w === 0 ? a.push(f.minValue, f.maxValue + 1e-4) : a.push(f.minValue + 1e-4, f.maxValue + 1e-4), e.push(w), n.push([w, y.r, y.g, y.b])) : t.push(f.minValue, f.maxValue);
+  });
+  const d = u ? ut(n, u) : n, h = new S();
+  h.functionName = "Remap", h.functionArguments = { InputRanges: a, OutputValues: e, NoDataRanges: t }, h.variableName = "Raster";
+  const R = new S();
+  return R.functionName = "Colormap", R.functionArguments = { Colormap: d, Raster: h }, r.convertToRFT ? new S({ rasterFunctionDefinition: ne(R) }) : R;
+}
+function ut(s, r) {
+  const a = Xr.has(r) ? Tr(r) : null;
+  return a && s.push([Math.floor(a[0] - 1), 0, 0, 0], [Math.ceil(a[1] + 1), 0, 0, 0]), s;
+}
+function Ut(s) {
+  if (s == null)
+    return;
+  const { fields: r } = s, a = r == null ? void 0 : r.find((e) => (e == null ? void 0 : e.name) && e.name.toLowerCase() === "value");
+  return a == null ? void 0 : a.name;
+}
+function ai(s, r) {
+  var d, h, R;
+  const a = [], { pixelType: e, rasterAttributeTable: t } = r, n = t == null ? null : t.features, l = Ut(t), u = (h = (d = s.defaultSymbol) == null ? void 0 : d.color) == null ? void 0 : h.toRgb(), p = s.uniqueValueInfos;
+  if (p)
+    if (n) {
+      if (l) {
+        const f = /* @__PURE__ */ new Map();
+        p.forEach((y) => {
+          var O;
+          const g = y.value, v = (O = y.symbol) == null ? void 0 : O.color;
+          g != null && (v != null && v.a) && f.set(String(g), v.toRgb());
+        });
+        const w = s.field;
+        n.forEach(({ attributes: y }) => {
+          const g = String(y[w]), v = y[l], O = f.get(g);
+          O ? a.push([v, ...O]) : u && a.push([v, ...u]);
+        });
+      }
+    } else
+      for (let f = 0; f < p.length; f++) {
+        const w = p[f], y = (R = w.symbol) == null ? void 0 : R.color, g = +w.value;
+        if (y != null && y.a) {
+          if (isNaN(g))
+            return null;
+          a.push([g, y.r, y.g, y.b]);
+        }
+      }
+  const m = e ? ut(a, e) : a, c = new S();
+  return c.functionName = "Colormap", c.functionArguments = {}, c.functionArguments.Colormap = m, c.variableName = "Raster", r.convertToRFT ? new S({ rasterFunctionDefinition: ne(c) }) : c;
+}
+function oi(s, r) {
+  const a = s.extractColormap();
+  if (!a || a.length === 0)
+    return null;
+  const { pixelType: e } = r, t = e ? ut(a, e) : a, n = new S();
+  return n.functionName = "Colormap", n.functionArguments = {}, n.functionArguments.Colormap = t, r.convertToRFT ? new S({ rasterFunctionDefinition: ne(n) }) : n;
+}
+function li(s) {
+  const r = [];
+  return s == null || s.forEach((a) => {
+    const e = a;
+    if (Array.isArray(e))
+      r.push(e);
+    else {
+      if (e.min == null || e.max == null)
+        return;
+      const t = [e.min, e.max, e.avg || 0, e.stddev || 0];
+      r.push(t);
+    }
+  }), r;
+}
+function ui(s) {
+  const r = [], a = [];
+  return s.forEach((e) => {
+    r.push(e[0]), a.push(_r([...e.slice(1), 255]));
+  }), { type: "RasterColormap", values: r, colors: a };
+}
+let _ = class extends j {
+  constructor() {
+    super(...arguments), this.layer = null, this.compression = void 0, this.pixelType = void 0, this.lercVersion = 2;
+  }
+  get adjustAspectRatio() {
+    return this.layer.adjustAspectRatio;
+  }
+  writeAdjustAspectRatio(r, a, e) {
+    this.layer.version < 10.3 || (a[e] = r);
+  }
+  get bandIds() {
+    return this.layer.bandIds;
+  }
+  get compressionQuality() {
+    return this.layer.compressionQuality;
+  }
+  writeCompressionQuality(r, a, e) {
+    this.format && this.format.toLowerCase().includes("jpg") && r != null && (a[e] = r);
+  }
+  get compressionTolerance() {
+    return this.layer.compressionTolerance;
+  }
+  writeCompressionTolerance(r, a, e) {
+    this.format === "lerc" && r != null && (a[e] = r);
+  }
+  get format() {
+    var r;
+    return ((r = this.layer.renderer) == null ? void 0 : r.type) === "vector-field" ? "lerc" : this.layer.format;
+  }
+  get interpolation() {
+    return this.layer.interpolation;
+  }
+  get noData() {
+    return this.layer.noData;
+  }
+  get noDataInterpretation() {
+    return this.layer.noDataInterpretation;
+  }
+  writeLercVersion(r, a, e) {
+    this.format === "lerc" && this.layer.version >= 10.5 && (a[e] = r);
+  }
+  get version() {
+    const r = this.layer;
+    return r.commitProperty("bandIds"), r.commitProperty("format"), r.commitProperty("compressionQuality"), r.commitProperty("compressionTolerance"), r.commitProperty("interpolation"), r.commitProperty("noData"), r.commitProperty("noDataInterpretation"), r.commitProperty("mosaicRule"), r.commitProperty("rasterFunction"), r.commitProperty("adjustAspectRatio"), r.commitProperty("pixelFilter"), r.commitProperty("definitionExpression"), r.commitProperty("multidimensionalSubset"), (this._get("version") || 0) + 1;
+  }
+  set version(r) {
+    this._set("version", r);
+  }
+  get mosaicRule() {
+    const r = this.layer;
+    let a = r.mosaicRule;
+    const e = r.definitionExpression;
+    return a ? e && e !== a.where && (a = a.clone(), a.where = e) : e && (a = new k({ where: e })), a;
+  }
+  get rasterFunction() {
+    var l, u;
+    const r = this.layer;
+    let { rasterFunction: a } = r;
+    const e = r.pixelFilter, t = !r.format || r.format.includes("jpg") || r.format.includes("png");
+    a = this._addResampleRasterFunction(a);
+    const n = (l = r.multidimensionalSubset) == null ? void 0 : l.areaOfInterest;
+    return n && (a = this._addClipFunction(a, n)), t && !e && ((u = r.renderer) == null ? void 0 : u.type) !== "vector-field" && (a = this.combineRendererWithRenderingRule(a)), a;
+  }
+  combineRendererWithRenderingRule(r) {
+    const a = this.layer, { rasterInfo: e, renderer: t } = a;
+    return r = r || a.rasterFunction, !t || !Gt(t) ? r : ft(ti(t, { rasterAttributeTable: e.attributeTable, pixelType: e.pixelType, dataType: e.dataType, bandNames: e.bandInfos.map(({ name: n }) => n), convertColorRampToColormap: a.version < 10.6, convertToRFT: !!(r != null && r.rasterFunctionDefinition), bandCount: e.bandCount }), r);
+  }
+  _addResampleRasterFunction(r) {
+    var n;
+    if (((n = this.layer.renderer) == null ? void 0 : n.type) !== "vector-field" || (r == null ? void 0 : r.functionName) === "Resample")
+      return r;
+    const a = this.layer.serviceDataType === "esriImageServiceDataTypeVector-UV" ? 7 : 10, e = this.layer.serviceRasterInfo.pixelSize;
+    let t = new S({ functionName: "Resample", functionArguments: { ResamplingType: a, InputCellSize: e } });
+    return t = r != null && r.rasterFunctionDefinition ? new S({ rasterFunctionDefinition: ne(t) }) : t, ft(t, r);
+  }
+  _addClipFunction(r, a) {
+    const e = new S({ functionName: "Clip", functionArguments: { ClippingGeometry: a.toJSON(), ClippingType: 1 } });
+    return ft(e, r);
+  }
+};
+i([o()], _.prototype, "layer", void 0), i([o({ json: { write: !0 } })], _.prototype, "adjustAspectRatio", null), i([T("adjustAspectRatio")], _.prototype, "writeAdjustAspectRatio", null), i([o({ json: { write: !0 } })], _.prototype, "bandIds", null), i([o({ json: { write: !0 } })], _.prototype, "compression", void 0), i([o({ json: { write: !0 } })], _.prototype, "compressionQuality", null), i([T("compressionQuality")], _.prototype, "writeCompressionQuality", null), i([o({ json: { write: !0 } })], _.prototype, "compressionTolerance", null), i([T("compressionTolerance")], _.prototype, "writeCompressionTolerance", null), i([o({ json: { write: !0 } })], _.prototype, "format", null), i([o({ type: String, json: { read: { reader: ve.read }, write: { writer: ve.write } } })], _.prototype, "interpolation", null), i([o({ json: { write: !0 } })], _.prototype, "noData", null), i([o({ type: String, json: { read: { reader: Ue.read }, write: { writer: Ue.write } } })], _.prototype, "noDataInterpretation", null), i([o({ json: { write: !0 } })], _.prototype, "pixelType", void 0), i([o({ json: { write: !0 } })], _.prototype, "lercVersion", void 0), i([T("lercVersion")], _.prototype, "writeLercVersion", null), i([o({ type: Number })], _.prototype, "version", null), i([o({ json: { write: !0 } })], _.prototype, "mosaicRule", null), i([o({ json: { write: !0, name: "renderingRule" } })], _.prototype, "rasterFunction", null), _ = i([b("esri.layers.mixins.ExportImageServiceParameters")], _);
+const Ht = (s) => {
+  let r = class extends s {
+    constructor() {
+      super(...arguments), this.make = null, this.model = null, this.focalLength = null, this.pixelSize = null, this.rows = null, this.cols = null;
+    }
+  };
+  return i([o({ json: { write: !0 } })], r.prototype, "make", void 0), i([o({ json: { write: !0 } })], r.prototype, "model", void 0), i([o({ json: { write: !0 } })], r.prototype, "focalLength", void 0), i([o({ json: { write: !0 } })], r.prototype, "pixelSize", void 0), i([o({ json: { write: !0 } })], r.prototype, "rows", void 0), i([o({ json: { write: !0 } })], r.prototype, "cols", void 0), r = i([b("esri.rest.support.CameraInfoMixin")], r), r;
+};
+let K = class extends Ht(j) {
+  constructor() {
+    super(...arguments), this.id = null, this.referenceUri = null, this.acquisitionDate = null, this.cameraID = null, this.center = null, this.perspectiveCenter = null, this.orientation = null;
+  }
+  writeAcquisitionDate(r, a) {
+    a.acquisitionDate = r == null ? void 0 : r.getTime();
+  }
+};
+i([o({ json: { write: !0 } })], K.prototype, "id", void 0), i([o({ json: { name: "uri", write: !0 } })], K.prototype, "referenceUri", void 0), i([o({ type: Date, json: { write: !0 } })], K.prototype, "acquisitionDate", void 0), i([T("acquisitionDate")], K.prototype, "writeAcquisitionDate", null), i([o({ json: { write: !0 } })], K.prototype, "cameraID", void 0), i([o({ type: A, json: { write: !0 } })], K.prototype, "center", void 0), i([o({ type: A, json: { write: !0 } })], K.prototype, "perspectiveCenter", void 0), i([o({ json: { write: !0 } })], K.prototype, "orientation", void 0), K = i([b("esri.rest.support.ImageInspectionInfo")], K);
+const pi = K;
+let Ke = class extends j {
+  constructor() {
+    super(...arguments), this.images = null;
+  }
+};
+i([o({ type: [pi], json: { write: !0 } })], Ke.prototype, "images", void 0), Ke = i([b("esri.rest.support.FindImagesResult")], Ke);
+const ci = Ke;
+let Oe = class extends j {
+  constructor(r) {
+    super(r), this.north = null, this.up = null, this.spatialReference = null;
+  }
+};
+i([o({ type: Number, json: { write: !0 } })], Oe.prototype, "north", void 0), i([o({ type: Number, json: { write: !0 } })], Oe.prototype, "up", void 0), i([o({ type: se, json: { write: !0 } })], Oe.prototype, "spatialReference", void 0), Oe = i([b("esri.rest.support.ImageAngleResult")], Oe);
+const mi = Oe;
+let fe = class extends j {
+  constructor() {
+    super(...arguments), this.value = null, this.displayValue = null, this.uncertainty = null;
+  }
+};
+i([o({ type: Number, json: { read: !0, write: !0 } })], fe.prototype, "value", void 0), i([o({ type: String, json: { read: !0, write: !0 } })], fe.prototype, "displayValue", void 0), i([o({ type: Number, json: { read: !0, write: !0 } })], fe.prototype, "uncertainty", void 0), fe = i([b("esri.rest.support.ImageMeasureResultValue")], fe);
+let Me = class extends fe {
+  constructor() {
+    super(...arguments), this.unit = null;
+  }
+};
+i([o({ type: String, json: { read: be.read, write: be.write } })], Me.prototype, "unit", void 0), Me = i([b("esri.rest.support.ImageMeasureResultLengthValue")], Me);
+let Xe = class extends fe {
+  constructor() {
+    super(...arguments), this.unit = null;
+  }
+};
+i([o({ type: String, json: { read: ot.read, write: ot.write } })], Xe.prototype, "unit", void 0), Xe = i([b("esri.rest.support.ImageMeasureResultAreaValue")], Xe);
+let He = class extends fe {
+  constructor() {
+    super(...arguments), this.unit = null;
+  }
+};
+i([o({ type: String, json: { read: lt.read, write: lt.write } })], He.prototype, "unit", void 0), He = i([b("esri.rest.support.ImageMeasureResultAngleValue")], He);
+let Re = class extends j {
+  constructor() {
+    super(...arguments), this.name = null, this.sensorName = null;
+  }
+};
+i([o({ type: String, json: { read: !0, write: !0 } })], Re.prototype, "name", void 0), i([o({ type: String, json: { read: !0, write: !0 } })], Re.prototype, "sensorName", void 0), Re = i([b("esri.rest.support.BaseImageMeasureResult")], Re);
+let qe = class extends Re {
+  constructor() {
+    super(...arguments), this.area = null, this.perimeter = null;
+  }
+};
+i([o({ type: Xe, json: { read: !0, write: !0 } })], qe.prototype, "area", void 0), i([o({ type: Me, json: { read: !0, write: !0 } })], qe.prototype, "perimeter", void 0), qe = i([b("esri.rest.support.ImageAreaResult")], qe);
+const di = qe;
+let _e = class extends j {
+  constructor() {
+    super(...arguments), this.area = null, this.geometry = null;
+  }
+  readGeometry(r, a) {
+    return r == null ? null : r.rings ? Ze.fromJSON(r) : ze.fromJSON(r);
+  }
+};
+i([o({ type: Number, json: { write: !0 } })], _e.prototype, "area", void 0), i([o({ json: { name: "shape", write: !0 } })], _e.prototype, "geometry", void 0), i([V("geometry")], _e.prototype, "readGeometry", null), _e = i([b("esri.rest.support.ImageBoundaryResult")], _e);
+const yi = _e;
+let Ce = class extends Re {
+  constructor() {
+    super(...arguments), this.distance = null, this.azimuthAngle = null, this.elevationAngle = null;
+  }
+};
+i([o({ type: Me, json: { read: !0, write: !0 } })], Ce.prototype, "distance", void 0), i([o({ type: He, json: { read: !0, write: !0 } })], Ce.prototype, "azimuthAngle", void 0), i([o({ type: He, json: { read: !0, write: !0 } })], Ce.prototype, "elevationAngle", void 0), Ce = i([b("esri.rest.support.ImageDistanceResult")], Ce);
+const hi = Ce;
+let Ye = class extends Ht(j) {
+  constructor() {
+    super(...arguments), this.id = null;
+  }
+};
+i([o({ json: { write: !0 } })], Ye.prototype, "id", void 0), Ye = i([b("esri.rest.support.CameraInfo")], Ye);
+const gi = Ye;
+let X = class extends j {
+  constructor() {
+    super(...arguments), this.id = null, this.name = null, this.acquisitionDate = null, this.cameraID = null, this.center = null, this.gps = null, this.orientation = null;
+  }
+  writeAcquisitionDate(r, a) {
+    a.acquisitionDate = r == null ? void 0 : r.getTime();
+  }
+};
+i([o({ json: { write: !0 } })], X.prototype, "id", void 0), i([o({ json: { write: !0 } })], X.prototype, "name", void 0), i([o({ type: Date, json: { write: !0 } })], X.prototype, "acquisitionDate", void 0), i([T("acquisitionDate")], X.prototype, "writeAcquisitionDate", null), i([o({ json: { write: !0 } })], X.prototype, "cameraID", void 0), i([o({ type: A, json: { write: !0 } })], X.prototype, "center", void 0), i([o({ json: { write: !0 } })], X.prototype, "gps", void 0), i([o({ json: { write: !0 } })], X.prototype, "orientation", void 0), X = i([b("esri.rest.support.ImageGPSInfo")], X);
+const fi = X;
+let Ge = class extends j {
+  constructor() {
+    super(...arguments), this.images = null, this.cameras = null;
+  }
+};
+i([o({ type: [fi], json: { write: !0 } })], Ge.prototype, "images", void 0), i([o({ type: [gi], json: { write: !0 } })], Ge.prototype, "cameras", void 0), Ge = i([b("esri.rest.support.ImageGPSInfoResult")], Ge);
+const wi = Ge;
+let et = class extends Re {
+  constructor() {
+    super(...arguments), this.height = null;
+  }
+};
+i([o({ type: Me, json: { read: !0, write: !0 } })], et.prototype, "height", void 0), et = i([b("esri.rest.support.ImageHeightResult")], et);
+const Ri = et;
+let Y = class extends j {
+  constructor() {
+    super(...arguments), this.catalogItemVisibilities = null, this.catalogItems = null, this.location = null, this.name = null, this.objectId = null, this.processedValues = null, this.properties = null, this.value = null;
+  }
+};
+i([o({ json: { write: !0 } })], Y.prototype, "catalogItemVisibilities", void 0), i([o({ type: qt, json: { write: !0 } })], Y.prototype, "catalogItems", void 0), i([o({ type: A, json: { write: !0 } })], Y.prototype, "location", void 0), i([o({ json: { write: !0 } })], Y.prototype, "name", void 0), i([o({ json: { write: !0 } })], Y.prototype, "objectId", void 0), i([o({ json: { write: !0 } })], Y.prototype, "processedValues", void 0), i([o({ json: { write: !0 } })], Y.prototype, "properties", void 0), i([o({ json: { write: !0 } })], Y.prototype, "value", void 0), Y = i([b("esri.rest.support.ImageIdentifyResult")], Y);
+const vi = Y;
+let tt = class extends j {
+  constructor() {
+    super(...arguments), this.geometries = null;
+  }
+};
+i([o({ json: { write: !0 } })], tt.prototype, "geometries", void 0), tt = i([b("esri.rest.support.ImagePixelLocationResult")], tt);
+const bi = tt;
+let rt = class extends Re {
+  constructor() {
+    super(...arguments), this.point = null;
+  }
+};
+i([o({ type: A, json: { name: "point.value", read: !0, write: !0 } })], rt.prototype, "point", void 0), rt = i([b("esri.rest.support.ImagePointResult")], rt);
+const Si = rt;
+let ue = class extends j {
+  constructor() {
+    super(...arguments), this.attributes = null, this.location = null, this.locationId = null, this.rasterId = null, this.resolution = null, this.pixelValue = null;
+  }
+};
+i([o({ json: { write: !0 } })], ue.prototype, "attributes", void 0), i([o({ type: A, json: { write: !0 } })], ue.prototype, "location", void 0), i([o({ json: { write: !0 } })], ue.prototype, "locationId", void 0), i([o({ json: { write: !0 } })], ue.prototype, "rasterId", void 0), i([o({ json: { write: !0 } })], ue.prototype, "resolution", void 0), i([o({ json: { write: !0 } })], ue.prototype, "pixelValue", void 0), ue = i([b("esri.rest.support.ImageSample")], ue);
+const xi = ue;
+let it = class extends j {
+  constructor() {
+    super(...arguments), this.samples = null;
+  }
+};
+i([o({ type: [xi], json: { write: !0 } })], it.prototype, "samples", void 0), it = i([b("esri.rest.support.ImageSampleResult")], it);
+const Ii = it;
+let st = class extends j {
+  constructor() {
+    super(...arguments), this.url = null;
+  }
+};
+i([o({ json: { name: "imageURL", write: !0 } })], st.prototype, "url", void 0), st = i([b("esri.rest.support.ImageUrlResult")], st);
+const Fi = st;
+let he = class extends j {
+  constructor() {
+    super(...arguments), this.geometry = null, this.length = null, this.area = null, this.center = null;
+  }
+  readCenter(r, a) {
+    return r.spatialReference || (r = { ...r, spatialReference: a.Shape.spatialReference }), A.fromJSON(r);
+  }
+};
+i([o({ types: oe, json: { name: "Shape", read: te, write: !0 } })], he.prototype, "geometry", void 0), i([o({ json: { name: "Length", write: !0 } })], he.prototype, "length", void 0), i([o({ json: { name: "Area", write: !0 } })], he.prototype, "area", void 0), i([o({ json: { name: "Center", write: !0 } })], he.prototype, "center", void 0), i([V("center")], he.prototype, "readCenter", null), he = i([b("esri.rest.support.MeasureAreaFromImageResult")], he);
+const Di = he;
+let Le = class extends j {
+  constructor() {
+    super(...arguments), this.geometry = null, this.length = null;
+  }
+};
+i([o({ types: oe, json: { name: "Shape", read: te, write: !0 } })], Le.prototype, "geometry", void 0), i([o({ json: { name: "Length", write: !0 } })], Le.prototype, "length", void 0), Le = i([b("esri.rest.support.MeasureLengthFromImageResult")], Le);
+const Ti = Le;
+function Pt(s) {
+  const r = s == null ? void 0 : s.time;
+  if (r && (r.start != null || r.end != null)) {
+    const a = [];
+    r.start != null && a.push(r.start), r.end == null || a.includes(r.end) || a.push(r.end), s.time = a.join(",");
+  }
+}
+async function Bt(s, r, a) {
+  const e = M(s), t = r.geometry ? [r.geometry] : [], n = await Ne(t), l = r.toJSON();
+  Pt(l);
+  const u = n == null ? void 0 : n[0];
+  u != null && (l.geometry = ae(u));
+  const p = z({ ...e.query, f: "json", ...l });
+  return U(p, a);
+}
+async function ji(s, r, a) {
+  var p, m, c;
+  const e = r.toJSON();
+  e.angleName != null && (e.angleName = e.angleName.join(",")), (m = (p = r == null ? void 0 : r.point) == null ? void 0 : p.spatialReference) != null && m.imageCoordinateSystem && (e.point.spatialReference = ct(r.point.spatialReference)), (c = r == null ? void 0 : r.spatialReference) != null && c.imageCoordinateSystem && (e.spatialReference = Je(r.spatialReference));
+  const t = M(s), n = z({ ...t.query, f: "json", ...e }), l = U(n, a), { data: u } = await D(`${t.path}/computeAngles`, l);
+  return u.spatialReference = u.spatialReference ? u.spatialReference.geodataXform != null ? new se({ wkid: 0, imageCoordinateSystem: u.spatialReference }) : se.fromJSON(u.spatialReference) : null, u.north === "NaN" && (u.north = null), u.up === "NaN" && (u.up = null), new mi(u);
+}
+async function Pi(s, r, a) {
+  var m;
+  const e = r.toJSON(), { geometries: t } = r;
+  if (t)
+    for (let c = 0; c < t.length; c++)
+      (m = t[c].spatialReference) != null && m.imageCoordinateSystem && (e.geometries.geometries[c].spatialReference = ct(t[c].spatialReference));
+  const n = M(s), l = z({ ...n.query, f: "json", ...e }), u = U(l, a), { data: p } = await D(`${n.path}/computePixelLocation`, u);
+  return bi.fromJSON(p);
+}
+async function Ni(s, r, a) {
+  const e = await Bt(s, r, a), t = M(s), { data: n } = await D(`${t.path}/computeStatisticsHistograms`, e), { statistics: l } = n;
+  return l != null && l.length && l.forEach((u) => {
+    u.avg = u.mean, u.stddev = u.standardDeviation;
+  }), { statistics: l, histograms: n.histograms };
+}
+async function Oi(s, r, a) {
+  const e = await Bt(s, r, a), t = M(s), { data: n } = await D(`${t.path}/computeHistograms`, e);
+  return { histograms: n.histograms };
+}
+async function _i(s, r, a) {
+  var d, h;
+  const e = r.toJSON();
+  Pt(e), (d = e.outFields) != null && d.length && (e.outFields = e.outFields.join(","));
+  const t = await Ne(r.geometry), n = t == null ? void 0 : t[0];
+  n != null && (e.geometry = ae(n));
+  const l = M(s), u = z({ ...l.query, f: "json", ...e }), p = U(u, a), { data: m } = await D(`${l.path}/getSamples`, p), c = (h = m == null ? void 0 : m.samples) == null ? void 0 : h.map((R) => {
+    const f = R.value === "NaN" || R.value === "" ? null : R.value.split(" ").map((w) => Number(w));
+    return { ...R, pixelValue: f };
+  });
+  return Ii.fromJSON({ samples: c });
+}
+async function $t(s, r, a) {
+  const e = M(s), t = r.geometry ? [r.geometry] : [];
+  return Ne(t).then((n) => {
+    const l = r.toJSON(), u = n == null ? void 0 : n[0];
+    u != null && (l.geometry = JSON.stringify(ae(u)));
+    const p = z({ ...e.query, f: "json", ...l }), m = U(p, a);
+    return D(e.path + "/identify", m);
+  }).then((n) => vi.fromJSON(n.data));
+}
+async function Ci(s, r, a) {
+  const e = await pt(s, r, [r.fromGeometry, r.toGeometry], a);
+  return Ri.fromJSON(e);
+}
+async function $i(s, r, a) {
+  const e = await pt(s, r, [r.geometry], a);
+  return di.fromJSON(e);
+}
+async function Ai(s, r, a) {
+  const e = await pt(s, r, [r.geometry], a);
+  return Si.fromJSON(e);
+}
+async function Vi(s, r, a) {
+  const e = await pt(s, r, [r.fromGeometry, r.toGeometry], a);
+  return hi.fromJSON(e);
+}
+async function pt(s, r, a, e) {
+  const t = M(s), n = await Ne(a), l = r.toJSON();
+  n[0] != null && (l.fromGeometry = JSON.stringify(ae(n[0]))), n[1] != null && (l.toGeometry = JSON.stringify(ae(n[1])));
+  const u = z({ ...t.query, f: "json", ...l }), p = U(u, e), { data: m } = await D(t.path + "/measure", p);
+  return m;
+}
+async function Mi(s, r, a) {
+  const e = await Qt(s, r, a);
+  return Ti.fromJSON(e);
+}
+async function Ji(s, r, a) {
+  const e = await Qt(s, r, a);
+  return Di.fromJSON(e);
+}
+async function Qt(s, r, a) {
+  const e = M(s), t = r.toJSON(), n = z({ ...e.query, f: "json", ...t }), l = U(n, a), { data: u } = await D(e.path + "/measureFromImage", l);
+  return u;
+}
+function ae(s) {
+  var a;
+  const r = s.toJSON();
+  return (a = s.spatialReference) != null && a.imageCoordinateSystem && (r.spatialReference = ct(s.spatialReference)), r;
+}
+function ct(s) {
+  const { imageCoordinateSystem: r } = s;
+  if (r) {
+    const { id: a, referenceServiceName: e } = r;
+    return a != null ? e ? { icsid: a, icsns: e } : { icsid: a } : { ics: r };
+  }
+  return s.toJSON();
+}
+function Je(s, r) {
+  if (!s.imageCoordinateSystem)
+    return wt(s);
+  const a = ct(s), { icsid: e, icsns: t } = a;
+  return e == null || t != null && !(r != null && r.toLowerCase().includes("/" + t.toLowerCase() + "/")) ? JSON.stringify(a) : `0:${e}`;
+}
+async function Ei(s, r, a) {
+  const e = M(s), t = r.toJSON();
+  r.outSpatialReference && (t.outSR = Je(r.outSpatialReference));
+  const n = z({ ...e.query, f: "json", ...t }), l = U(n, a), { data: u } = await D(e.path + "/queryBoundary", l);
+  return yi.fromJSON(u);
+}
+async function qi(s, r, a) {
+  var d, h;
+  const e = r.toJSON();
+  Pt(e), (d = e.objectIds) != null && d.length && (e.objectIds = e.objectIds.join(",")), e.geometry || e.objectIds || e.time || e.where || (e.where = "1=1");
+  const t = await Ne(r.geometry), n = t == null ? void 0 : t[0];
+  n != null && (e.geometry = ae(n));
+  const l = (n == null ? void 0 : n.spatialReference) ?? ((h = r.geometry) == null ? void 0 : h.spatialReference);
+  l && (e.inSR = Je(l));
+  const u = M(s), p = z({ ...u.query, f: "json", ...e }), m = U(p, a), { data: c } = await D(`${u.path}/queryGPSInfo`, m);
+  return wi.fromJSON(c);
+}
+async function Gi(s, r, a) {
+  const e = r.toJSON();
+  r.geometry.spatialReference.imageCoordinateSystem && (e.geometry = ae(r.geometry)), r.depthOffset && r.adjust || delete e.options;
+  const t = M(s), n = z({ ...t.query, f: "json", ...e }), l = U(n, a), { data: u } = await D(`${t.path}/imageToMap`, l);
+  return te(u);
+}
+async function Li(s, r, a) {
+  var p;
+  const e = r.toJSON();
+  (p = r.rasterIds) != null && p.length && (e.rasterIds = r.rasterIds.join(","));
+  const t = M(s), n = z({ ...t.query, f: "json", ...e }), l = U(n, a), { data: u } = await D(`${t.path}/imageToMapMultiray`, l);
+  return te(u);
+}
+async function zi(s, r, a) {
+  var d;
+  const e = r.toJSON(), t = await Ne(r.geometry), n = t == null ? void 0 : t[0];
+  n != null && (e.geometry = ae(n)), r.visibleOnly || delete e.options;
+  const l = (n == null ? void 0 : n.spatialReference) ?? ((d = r.geometry) == null ? void 0 : d.spatialReference);
+  l && (e.inSR = Je(l));
+  const u = M(s), p = z({ ...u.query, f: "json", ...e }), m = U(p, a), { data: c } = await D(`${u.path}/mapToImage`, m);
+  return te(c);
+}
+async function Ui(s, r, a) {
+  const e = r.toJSON(), t = M(s), n = z({ ...t.query, f: "json", ...e }), l = U(n, a), { data: u } = await D(`${t.path}/getImageUrl`, l);
+  return Fi.fromJSON(u);
+}
+async function Hi(s, r, a) {
+  var m;
+  const e = r.toJSON(), t = await Ne([r.fromGeometry, r.toGeometry]);
+  t[0] != null && (e.fromGeometry = ae(t[0]), t[0].spatialReference && (e.inSR = Je(t[0].spatialReference))), t[1] != null && (e.toGeometry = ae(t[1])), (m = r.objectIds) != null && m.length && (e.objectIds = e.objectIds.join(","));
+  const n = M(s), l = z({ ...n.query, f: "json", ...e }), u = U(l, a), { data: p } = await D(`${n.path}/find`, u);
+  return ci.fromJSON(p);
+}
+async function Bi(s, r, a) {
+  var G, J;
+  const e = M(s), t = z({ ...e == null ? void 0 : e.query, f: "json" }), n = U(t, a), l = `${e == null ? void 0 : e.path}/${r}/info`, u = D(`${l}`, n), p = D(`${l}/keyProperties`, n), m = await Promise.allSettled([u, p]), c = m[0].status === "fulfilled" ? m[0].value.data : null, d = m[1].status === "fulfilled" ? m[1].value.data : null;
+  let h = null;
+  (G = c.statistics) != null && G.length && (h = c.statistics.map((F) => ({ min: F[0], max: F[1], avg: F[2], stddev: F[3] })));
+  const R = ze.fromJSON(c.extent), f = Math.ceil(R.width / c.pixelSizeX - 0.1), w = Math.ceil(R.height / c.pixelSizeY - 0.1), y = R.spatialReference, g = new A({ x: c.pixelSizeX, y: c.pixelSizeY, spatialReference: y }), v = (J = c.histograms) != null && J.length ? c.histograms : null, O = new Cr({ origin: c.origin, blockWidth: c.blockWidth, blockHeight: c.blockHeight, firstPyramidLevel: c.firstPyramidLevel, maximumPyramidLevel: c.maxPyramidLevel });
+  return new Et({ width: f, height: w, bandCount: c.bandCount, extent: R, spatialReference: y, pixelSize: g, pixelType: c.pixelType.toLowerCase(), statistics: h, histograms: v, keyProperties: d, storageInfo: O });
+}
+let ge = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.fromGeometry = null, this.toGeometry = null, this.objectIds = null, this.where = null, this.maxCount = null;
+  }
+};
+i([o({ type: A, json: { read: !0 } })], ge.prototype, "fromGeometry", void 0), i([o({ type: A, json: { read: !0, write: !0 } })], ge.prototype, "toGeometry", void 0), i([o({ json: { write: !0 } })], ge.prototype, "objectIds", void 0), i([o({ type: String, json: { write: !0 } })], ge.prototype, "where", void 0), i([o({ type: Number, json: { write: !0 } })], ge.prototype, "maxCount", void 0), ge = i([b("esri.rest.support.FindImagesParameters")], ge);
+const Qi = ge;
+var Rt;
+let De = Rt = class extends j {
+  constructor(s) {
+    super(s), this.angleNames = null, this.point = null, this.spatialReference = null, this.rasterId = null;
+  }
+  clone() {
+    return new Rt(Q({ angleNames: this.angleNames, point: this.point, spatialReference: this.spatialReference, rasterId: this.rasterId }));
+  }
+};
+i([o({ type: [String], json: { name: "angleName", write: !0 } })], De.prototype, "angleNames", void 0), i([o({ type: A, json: { write: !0 } })], De.prototype, "point", void 0), i([o({ type: se, json: { write: !0 } })], De.prototype, "spatialReference", void 0), i([o({ type: Be, json: { write: !0 } })], De.prototype, "rasterId", void 0), De = Rt = i([b("esri.rest.support.ImageAngleParameters")], De);
+const ki = De, W = new kt({ esriMensurationPoint: "point", esriMensurationCentroid: "centroid", esriMensurationDistanceAndAngle: "distance-and-angle", esriMensurationAreaAndPerimeter: "area-and-perimeter", esriMensurationHeightFromBaseAndTop: "base-and-top", esriMensurationHeightFromBaseAndTopShadow: "base-and-top-shadow", esriMensurationHeightFromTopAndTopShadow: "top-and-top-shadow", esriMensurationPoint3D: "point-3D", esriMensurationCentroid3D: "centroid-3D", esriMensurationDistanceAndAngle3D: "distance-and-angle-3D", esriMensurationAreaAndPerimeter3D: "area-and-perimeter-3D" });
+let ee = class extends j {
+  constructor() {
+    super(...arguments), this.type = null, this.measureOperation = null, this.mosaicRule = null, this.pixelSize = null, this.raster = void 0;
+  }
+};
+i([o()], ee.prototype, "type", void 0), i([o({ type: W.apiValues, json: { read: W.read, write: W.write } })], ee.prototype, "measureOperation", void 0), i([o({ type: k, json: { write: !0 } })], ee.prototype, "mosaicRule", void 0), i([o({ type: A, json: { write: !0 } })], ee.prototype, "pixelSize", void 0), i([o({ json: { write: !0 } })], ee.prototype, "raster", void 0), ee = i([b("esri.rest.support.BaseImageMeasureParameters")], ee);
+var vt;
+let pe = vt = class extends ee {
+  constructor() {
+    super(...arguments), this.type = "area-perimeter", this.geometry = null, this.is3D = !1, this.linearUnit = "meters", this.areaUnit = "square-meters";
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = s.toJSON());
+  }
+  get measureOperation() {
+    return this.is3D ? "area-and-perimeter-3D" : "area-and-perimeter";
+  }
+  clone() {
+    return new vt(Q({ geometry: this.geometry, is3D: this.is3D, linearUnit: this.linearUnit, areaUnit: this.areaUnit, mosaicRule: this.mosaicRule, pixelSize: this.pixelSize, raster: this.raster }));
+  }
+};
+i([o({ types: oe, json: { name: "fromGeometry", read: !0, write: !0 } })], pe.prototype, "geometry", void 0), i([T("geometry")], pe.prototype, "writeGeometry", null), i([o({ type: W.apiValues, json: { write: W.write } })], pe.prototype, "measureOperation", null), i([o({ json: { read: !0 } })], pe.prototype, "is3D", void 0), i([o({ type: String, json: { read: be.read, write: be.write } })], pe.prototype, "linearUnit", void 0), i([o({ type: String, json: { read: ot.read, write: ot.write } })], pe.prototype, "areaUnit", void 0), pe = vt = i([b("esri.rest.support.ImageAreaParameters")], pe);
+const Wi = pe;
+let nt = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.outSpatialReference = null;
+  }
+};
+i([o({ type: se, json: { name: "outSR", write: !0 } })], nt.prototype, "outSpatialReference", void 0), nt = i([b("esri.rest.support.ImageBoundaryParameters")], nt);
+const Zi = nt;
+var bt;
+let ie = bt = class extends ee {
+  constructor() {
+    super(...arguments), this.type = "distance-angle", this.fromGeometry = null, this.toGeometry = null, this.is3D = !1, this.linearUnit = "meters", this.angularUnit = "degrees";
+  }
+  writeFromGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = s.toJSON());
+  }
+  get measureOperation() {
+    return this.is3D ? "distance-and-angle-3D" : "distance-and-angle";
+  }
+  clone() {
+    return new bt(Q({ fromGeometry: this.fromGeometry, toGeometry: this.toGeometry, is3D: this.is3D, linearUnit: this.linearUnit, angularUnit: this.angularUnit, mosaicRule: this.mosaicRule, pixelSize: this.pixelSize, raster: this.raster }));
+  }
+};
+i([o({ type: A, json: { read: !0, write: !0 } })], ie.prototype, "fromGeometry", void 0), i([T("fromGeometry")], ie.prototype, "writeFromGeometry", null), i([o({ type: A, json: { read: !0, write: !0 } })], ie.prototype, "toGeometry", void 0), i([o({ type: W.apiValues, json: { write: W.write } })], ie.prototype, "measureOperation", null), i([o({ json: { read: !0 } })], ie.prototype, "is3D", void 0), i([o({ type: String, json: { read: be.read, write: be.write } })], ie.prototype, "linearUnit", void 0), i([o({ type: String, json: { read: lt.read, write: lt.write } })], ie.prototype, "angularUnit", void 0), ie = bt = i([b("esri.rest.support.ImageDistanceParameters")], ie);
+const Ki = ie;
+let ce = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.geometry = null, this.objectIds = null, this.spatialRelationship = "intersects", this.timeExtent = null, this.where = null;
+  }
+  writeGeometry(r, a, e) {
+    r != null && (a.geometryType = re(r), a[e] = JSON.stringify(r.toJSON()));
+  }
+};
+i([o({ types: oe, json: { read: te, write: !0 } })], ce.prototype, "geometry", void 0), i([T("geometry")], ce.prototype, "writeGeometry", null), i([o({ json: { write: !0 } })], ce.prototype, "objectIds", void 0), i([Wt(Zt, { ignoreUnknown: !1, name: "spatialRel" })], ce.prototype, "spatialRelationship", void 0), i([o({ type: jt, json: { name: "time", write: !0 } })], ce.prototype, "timeExtent", void 0), i([o({ type: String, json: { write: !0 } })], ce.prototype, "where", void 0), ce = i([b("esri.rest.support.ImageGPSInfoParameters")], ce);
+const Xi = ce;
+var St;
+let me = St = class extends ee {
+  constructor() {
+    super(...arguments), this.type = "height", this.fromGeometry = null, this.toGeometry = null, this.operationType = "base-and-top", this.linearUnit = "meters";
+  }
+  writeFromGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = s.toJSON());
+  }
+  get measureOperation() {
+    return this.operationType;
+  }
+  clone() {
+    return new St(Q({ fromGeometry: this.fromGeometry, toGeometry: this.toGeometry, operationType: this.operationType, linearUnit: this.linearUnit, mosaicRule: this.mosaicRule, pixelSize: this.pixelSize, raster: this.raster }));
+  }
+};
+i([o({ type: A, json: { read: !0 } })], me.prototype, "fromGeometry", void 0), i([T("fromGeometry")], me.prototype, "writeFromGeometry", null), i([o({ type: A, json: { read: !0, write: !0 } })], me.prototype, "toGeometry", void 0), i([o({ type: W.apiValues, json: { write: W.write } })], me.prototype, "measureOperation", null), i([o({ json: { read: !0 } })], me.prototype, "operationType", void 0), i([o({ type: String, json: { read: be.read, write: be.write } })], me.prototype, "linearUnit", void 0), me = St = i([b("esri.rest.support.ImageHeightParameters")], me);
+const Yi = me;
+var xt;
+let N = xt = class extends j {
+  constructor() {
+    super(...arguments), this.geometry = null, this.rasterFunctions = null, this.pixelSize = null, this.returnGeometry = !0, this.returnCatalogItems = !0, this.returnPixelValues = !0, this.maxItemCount = null, this.timeExtent = null, this.raster = void 0, this.viewId = void 0, this.processAsMultidimensional = !1;
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = JSON.stringify(s.toJSON()));
+  }
+  set mosaicRule(s) {
+    let r = s;
+    r != null && r.mosaicMethod && (r = k.fromJSON({ ...r.toJSON(), mosaicMethod: r.mosaicMethod, mosaicOperation: r.mosaicOperation })), this._set("mosaicRule", r);
+  }
+  writeMosaicRule(s, r, a) {
+    s != null && (r[a] = JSON.stringify(s.toJSON()));
+  }
+  get renderingRule() {
+    return Ve(we.getLogger(this), "renderingRule", { replacement: "rasterFunction", version: "4.27", warnOnce: !0 }), this._get("rasterFunction");
+  }
+  set renderingRule(s) {
+    Ve(we.getLogger(this), "renderingRule", { replacement: "rasterFunction", version: "4.27", warnOnce: !0 }), this._set("rasterFunction", s);
+  }
+  get renderingRules() {
+    return Ve(we.getLogger(this), "renderingRules", { replacement: "rasterFunctions", version: "4.27", warnOnce: !0 }), this._get("rasterFunctions");
+  }
+  set renderingRules(s) {
+    Ve(we.getLogger(this), "renderingRules", { replacement: "rasterFunctions", version: "4.27", warnOnce: !0 }), this._set("rasterFunctions", s);
+  }
+  set rasterFunction(s) {
+    let r = s;
+    r != null && r.rasterFunction && (r = S.fromJSON({ ...r.toJSON(), rasterFunction: r.rasterFunction, rasterFunctionArguments: r.rasterFunctionArguments })), this._set("rasterFunction", r);
+  }
+  writeRasterFunction(s, r, a) {
+    s != null && (r[a] = JSON.stringify(s.toJSON())), s.rasterFunctionDefinition && (r[a] = JSON.stringify(s.rasterFunctionDefinition));
+  }
+  writeRasterFunctions(s, r, a) {
+    s != null && (r[a] = JSON.stringify(s.map((e) => e.rasterFunctionDefinition || e.toJSON())));
+  }
+  writePixelSize(s, r, a) {
+    s != null && (r[a] = JSON.stringify(s));
+  }
+  writeTimeExtent(s, r, a) {
+    if (s != null) {
+      const e = s.start != null ? s.start.getTime() : null, t = s.end != null ? s.end.getTime() : null;
+      r[a] = e != null ? t != null ? `${e},${t}` : `${e}` : null;
+    }
+  }
+  clone() {
+    return new xt(Q({ geometry: this.geometry, mosaicRule: this.mosaicRule, rasterFunction: this.rasterFunction, rasterFunctions: this.rasterFunctions, pixelSize: this.pixelSize, returnGeometry: this.returnGeometry, returnCatalogItems: this.returnCatalogItems, returnPixelValues: this.returnPixelValues, maxItemCount: this.maxItemCount, processAsMultidimensional: this.processAsMultidimensional, raster: this.raster, viewId: this.viewId, timeExtent: this.timeExtent }));
+  }
+};
+i([o({ json: { write: !0 } })], N.prototype, "geometry", void 0), i([T("geometry")], N.prototype, "writeGeometry", null), i([o({ type: k, json: { write: !0 } })], N.prototype, "mosaicRule", null), i([T("mosaicRule")], N.prototype, "writeMosaicRule", null), i([o({ type: S })], N.prototype, "renderingRule", null), i([o({ type: [S] })], N.prototype, "renderingRules", null), i([o({ type: S, json: { write: !0, name: "renderingRule" } })], N.prototype, "rasterFunction", null), i([T("rasterFunction")], N.prototype, "writeRasterFunction", null), i([o({ type: [S], json: { write: !0, name: "renderingRules" } })], N.prototype, "rasterFunctions", void 0), i([T("rasterFunctions")], N.prototype, "writeRasterFunctions", null), i([o({ type: A, json: { write: !0 } })], N.prototype, "pixelSize", void 0), i([T("pixelSize")], N.prototype, "writePixelSize", null), i([o({ type: Boolean, json: { write: !0 } })], N.prototype, "returnGeometry", void 0), i([o({ type: Boolean, json: { write: !0 } })], N.prototype, "returnCatalogItems", void 0), i([o({ type: Boolean, json: { write: !0 } })], N.prototype, "returnPixelValues", void 0), i([o({ type: Number, json: { write: !0 } })], N.prototype, "maxItemCount", void 0), i([o({ type: jt, json: { write: { target: "time" } } })], N.prototype, "timeExtent", void 0), i([T("timeExtent")], N.prototype, "writeTimeExtent", null), i([o({ json: { write: !0 } })], N.prototype, "raster", void 0), i([o({ json: { write: !0 } })], N.prototype, "viewId", void 0), i([o({ type: Boolean, json: { write: !0 } })], N.prototype, "processAsMultidimensional", void 0), N = xt = i([b("esri.rest.support.ImageIdentifyParameters")], N);
+const At = N;
+var It;
+let $e = It = class extends j {
+  constructor() {
+    super(...arguments), this.geometries = null, this.rasterId = null;
+  }
+  writeGeometry(s, r, a) {
+    r.geometries = { geometryType: "esriGeometryPoint", geometries: s.map((e) => e.toJSON()) };
+  }
+  clone() {
+    var s;
+    return new It({ geometries: ((s = this.geometries) == null ? void 0 : s.map((r) => r.clone())) ?? [], rasterId: this.rasterId });
+  }
+};
+i([o({ type: [A], json: { write: !0 } })], $e.prototype, "geometries", void 0), i([T("geometries")], $e.prototype, "writeGeometry", null), i([o({ type: Be, json: { write: !0 } })], $e.prototype, "rasterId", void 0), $e = It = i([b("esri.rest.support.ImagePixelLocationParameters")], $e);
+const es = $e;
+var Ft;
+let Te = Ft = class extends ee {
+  constructor() {
+    super(...arguments), this.type = "point", this.geometry = null, this.is3D = !1;
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = s.toJSON());
+  }
+  get measureOperation() {
+    const { is3D: s, geometry: r } = this;
+    return r.type === "point" ? s ? "point-3D" : "point" : s ? "centroid-3D" : "centroid";
+  }
+  clone() {
+    return new Ft(Q({ geometry: this.geometry, is3D: this.is3D, mosaicRule: this.mosaicRule, pixelSize: this.pixelSize, raster: this.raster }));
+  }
+};
+i([o({ types: oe, json: { name: "fromGeometry", read: te } })], Te.prototype, "geometry", void 0), i([T("geometry")], Te.prototype, "writeGeometry", null), i([o({ type: W.apiValues, json: { read: W.read, write: W.write } })], Te.prototype, "measureOperation", null), i([o({ json: { read: !0 } })], Te.prototype, "is3D", void 0), Te = Ft = i([b("esri.rest.support.ImagePointParameters")], Te);
+const ts = Te;
+var Dt;
+let q = Dt = class extends j {
+  constructor() {
+    super(...arguments), this.geometry = null, this.interpolation = "nearest", this.mosaicRule = null, this.outFields = null, this.pixelSize = null, this.returnFirstValueOnly = !0, this.sampleDistance = null, this.sampleCount = null, this.sliceId = null, this.timeExtent = null;
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = s.toJSON());
+  }
+  set locations(s) {
+    if (s != null && s.length) {
+      const r = new Kt({ spatialReference: s[0].spatialReference });
+      r.points = s.map((a) => [a.x, a.y]), this._set("locations", s), this.geometry = r;
+    }
+  }
+  clone() {
+    return new Dt(Q({ geometry: this.geometry, locations: this.locations, interpolation: this.interpolation, mosaicRule: this.mosaicRule, outFields: this.outFields, raster: this.raster, returnFirstValueOnly: this.returnFirstValueOnly, sampleDistance: this.sampleDistance, sampleCount: this.sampleCount, sliceId: this.sliceId, pixelSize: this.pixelSize, timeExtent: this.timeExtent }));
+  }
+};
+i([o({ types: oe, json: { read: te } })], q.prototype, "geometry", void 0), i([T("geometry")], q.prototype, "writeGeometry", null), i([o()], q.prototype, "locations", null), i([o({ type: String, json: { type: ve.jsonValues, read: ve.read, write: ve.write } })], q.prototype, "interpolation", void 0), i([o({ type: k, json: { write: !0 } })], q.prototype, "mosaicRule", void 0), i([o({ type: [String], json: { write: !0 } })], q.prototype, "outFields", void 0), i([o({ type: A, json: { write: !0 } })], q.prototype, "pixelSize", void 0), i([o({ type: String, json: { write: !0 } })], q.prototype, "raster", void 0), i([o({ type: Boolean, json: { write: !0 } })], q.prototype, "returnFirstValueOnly", void 0), i([o({ type: Number, json: { write: !0 } })], q.prototype, "sampleDistance", void 0), i([o({ type: Number, json: { write: !0 } })], q.prototype, "sampleCount", void 0), i([o({ type: Number, json: { write: !0 } })], q.prototype, "sliceId", void 0), i([o({ type: jt, json: { read: { source: "time" }, write: { target: "time" } } })], q.prototype, "timeExtent", void 0), q = Dt = i([b("esri.rest.support.ImageSampleParameters")], q);
+const rs = q;
+let je = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.geometries = [], this.rasterIds = null, this.outSpatialReference = null;
+  }
+  writeGeometries(r, a, e) {
+    a.geometries = r != null && r.length ? { geometryType: re(r[0]), geometries: r.map((t) => ({ ...t.toJSON(), spatialReference: void 0 })) } : null;
+  }
+};
+i([o({ types: [oe] })], je.prototype, "geometries", void 0), i([T("geometries")], je.prototype, "writeGeometries", null), i([o({ type: [Be], json: { write: !0 } })], je.prototype, "rasterIds", void 0), i([o({ type: se, json: { name: "outSR", write: !0 } })], je.prototype, "outSpatialReference", void 0), je = i([b("esri.rest.support.ImageToMapMultirayParameters")], je);
+const is = je;
+let de = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.geometry = null, this.rasterId = null, this.outSpatialReference = null, this.depthOffset = 0, this.adjust = !1;
+  }
+  writeGeometry(r, a, e) {
+    r != null && (a.geometryType = re(r), a[e] = { ...r.toJSON(), spatialReference: void 0 });
+  }
+};
+i([o({ types: oe, json: { read: te, write: !0 } })], de.prototype, "geometry", void 0), i([T("geometry")], de.prototype, "writeGeometry", null), i([o({ json: { write: !0 } })], de.prototype, "rasterId", void 0), i([o({ type: se, json: { name: "outSR", write: !0 } })], de.prototype, "outSpatialReference", void 0), i([o({ json: { name: "options.DOff", write: !0 } })], de.prototype, "depthOffset", void 0), i([o({ json: { name: "options.Adjust", write: !0 } })], de.prototype, "adjust", void 0), de = i([b("esri.rest.support.ImageToMapParameters")], de);
+const ss = de;
+let at = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.referenceUri = null;
+  }
+};
+i([o({ type: String, json: { name: "uri", write: !0 } })], at.prototype, "referenceUri", void 0), at = i([b("esri.rest.support.ImageUrlParameters")], at);
+const ns = at;
+let Pe = class extends Se(j) {
+  constructor() {
+    super(...arguments), this.geometry = null, this.rasterId = null, this.visibleOnly = !1;
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = JSON.stringify(s));
+  }
+};
+i([o({ types: oe, json: { read: te, write: !0 } })], Pe.prototype, "geometry", void 0), i([T("geometry")], Pe.prototype, "writeGeometry", null), i([o({ json: { write: !0 } })], Pe.prototype, "rasterId", void 0), i([o({ json: { name: "options.VisibleOnly", write: !0 } })], Pe.prototype, "visibleOnly", void 0), Pe = i([b("esri.rest.support.MapToImageParameters")], Pe);
+const as = Pe;
+var Tt;
+let Ae = Tt = class extends j {
+  constructor() {
+    super(...arguments), this.geometry = null, this.rasterId = void 0;
+  }
+  writeGeometry(s, r, a) {
+    s != null && (r.geometryType = re(s), r[a] = { ...s.toJSON(), spatialReference: void 0 });
+  }
+  clone() {
+    const s = Q({ geometry: this.geometry, rasterId: this.rasterId });
+    return new Tt(s);
+  }
+};
+i([o({ types: oe, json: { name: "fromGeometry", read: te, write: !0 } })], Ae.prototype, "geometry", void 0), i([T("geometry")], Ae.prototype, "writeGeometry", null), i([o({ json: { write: !0 } })], Ae.prototype, "rasterId", void 0), Ae = Tt = i([b("esri.rest.support.MeasureFromImageParameters")], Ae);
+const Vt = Ae, os = /* @__PURE__ */ new Set(["png", "png8", "png24", "png32", "jpg", "bmp", "gif", "jpgpng", "lerc", "tiff"]), ls = tr(rr, { min: 0, max: 255 });
+function us(s) {
+  if (!s)
+    return null;
+  const r = JSON.stringify(s).match(/"rasterFunction":"(.*?")/gi), a = r == null ? void 0 : r.map((e) => e.replace('"rasterFunction":"', "").replace('"', ""));
+  return a ? a.join("/") : null;
+}
+const ps = (s) => {
+  let r = class extends s {
+    constructor() {
+      super(...arguments), this._functionRasterInfos = {}, this._rasterJobHandler = { instance: null, refCount: 0, connectionPromise: null }, this._cachedRendererJson = null, this._serviceSupportsMosaicRule = null, this._rasterAttributeTableFieldPrefix = "Raster.", this.adjustAspectRatio = null, this.bandIds = void 0, this.capabilities = null, this.compressionQuality = void 0, this.compressionTolerance = 0.01, this.copyright = null, this.defaultMosaicRule = null, this.definitionExpression = null, this.exportImageServiceParameters = null, this.rasterInfo = null, this.fields = null, this.fullExtent = null, this.hasMultidimensions = !1, this.imageMaxHeight = 4100, this.imageMaxWidth = 4100, this.interpolation = void 0, this.minScale = 0, this.maxScale = 0, this.multidimensionalInfo = null, this.multidimensionalSubset = null, this.noData = null, this.noDataInterpretation = void 0, this.objectIdField = null, this.geometryType = "polygon", this.typeIdField = null, this.types = [], this.pixelFilter = null, this.raster = void 0, this.sourceType = null, this.viewId = void 0, this.symbolizer = null, this.rasterFunctionInfos = null, this.serviceDataType = null, this.spatialReference = null, this.pixelType = null, this.serviceRasterInfo = null, this.sourceJSON = null, this.url = null, this.version = void 0;
+    }
+    initialize() {
+      this._set("exportImageServiceParameters", new _({ layer: this }));
+    }
+    readServiceSupportsMosaicRule(e, t) {
+      return this._isMosaicRuleSupported(t);
+    }
+    get _rasterFunctionNamesIndex() {
+      const e = /* @__PURE__ */ new Map();
+      return !this.rasterFunctionInfos || this.rasterFunctionInfos != null && this.rasterFunctionInfos.length < 1 || this.rasterFunctionInfos != null && this.rasterFunctionInfos.forEach((t) => {
+        e.set(t.name.toLowerCase().replaceAll(/ /gi, "_"), t.name);
+      }), e;
+    }
+    readBandIds(e, t) {
+      if (Array.isArray(e) && e.length > 0 && e.every((n) => typeof n == "number"))
+        return e;
+    }
+    readCapabilities(e, t) {
+      return this._readCapabilities(t);
+    }
+    writeCompressionQuality(e, t, n) {
+      e != null && this.format !== "lerc" && (t[n] = e);
+    }
+    writeCompressionTolerance(e, t, n) {
+      this.format === "lerc" && e != null && (t[n] = e);
+    }
+    readDefaultMosaicRule(e, t) {
+      return this._serviceSupportsMosaicRule ? k.fromJSON(t) : null;
+    }
+    get fieldsIndex() {
+      return this.fields ? new Mr(this.fields) : null;
+    }
+    set format(e) {
+      e && os.has(e.toLowerCase()) && this._set("format", e.toLowerCase());
+    }
+    readFormat(e, t) {
+      return t.serviceDataType === "esriImageServiceDataTypeVector-UV" || t.serviceDataType === "esriImageServiceDataTypeVector-MagDir" || this.pixelFilter != null ? "lerc" : "jpgpng";
+    }
+    readMinScale(e, t) {
+      return t.minLOD != null && t.maxLOD != null ? e : 0;
+    }
+    readMaxScale(e, t) {
+      return t.minLOD != null && t.maxLOD != null ? e : 0;
+    }
+    set mosaicRule(e) {
+      let t = e;
+      t != null && t.mosaicMethod && (t = k.fromJSON({ ...t.toJSON(), mosaicMethod: t.mosaicMethod, mosaicOperation: t.mosaicOperation })), this._set("mosaicRule", t);
+    }
+    readMosaicRule(e, t) {
+      const n = e || t.mosaicRule;
+      return n ? k.fromJSON(n) : this._isMosaicRuleSupported(t) ? k.fromJSON(t) : null;
+    }
+    writeMosaicRule(e, t, n) {
+      let l = this.mosaicRule;
+      const u = this.definitionExpression;
+      l ? u && u !== l.where && (l = l.clone(), l.where = u) : u && (l = new k({ where: u })), this._isValidCustomizedMosaicRule(l) && (t[n] = l.toJSON());
+    }
+    writeNoData(e, t, n) {
+      e != null && typeof e == "number" && (t[n] = ls(e));
+    }
+    readObjectIdField(e, t) {
+      if (!e) {
+        const n = t.fields.find((l) => l.type === "esriFieldTypeOID" || l.type === "oid");
+        e = n == null ? void 0 : n.name;
+      }
+      return e;
+    }
+    get parsedUrl() {
+      return Xt(this.url);
+    }
+    readSourceType(e, t) {
+      return this._isMosaicDataset(t) ? "mosaic-dataset" : "raster-dataset";
+    }
+    set renderer(e) {
+      this.loaded && (e = this._configRenderer(e)), this._set("renderer", e);
+    }
+    readRenderer(e, t, n) {
+      var p, m;
+      const l = (m = (p = t == null ? void 0 : t.layerDefinition) == null ? void 0 : p.drawingInfo) == null ? void 0 : m.renderer, u = cr(l, n);
+      return u == null ? null : (u.type === "vector-field" && t.symbolTileSize && !l.symbolTileSize && (u.symbolTileSize = t.symbolTileSize), Gt(u) || we.getLogger(this).warn("ArcGISImageService", "Imagery layer doesn't support given renderer type."), u);
+    }
+    writeRenderer(e, t, n) {
+      t.layerDefinition = t.layerDefinition || {}, t.layerDefinition.drawingInfo = t.layerDefinition.drawingInfo || {}, t.layerDefinition.drawingInfo.renderer = e.toJSON(), e.type === "vector-field" && (t.symbolTileSize = e.symbolTileSize);
+    }
+    get rasterFields() {
+      var m;
+      const e = this._rasterAttributeTableFieldPrefix, t = new Fe({ name: "Raster.ItemPixelValue", alias: "Item Pixel Value", domain: null, editable: !1, length: 50, type: "string" }), n = new Fe({ name: "Raster.ServicePixelValue", alias: "Service Pixel Value", domain: null, editable: !1, length: 50, type: "string" }), l = new Fe({ name: "Raster.ServicePixelValue.Raw", alias: "Raw Service Pixel Value", domain: null, editable: !1, length: 50, type: "string" });
+      let u = this.fields ? Q(this.fields) : [];
+      u.push(n), (m = this.capabilities) != null && m.operations.supportsQuery && this.fields && this.fields.length > 0 && u.push(t), this.version >= 10.4 && this.rasterFunctionInfos != null && this.rasterFunctionInfos.some((c) => c.name.toLowerCase() === "none") && u.push(l), this.rasterFunctionInfos != null && this.rasterFunctionInfos.filter((c) => c.name.toLowerCase() !== "none").forEach((c) => {
+        u.push(new Fe({ name: "Raster.ServicePixelValue." + c.name, alias: c.name, domain: null, editable: !1, length: 50, type: "string" }));
+      }), this._isVectorDataSet() && (u.push(new Fe({ name: "Raster.Magnitude", alias: "Magnitude", domain: null, editable: !1, type: "double" })), u.push(new Fe({ name: "Raster.Direction", alias: "Direction", domain: null, editable: !1, type: "double" })));
+      const { attributeTable: p } = this.rasterInfo ?? {};
+      if (p != null) {
+        const c = p.fields.filter((d) => d.type !== "esriFieldTypeOID" && d.name.toLowerCase() !== "value").map((d) => {
+          const h = Q(d);
+          return h.name = e + d.name, h;
+        });
+        u = u.concat(c);
+      }
+      return u;
+    }
+    get renderingRule() {
+      return Ve(we.getLogger(this), "renderingRule", { replacement: "rasterFunction", version: "4.27", warnOnce: !0 }), this.rasterFunction;
+    }
+    set renderingRule(e) {
+      Ve(we.getLogger(this), "renderingRule", { replacement: "rasterFunction", version: "4.27", warnOnce: !0 }), this._set("rasterFunction", e);
+    }
+    set rasterFunction(e) {
+      let t = e;
+      t != null && t.rasterFunction && (t = S.fromJSON({ ...t.toJSON(), rasterFunction: t.rasterFunction, rasterFunctionArguments: t.rasterFunctionArguments })), this._set("rasterFunction", t);
+    }
+    readRasterFunction(e, t) {
+      const n = t.rasterFunctionInfos;
+      return t.renderingRule || n != null && n.length && n[0].name !== "None" ? this._isRFTJson(t.renderingRule) ? S.fromJSON({ rasterFunctionDefinition: t.renderingRule }) : S.fromJSON(t.renderingRule || { rasterFunctionInfos: t.rasterFunctionInfos }) : null;
+    }
+    readSpatialReference(e, t) {
+      const n = e || t.extent.spatialReference;
+      return n ? se.fromJSON(n) : null;
+    }
+    readPixelType(e) {
+      return dt.fromJSON(e) || e;
+    }
+    writePixelType(e, t, n) {
+      this.serviceRasterInfo != null && this.pixelType === this.serviceRasterInfo.pixelType || (t[n] = dt.toJSON(e));
+    }
+    readVersion(e, t) {
+      let n = t.currentVersion;
+      return n || (n = t.hasOwnProperty("fields") || t.hasOwnProperty("timeInfo") ? 10 : 9.3), n;
+    }
+    applyFilter(e) {
+      let t = e;
+      return this.pixelFilter && (t = this._clonePixelData(e), this.pixelFilter(t)), t;
+    }
+    async applyRenderer(e, t) {
+      let n = e;
+      const { renderer: l, symbolizer: u, pixelFilter: p, bandIds: m } = this;
+      if (!this._isPicture() && l && u && !p) {
+        const c = JSON.stringify(this._cachedRendererJson) !== JSON.stringify(l.toJSON()), d = this._rasterJobHandler.instance;
+        if (d) {
+          c && (u.bind(), await d.updateSymbolizer(u, t), this._cachedRendererJson = l.toJSON());
+          const h = await d.symbolize({ bandIds: m, ...e }, t);
+          n = { extent: e.extent, pixelBlock: h };
+        } else
+          n = { extent: e.extent, pixelBlock: u.symbolize({ bandIds: m, ...e }) };
+      }
+      return n;
+    }
+    destroy() {
+      this._shutdownJobHandler();
+    }
+    increaseRasterJobHandlerUsage() {
+      this._rasterJobHandler.refCount++;
+    }
+    decreaseRasterJobHandlerUsage() {
+      this._rasterJobHandler.refCount--, this._rasterJobHandler.refCount <= 0 && this._shutdownJobHandler();
+    }
+    async computeAngles(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsComputeAngles)
+        throw new I("imagery-layer:compute-angles", "this operation is not supported on the input image service");
+      return e = $(ki, e).clone(), ji(this.url, e, this._getRequestOptions(t));
+    }
+    async computePixelSpaceLocations(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsComputePixelLocation)
+        throw new I("imagery-layer:compute-pixel-space-locations", "this operation is not supported on the input image service");
+      return e = $(es, e).clone(), Pi(this.url, e, this._getRequestOptions(t));
+    }
+    async computeHistograms(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsComputeHistograms)
+        throw new I("imagery-layer:compute-histograms", "this operation is not supported on the input image service");
+      return e = $(yt, e).clone(), this._applyMosaicAndRenderingRules(e), Oi(this.url, e, this._getRequestOptions(t));
+    }
+    async computeStatisticsHistograms(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsComputeStatisticsHistograms)
+        throw new I("imagery-layer:compute-statistics-histograms", "this operation is not supported on the input image service");
+      return e = $(yt, e).clone(), this._applyMosaicAndRenderingRules(e), Ni(this.url, e, this._getRequestOptions(t));
+    }
+    async measureHeight(e, t) {
+      const n = await this._fetchCapabilities(t == null ? void 0 : t.signal);
+      if (!(e.operationType === "base-and-top" ? n.mensuration.supportsHeightFromBaseAndTop : e.operationType === "base-and-top-shadow" ? n.mensuration.supportsHeightFromBaseAndTopShadow : n.mensuration.supportsHeightFromTopAndTopShadow))
+        throw new I("imagery-layer:measure-height", "this operation is not supported on the input image service");
+      return e = $(Yi, e).clone(), this._applyMosaicAndRenderingRules(e), Ci(this.url, e, this._getRequestOptions(t));
+    }
+    async measureAreaAndPerimeter(e, t) {
+      const n = await this._fetchCapabilities(t == null ? void 0 : t.signal);
+      if (!(n.mensuration.supportsAreaAndPerimeter && (!e.is3D || n.mensuration.supports3D)))
+        throw new I("imagery-layer:measure-area-and-perimeter", "this operation is not supported on the input image service");
+      return e = $(Wi, e).clone(), this._applyMosaicAndRenderingRules(e), $i(this.url, e, this._getRequestOptions(t));
+    }
+    async measureDistanceAndAngle(e, t) {
+      const n = await this._fetchCapabilities(t == null ? void 0 : t.signal);
+      if (!(n.mensuration.supportsDistanceAndAngle && (!e.is3D || n.mensuration.supports3D)))
+        throw new I("imagery-layer:measure-distance-and-angle", "this operation is not supported on the input image service");
+      return e = $(Ki, e).clone(), this._applyMosaicAndRenderingRules(e), Vi(this.url, e, this._getRequestOptions(t));
+    }
+    async measurePointOrCentroid(e, t) {
+      const n = await this._fetchCapabilities(t == null ? void 0 : t.signal);
+      if (!(n.mensuration.supportsPointOrCentroid && (!e.is3D || n.mensuration.supports3D)))
+        throw new I("imagery-layer:measure-point-or-centroid", "this operation is not supported on the input image service");
+      return e = $(ts, e).clone(), this._applyMosaicAndRenderingRules(e), Ai(this.url, e, this._getRequestOptions(t));
+    }
+    async measureLengthFromImage(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsMeasureFromImage)
+        throw new I("imagery-layer:measure-length-from-image", "this operation is not supported on the input image service");
+      if (e.geometry.type !== "polyline")
+        throw new I("imagery-layer:measure-length-from-image", "this input geometry must be a polyline");
+      return e = $(Vt, e).clone(), Mi(this.url, e, this._getRequestOptions(t));
+    }
+    async measureAreaFromImage(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsMeasureFromImage)
+        throw new I("imagery-layer:measure-area-from-image", "this operation is not supported on the input image service");
+      if (e.geometry.type !== "polygon")
+        throw new I("imagery-layer:measure-area-from-image", "this input geometry must be a polygon");
+      return e = $(Vt, e).clone(), Ji(this.url, e, this._getRequestOptions(t));
+    }
+    getField(e) {
+      const { fieldsIndex: t } = this;
+      return t != null ? t.get(e) : void 0;
+    }
+    getFieldDomain(e, t) {
+      const n = this.getField(e);
+      return n ? n.domain : null;
+    }
+    async fetchImage(e, t, n, l = {}) {
+      if (e == null || t == null || n == null)
+        throw new I("imagery-layer:fetch-image", "Insufficient parameters for requesting an image. A valid extent, width and height values are required.");
+      if (this.renderer || this.symbolizer) {
+        const d = await this._generateRasterInfo(this.rasterFunction, { signal: l.signal });
+        d && (this.rasterInfo = d);
+      }
+      const u = this.getExportImageServiceParameters(e, t, n, l.timeExtent);
+      if (u == null) {
+        if (l.requestAsImageElement && this._canRequestImageElement(this.format)) {
+          const g = document.createElement("canvas");
+          return g.width = t, g.height = n, l.returnImageBitmap ? { imageBitmap: await Ct(g, `${a(this.parsedUrl)}/exportImage`, l.signal) } : { imageOrCanvasElement: g };
+        }
+        const { bandIds: d, rasterInfo: h } = this, R = ((d == null ? void 0 : d.length) || h.bandCount) ?? 0, f = t * n, w = h.pixelType, y = [];
+        for (let g = 0; g < R; g++)
+          y.push(gt.createEmptyBand(w, f));
+        return { pixelData: { pixelBlock: new gt({ width: t, height: n, pixels: y, mask: new Uint8Array(f), pixelType: w }), extent: e } };
+      }
+      const p = !!l.requestAsImageElement && !this.pixelFilter, m = p && !!l.returnImageBitmap, c = { imageServiceParameters: u, imageProps: { extent: e, width: t, height: n, format: this.format }, requestAsImageElement: p, returnImageBitmap: m, signal: l.signal };
+      return this._requestArrayBuffer(c);
+    }
+    fetchKeyProperties(e) {
+      return D(a(this.parsedUrl) + "/keyProperties", { query: this._getQueryParams({ renderingRule: this.version >= 10.3 ? e == null ? void 0 : e.rasterFunction : null }) }).then((t) => t.data);
+    }
+    fetchRasterAttributeTable(e) {
+      return this.version < 10.1 ? Promise.reject(new I("#fetchRasterAttributeTable()", "Failed to get rasterAttributeTable")) : D(a(this.parsedUrl) + "/rasterAttributeTable", { query: this._getQueryParams({ renderingRule: this.version >= 10.3 ? e == null ? void 0 : e.rasterFunction : null }) }).then((t) => qt.fromJSON(t.data));
+    }
+    getCatalogItemRasterInfo(e, t) {
+      const n = { ...t, query: this._getQueryParams() };
+      return Bi(a(this.parsedUrl), e, n);
+    }
+    async getCatalogItemICSInfo(e, t) {
+      var xe, Ie, le, Nt, Ot;
+      const { data: n } = await D(a(this.parsedUrl) + "/" + e + "/info/ics", { query: this._getQueryParams(), ...t }), l = n == null ? void 0 : n.ics;
+      if (!l)
+        return;
+      let u = null;
+      try {
+        u = (await D(a(this.parsedUrl) + "/" + e + "/info", { query: this._getQueryParams(), ...t })).data.extent;
+      } catch {
+      }
+      if (!u || !u.spatialReference)
+        return { ics: l, icsToPixelTransform: null, icsExtent: null, northDirection: null };
+      const p = this.version >= 10.7 ? D(a(this.parsedUrl) + "/" + e + "/info/icstopixel", { query: this._getQueryParams(), ...t }).then((x) => x.data).catch(() => ({})) : {}, m = u.spatialReference, c = { geometries: JSON.stringify({ geometryType: "esriGeometryEnvelope", geometries: [u] }), inSR: wt(m), outSR: "0:" + e }, d = D(a(this.parsedUrl) + "/project", { query: this._getQueryParams(c), ...t }).then((x) => x.data).catch(() => ({})), h = 5, R = (u.xmin + u.xmax) / 2, f = (u.ymax - u.ymin) / (h + 1), w = u.ymin + f, y = [];
+      for (let x = 0; x < h; x++)
+        y.push({ x: R, y: w + f * x });
+      const g = { geometries: JSON.stringify({ geometryType: "esriGeometryPoint", geometries: y }), inSR: wt(m), outSR: "0:" + e }, v = D(a(this.parsedUrl) + "/project", { query: this._getQueryParams(g), ...t }).then((x) => x.data).catch(() => ({})), O = await Promise.all([p, d, v]);
+      let G = O[0].ipxf;
+      if (G == null) {
+        const x = (xe = l.geodataXform) == null ? void 0 : xe.xf_0;
+        ((Ie = x == null ? void 0 : x.name) == null ? void 0 : Ie.toLowerCase()) === "topup" && ((le = x == null ? void 0 : x.coefficients) == null ? void 0 : le.length) === 6 && (G = { affine: { name: "ics [sensor: Frame] to pixel (column, row) transformation", coefficients: x.coefficients, cellsizeRatio: 0, type: "GeometricXform" } });
+      }
+      const J = ze.fromJSON((Ot = (Nt = O[1]) == null ? void 0 : Nt.geometries) == null ? void 0 : Ot[0]);
+      J && (J.spatialReference = new se({ wkid: 0, imageCoordinateSystem: l }));
+      const F = O[2].geometries ? O[2].geometries.filter((x) => (x == null ? void 0 : x.x) != null && x.y != null && x.x !== "NaN" && x.y !== "NaN") : [], H = F.length;
+      if (H < 3)
+        return { ics: l, icsToPixelTransform: G, icsExtent: J, northDirection: null };
+      let Z = 0, C = 0, P = 0, L = 0;
+      for (let x = 0; x < H; x++)
+        Z += F[x].x, C += F[x].y, P += F[x].x * F[x].x, L += F[x].x * F[x].y;
+      const E = (H * L - Z * C) / (H * P - Z * Z);
+      let ye = 0;
+      const Qe = F[h - 1].x > F[0].x, ke = F[h - 1].y > F[0].y;
+      return E === 1 / 0 ? ye = ke ? 90 : 270 : E === 0 ? ye = Qe ? 0 : 180 : E > 0 ? ye = Qe ? 180 * Math.atan(E) / Math.PI : 180 * Math.atan(E) / Math.PI + 180 : E < 0 && (ye = ke ? 180 + 180 * Math.atan(E) / Math.PI : 360 + 180 * Math.atan(E) / Math.PI), { ics: l, icsToPixelTransform: G, icsExtent: J, northDirection: ye };
+    }
+    async generateRasterInfo(e, t) {
+      var p;
+      if (e = $(S, e), this.serviceRasterInfo && (!e || ((p = e.functionName) == null ? void 0 : p.toLowerCase()) === "none" || this._isVectorFieldResampleFunction(e)))
+        return this.serviceRasterInfo;
+      const n = us(e);
+      if (!n)
+        throw new I("imagery-layer:generate-raster-info", "the rendering rule is not supported");
+      if (this._functionRasterInfos[n])
+        return this._functionRasterInfos[n];
+      const l = { ...t, query: this._getQueryParams() }, u = mr(a(this.parsedUrl), e, l);
+      this._functionRasterInfos[n] = u;
+      try {
+        return await u;
+      } catch (m) {
+        throw this._functionRasterInfos[n] = null, m;
+      }
+    }
+    getExportImageServiceParameters(e, t, n, l) {
+      var y;
+      e = e.clone().shiftCentralMeridian();
+      const u = Je(e.spatialReference, a(this.parsedUrl));
+      this.pixelType !== this.serviceRasterInfo.pixelType && (this.exportImageServiceParameters.pixelType = this.pixelType);
+      const p = this.exportImageServiceParameters.toJSON(), { bandIds: m, noData: c } = p;
+      let { renderingRule: d } = p;
+      const h = (y = this.rasterFunction) == null ? void 0 : y.rasterFunctionDefinition, R = !this.renderer || this.renderer.type === "raster-stretch";
+      if (m != null && m.length && this._hasRasterFunction(this.rasterFunction) && !h && R) {
+        const g = { rasterFunction: "ExtractBand", rasterFunctionArguments: { BandIds: m } };
+        if (d.rasterFunction === "Stretch")
+          g.rasterFunctionArguments.Raster = d.rasterFunctionArguments.Raster, d.rasterFunctionArguments.Raster = g;
+        else if (d.rasterFunction === "Colormap") {
+          const v = d.rasterFunctionArguments.Raster;
+          (v == null ? void 0 : v.rasterFunction) === "Stretch" ? (g.rasterFunctionArguments.Raster = v.rasterFunctionArguments.Raster, v.rasterFunctionArguments.Raster = g) : (g.rasterFunctionArguments.Raster = v, d.rasterFunctionArguments.Raster = g);
+        } else
+          g.rasterFunctionArguments.Raster = d, d = g;
+        p.bandIds = void 0;
+      } else
+        p.bandIds = m == null ? void 0 : m.join(",");
+      c instanceof Array && c.length > 0 && (p.noData = c.join(","));
+      const f = this._processMultidimensionalIntersection(null, l, this.exportImageServiceParameters.mosaicRule);
+      if (f.isOutSide)
+        return null;
+      p.mosaicRule = f.mosaicRule != null ? JSON.stringify(f.mosaicRule) : null, l = f.timeExtent, p.renderingRule = this._getRenderingRuleString(S.fromJSON(d));
+      const w = {};
+      if (l != null) {
+        const { start: g, end: v } = l.toJSON();
+        g && v && g === v ? w.time = "" + g : g == null && v == null || (w.time = `${g ?? "null"},${v ?? "null"}`);
+      }
+      return { bbox: e.xmin + "," + e.ymin + "," + e.xmax + "," + e.ymax, bboxSR: u, imageSR: u, size: t + "," + n, ...p, ...w };
+    }
+    async getSamples(e, t) {
+      const n = await this._fetchCapabilities(t == null ? void 0 : t.signal);
+      if (!(n != null && n.operations.supportsGetSamples))
+        throw new I("imagery-layer:get-samples", "getSamples operation is not supported on the input image service");
+      e = $(rs, e).clone();
+      const { raster: l } = this;
+      return l && e.raster == null && (e.raster = l), _i(this.url, e, this._getRequestOptions(t));
+    }
+    async identify(e, t) {
+      var p;
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsIdentify)
+        throw new I("imagery-layer:identify", "identify operation is not supported on the input image service");
+      e = $(At, e).clone(), this.version < 10.91 && ((p = e.geometry) == null ? void 0 : p.type) === "extent" && (e.geometry = Ze.fromExtent(e.geometry));
+      const n = this._processMultidimensionalIntersection(e.geometry, e.timeExtent, e.mosaicRule || this.mosaicRule);
+      if (n.isOutSide)
+        throw new I("imagery-layer:identify", "the request cannot be fulfilled when falling outside of the multidimensional subset");
+      e.timeExtent = n.timeExtent, e.mosaicRule = n.mosaicRule;
+      const { raster: l, rasterFunction: u } = this;
+      return u && e.rasterFunction == null && (e.rasterFunction = u), l && e.raster == null && (e.raster = l), $t(this.url, e, this._getRequestOptions(t));
+    }
+    async imageToMap(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsImageToMap)
+        throw new I("imagery-layer:image-to-map", "imageToMap operation is not supported on the input image service");
+      return e = $(ss, e), Gi(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async imageToMapMultiray(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsImageToMapMultiray)
+        throw new I("imagery-layer:image-to-map-multiray", "imageToMapMultiray operation is not supported on the input image service");
+      return e = $(is, e), Li(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async mapToImage(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsMapToImage)
+        throw new I("imagery-layer:map-to-image", "mapToImage operation is not supported on the input image service");
+      return e = $(as, e), zi(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async findImages(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsFindImages)
+        throw new I("imagery-layer:find-images", "findImages operation is not supported on the input image service");
+      return e = $(Qi, e), Hi(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async getImageUrl(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsGetImageUrl)
+        throw new I("imagery-layer:get-image-url", "getImageUrl operation is not supported on the input image service");
+      return e = $(ns, e), Ui(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    createQuery() {
+      const e = new mt();
+      return e.outFields = ["*"], e.returnGeometry = !0, e.where = this.definitionExpression || "1=1", e;
+    }
+    async queryBoundary(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsQueryBoundary)
+        throw new I("imagery-layer:query-boundary", "queryBoundary operation is not supported on the input image service");
+      return e = $(Zi, e ?? { outSpatialReference: this.spatialReference }).clone(), Ei(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async queryRasters(e, t) {
+      return { query: e, requestOptions: t } = await this._prepareForQuery(e, t), Jr(this.url, e, t);
+    }
+    async queryObjectIds(e, t) {
+      return { query: e, requestOptions: t } = await this._prepareForQuery(e, t), Er(this.url, e, t);
+    }
+    async queryGPSInfo(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsQueryGPSInfo)
+        throw new I("imagery-layer:query-gps-info", "queryGPSInfo operation is not supported on the input image service");
+      return e = $(Xi, e ?? { outSpatialReference: this.spatialReference }).clone(), qi(a(this.parsedUrl), e, this._getRequestOptions(t));
+    }
+    async queryRasterCount(e, t) {
+      return { query: e, requestOptions: t } = await this._prepareForQuery(e, t), qr(this.url, e, t);
+    }
+    async queryVisibleRasters(e, t) {
+      var J, F, H, Z;
+      if (!e)
+        throw new I("imagery-layer: query-visible-rasters", "missing query parameter");
+      await this.load();
+      const { pixelSize: n, returnDomainValues: l, returnTopmostRaster: u, showNoDataRecords: p } = t || { pixelSize: null, returnDomainValues: !1, returnTopmostRaster: !1, showNoDataRecords: !1 };
+      let m = !1, c = null, d = null;
+      const h = "raster.servicepixelvalue", R = this._rasterFunctionNamesIndex;
+      if (e.outFields != null && (m = e.outFields.some((C) => !C.toLowerCase().includes(h)), this.version >= 10.4)) {
+        const C = e.outFields.filter((L) => L.toLowerCase().includes(h) && L.length > h.length).map((L) => {
+          const E = L.slice(h.length + 1);
+          return [this._updateRenderingRulesFunctionName(E, R), E];
+        });
+        c = C.map((L) => new S({ functionName: L[0] })), d = C.map((L) => L[1]);
+        const { rasterFunction: P } = this;
+        c.length === 0 ? P != null && P.functionName ? (c.push(P), d.push(P.functionName)) : c = null : P != null && P.functionName && !c.some((L) => L.functionName === P.functionName) && (c.push(P), d.push(P.functionName));
+      }
+      const f = e.outSpatialReference == null || e.outSpatialReference.equals(this.spatialReference), { multidimensionalSubset: w } = this;
+      let y = e.timeExtent || this.timeExtent;
+      if (w) {
+        const { isOutside: C, intersection: P } = ht(w, { geometry: e.geometry, timeExtent: e.timeExtent, multidimensionalDefinition: (J = this.exportImageServiceParameters.mosaicRule) == null ? void 0 : J.multidimensionalDefinition });
+        if (C)
+          throw new I("imagery-layer:query-visible-rasters", "the request cannot be fulfilled when falling outside of the multidimensional subset");
+        (P == null ? void 0 : P.timeExtent) != null && (y = P.timeExtent);
+      }
+      const g = this._combineMosaicRuleWithTimeExtent(this.exportImageServiceParameters.mosaicRule, y);
+      let v = e.geometry;
+      this.version < 10.91 && (v == null ? void 0 : v.type) === "extent" && (v = Ze.fromExtent(v));
+      const O = this._getQueryParams({ geometry: v, timeExtent: y, mosaicRule: g, rasterFunction: this.version < 10.4 ? this.rasterFunction : null, rasterFunctions: c, pixelSize: n, returnCatalogItems: m, returnGeometry: f, raster: this.raster, maxItemCount: u ? 1 : null });
+      delete O.f;
+      const G = new At(O);
+      try {
+        await this._generateRasterInfo(this.rasterFunction);
+        const C = await $t(this.url, G, { signal: t == null ? void 0 : t.signal, query: { ...this.customParameters } }), P = e.outFields, L = C.value != null && C.value.toLowerCase().includes("nodata");
+        if (!(m && !f && ((F = C == null ? void 0 : C.catalogItems) != null && F.features.length) && (p || !L)))
+          return this._processVisibleRastersResponse(C, { returnDomainValues: l, templateRRFunctionNames: d, showNoDataRecords: p, templateFields: P });
+        const E = this.objectIdField || "ObjectId", ye = ((H = C.catalogItems) == null ? void 0 : H.features) ?? [], Qe = ye.map((Ie) => {
+          var le;
+          return (le = Ie.attributes) == null ? void 0 : le[E];
+        }), ke = new mt({ objectIds: Qe, returnGeometry: !0, outSpatialReference: e.outSpatialReference, outFields: [E] }), xe = await this.queryRasters(ke);
+        return (Z = xe == null ? void 0 : xe.features) != null && Z.length && xe.features.forEach((Ie) => {
+          ye.forEach((le) => {
+            le.attributes[E] === Ie.attributes[E] && (le.geometry = new Ze(Ie.geometry), e.outSpatialReference != null && (le.geometry.spatialReference = e.outSpatialReference));
+          });
+        }), this._processVisibleRastersResponse(C, { returnDomainValues: l, templateRRFunctionNames: d, showNoDataRecords: p, templateFields: P });
+      } catch {
+        throw new I("imagery-layer:query-visible-rasters", "encountered error when querying visible rasters");
+      }
+    }
+    async fetchVariableStatisticsHistograms(e, t) {
+      const n = D(a(this.parsedUrl) + "/statistics", { query: this._getQueryParams({ variable: e }), signal: t }).then((p) => {
+        var m;
+        return (m = p.data) == null ? void 0 : m.statistics;
+      }), l = D(a(this.parsedUrl) + "/histograms", { query: this._getQueryParams({ variable: e }), signal: t }).then((p) => {
+        var m;
+        return (m = p.data) == null ? void 0 : m.histograms;
+      }), u = await Promise.all([n, l]);
+      return u[0] && u[0].forEach((p) => {
+        p.avg = p.mean, p.stddev = p.standardDeviation;
+      }), { statistics: u[0] || null, histograms: u[1] || null };
+    }
+    async createFlowMesh(e, t) {
+      const n = this._rasterJobHandler.instance;
+      return n ? n.createFlowMesh(e, t) : jr(e.meshType, e.simulationSettings, e.flowData, t.signal != null ? t.signal : new AbortController().signal);
+    }
+    getMultidimensionalSubsetVariables(e) {
+      const t = e ?? this.serviceRasterInfo.multidimensionalInfo;
+      return Ir(this.multidimensionalSubset, t);
+    }
+    async _fetchService(e) {
+      await this._fetchServiceInfo(e), this.rasterInfo || (this.rasterInfo = this.serviceRasterInfo);
+      const t = this.sourceJSON, n = this.serviceRasterInfo != null ? Promise.resolve(this.serviceRasterInfo) : dr(a(this.parsedUrl), t, { signal: e, query: this._getQueryParams() }).then((p) => (this._set("serviceRasterInfo", p), this._set("multidimensionalInfo", p.multidimensionalInfo), yr(p, t), p)), l = this._hasRasterFunction(this.rasterFunction) ? this._generateRasterInfo(this.rasterFunction, { signal: e }) : null, u = this._getRasterFunctionInfos();
+      return Promise.all([n, l, u]).then((p) => {
+        p[1] ? this._set("rasterInfo", p[1]) : this._set("rasterInfo", p[0]), p[2] && this._set("rasterFunctionInfos", p[2]), this.renderer && !this._isSupportedRenderer(this.renderer) && (this._set("renderer", null), we.getLogger(this).warn("ArcGISImageService", "Switching to the default renderer. Renderer applied is not valid for this Imagery Layer")), this._set("renderer", this._configRenderer(this.renderer)), this.addHandles([Yt(() => this.rasterFunction, (c) => {
+          (this.renderer || this.symbolizer || this.popupEnabled && this.popupTemplate) && this._generateRasterInfo(c).then((d) => {
+            d && (this.rasterInfo = d);
+          });
+        })]);
+        const { serviceRasterInfo: m } = this;
+        m.multidimensionalInfo != null && this._updateMultidimensionalDefinition(m);
+      });
+    }
+    _combineMosaicRuleWithTimeExtent(e, t) {
+      var w;
+      const n = this.timeInfo, { multidimensionalInfo: l } = this.serviceRasterInfo;
+      if (e == null || l == null || t == null || (n == null ? void 0 : n.startField) == null)
+        return e;
+      const { startField: u } = n, p = l.variables.some((y) => y.dimensions.some((g) => g.name === u)) ? u : "StdTime";
+      if (e = e.clone(), this.sourceType === "mosaic-dataset")
+        return e.multidimensionalDefinition = (w = e.multidimensionalDefinition) == null ? void 0 : w.filter((y) => y.dimensionName !== p), this._cleanupMultidimensionalDefinition(e);
+      e.multidimensionalDefinition = e.multidimensionalDefinition || [];
+      const m = e.multidimensionalDefinition.filter((y) => y.dimensionName === p), c = t.start != null ? t.start.getTime() : null, d = t.end != null ? t.end.getTime() : null, h = c == null || d == null || c === d, R = h ? [c || d] : [[c, d]], f = this.version >= 10.8;
+      if (m.length)
+        m.forEach((y) => {
+          y.dimensionName === p && (f ? (y.dimensionName = null, y.isSlice = !1, y.values = []) : (y.isSlice = h, y.values = R));
+        });
+      else if (!f) {
+        const y = e.multidimensionalDefinition.filter((g) => g.variableName != null && g.dimensionName == null);
+        y.length ? y.forEach((g) => {
+          g.dimensionName = p, g.isSlice = h, g.values = R;
+        }) : e.multidimensionalDefinition.push(new Fr({ variableName: "", dimensionName: p, isSlice: h, values: R }));
+      }
+      return this._cleanupMultidimensionalDefinition(e);
+    }
+    _cleanupMultidimensionalDefinition(e) {
+      return e == null ? null : (e.multidimensionalDefinition && (e.multidimensionalDefinition = e.multidimensionalDefinition.filter((t) => !(!t.variableName && !t.dimensionName)), e.multidimensionalDefinition.length === 0 && (e.multidimensionalDefinition = null)), this.sourceType !== "mosaic-dataset" && e.multidimensionalDefinition == null ? null : e);
+    }
+    async _prepareForQuery(e, t) {
+      if (!(await this._fetchCapabilities(t == null ? void 0 : t.signal)).operations.supportsQuery)
+        throw new I("imagery-layer:query-rasters", "query operation is not supported on the input image service");
+      return e = e != null ? $(mt, e) : this.createQuery(), t = this._getRequestOptions(t), this.raster && (t.query = { ...t.query, raster: this.raster }), { query: e, requestOptions: t };
+    }
+    async _initJobHandler() {
+      if (this._rasterJobHandler.connectionPromise != null)
+        return this._rasterJobHandler.connectionPromise;
+      const e = new Rr();
+      this._rasterJobHandler.connectionPromise = e.initialize().then(() => {
+        this._rasterJobHandler.instance = e;
+      }, () => {
+      }), await 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;
+    }
+    _isSupportedRenderer(e) {
+      const { rasterInfo: t, rasterFunction: n } = this;
+      return e.type === "unique-value" && this._hasRasterFunction(n) && (t == null ? void 0 : t.bandCount) === 1 && ["u8", "s8"].includes(t.pixelType) || t != null && e != null && hr(t).includes(e.type);
+    }
+    async _fetchCapabilities(e) {
+      return this.capabilities || await this._fetchServiceInfo(e), this.capabilities;
+    }
+    async _fetchServiceInfo(e) {
+      var n;
+      let t = this.sourceJSON;
+      if (!t) {
+        const { data: l, ssl: u } = await D(a(this.parsedUrl), { query: this._getQueryParams(), signal: e });
+        t = l, this.sourceJSON = t, u && (this.url = this.url.replace(/^http:/i, "https:"));
+      }
+      if (((n = t.capabilities) == null ? void 0 : n.toLowerCase().split(",").map((l) => l.trim()).indexOf("tilesonly")) > -1)
+        throw new I("imagery-layer:fetch-service-info", "use ImageryTileLayer to open tiles-only image services");
+      this.read(t, { origin: "service", url: this.parsedUrl });
+    }
+    _isMosaicDataset(e) {
+      var t;
+      return e.serviceSourceType ? e.serviceSourceType === "esriImageServiceSourceTypeMosaicDataset" : ((t = e.fields) == null ? void 0 : t.length) > 0;
+    }
+    _isMosaicRuleSupported(e) {
+      var l;
+      if (!e)
+        return !1;
+      const t = this._isMosaicDataset(e), n = e.currentVersion >= 10.71 && e.hasMultidimensions && !(((l = e.fields) == null ? void 0 : l.length) > 1);
+      return t || n;
+    }
+    _isVectorFieldResampleFunction(e) {
+      if (e == null)
+        return !1;
+      const { functionName: t, functionArguments: n } = e, l = (t == null ? void 0 : t.toLowerCase()) === "resample", u = (n == null ? void 0 : n.ResampleType) || (n == null ? void 0 : n.resampleType);
+      return l && (u === 7 || u === 10);
+    }
+    _isPicture() {
+      return !this.format || this.format.includes("jpg") || this.format.includes("png");
+    }
+    _configRenderer(e) {
+      var l, u;
+      const t = this._isPicture(), { rasterInfo: n } = this;
+      if (!t && !this.pixelFilter || this._isVectorDataSet()) {
+        if (!this.bandIds && n.bandCount >= 3) {
+          const m = gr(n);
+          !m || n.bandCount === 3 && m[0] === 0 && m[1] === 1 && m[2] === 2 || (this.bandIds = m);
+        }
+        e || (e = fr(n, { bandIds: this.bandIds, variableName: this.rasterFunction ? null : (u = (l = this.mosaicRule) == null ? void 0 : l.multidimensionalDefinition) == null ? void 0 : u[0].variableName }));
+        const p = wr(e.toJSON());
+        this.symbolizer ? (this.symbolizer.rendererJSON = p, this.symbolizer.rasterInfo = n) : this.symbolizer = new $r({ rendererJSON: p, rasterInfo: n }), this.symbolizer.bind().success || (this.symbolizer = null);
+      }
+      return e;
+    }
+    _clonePixelData(e) {
+      return e == null ? e : { extent: e.extent && e.extent.clone(), pixelBlock: e.pixelBlock != null ? e.pixelBlock.clone() : null };
+    }
+    _getQueryParams(e) {
+      (e == null ? void 0 : e.renderingRule) != null && typeof e.renderingRule != "string" && (e.renderingRule = this._getRenderingRuleString(e.renderingRule));
+      const { raster: t, viewId: n } = this;
+      return { raster: t, viewId: n, f: "json", ...e, ...this.customParameters };
+    }
+    _getRequestOptions(e) {
+      return { ...e, query: { ...e == null ? void 0 : e.query, ...this.customParameters } };
+    }
+    _decodePixelBlock(e, t, n) {
+      return this._rasterJobHandler.instance ? this._rasterJobHandler.instance.decode({ data: e, options: t }) : _t(e, t, n);
+    }
+    async _getRasterFunctionInfos(e) {
+      var n;
+      const t = this.sourceJSON.rasterFunctionInfos;
+      return this.loaded ? t : t && this.version >= 10.3 ? t.length === 1 && t[0].name.toLowerCase() === "none" ? t : (n = (await D(a(this.parsedUrl) + "/rasterFunctionInfos", { query: this._getQueryParams(), signal: e })).data) == null ? void 0 : n.rasterFunctionInfos : null;
+    }
+    _canRequestImageElement(e) {
+      return !this.pixelFilter && (!e || e.includes("png"));
+    }
+    async _requestArrayBuffer(e) {
+      const { imageProps: t, requestAsImageElement: n, returnImageBitmap: l, signal: u } = e;
+      if (n && this._canRequestImageElement(t.format)) {
+        const w = `${a(this.parsedUrl)}/exportImage`, { data: y } = await D(w, { responseType: l ? "blob" : "image", query: this._getQueryParams({ f: "image", ...this.refreshParameters, ...e.imageServiceParameters }), signal: u });
+        return y instanceof Blob ? { imageBitmap: await Ct(y, w, u), params: t } : { imageOrCanvasElement: y, params: t };
+      }
+      const p = this._initJobHandler(), m = D(a(this.parsedUrl) + "/exportImage", { responseType: "array-buffer", query: this._getQueryParams({ f: "image", ...e.imageServiceParameters }), signal: u }), c = (await Promise.all([m, p]))[0].data, d = t.format || "jpgpng";
+      let h = d;
+      if (h !== "bsq" && h !== "bip" && (h = Ar(c)), !h)
+        throw new I("imagery-layer:fetch-image", "unsupported format signature " + String.fromCharCode.apply(null, new Uint8Array(c)));
+      const R = { signal: u };
+      return { pixelData: { pixelBlock: await (d === "gif" || d === "bmp" || d.includes("png") && (h === "png" || h === "jpg") ? _t(c, { useCanvas: !0, ...t }, R) : this._decodePixelBlock(c, { width: t.width, height: t.height, planes: null, pixelType: null, noDataValue: null, format: d }, R)), extent: t.extent }, params: t };
+    }
+    _generateRasterInfo(e, t) {
+      return this.generateRasterInfo(e, t).catch(() => null);
+    }
+    _isValidCustomizedMosaicRule(e) {
+      var t;
+      return e && JSON.stringify(e.toJSON()) !== JSON.stringify((t = this.defaultMosaicRule) == null ? void 0 : t.toJSON());
+    }
+    _updateMultidimensionalDefinition(e) {
+      var n;
+      if (this._isValidCustomizedMosaicRule(this.mosaicRule))
+        return;
+      let t = Dr(e, { multidimensionalSubset: this.multidimensionalSubset });
+      if (t != null && t.length > 0) {
+        this.mosaicRule = this.mosaicRule || new k();
+        const l = this.mosaicRule.multidimensionalDefinition;
+        !this.sourceJSON.defaultVariableName && this.rasterFunction && ((n = this.rasterFunction.functionName) == null ? void 0 : n.toLowerCase()) !== "none" && t.forEach((u) => u.variableName = ""), t = t.filter(({ variableName: u, dimensionName: p }) => u && u !== "*" || p), !(l != null && l.length) && t.length && (this.mosaicRule.multidimensionalDefinition = t);
+      }
+    }
+    _processVisibleRastersResponse(e, t) {
+      var O, G, J;
+      t = t || {};
+      const n = e.value, { templateRRFunctionNames: l, showNoDataRecords: u, returnDomainValues: p, templateFields: m } = t, c = e.processedValues;
+      let d = (O = e.catalogItems) == null ? void 0 : O.features, h = ((J = (G = e.properties) == null ? void 0 : G.Values) == null ? void 0 : J.map((F) => F.replaceAll(/ /gi, ", "))) || [];
+      const R = this.objectIdField || "ObjectId", f = typeof n == "string" && n.toLowerCase().includes("nodata"), w = [];
+      if (n && !d && !f) {
+        const F = {};
+        F[R] = 0, h = [n], d = [new er(this.fullExtent, null, F)];
+      }
+      if (!d)
+        return [];
+      let y, g, v;
+      this._updateResponseFieldNames(d, m), f && !u && (d = []);
+      for (let F = 0; F < d.length; F++) {
+        if (y = d[F], n != null) {
+          if (g = h[F], v = this.rasterFunction && c && c.length > 0 && l && l.length > 0 && l.includes(this.rasterFunction.functionName) ? c[l.indexOf(this.rasterFunction.functionName)] : n, g.toLowerCase() === "nodata" && !u)
+            continue;
+          const H = "Raster.ItemPixelValue", Z = "Raster.ServicePixelValue";
+          y.attributes[H] = g, y.attributes[Z] = v, this._updateFeatureWithMagDirValues(y, g);
+          const C = this.fields && this.fields.length > 0;
+          let P = this.rasterFunction && this.serviceRasterInfo.attributeTable != null ? C ? g : n : v;
+          this.rasterFunction || (P = C ? g : n), this._updateFeatureWithRasterAttributeTableValues(y, P);
+        }
+        if (y.sourceLayer = y.layer = this, p && this._updateFeatureWithDomainValues(y), l && c && l.length === c.length)
+          for (let H = 0; H < l.length; H++) {
+            const Z = "Raster.ServicePixelValue." + l[H];
+            y.attributes[Z] = c[H];
+          }
+        w.push(d[F]);
+      }
+      return w;
+    }
+    _processMultidimensionalIntersection(e, t, n) {
+      const { multidimensionalSubset: l } = this;
+      if (!l)
+        return { isOutSide: !1, timeExtent: t, mosaicRule: n = this._combineMosaicRuleWithTimeExtent(n, t) };
+      if (l) {
+        const { isOutside: u, intersection: p } = ht(l, { geometry: e, timeExtent: t });
+        if (u)
+          return { isOutSide: !0, timeExtent: null, mosaicRule: null };
+        (p == null ? void 0 : p.timeExtent) != null && (t = p.timeExtent);
+      }
+      if (n = this._combineMosaicRuleWithTimeExtent(n, t), n == null ? void 0 : n.multidimensionalDefinition) {
+        const { isOutside: u } = ht(l, { multidimensionalDefinition: n.multidimensionalDefinition });
+        if (u)
+          return { isOutSide: !0, timeExtent: null, mosaicRule: null };
+      }
+      return { isOutSide: !1, timeExtent: t, mosaicRule: n };
+    }
+    _updateFeatureWithRasterAttributeTableValues(e, t) {
+      const n = this.rasterInfo.attributeTable || this.serviceRasterInfo.attributeTable;
+      if (n == null)
+        return;
+      const { features: l, fields: u } = n, p = u.map((c) => c.name).find((c) => c.toLowerCase() === "value");
+      if (!p)
+        return;
+      const m = l.filter((c) => c.attributes[p] === (t != null ? parseInt(t, 10) : null));
+      m && m[0] && u.forEach((c) => {
+        const d = this._rasterAttributeTableFieldPrefix + c.name;
+        e.attributes[d] = m[0].attributes[c.name];
+      });
+    }
+    _updateFeatureWithMagDirValues(e, t) {
+      if (!this._isVectorDataSet())
+        return;
+      const n = t.split(/,\s*/).map((c) => parseFloat(c)), l = n.map((c) => [c]), u = n.map((c) => ({ minValue: c, maxValue: c, noDataValue: null })), p = new gt({ height: 1, width: 1, pixelType: "f32", pixels: l, statistics: u });
+      this.pixelFilter != null && this.pixelFilter({ pixelBlock: p, extent: new ze(0, 0, 0, 0, this.spatialReference) });
+      const m = this.serviceDataType === "esriImageServiceDataTypeVector-MagDir" ? [p.pixels[0][0], p.pixels[1][0]] : Pr([p.pixels[0][0], p.pixels[1][0]]);
+      e.attributes["Raster.Magnitude"] = m[0], e.attributes["Raster.Direction"] = m[1];
+    }
+    _updateFeatureWithDomainValues(e) {
+      const t = this.fields && this.fields.filter((n) => n.domain && n.domain.type === "coded-value");
+      t != null && t.forEach((n) => {
+        const l = e.attributes[n.name];
+        if (l != null) {
+          const u = n.domain.codedValues.find((p) => p.code === l);
+          u && (e.attributes[n.name] = u.name);
+        }
+      });
+    }
+    _updateResponseFieldNames(e, t) {
+      if (!t || t.length < 1)
+        return;
+      const n = this.fieldsIndex;
+      n != null && e.forEach((l) => {
+        var u;
+        if (l != null && l.attributes)
+          for (const p of t) {
+            const m = (u = n.get(p)) == null ? void 0 : u.name;
+            m && m !== p && (l.attributes[p] = l.attributes[m], delete l.attributes[m]);
+          }
+      });
+    }
+    _getRenderingRuleString(e) {
+      if (e) {
+        let t = e.toJSON();
+        return t = t.rasterFunctionDefinition ?? t, (t.thumbnail || t.thumbnailEx) && (t.thumbnail = t.thumbnailEx = null), JSON.stringify(t);
+      }
+      return null;
+    }
+    _hasRasterFunction(e) {
+      return (e == null ? void 0 : e.functionName) != null && e.functionName.toLowerCase() !== "none";
+    }
+    _updateRenderingRulesFunctionName(e, t) {
+      if (!e || e.length < 1)
+        return;
+      if (e === "Raw")
+        return e.replace("Raw", "None");
+      const n = e.toLowerCase().replaceAll(/ /gi, "_");
+      return t.has(n) ? t.get(n) : e;
+    }
+    _isRFTJson(e) {
+      return (e == null ? void 0 : e.name) && e.arguments && e.function && e.hasOwnProperty("functionType");
+    }
+    _isVectorDataSet() {
+      return this.serviceDataType === "esriImageServiceDataTypeVector-UV" || this.serviceDataType === "esriImageServiceDataTypeVector-MagDir";
+    }
+    _applyMosaicAndRenderingRules(e) {
+      const { raster: t, mosaicRule: n, rasterFunction: l } = this;
+      l && e instanceof yt && e.rasterFunction == null && (e.rasterFunction = l), n && e.mosaicRule == null && (e.mosaicRule = n), t && e.raster == null && (e.raster = t);
+    }
+    _readCapabilities(e) {
+      var g;
+      const t = e.capabilities ? e.capabilities.toLowerCase().split(",").map((v) => v.trim()) : ["image", "catalog"], { currentVersion: n, advancedQueryCapabilities: l, maxRecordCount: u } = e, p = t.includes("image"), m = e.serviceDataType === "esriImageServiceDataTypeElevation", c = !(!e.spatialReference && !((g = e.extent) != null && g.spatialReference)), d = t.includes("edit"), h = t.includes("mensuration") && c, R = e.mensurationCapabilities == null ? [] : e.mensurationCapabilities.toLowerCase().split(",").map((v) => v.trim()), f = h && R.includes("basic"), w = this._isMosaicDataset(e) && t.includes("catalog"), y = t.includes("download");
+      return { data: { supportsAttachment: !1 }, operations: { supportsComputeHistograms: p, supportsExportImage: p, supportsIdentify: p, supportsImageToMap: n >= 11.2 && w, supportsImageToMapMultiray: n >= 11.2 && w, supportsMapToImage: n >= 11.2 && w, supportsFindImages: n >= 11.2 && w, supportsGetImageUrl: n >= 11.2 && y, supportsMeasure: h, supportsMeasureFromImage: n >= 11.2, supportsDownload: y, supportsQuery: w && e.fields && e.fields.length > 0, supportsGetSamples: n >= 10.2 && p, supportsProject: n >= 10.3 && p, supportsComputeStatisticsHistograms: n >= 10.4 && p, supportsQueryBoundary: n >= 10.6 && p, supportsCalculateVolume: n >= 10.7 && m, supportsComputePixelLocation: n >= 10.7 && w, supportsComputeAngles: n >= 10.91, supportsQueryGPSInfo: n >= 11.2 && w, supportsAdd: d, supportsDelete: d, supportsEditing: d, supportsUpdate: d, supportsCalculate: !1, supportsTruncate: !1, supportsValidateSql: !1, supportsChangeTracking: !1, supportsQueryAttachments: !1, supportsResizeAttachments: !1, supportsSync: !1, supportsExceedsLimitStatistics: !1, supportsQueryAnalytics: !1, supportsQueryTopFeatures: !1, supportsAsyncConvert3D: !1 }, query: { maxRecordCount: u, maxRecordCountFactor: void 0, supportsStatistics: !!(l != null && l.supportsStatistics), supportsOrderBy: !!(l != null && l.supportsOrderBy), supportsDistinct: !!(l != null && l.supportsDistinct), supportsPagination: !!(l != null && l.supportsPagination), supportsStandardizedQueriesOnly: !!(l != null && l.useStandardizedQueries), supportsPercentileStatistics: !!(l != null && l.supportsPercentileStatistics), supportsCentroid: !!(l != null && l.supportsReturningGeometryCentroid), supportsDistance: !!(l != null && l.supportsQueryWithDistance), supportsExtent: !!(l != null && l.supportsReturningQueryExtent), supportsGeometryProperties: !!(l != null && l.supportsReturningGeometryProperties), supportsHavingClause: !!(l != null && l.supportsHavingClause), supportsQuantization: !1, supportsQuantizationEditMode: !1, supportsQueryGeometry: !1, supportsResultType: !1, supportsMaxRecordCountFactor: !1, supportsSqlExpression: !1, supportsTopFeaturesQuery: !1, supportsQueryByAnonymous: !1, supportsQueryByOthers: !1, supportsHistoricMoment: !1, supportsFormatPBF: !1, supportsDisjointSpatialRelationship: !1, supportsCacheHint: !1, supportsSpatialAggregationStatistics: !1, supportedSpatialAggregationStatistics: { envelope: !1, centroid: !1, convexHull: !1 }, supportsDefaultSpatialReference: !!(l != null && l.supportsDefaultSR), supportsFullTextSearch: !1, supportsCompactGeometry: !1, standardMaxRecordCount: void 0, tileMaxRecordCount: void 0 }, mensuration: { supportsDistanceAndAngle: f, supportsAreaAndPerimeter: f, supportsPointOrCentroid: f, supportsHeightFromBaseAndTop: h && R.includes("base-top height"), supportsHeightFromBaseAndTopShadow: h && R.includes("base-top shadow height"), supportsHeightFromTopAndTopShadow: h && R.includes("top-top shadow height"), supports3D: h && R.includes("3d") } };
+    }
+  };
+  function a(e) {
+    return (e == null ? void 0 : e.path) ?? "";
+  }
+  return i([o({ clonable: !1 })], r.prototype, "_functionRasterInfos", void 0), i([o({ clonable: !1 })], r.prototype, "_rasterJobHandler", void 0), i([o({ clonable: !1 })], r.prototype, "_cachedRendererJson", void 0), i([o({ readOnly: !0 })], r.prototype, "_serviceSupportsMosaicRule", void 0), i([V("_serviceSupportsMosaicRule", ["currentVersion", "fields"])], r.prototype, "readServiceSupportsMosaicRule", null), i([o({ readOnly: !0 })], r.prototype, "_rasterAttributeTableFieldPrefix", void 0), i([o({ readOnly: !0 })], r.prototype, "_rasterFunctionNamesIndex", null), i([o()], r.prototype, "adjustAspectRatio", void 0), i([o({ type: [Be], json: { write: !0 } })], r.prototype, "bandIds", void 0), i([V("bandIds")], r.prototype, "readBandIds", null), i([o({ readOnly: !0, json: { read: !1 } })], r.prototype, "capabilities", void 0), i([V("service", "capabilities", ["capabilities", "currentVersion", "serviceDataType"])], r.prototype, "readCapabilities", null), i([o({ type: Number })], r.prototype, "compressionQuality", void 0), i([T("compressionQuality")], r.prototype, "writeCompressionQuality", null), i([o({ type: Number })], r.prototype, "compressionTolerance", void 0), i([T("compressionTolerance")], r.prototype, "writeCompressionTolerance", null), i([o({ json: { read: { source: "copyrightText" } } })], r.prototype, "copyright", void 0), i([o({ readOnly: !0, dependsOn: ["_serviceSupportsMosaicRule"] })], r.prototype, "defaultMosaicRule", void 0), i([V("defaultMosaicRule", ["defaultMosaicMethod"])], r.prototype, "readDefaultMosaicRule", null), i([o({ type: String, json: { name: "layerDefinition.definitionExpression", write: { enabled: !0, allowNull: !0 } } })], r.prototype, "definitionExpression", void 0), i([o({ readOnly: !0, constructOnly: !0 })], r.prototype, "exportImageServiceParameters", void 0), i([o()], r.prototype, "rasterInfo", void 0), i([o({ readOnly: !0, type: [Fe] })], r.prototype, "fields", void 0), i([o({ readOnly: !0 })], r.prototype, "fieldsIndex", null), i([o({ type: ["png", "png8", "png24", "png32", "jpg", "bmp", "gif", "jpgpng", "lerc", "tiff"], json: { write: !0 } })], r.prototype, "format", null), i([V("service", "format", ["serviceDataType"])], r.prototype, "readFormat", null), i([o({ type: ze })], r.prototype, "fullExtent", void 0), i([o({ readOnly: !0 })], r.prototype, "hasMultidimensions", void 0), i([o({ json: { read: { source: "maxImageHeight" } } })], r.prototype, "imageMaxHeight", void 0), i([o({ json: { read: { source: "maxImageWidth" } } })], r.prototype, "imageMaxWidth", void 0), i([o({ type: String, json: { type: ve.jsonValues, read: ve.read, write: ve.write } })], r.prototype, "interpolation", void 0), i([o()], r.prototype, "minScale", void 0), i([V("service", "minScale")], r.prototype, "readMinScale", null), i([o()], r.prototype, "maxScale", void 0), i([V("service", "maxScale")], r.prototype, "readMaxScale", null), i([o({ type: k })], r.prototype, "mosaicRule", null), i([V("mosaicRule", ["mosaicRule", "defaultMosaicMethod"])], r.prototype, "readMosaicRule", null), i([T("mosaicRule")], r.prototype, "writeMosaicRule", null), i([o()], r.prototype, "multidimensionalInfo", void 0), i([o({ type: lr, json: { write: !0 } })], r.prototype, "multidimensionalSubset", void 0), i([o({ json: { type: Be } })], r.prototype, "noData", void 0), i([T("noData")], r.prototype, "writeNoData", null), i([o({ type: String, json: { type: Ue.jsonValues, read: Ue.read, write: Ue.write } })], r.prototype, "noDataInterpretation", void 0), i([o({ type: String, readOnly: !0, json: { read: { source: ["fields"] } } })], r.prototype, "objectIdField", void 0), i([V("objectIdField")], r.prototype, "readObjectIdField", null), i([o({ readOnly: !0 })], r.prototype, "geometryType", void 0), i([o({})], r.prototype, "typeIdField", void 0), i([o({})], r.prototype, "types", void 0), i([o({ readOnly: !0 })], r.prototype, "parsedUrl", null), i([o({ type: Function })], r.prototype, "pixelFilter", void 0), i([o()], r.prototype, "raster", void 0), i([o({ readOnly: !0 })], r.prototype, "sourceType", void 0), i([V("sourceType", ["serviceSourceType", "fields"])], r.prototype, "readSourceType", null), i([o()], r.prototype, "viewId", void 0), i([o({ types: ur, json: { name: "layerDefinition.drawingInfo.renderer", origins: { "web-scene": { types: pr, name: "layerDefinition.drawingInfo.renderer", write: { overridePolicy: (e) => ({ enabled: e && e.type !== "vector-field" && e.type !== "flow" }) } } } } })], r.prototype, "renderer", null), i([V("renderer")], r.prototype, "readRenderer", null), i([T("renderer")], r.prototype, "writeRenderer", null), i([o({ clonable: !1 })], r.prototype, "symbolizer", void 0), i([o(vr)], r.prototype, "opacity", void 0), i([o({ readOnly: !0 })], r.prototype, "rasterFields", null), i([o({ constructOnly: !0 })], r.prototype, "rasterFunctionInfos", void 0), i([o({ type: S })], r.prototype, "renderingRule", null), i([o({ type: S, json: { name: "renderingRule" } })], r.prototype, "rasterFunction", null), i([V("rasterFunction", ["renderingRule", "rasterFunctionInfos"])], r.prototype, "readRasterFunction", null), i([o({ readOnly: !0 })], r.prototype, "serviceDataType", void 0), i([o({ readOnly: !0, type: se })], r.prototype, "spatialReference", void 0), i([V("spatialReference", ["spatialReference", "extent"])], r.prototype, "readSpatialReference", null), i([o({ json: { type: dt.jsonValues } })], r.prototype, "pixelType", void 0), i([V("pixelType")], r.prototype, "readPixelType", null), i([T("pixelType")], r.prototype, "writePixelType", null), i([o({ constructOnly: !0, type: Et })], r.prototype, "serviceRasterInfo", void 0), i([o()], r.prototype, "sourceJSON", void 0), i([o(br)], r.prototype, "url", void 0), i([o({ readOnly: !0 })], r.prototype, "version", void 0), i([V("version", ["currentVersion", "fields", "timeInfo"])], r.prototype, "readVersion", null), r = i([b("esri.layers.mixins.ArcGISImageService")], r), r;
+};
+let B = class extends Lr(kr(Qr(Ur(Hr(ps(Br(zr(Gr(or(Se(ar))))))))))) {
+  constructor(...s) {
+    super(...s), this.isReference = null, this.operationalLayerType = "ArcGISImageServiceLayer", this.popupEnabled = !0, this.popupTemplate = null, this.type = "imagery", this._debouncedSaveOperations = ir(async (r, a, e) => {
+      const { save: t, saveAs: n } = await import("./imageryUtils-31c938b0.js");
+      switch (r) {
+        case We.SAVE:
+          return t(this, a);
+        case We.SAVE_AS:
+          return n(this, e, a);
+      }
+    });
+  }
+  normalizeCtorArgs(s, r) {
+    return typeof s == "string" ? { url: s, ...r } : s;
+  }
+  load(s) {
+    const r = s != null ? s.signal : null;
+    return this.addResolvingPromise(this.loadFromPortal({ supportedTypes: ["Image Service"] }, s).catch(sr).then(() => this._fetchService(r))), Promise.resolve(this);
+  }
+  get legendEnabled() {
+    return !this._isPreviewLayer && (this._get("legendEnabled") ?? !0);
+  }
+  set legendEnabled(s) {
+    this._set("legendEnabled", s);
+  }
+  get listMode() {
+    return this._isPreviewLayer ? "hide" : this._get("listMode");
+  }
+  set listMode(s) {
+    this._set("listMode", s);
+  }
+  writeOperationalLayerType(s, r, a) {
+    var t;
+    const e = ((t = this.renderer) == null ? void 0 : t.type) === "vector-field";
+    r[a] = e ? "ArcGISImageServiceVectorLayer" : "ArcGISImageServiceLayer";
+  }
+  get defaultPopupTemplate() {
+    return this.createPopupTemplate();
+  }
+  get _isPreviewLayer() {
+    var s;
+    return !(!this.raster || !((s = this.url) != null && s.toLowerCase().includes("/rasterrendering/imageserver")));
+  }
+  createPopupTemplate(s) {
+    var p;
+    const r = this.rasterFields, a = this.title, e = /* @__PURE__ */ new Set();
+    let t = !1, n = !1;
+    this.capabilities && (t = this.capabilities.operations.supportsQuery && this.fields && this.fields.length > 0, n = this.serviceDataType === "esriImageServiceDataTypeVector-UV" || this.serviceDataType === "esriImageServiceDataTypeVector-MagDir");
+    const l = /* @__PURE__ */ new Set();
+    t && l.add("raster.itempixelvalue");
+    for (const m of r) {
+      const c = m.name.toLowerCase();
+      l.has(c) || c.includes("raster.servicepixelvalue.") || e.add(m.name);
+    }
+    n && e.add("raster.magnitude").add("raster.direction");
+    const u = Zr({ fields: r, title: a }, { ...s, visibleFieldNames: e });
+    return u != null && u.fieldInfos && ((p = this.rasterInfo) != null && p.pixelType.startsWith("f")) && u.fieldInfos.forEach(({ format: m, fieldName: c }) => {
+      m && /^raster\.(item|service)pixelvalue/i.test(c) && (m.places = 2);
+    }), u;
+  }
+  queryFeatures(s, r) {
+    return this.queryRasters(s, r).then((a) => {
+      if (a != null && a.features)
+        for (const e of a.features)
+          e.layer = e.sourceLayer = this;
+      return a;
+    });
+  }
+  queryFeatureCount(s, r) {
+    return this.queryRasterCount(s, r);
+  }
+  redraw() {
+    this.emit("redraw");
+  }
+  async save(s) {
+    return this._debouncedSaveOperations(We.SAVE, s);
+  }
+  async saveAs(s, r) {
+    return this._debouncedSaveOperations(We.SAVE_AS, r, s);
+  }
+  serviceSupportsSpatialReference(s) {
+    return Wr(this, s);
+  }
+  write(s, r) {
+    if (!this._isPreviewLayer)
+      return super.write(s, r);
+    if (r != null && r.messages) {
+      const a = `${r.origin}/${r.layerContainerType || "operational-layers"}`;
+      r.messages.push(new I("layer:unsupported", `Imagery preview layer (${this.title}, ${this.id}) of type '${this.declaredClass}' are not supported in the context of '${a}'`, { layer: this }));
+    }
+    return null;
+  }
+};
+i([o(Sr)], B.prototype, "legendEnabled", null), i([o({ type: ["show", "hide"] })], B.prototype, "listMode", null), i([o({ type: Boolean, json: { read: !1, write: { enabled: !0, overridePolicy: () => ({ enabled: !1 }) } } })], B.prototype, "isReference", void 0), i([o({ type: ["ArcGISImageServiceLayer"], json: { origins: { "web-map": { type: ["ArcGISImageServiceLayer", "ArcGISImageServiceVectorLayer"], read: !1, write: { target: "layerType", ignoreOrigin: !0 } } } } })], B.prototype, "operationalLayerType", void 0), i([T("web-map", "operationalLayerType")], B.prototype, "writeOperationalLayerType", null), i([o(xr)], B.prototype, "popupEnabled", void 0), i([o({ type: nr, json: { read: { source: "popupInfo" }, write: { target: "popupInfo" } } })], B.prototype, "popupTemplate", void 0), i([o({ readOnly: !0 })], B.prototype, "defaultPopupTemplate", null), i([o({ readOnly: !0, json: { read: !1 } })], B.prototype, "type", void 0), i([o({ readOnly: !0 })], B.prototype, "_isPreviewLayer", null), B = i([b("esri.layers.ImageryLayer")], B);
+const zn = B;
+export {
+  zn as default
+};