jtBaseApp/node_modules/.vite/deps/VoxelLayer-UZ3WZOBC.js

import {
  g
} from "./chunk-IN44RUPP.js";
import {
  N
} from "./chunk-DRPR56GA.js";
import "./chunk-LX2NI53X.js";
import "./chunk-IZUZZJS7.js";
import {
  v,
  y as y3
} from "./chunk-W3XAGTM6.js";
import {
  e as e4
} from "./chunk-XFDO4CMR.js";
import "./chunk-GHN7C53L.js";
import "./chunk-56OWH4DC.js";
import {
  s as s4
} from "./chunk-AJFR3FGC.js";
import "./chunk-7B57NUGF.js";
import "./chunk-I4RYNNL6.js";
import {
  i as i3
} from "./chunk-WWXZOC2Y.js";
import {
  p as p2
} from "./chunk-ZOKNWEG3.js";
import {
  i as i2
} from "./chunk-JOYXMSKE.js";
import {
  S
} from "./chunk-SZFMKPVM.js";
import {
  v as v2
} from "./chunk-JUWKPBLS.js";
import {
  c as c3
} from "./chunk-WLSB4F4I.js";
import {
  c as c2,
  f,
  p as p3
} from "./chunk-GLSWDDR3.js";
import {
  O
} from "./chunk-MIQGEDET.js";
import "./chunk-DUEMJ5XS.js";
import "./chunk-VRLXUHP2.js";
import "./chunk-3LVSQLWJ.js";
import {
  p
} from "./chunk-4ONPMX2F.js";
import "./chunk-CRGY2SDS.js";
import "./chunk-4T5ZGMEN.js";
import {
  t
} from "./chunk-PLWDAYK7.js";
import "./chunk-3RSFVUKZ.js";
import {
  l as l2
} from "./chunk-X4SA4ELJ.js";
import {
  n as n2
} from "./chunk-ZAY3CMAZ.js";
import "./chunk-P3XKUGLS.js";
import "./chunk-2ZSOO377.js";
import "./chunk-YUA3AHKR.js";
import "./chunk-LU5IJZB4.js";
import "./chunk-7IBV2TRE.js";
import "./chunk-ZLNEXZAN.js";
import "./chunk-5UVJ64RB.js";
import "./chunk-SFEFRQCL.js";
import {
  b
} from "./chunk-DXVOOCG4.js";
import "./chunk-3GZSQU56.js";
import "./chunk-ZYRIJWLX.js";
import {
  a as a2,
  h
} from "./chunk-RYY6632W.js";
import {
  E as E2,
  c,
  e as e3,
  i,
  r as r4,
  u as u2,
  z
} from "./chunk-DW42UVIT.js";
import "./chunk-YAEIHDJH.js";
import {
  e as e2,
  n as n3,
  r as r2
} from "./chunk-TJNOJH33.js";
import {
  r as r3,
  u
} from "./chunk-OSHI574D.js";
import "./chunk-ETGAZ7LF.js";
import "./chunk-75U5LM2V.js";
import "./chunk-RMDDCMKS.js";
import "./chunk-VCH45Q2I.js";
import {
  j
} from "./chunk-LBW34VZ2.js";
import "./chunk-GSSTTHIT.js";
import "./chunk-YFSLJIO4.js";
import "./chunk-IM3LVQXV.js";
import "./chunk-55RWC67C.js";
import "./chunk-HZRKBTHJ.js";
import "./chunk-DVUG3KID.js";
import "./chunk-FWSQEIAR.js";
import "./chunk-VEGAOVMY.js";
import {
  o,
  w as w2,
  w2 as w3
} from "./chunk-6T6G6LCQ.js";
import {
  s as s3
} from "./chunk-YEJL5NEF.js";
import {
  E,
  k2 as k
} from "./chunk-PQFTYGF5.js";
import {
  e,
  l3 as l,
  n5 as n,
  y3 as y2
} from "./chunk-2Z2TG5CU.js";
import "./chunk-6KZ2LTDA.js";
import "./chunk-U2XHEJM7.js";
import {
  T,
  a
} from "./chunk-SQOPWYIT.js";
import {
  w
} from "./chunk-V6P2MAQQ.js";
import {
  s2 as s,
  s3 as s2
} from "./chunk-E5O6P5I2.js";
import {
  y
} from "./chunk-SPWQ3AWG.js";
import "./chunk-2TIUKVZN.js";
import {
  r
} from "./chunk-YXWMMD76.js";
import "./chunk-S5KM4IGW.js";

// node_modules/@arcgis/core/layers/voxel/voxelPlaneUtils.js
var f2 = n3();
var e5 = e4();
var h2 = e4();
var i4 = e4();
var p4 = new Float64Array([0, 0, 1]);
var j2 = new Float64Array([0, 1, 0]);
var k2 = new Float64Array([1, 0, 0]);
function l3(s7) {
  r4(f2, s7), z(f2, f2);
  const n4 = Math.atan2(f2[1], f2[0]), r5 = v(e4(), p4, -n4);
  E2(f2, f2, r5);
  const e6 = -1 * Math.atan2(f2[2], f2[0]);
  return [u(n4) + 270, u(e6) + 90];
}
function q(t6, n4) {
  return v(h2, p4, r3(t6 - 270)), v(i4, j2, r3(n4 - 90)), y3(e5, h2, i4), r4(f2, k2), E2(f2, f2, e5), z(f2, f2), [f2[0], f2[1], f2[2]];
}

// node_modules/@arcgis/core/layers/voxel/VoxelSlice.js
var m = class extends i2(l) {
  constructor(t6) {
    super(t6), this.enabled = true, this.label = "", this.normal = null, this.point = null;
  }
  get orientation() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [t6, o2] = l3(this.normal);
    return s4.normalize(a(t6), 0, true);
  }
  set orientation(t6) {
    const o2 = q(t6, this.tilt);
    this._set("normal", o2), this._set("orientation", t6);
  }
  get tilt() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [t6, o2] = l3(this.normal);
    return s4.normalize(a(o2), 0, true);
  }
  set tilt(t6) {
    const o2 = q(this.orientation, t6);
    this._set("normal", o2), this._set("tilt", t6);
  }
};
e([y2({ type: Boolean, json: { write: true } })], m.prototype, "enabled", void 0), e([y2({ type: String, json: { write: true } })], m.prototype, "label", void 0), e([y2({ type: Number, json: { read: false }, clonable: false, range: { min: 0, max: 360 } }), s3((t6) => s4.normalize(a(t6), 0, true))], m.prototype, "orientation", null), e([y2({ type: Number, json: { read: false }, clonable: false, range: { min: 0, max: 360 } }), s3((t6) => s4.normalize(a(t6), 0, true))], m.prototype, "tilt", null), e([y2({ type: [Number], json: { write: true } })], m.prototype, "normal", void 0), e([y2({ type: [Number], json: { write: true } })], m.prototype, "point", void 0), m = e([n("esri.layers.voxel.VoxelSlice")], m);
var c4 = m;

// node_modules/@arcgis/core/layers/voxel/VoxelSection.js
var d = class extends i2(l) {
  constructor() {
    super(...arguments), this.enabled = true, this.href = null, this.id = null, this.label = "", this.normal = null, this.point = null, this.sizeInPixel = null, this.slices = null, this.timeId = 0, this.variableId = null;
  }
  get orientation() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [e6, r5] = l3(this.normal);
    return s4.normalize(a(e6), 0, true);
  }
  get tilt() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [e6, r5] = l3(this.normal);
    return s4.normalize(a(r5), 0, true);
  }
};
e([y2({ type: Boolean, json: { default: true, write: true } })], d.prototype, "enabled", void 0), e([y2({ type: String, json: { origins: { service: { read: p } }, write: { enabled: true, isRequired: true } } }), g({ origins: ["web-scene"], type: "resource", prefix: "sections", compress: true })], d.prototype, "href", void 0), e([y2({ type: T, json: { write: { enabled: true, isRequired: true } } })], d.prototype, "id", void 0), e([y2({ type: String, json: { write: true } })], d.prototype, "label", void 0), e([y2({ type: Number, clonable: false, readOnly: true, range: { min: 0, max: 360 } })], d.prototype, "orientation", null), e([y2({ type: Number, clonable: false, readOnly: true, range: { min: 0, max: 360 } })], d.prototype, "tilt", null), e([y2({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], d.prototype, "normal", void 0), e([y2({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], d.prototype, "point", void 0), e([y2({ type: [T], json: { write: { enabled: true, isRequired: true } } })], d.prototype, "sizeInPixel", void 0), e([y2({ type: [c4], json: { write: true } })], d.prototype, "slices", void 0), e([y2({ type: T, json: { default: 0, write: true } })], d.prototype, "timeId", void 0), e([y2({ type: T, json: { write: { enabled: true, isRequired: true } } })], d.prototype, "variableId", void 0), d = e([n("esri.layers.voxel.VoxelSection")], d);
var u3 = d;

// node_modules/@arcgis/core/layers/voxel/VoxelSimpleShading.js
var t2 = class extends l {
  constructor() {
    super(...arguments), this.diffuseFactor = 0.5, this.specularFactor = 0.5;
  }
};
e([y2({ type: Number, range: { min: 0, max: 1 }, json: { default: 0.5, write: true } })], t2.prototype, "diffuseFactor", void 0), e([y2({ type: Number, range: { min: 0, max: 1 }, json: { default: 0.5, write: true } })], t2.prototype, "specularFactor", void 0), t2 = e([n("esri.layers.voxel.VoxelSimpleShading")], t2);
var p5 = t2;

// node_modules/@arcgis/core/layers/voxel/VoxelFormat.js
var s5 = class extends l {
  constructor() {
    super(...arguments), this.continuity = null, this.hasNoData = false, this.noData = 0, this.offset = 0, this.scale = 1, this.type = null;
  }
};
e([y2({ type: ["discrete", "continuous"], json: { write: true } })], s5.prototype, "continuity", void 0), e([y2({ type: Boolean, json: { write: true } })], s5.prototype, "hasNoData", void 0), e([y2({ type: Number, json: { write: true } })], s5.prototype, "noData", void 0), e([y2({ type: Number, json: { write: true } })], s5.prototype, "offset", void 0), e([y2({ type: Number, json: { write: true } })], s5.prototype, "scale", void 0), e([y2({ type: String, json: { write: { enabled: true, isRequired: true } } })], s5.prototype, "type", void 0), s5 = e([n("esri.layers.voxel.VoxelFormat")], s5);
var p6 = s5;

// node_modules/@arcgis/core/layers/voxel/VoxelVariable.js
var i5 = class extends l {
  constructor() {
    super(...arguments), this.id = null, this.description = "", this.name = null, this.originalFormat = null, this.renderingFormat = null, this.unit = "", this.volumeId = 0, this.type = null;
  }
};
e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "id", void 0), e([y2({ type: String, json: { write: true } })], i5.prototype, "description", void 0), e([y2({ type: String, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "name", void 0), e([y2({ type: p6, json: { write: true } })], i5.prototype, "originalFormat", void 0), e([y2({ type: p6, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "renderingFormat", void 0), e([y2({ type: String, json: { write: true } })], i5.prototype, "unit", void 0), e([y2({ type: Number, json: { write: true } })], i5.prototype, "volumeId", void 0), e([y2({ type: ["stc-hot-spot-results", "stc-cluster-outlier-results", "stc-estimated-bin", "generic-nearest-interpolated"], json: { write: true } })], i5.prototype, "type", void 0), i5 = e([n("esri.layers.voxel.VoxelVariable")], i5);
var p7 = i5;

// node_modules/@arcgis/core/layers/voxel/VoxelIsosurface.js
var l4 = class extends i2(l) {
  constructor() {
    super(...arguments), this.color = l2.fromArray([0, 0, 0, 0]), this.value = 0, this.enabled = true, this.label = "", this.colorLocked = true;
  }
};
e([y2({ type: l2, json: { type: [T], write: { enabled: true, isRequired: true } } })], l4.prototype, "color", void 0), e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], l4.prototype, "value", void 0), e([y2({ type: Boolean, json: { default: true, write: true } })], l4.prototype, "enabled", void 0), e([y2({ type: String, json: { write: true } })], l4.prototype, "label", void 0), e([y2({ type: Boolean, json: { default: false } })], l4.prototype, "colorLocked", void 0), l4 = e([n("esri.layers.voxel.VoxelIsosurface")], l4);
var a3 = l4;

// node_modules/@arcgis/core/layers/voxel/VoxelColorStop.js
var c5 = class extends i2(l) {
  constructor() {
    super(...arguments), this.color = null, this.position = 0;
  }
};
e([y2({ type: l2, json: { type: [T], write: { enabled: true, isRequired: true } } })], c5.prototype, "color", void 0), e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], c5.prototype, "position", void 0), c5 = e([n("esri.layers.voxel.VoxelColorStop")], c5);
var l5 = c5;

// node_modules/@arcgis/core/layers/voxel/VoxelOpacityStop.js
var p8 = class extends i2(l) {
  constructor() {
    super(...arguments), this.opacity = 1, this.position = 0;
  }
};
e([y2({ type: Number, json: { name: "alpha", write: { enabled: true, isRequired: true } } })], p8.prototype, "opacity", void 0), e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], p8.prototype, "position", void 0), p8 = e([n("esri.layers.voxel.VoxelOpacityStop")], p8);
var i6 = p8;

// node_modules/@arcgis/core/layers/voxel/VoxelRangeFilter.js
var p9 = class extends i2(l) {
  constructor() {
    super(...arguments), this.enabled = false, this.range = null;
  }
};
e([y2({ type: Boolean, json: { default: false, write: true } })], p9.prototype, "enabled", void 0), e([y2({ type: [Number], json: { write: true } })], p9.prototype, "range", void 0), p9 = e([n("esri.layers.voxel.VoxelRangeFilter")], p9);
var a4 = p9;

// node_modules/@arcgis/core/layers/voxel/VoxelTransferFunctionStyle.js
var u4;
!function(o2) {
  o2[o2.Color = 1] = "Color", o2[o2.Alpha = 2] = "Alpha", o2[o2.Both = 3] = "Both";
}(u4 || (u4 = {}));
var y4 = class extends i2(l) {
  constructor(o2) {
    super(o2), this.interpolation = null, this.stretchRange = null, this.rangeFilter = null, this._colorMapSize = 256, this.colorStops = new (j.ofType(l5))(), this.opacityStops = new (j.ofType(i6))();
  }
  set colorStops(o2) {
    this._set("colorStops", n2(o2, this._get("colorStops"), j.ofType(l5)));
  }
  set opacityStops(o2) {
    this._set("opacityStops", n2(o2, this._get("opacityStops"), j.ofType(i6)));
  }
  getPreviousNext(o2, t6, r5) {
    let e6 = o2;
    for (; --e6 > 0 && t6[e6].type !== r5 && t6[e6].type !== u4.Both; )
      ;
    let s7 = o2;
    const i7 = t6.length;
    for (; ++s7 < i7 && t6[s7].type !== r5 && t6[s7].type !== u4.Both; )
      ;
    return [e6, s7];
  }
  get rasterizedTransferFunction() {
    const o2 = [];
    if (this.colorStops.length < 2)
      return o2;
    const r5 = [], e6 = [], s7 = 1e-5;
    for (const t6 of this.colorStops) {
      if (!t6.color)
        return o2;
      e6.push({ color: { r: t6.color.r, g: t6.color.g, b: t6.color.b, a: Math.round(255 * (1 - t6.color.a)) }, position: t6.position, type: u4.Color });
    }
    if (0 === this.opacityStops.length)
      for (const t6 of e6)
        r5.push({ color: t6.color, position: t6.position });
    else {
      for (const t6 of this.opacityStops) {
        const o4 = a2(t6.position, 0, 1), r6 = Math.round(255 * a2(1 - t6.opacity, 0, 1));
        let i8 = false;
        for (const t7 of e6)
          if (t7.type === u4.Color && Math.abs(t7.position - o4) < s7) {
            t7.color.a = r6, t7.type = u4.Both, i8 = true;
            break;
          }
        i8 || e6.push({ color: { r: 0, g: 0, b: 0, a: r6 }, position: t6.position, type: u4.Alpha });
      }
      e6.sort((o4, t6) => o4.position < t6.position ? -1 : 1);
      const o3 = e6.length;
      for (let t6 = 0; t6 < o3; ++t6) {
        const r6 = e6[t6];
        if (r6.type !== u4.Both)
          if (r6.type === u4.Color) {
            const [s8, i8] = this.getPreviousNext(t6, e6, u4.Alpha);
            if (-1 !== s8 && i8 !== o3) {
              const o4 = (r6.position - e6[s8].position) / (e6[i8].position - e6[s8].position);
              r6.color.a = Math.round(h(e6[s8].color.a, e6[i8].color.a, o4));
            } else
              r6.color.a = -1 !== s8 ? e6[s8].color.a : e6[i8].color.a;
          } else {
            const [s8, i8] = this.getPreviousNext(t6, e6, u4.Color);
            if (-1 !== s8 && i8 !== o3) {
              const o4 = (r6.position - e6[s8].position) / (e6[i8].position - e6[s8].position), t7 = e6[s8].color, p16 = e6[i8].color;
              ["r", "g", "b"].forEach((e7) => {
                r6.color[e7] = Math.round(h(t7[e7], p16[e7], o4));
              });
            } else
              ["r", "g", "b"].forEach(-1 !== s8 ? (o4) => {
                r6.color[o4] = e6[s8][o4];
              } : (o4) => {
                r6.color[o4] = e6[i8][o4];
              });
          }
      }
      for (const t6 of e6)
        r5.push({ color: t6.color, position: t6.position });
    }
    r5[0].position = 0, r5[r5.length - 1].position = 1;
    let i7 = 0, l7 = 1;
    for (let c8 = 0; c8 < this._colorMapSize; ++c8) {
      const e7 = c8 / this._colorMapSize;
      for (; e7 > r5[l7].position; )
        i7 = l7++;
      const s8 = (e7 - r5[i7].position) / (r5[l7].position - r5[i7].position), a7 = r5[i7].color, h3 = r5[l7].color, f5 = new l2();
      ["r", "g", "b"].forEach((o3) => {
        f5[o3] = Math.round(h(a7[o3], h3[o3], s8));
      }), f5.a = a2(1 - h(a7.a, h3.a, s8) / 255, 0, 1), o2.push(f5);
    }
    return o2;
  }
  getColorForContinuousDataValue(o2, t6) {
    const r5 = this.rasterizedTransferFunction;
    if (this.colorStops.length < 2 || !Array.isArray(this.stretchRange) || this.stretchRange.length < 2 || r5.length < 256)
      return null;
    let e6 = this.stretchRange[0], s7 = this.stretchRange[1];
    if (e6 > s7) {
      const o3 = e6;
      e6 = s7, s7 = o3;
    }
    o2 = a2(o2, e6, s7);
    const i7 = r5[Math.round((o2 - e6) / (s7 - e6) * (this._colorMapSize - 1))].clone();
    return t6 || (i7.a = 1), i7;
  }
};
e([y2({ type: ["linear", "nearest"], json: { write: true } })], y4.prototype, "interpolation", void 0), e([y2({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], y4.prototype, "stretchRange", void 0), e([y2({ type: j.ofType(l5), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.colorStops && this.colorStops.length > 0 };
} } } })], y4.prototype, "colorStops", null), e([y2({ type: j.ofType(i6), json: { read: { source: "alphaStops" }, write: { enabled: true, target: "alphaStops", overridePolicy() {
  return { enabled: !!this.opacityStops && this.opacityStops.length > 0 };
} } } })], y4.prototype, "opacityStops", null), e([y2({ type: a4, json: { write: true } })], y4.prototype, "rangeFilter", void 0), e([y2({ type: [l2], clonable: false, json: { read: false } })], y4.prototype, "rasterizedTransferFunction", null), y4 = e([n("esri.layers.voxel.VoxelTransferFunctionStyle")], y4);
var g2 = y4;

// node_modules/@arcgis/core/layers/voxel/VoxelUniqueValue.js
var l6 = class extends i2(l) {
  constructor() {
    super(...arguments), this.color = l2.fromArray([0, 0, 0, 0]), this.value = 0, this.enabled = true, this.label = "";
  }
};
e([y2({ type: l2, json: { type: [T], write: { enabled: true, isRequired: true } } })], l6.prototype, "color", void 0), e([y2({ type: T, json: { write: { enabled: true, isRequired: true } } })], l6.prototype, "value", void 0), e([y2({ type: Boolean, json: { default: true, write: true } })], l6.prototype, "enabled", void 0), e([y2({ type: String, json: { write: true } })], l6.prototype, "label", void 0), l6 = e([n("esri.layers.voxel.VoxelUniqueValue")], l6);
var a5 = l6;

// node_modules/@arcgis/core/layers/voxel/VoxelVariableStyle.js
var p10;
var c6 = p10 = class extends l {
  constructor(e6) {
    super(e6), this.variableId = 0, this.label = "", this.transferFunction = null, this.uniqueValues = null, this.isosurfaces = null, this.uniqueValues = new (j.ofType(a5))(), this.isosurfaces = new (j.ofType(a3))();
  }
  clone() {
    return new p10({ variableId: this.variableId, label: this.label, transferFunction: y(this.transferFunction), uniqueValues: y(this.uniqueValues), isosurfaces: y(this.isosurfaces) });
  }
};
e([y2({ type: T, json: { write: { enabled: true, isRequired: true } } })], c6.prototype, "variableId", void 0), e([y2({ type: String, json: { write: true } })], c6.prototype, "label", void 0), e([y2({ type: g2, json: { write: { enabled: true, overridePolicy() {
  return { enabled: !this.uniqueValues || this.uniqueValues.length < 1 };
} } } })], c6.prototype, "transferFunction", void 0), e([y2({ type: j.ofType(a5), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.uniqueValues && this.uniqueValues.length > 0 };
} } } })], c6.prototype, "uniqueValues", void 0), e([y2({ type: j.ofType(a3), json: { write: { enabled: true, overridePolicy() {
  const e6 = !this.uniqueValues || this.uniqueValues.length < 1, s7 = !!this.isosurfaces && this.isosurfaces.length > 0;
  return { enabled: e6 && s7 };
} } } })], c6.prototype, "isosurfaces", void 0), c6 = p10 = e([n("esri.layers.voxel.VoxelVariableStyle")], c6);
var f3 = c6;

// node_modules/@arcgis/core/layers/voxel/VoxelIrregularSpacing.js
var t3 = class extends l {
  constructor() {
    super(...arguments), this.values = null;
  }
};
e([y2({ type: [Number], json: { write: true } })], t3.prototype, "values", void 0), t3 = e([n("esri.layers.voxel.VoxelIrregularSpacing")], t3);
var p11 = t3;

// node_modules/@arcgis/core/layers/voxel/VoxelRegularSpacing.js
var t4 = class extends l {
  constructor() {
    super(...arguments), this.scale = 1, this.offset = 0;
  }
};
e([y2({ type: Number, json: { write: true } })], t4.prototype, "scale", void 0), e([y2({ type: Number, json: { write: true } })], t4.prototype, "offset", void 0), t4 = e([n("esri.layers.voxel.VoxelRegularSpacing")], t4);
var p12 = t4;

// node_modules/@arcgis/core/layers/voxel/VoxelDimension.js
var p13 = class extends l {
  constructor() {
    super(...arguments), this.irregularSpacing = null, this.isPositiveUp = true, this.isWrappedDateLine = false, this.label = null, this.name = null, this.quantity = null, this.regularSpacing = null, this.size = 0, this.unit = null;
  }
  get isRegular() {
    return (null == this.irregularSpacing || void 0 === this.irregularSpacing) && null !== this.regularSpacing;
  }
  getRange() {
    var _a;
    return this.isRegular ? [this.regularSpacing.offset, this.regularSpacing.offset + this.regularSpacing.scale * (this.size - 1)] : Array.isArray((_a = this.irregularSpacing) == null ? void 0 : _a.values) && this.irregularSpacing.values.length > 1 ? [this.irregularSpacing.values[0], this.irregularSpacing.values[this.irregularSpacing.values.length - 1]] : [0, 0];
  }
};
e([y2({ type: p11, json: { write: true } })], p13.prototype, "irregularSpacing", void 0), e([y2({ type: Boolean, json: { write: true } })], p13.prototype, "isPositiveUp", void 0), e([y2({ type: Boolean, json: { write: true } })], p13.prototype, "isWrappedDateLine", void 0), e([y2({ type: String, json: { write: true } })], p13.prototype, "label", void 0), e([y2({ type: String, json: { write: true } })], p13.prototype, "name", void 0), e([y2({ type: String, json: { write: true } })], p13.prototype, "quantity", void 0), e([y2({ type: p12, json: { write: true } })], p13.prototype, "regularSpacing", void 0), e([y2({ type: Number, json: { write: true } })], p13.prototype, "size", void 0), e([y2({ type: String, json: { write: true } })], p13.prototype, "unit", void 0), e([y2({ type: Boolean, json: { read: false } })], p13.prototype, "isRegular", null), p13 = e([n("esri.layers.voxel.VoxelDimension")], p13);
var a6 = p13;

// node_modules/@arcgis/core/layers/voxel/VoxelVolume.js
var d2 = "esri.layers.voxel.VoxelVolume";
var y5 = s.getLogger(d2);
var f4 = class extends l {
  constructor(e6) {
    super(e6), this.id = 0, this.dimensions = null, this.spatialReference = k.WGS84;
  }
  get zDimension() {
    if (!this.dimensions)
      return -1;
    if (!Array.isArray(this.dimensions))
      return -1;
    if (4 !== this.dimensions.length)
      return -1;
    for (let e6 = 2; e6 < 4; ++e6)
      if (this.dimensions[e6].size > 0)
        return e6;
    return -1;
  }
  get isValid() {
    return !!this.dimensions && (!!Array.isArray(this.dimensions) && (4 === this.dimensions.length && (!(this.dimensions[0].size < 1 || this.dimensions[1].size < 1) && !(-1 === this.zDimension || this.dimensions[this.zDimension].size < 1))));
  }
  get originInLayerSpace3D() {
    if (!this.isValid || "xyt" === this.volumeType)
      return [0, 0, 0];
    const e6 = this.dimensions[0].getRange(), i7 = this.dimensions[1].getRange(), s7 = this.dimensions[2], r5 = s7.isRegular ? s7.getRange() : [0, s7.size];
    return [e6[0], i7[0], r5[0]];
  }
  get voxelSizeInLayerSpaceSigned() {
    if (!this.isValid || "xyt" === this.volumeType)
      return [0, 0, 0];
    const e6 = this.dimensions[0].getRange(), i7 = this.dimensions[1].getRange(), s7 = this.dimensions[2], r5 = s7.isRegular ? s7.getRange() : [0, s7.size], t6 = [this.sizeInVoxels[0], this.sizeInVoxels[1], this.sizeInVoxels[2]];
    for (let n4 = 0; n4 < 3; ++n4)
      t6[n4] < 2 ? t6[n4] = 1 : t6[n4] -= 1;
    return s7.isRegular && !s7.isPositiveUp && (t6[2] *= -1), [(e6[1] - e6[0]) / t6[0], (i7[1] - i7[0]) / t6[1], (r5[1] - r5[0]) / t6[2]];
  }
  get volumeType() {
    if (this.isValid) {
      const e6 = this.dimensions[2].size > 0, i7 = this.dimensions[3].size > 0;
      if (!e6 && i7)
        return "xyt";
      if (e6 && i7)
        return "xyzt";
    }
    return "xyz";
  }
  get sizeInVoxels() {
    if (!this.isValid)
      return [0, 0, 0];
    const e6 = this.zDimension;
    return [this.dimensions[0].size, this.dimensions[1].size, this.dimensions[e6].size];
  }
  computeVoxelSpaceLocation(e6) {
    var _a, _b, _c;
    if (!this.isValid)
      return [0, 0, 0];
    if ("xyt" === this.volumeType)
      return y5.error("computeVoxelSpacePosition cannot be used with XYT volumes."), [0, 0, 0];
    if (!E(this.spatialReference, e6.spatialReference))
      return y5.error("pos argument should have the same spatial reference as the VoxelLayer."), [0, 0, 0];
    const i7 = r2(e6.x, e6.y, (_a = e6.z) != null ? _a : 0);
    e3(i7, i7, this.originInLayerSpace3D), i(i7, i7, this.voxelSizeInLayerSpaceSigned);
    const s7 = this.dimensions[this.zDimension];
    if (!s7.isRegular && Array.isArray((_b = s7.irregularSpacing) == null ? void 0 : _b.values) && s7.irregularSpacing.values.length > 1) {
      const r5 = (_c = e6.z) != null ? _c : 0, t6 = s7.irregularSpacing.values, n4 = s7.isPositiveUp ? 1 : -1, o2 = t6.reduce((e7, i8) => Math.abs(n4 * i8 - r5) < Math.abs(n4 * e7 - r5) ? i8 : e7);
      for (let e7 = 0; e7 < t6.length; ++e7)
        if (t6[e7] === o2) {
          i7[2] = e7;
          break;
        }
    }
    return [i7[0], i7[1], i7[2]];
  }
  computeLayerSpaceLocation(e6) {
    var _a;
    if (!this.isValid)
      return new w2({ x: 0, y: 0, spatialReference: this.spatialReference });
    const i7 = e2(e6);
    if (c(i7, i7, this.voxelSizeInLayerSpaceSigned), u2(i7, i7, this.originInLayerSpace3D), "xyt" === this.volumeType)
      return new w2({ x: i7[0], y: i7[1], spatialReference: this.spatialReference });
    const s7 = this.dimensions[this.zDimension];
    return s7.isRegular || Array.isArray((_a = s7.irregularSpacing) == null ? void 0 : _a.values) && (e6[2] < 0 ? i7[2] = s7.irregularSpacing.values[0] : e6[2] < s7.irregularSpacing.values.length ? i7[2] = s7.irregularSpacing.values[e6[2]] : i7[2] = s7.irregularSpacing.values[s7.irregularSpacing.values.length - 1], s7.isPositiveUp || (i7[2] *= -1)), new w2({ x: i7[0], y: i7[1], z: i7[2], spatialReference: this.spatialReference });
  }
};
e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], f4.prototype, "id", void 0), e([y2({ type: [a6], json: { write: { enabled: true, isRequired: true } } })], f4.prototype, "dimensions", void 0), e([y2({ type: k, json: { read: { enabled: false } } })], f4.prototype, "spatialReference", void 0), e([y2({ type: Number, json: { read: false } })], f4.prototype, "zDimension", null), e([y2({ type: [Boolean], json: { read: false } })], f4.prototype, "isValid", null), e([y2({ type: [Number], json: { read: false } })], f4.prototype, "originInLayerSpace3D", null), e([y2({ type: [Number], json: { read: false } })], f4.prototype, "voxelSizeInLayerSpaceSigned", null), e([y2({ type: ["xyz", "xyzt", "xyt"], json: { read: { enabled: false } } })], f4.prototype, "volumeType", null), e([y2({ type: [Number], json: { read: false } })], f4.prototype, "sizeInVoxels", null), f4 = e([n(d2)], f4);
var S2 = f4;

// node_modules/@arcgis/core/layers/voxel/VoxelVolumeIndex.js
var t5;
var s6 = t5 = class extends l {
  constructor() {
    super(...arguments), this.apronWidth = 1, this.brickSize = [32, 32, 32], this.maxLodLevel = 0, this.nodeSize = [4, 4, 4];
  }
  isValid() {
    const e6 = new t5();
    return e6.apronWidth === this.apronWidth && e6.maxLodLevel === this.maxLodLevel && (!!this.brickSize && (!!this.nodeSize && (!(!Array.isArray(this.brickSize) || !Array.isArray(this.nodeSize)) && (3 === this.brickSize.length && 3 === this.nodeSize.length && (32 === this.brickSize[0] && 32 === this.brickSize[1] && 32 === this.brickSize[2] && (4 === this.nodeSize[0] && 4 === this.nodeSize[1] && 4 === this.nodeSize[2]))))));
  }
};
e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], s6.prototype, "apronWidth", void 0), e([y2({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], s6.prototype, "brickSize", void 0), e([y2({ type: Number, json: { write: { enabled: true, isRequired: true } } })], s6.prototype, "maxLodLevel", void 0), e([y2({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], s6.prototype, "nodeSize", void 0), s6 = t5 = e([n("esri.layers.voxel.VoxelVolumeIndex")], s6);
var p14 = s6;

// node_modules/@arcgis/core/layers/voxel/VoxelDynamicSection.js
var m2 = class extends i2(l) {
  constructor(t6) {
    super(t6), this.enabled = true, this.label = "", this.normal = null, this.point = null;
  }
  get orientation() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [t6, o2] = l3(this.normal);
    return s4.normalize(a(t6), 0, true);
  }
  set orientation(t6) {
    const o2 = q(t6, this.tilt);
    this._set("normal", o2), this._set("orientation", t6);
  }
  get tilt() {
    if (!Array.isArray(this.normal) || 3 !== this.normal.length)
      return 0;
    const [t6, o2] = l3(this.normal);
    return s4.normalize(a(o2), 0, true);
  }
  set tilt(t6) {
    const o2 = q(this.orientation, t6);
    this._set("normal", o2), this._set("tilt", t6);
  }
};
e([y2({ type: Boolean, json: { default: true, write: true } })], m2.prototype, "enabled", void 0), e([y2({ type: String, json: { write: true } })], m2.prototype, "label", void 0), e([y2({ type: Number, json: { read: false }, clonable: false, range: { min: 0, max: 360 } }), s3((t6) => s4.normalize(a(t6), 0, true))], m2.prototype, "orientation", null), e([y2({ type: Number, json: { read: false }, clonable: false, range: { min: 0, max: 360 } }), s3((t6) => s4.normalize(a(t6), 0, true))], m2.prototype, "tilt", null), e([y2({ type: [Number], json: { write: true } })], m2.prototype, "normal", void 0), e([y2({ type: [Number], json: { write: true } })], m2.prototype, "point", void 0), m2 = e([n("esri.layers.voxel.VoxelDynamicSection")], m2);
var c7 = m2;

// node_modules/@arcgis/core/layers/voxel/VoxelVolumeStyle.js
var p15;
var m3 = p15 = class extends l {
  constructor(e6) {
    super(e6), this.volumeId = 0, this.verticalExaggeration = 1, this.exaggerationMode = "scale-height", this.verticalOffset = 0, this.slices = new (j.ofType(c4))(), this.dynamicSections = new (j.ofType(c7))();
  }
  set slices(e6) {
    this._set("slices", n2(e6, this._get("slices"), j.ofType(c4)));
  }
  set dynamicSections(e6) {
    this._set("dynamicSections", n2(e6, this._get("dynamicSections"), j.ofType(c7)));
  }
  clone() {
    return new p15({ volumeId: this.volumeId, verticalExaggeration: this.verticalExaggeration, exaggerationMode: this.exaggerationMode, verticalOffset: this.verticalOffset, slices: y(this.slices), dynamicSections: y(this.dynamicSections) });
  }
};
e([y2({ type: T, json: { write: { enabled: true, isRequired: true } } })], m3.prototype, "volumeId", void 0), e([y2({ type: Number, json: { default: 1, write: true } })], m3.prototype, "verticalExaggeration", void 0), e([y2({ type: ["scale-position", "scale-height"], json: { default: "scale-height", write: true } })], m3.prototype, "exaggerationMode", void 0), e([y2({ type: Number, json: { default: 0, write: true } })], m3.prototype, "verticalOffset", void 0), e([y2({ type: j.ofType(c4), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.slices && this.slices.length > 0 };
} } } })], m3.prototype, "slices", null), e([y2({ type: j.ofType(c7), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.dynamicSections && this.dynamicSections.length > 0 };
} } } })], m3.prototype, "dynamicSections", null), m3 = p15 = e([n("esri.layers.voxel.VoxelVolumeStyle")], m3);
var d3 = m3;

// node_modules/@arcgis/core/layers/VoxelLayer.js
var E3 = "esri.layers.VoxelLayer";
var R = s.getLogger(E3);
var M = class extends N(p2(c3(v2(t(O(i3(b))))))) {
  constructor(e6) {
    super(e6), this.serviceRoot = "", this.popupEnabled = true, this.operationalLayerType = "Voxel", this.legendEnabled = true, this.title = null, this.sections = null, this.currentVariableId = 0, this.volumeStyles = null, this.renderMode = "volume", this.variableStyles = null, this.enableSlices = true, this.enableSections = true, this.enableDynamicSections = true, this.enableIsosurfaces = true, this.shading = new p5(), this.opacity = 1, this.variables = new j(), this.volumes = new j(), this.index = null, this.minScale = 0, this.maxScale = 0, this.type = "voxel", this.version = { major: Number.NaN, minor: Number.NaN, versionString: "" }, this.fullExtent = null, this.volumeStyles = new (j.ofType(d3))(), this.variableStyles = new (j.ofType(f3))(), this.sections = new (j.ofType(u3))();
  }
  set url(e6) {
    this._set("url", S(e6, R));
  }
  load(e6) {
    const r5 = r(e6) ? e6.signal : null, i7 = this.loadFromPortal({ supportedTypes: ["Scene Service"] }, e6).catch(w).then(() => this._fetchService(r5)).then(() => this.serviceRoot = this.url);
    return this.addResolvingPromise(i7), Promise.resolve(this);
  }
  read(e6, r5) {
    super.read(e6, r5);
    for (const i7 of this.volumes)
      i7.spatialReference = this.spatialReference;
  }
  readVersion(e6, r5) {
    return super.parseVersionString(e6);
  }
  validateLayer(e6) {
    if (e6.layerType && e6.layerType !== this.operationalLayerType)
      throw new s2("voxel-layer:layer-type-not-supported", "VoxelLayer does not support this layer type", { layerType: e6.layerType });
    if (isNaN(this.version.major) || isNaN(this.version.minor) || this.version.major < 3)
      throw new s2("layer:service-version-not-supported", "Service version is not supported.", { serviceVersion: this.version.versionString, supportedVersions: "3.x" });
    if (this.version.major > 3)
      throw new s2("layer:service-version-too-new", "Service version is too new.", { serviceVersion: this.version.versionString, supportedVersions: "3.x" });
  }
  readFullExtent(e6, r5, i7) {
    if (null != e6 && "object" == typeof e6) {
      const o2 = w3.fromJSON(e6, i7);
      if (0 === o2.zmin && 0 === o2.zmax && Array.isArray(r5.volumes)) {
        const e7 = S2.fromJSON(r5.volumes[0]);
        if (e7.isValid && "xyt" !== e7.volumeType) {
          const r6 = e7.dimensions[2];
          if (r6.isRegular) {
            let e8 = r6.regularSpacing.offset, i8 = r6.regularSpacing.offset + r6.regularSpacing.scale * (r6.size - 1);
            if (e8 > i8) {
              const r7 = e8;
              e8 = i8, i8 = r7;
            }
            o2.zmin = e8, o2.zmax = i8;
          }
        }
      }
      return o2;
    }
    return null;
  }
  getConfiguration() {
    const e6 = { layerType: this.operationalLayerType, version: this.version.versionString, name: this.title, spatialReference: this.spatialReference, fullExtent: this.fullExtent, volumes: this.volumes.toJSON(), variables: this.variables.toJSON(), index: this.index.toJSON(), sections: this.getSections(), style: { volumeStyles: this.getVolumeStyles(), currentVariableId: this.currentVariableId, renderMode: this.renderMode, variableStyles: this.getVariableStyles(), enableSections: this.enableSections, enableDynamicSections: this.enableDynamicSections, enableIsosurfaces: this.enableIsosurfaces, enableSlices: this.enableSlices, shading: this.shading } };
    return e6.index && this.index.isValid() ? JSON.stringify(e6) : "";
  }
  getVariableStyle(e6) {
    let r5 = -1;
    r5 = r(e6) ? e6 : this.currentVariableId;
    if (!this.variableStyles || -1 === r5)
      return null;
    const i7 = this.variableStyles.findIndex((e7) => e7.variableId === r5);
    return i7 < 0 ? null : this.variableStyles.getItemAt(i7);
  }
  getVariable(e6) {
    let r5 = -1;
    if (r5 = r(e6) ? e6 : this.currentVariableId, !this.variables || -1 === r5)
      return null;
    const i7 = this.variables.findIndex((e7) => e7.id === r5);
    return i7 < 0 ? null : this.variables.getItemAt(i7);
  }
  getVolume(e6) {
    const r5 = this.getVariable(e6);
    return r(r5) ? this.volumes.find(({ id: e7 }) => e7 === r5.volumeId) : null;
  }
  getVolumeStyle(e6) {
    const r5 = this.getVariable(e6);
    return r(r5) ? this.volumeStyles.find(({ volumeId: e7 }) => e7 === r5.volumeId) : null;
  }
  getColorForContinuousDataValue(e6, r5, i7) {
    const o2 = this.getVariable(e6);
    if (!r(o2) || "continuous" !== o2.renderingFormat.continuity)
      return null;
    if (!this.variableStyles)
      return null;
    const s7 = this.variableStyles.findIndex((r6) => r6.variableId === e6);
    if (s7 < 0)
      return null;
    const n4 = this.variableStyles.getItemAt(s7);
    return n4.transferFunction ? n4.transferFunction.getColorForContinuousDataValue(r5, i7) : null;
  }
  getSections() {
    const e6 = [];
    for (const r5 of this.sections)
      e6.push(new u3({ enabled: r5.enabled, href: r5.href, id: r5.id, label: r5.label, normal: r5.normal, point: r5.point, sizeInPixel: r5.sizeInPixel, slices: r5.slices, timeId: r5.timeId, variableId: r5.variableId }));
    return e6;
  }
  getVariableStyles() {
    const e6 = [];
    for (const r5 of this.variableStyles) {
      const i7 = this._getVariable(r5);
      if (r(i7)) {
        const o2 = r5.clone();
        o2.isosurfaces.length > 4 && (o2.isosurfaces = o2.isosurfaces.slice(0, 3), R.error("A maximum of 4 isosurfaces are supported for Voxel Layers."));
        for (const e7 of o2.isosurfaces)
          if (e7.colorLocked) {
            const r6 = this.getColorForContinuousDataValue(o2.variableId, e7.value, false);
            null === r6 || r6.equals(e7.color) || (e7.color = r6);
          }
        if ("continuous" === i7.renderingFormat.continuity)
          (null === o2.transferFunction || o2.transferFunction.colorStops.length < 2) && R.error(`VoxelVariableStyle for variable ${i7.id} is invalid. At least 2 color stops are required in the transferFunction for continuous Voxel Layer variables.`), null !== o2.transferFunction && (Array.isArray(o2.transferFunction.stretchRange) && 2 === o2.transferFunction.stretchRange.length || (R.error(`VoxelVariableStyle for variable ${i7.id} is invalid. The stretchRange of the transferFunction for continuous Voxel Layer variables must be of the form [minimumDataValue, maximumDataValue].`), o2.transferFunction.stretchRange = [0, 1], o2.transferFunction.colorStops.removeAll()));
        else if ("discrete" === i7.renderingFormat.continuity)
          if (0 === r5.uniqueValues.length)
            R.error(`VoxelVariableStyle for variable ${i7.id} is invalid. Unique values are required for discrete Voxel Layer variables.`);
          else
            for (const e7 of r5.uniqueValues)
              null !== e7.label && void 0 !== e7.label || null === e7.value || void 0 === e7.value || (e7.label = e7.value.toString());
        e6.push(o2);
      } else
        R.error(`VoxelVariable ID=${r5.variableId} doesn't exist, VoxelVariableStyle for this VoxelVariable will be ignored.`);
    }
    return e6;
  }
  getVolumeStyles() {
    const e6 = [];
    for (const r5 of this.volumeStyles) {
      const i7 = this._getVolumeFromVolumeId(r5.volumeId);
      if (r(i7)) {
        const o2 = r5.clone();
        for (const e7 of o2.slices)
          this._isPlaneValid(e7, [0, 1, i7.zDimension], i7.dimensions) || (e7.enabled = false, e7.label = "invalid");
        for (const e7 of o2.dynamicSections)
          this._isPlaneValid(e7, [0, 1, i7.zDimension], i7.dimensions) || (e7.enabled = false, e7.label = "invalid");
        e6.push(o2);
      } else
        R.error(`VoxelVolume ID=${r5.volumeId} doesn't exist, VoxelVolumeStyle for this VoxelVolume will be ignored.`);
    }
    return e6;
  }
  _getVariable(e6) {
    const r5 = e6.variableId;
    for (const i7 of this.variables)
      if (i7.id === r5)
        return i7;
    return null;
  }
  _getVolumeFromVolumeId(e6) {
    for (const r5 of this.volumes)
      if (r5.id === e6)
        return r5;
    return null;
  }
  _isPlaneValid(e6, r5, i7) {
    if (!e6.point)
      return false;
    if (!Array.isArray(e6.point) || 3 !== e6.point.length)
      return false;
    if (!e6.normal)
      return false;
    if (!Array.isArray(e6.normal) || 3 !== e6.normal.length)
      return false;
    for (let s7 = 0; s7 < 3; ++s7) {
      const o3 = e6.point[s7];
      if (o3 < 0 || o3 >= i7[r5[s7]].size)
        return false;
    }
    const o2 = r2(e6.normal[0], e6.normal[1], e6.normal[2]);
    z(o2, o2);
    const t6 = 1e-6;
    return !(Math.abs(o2[0]) + Math.abs(o2[1]) + Math.abs(o2[2]) < t6) && (e6.normal[0] = o2[0], e6.normal[1] = o2[1], e6.normal[2] = o2[2], true);
  }
};
e([y2(p3)], M.prototype, "popupEnabled", void 0), e([y2({ type: ["Voxel"] })], M.prototype, "operationalLayerType", void 0), e([y2(c2)], M.prototype, "legendEnabled", void 0), e([y2({ json: { write: true } })], M.prototype, "title", void 0), e([y2(f)], M.prototype, "url", null), e([y2({ type: j.ofType(u3), json: { origins: { "web-scene": { name: "layerDefinition.sections", write: true } } } })], M.prototype, "sections", void 0), e([y2({ type: T, json: { origins: { "web-scene": { name: "layerDefinition.style.currentVariableId", write: { enabled: true, isRequired: true, ignoreOrigin: true } }, service: { name: "style.currentVariableId" } } } })], M.prototype, "currentVariableId", void 0), e([y2({ type: j.ofType(d3), json: { origins: { "web-scene": { name: "layerDefinition.style.volumeStyles", write: true }, service: { name: "style.volumeStyles" } } } })], M.prototype, "volumeStyles", void 0), e([y2({ type: ["volume", "surfaces"], json: { origins: { "web-scene": { name: "layerDefinition.style.renderMode", write: true }, service: { name: "style.renderMode" } } } })], M.prototype, "renderMode", void 0), e([y2({ type: j.ofType(f3), json: { origins: { "web-scene": { name: "layerDefinition.style.variableStyles", write: true }, service: { name: "style.variableStyles" } } } })], M.prototype, "variableStyles", void 0), e([y2({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableSlices", write: true }, service: { name: "style.enableSlices" } } } })], M.prototype, "enableSlices", void 0), e([y2({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableSections", write: true }, service: { name: "style.enableSections" } } } })], M.prototype, "enableSections", void 0), e([y2({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableDynamicSections", write: true }, service: { name: "style.enableDynamicSections" } } } })], M.prototype, "enableDynamicSections", void 0), e([y2({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableIsosurfaces", write: true }, service: { name: "style.enableIsosurfaces" } } } })], M.prototype, "enableIsosurfaces", void 0), e([y2({ type: p5, json: { origins: { "web-scene": { name: "layerDefinition.style.shading", write: true }, service: { name: "style.shading" } } } })], M.prototype, "shading", void 0), e([y2({ type: ["show", "hide"] })], M.prototype, "listMode", void 0), e([y2({ type: Number, range: { min: 0, max: 1 }, nonNullable: true, json: { read: false, write: false, origins: { "web-scene": { read: false, write: false }, "portal-item": { read: false, write: false } } } })], M.prototype, "opacity", void 0), e([y2({ type: j.ofType(p7) })], M.prototype, "variables", void 0), e([y2({ type: j.ofType(S2) })], M.prototype, "volumes", void 0), e([y2({ type: p14 })], M.prototype, "index", void 0), e([y2({ type: Number, json: { name: "layerDefinition.minScale", read: false, write: false, origins: { service: { read: false, write: false } } } })], M.prototype, "minScale", void 0), e([y2({ type: Number, json: { name: "layerDefinition.maxScale", read: false, write: false, origins: { service: { read: false, write: false } } } })], M.prototype, "maxScale", void 0), e([y2({ json: { read: false }, readOnly: true })], M.prototype, "type", void 0), e([y2({ readOnly: true, json: { name: "serviceVersion" } })], M.prototype, "version", void 0), e([o("service", "version")], M.prototype, "readVersion", null), e([y2({ type: w3 })], M.prototype, "fullExtent", void 0), e([o("service", "fullExtent", ["fullExtent"])], M.prototype, "readFullExtent", null), M = e([n(E3)], M);
var O2 = M;
export {
  O2 as default
};
//# sourceMappingURL=VoxelLayer-UZ3WZOBC.js.map