jtBaseApp/node_modules/.vite/VoxelLayer-VXHDUDBI.js

import {
  A
} from "./chunk-C62PEMUB.js";
import "./chunk-5ZZSM3DU.js";
import "./chunk-BQ7UE3XL.js";
import "./chunk-UILPRJKY.js";
import "./chunk-524XACB7.js";
import "./chunk-QY775BFA.js";
import {
  i as i2
} from "./chunk-FMKGHOGD.js";
import {
  p as p2
} from "./chunk-6URTNEGN.js";
import {
  l as l3
} from "./chunk-3D3QEPRE.js";
import {
  S as S2
} from "./chunk-X7DBH4KK.js";
import {
  l as l2
} from "./chunk-7XXXCK2A.js";
import {
  v
} from "./chunk-KHA63LLS.js";
import {
  c as c2
} from "./chunk-FGKNEJKJ.js";
import {
  c,
  f,
  p
} from "./chunk-PSV473TI.js";
import {
  O
} from "./chunk-I3OBGWNS.js";
import "./chunk-FONIFA5N.js";
import "./chunk-EG5OI4V4.js";
import {
  i
} from "./chunk-65BYCSII.js";
import "./chunk-WZQZRKNH.js";
import "./chunk-LRDX4TO7.js";
import "./chunk-6A4U74YA.js";
import {
  t as t2
} from "./chunk-W72F6AS3.js";
import "./chunk-O4FY3ITT.js";
import {
  b
} from "./chunk-4DDBH2K5.js";
import "./chunk-7N4X6GF3.js";
import "./chunk-JXW4QTJA.js";
import "./chunk-UXF37FQ4.js";
import "./chunk-ZOEK6QHJ.js";
import {
  z
} from "./chunk-XNLG7T2T.js";
import {
  r as r2
} from "./chunk-IR4PV7VK.js";
import "./chunk-2Z6LERTI.js";
import "./chunk-OWVBLVP3.js";
import {
  n as n2
} from "./chunk-AFZ7XSEW.js";
import "./chunk-EGZW6HC3.js";
import "./chunk-4NKD334K.js";
import "./chunk-65K7LC56.js";
import "./chunk-ATPLLI5W.js";
import "./chunk-WJ3OEUD3.js";
import "./chunk-MXB2XLKV.js";
import "./chunk-XH7RUGVZ.js";
import "./chunk-TBBTRX4O.js";
import "./chunk-YBSUITLL.js";
import {
  j
} from "./chunk-ALDCDSPV.js";
import "./chunk-DT6EAZQ5.js";
import "./chunk-HNOZUNJ4.js";
import "./chunk-VNFRAYHO.js";
import "./chunk-R5IG2D6H.js";
import "./chunk-VBRY5KJM.js";
import "./chunk-PDKDCAAD.js";
import {
  o
} from "./chunk-ECW2QABR.js";
import "./chunk-GCDJLKH4.js";
import "./chunk-MRJEICT6.js";
import {
  d,
  e,
  l3 as l,
  n2 as n
} from "./chunk-Y3WMVFTW.js";
import "./chunk-SAS7RONY.js";
import "./chunk-WSRBH7BF.js";
import {
  S
} from "./chunk-IHXECKQQ.js";
import {
  w
} from "./chunk-ULGDPLM2.js";
import {
  s,
  s3 as s2
} from "./chunk-EMJ4ZSM2.js";
import "./chunk-IKP3YN53.js";
import {
  r,
  t
} from "./chunk-GZT4BVFP.js";
import "./chunk-A5ICIBVI.js";

// node_modules/@arcgis/core/layers/support/VoxelDynamicSection.js
var p3 = class extends l3(l) {
  constructor() {
    super(...arguments), this.enabled = true, this.label = "", this.normal = null, this.point = null;
  }
};
e([d({ type: Boolean, json: { default: true, write: true } })], p3.prototype, "enabled", void 0), e([d({ type: String, json: { write: true } })], p3.prototype, "label", void 0), e([d({ type: [Number], json: { write: true } })], p3.prototype, "normal", void 0), e([d({ type: [Number], json: { write: true } })], p3.prototype, "point", void 0), p3 = e([n("esri.layers.support.VoxelDynamicSection")], p3);
var i3 = p3;

// node_modules/@arcgis/core/layers/support/VoxelSlice.js
var p4 = class extends l3(l) {
  constructor() {
    super(...arguments), this.enabled = true, this.label = "", this.normal = null, this.point = null;
  }
};
e([d({ type: Boolean, json: { write: true } })], p4.prototype, "enabled", void 0), e([d({ type: String, json: { write: true } })], p4.prototype, "label", void 0), e([d({ type: [Number], json: { write: true } })], p4.prototype, "normal", void 0), e([d({ type: [Number], json: { write: true } })], p4.prototype, "point", void 0), p4 = e([n("esri.layers.support.VoxelSlice")], p4);
var i4 = p4;

// node_modules/@arcgis/core/layers/support/VoxelSection.js
var n3 = class extends 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;
  }
  readHref(e2, r3, o2) {
    return i(e2, o2);
  }
};
e([d({ type: Boolean, json: { default: true, write: true } })], n3.prototype, "enabled", void 0), e([d({ type: String, json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "href", void 0), e([o(["service", "web-scene"], "href")], n3.prototype, "readHref", null), e([d({ type: S, json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "id", void 0), e([d({ type: String, json: { write: true } })], n3.prototype, "label", void 0), e([d({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "normal", void 0), e([d({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "point", void 0), e([d({ type: [S], json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "sizeInPixel", void 0), e([d({ type: [i4], json: { write: true } })], n3.prototype, "slices", void 0), e([d({ type: S, json: { default: 0, write: true } })], n3.prototype, "timeId", void 0), e([d({ type: S, json: { write: { enabled: true, isRequired: true } } })], n3.prototype, "variableId", void 0), n3 = e([n("esri.layers.support.VoxelSection")], n3);
var a = n3;

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

// node_modules/@arcgis/core/layers/support/VoxelFormat.js
var s3 = 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([d({ type: ["discrete", "continuous"], json: { write: true } })], s3.prototype, "continuity", void 0), e([d({ type: Boolean, json: { write: true } })], s3.prototype, "hasNoData", void 0), e([d({ type: Number, json: { write: true } })], s3.prototype, "noData", void 0), e([d({ type: Number, json: { write: true } })], s3.prototype, "offset", void 0), e([d({ type: Number, json: { write: true } })], s3.prototype, "scale", void 0), e([d({ type: String, json: { write: { enabled: true, isRequired: true } } })], s3.prototype, "type", void 0), s3 = e([n("esri.layers.support.VoxelFormat")], s3);
var p6 = s3;

// node_modules/@arcgis/core/layers/support/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([d({ type: Number, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "id", void 0), e([d({ type: String, json: { write: true } })], i5.prototype, "description", void 0), e([d({ type: String, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "name", void 0), e([d({ type: p6, json: { write: true } })], i5.prototype, "originalFormat", void 0), e([d({ type: p6, json: { write: { enabled: true, isRequired: true } } })], i5.prototype, "renderingFormat", void 0), e([d({ type: String, json: { write: true } })], i5.prototype, "unit", void 0), e([d({ type: Number, json: { write: true } })], i5.prototype, "volumeId", void 0), e([d({ 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.support.VoxelVariable")], i5);
var p7 = i5;

// node_modules/@arcgis/core/layers/support/VoxelIsosurface.js
var l4 = class extends l {
  constructor() {
    super(...arguments), this.color = null, this.value = null, this.enabled = true, this.label = null;
  }
};
e([d({ type: l2, json: { type: [S], write: { enabled: true, isRequired: true } } })], l4.prototype, "color", void 0), e([d({ type: Number, json: { write: { enabled: true, isRequired: true } } })], l4.prototype, "value", void 0), e([d({ type: Boolean, json: { default: true, write: true } })], l4.prototype, "enabled", void 0), e([d({ type: String, json: { write: true } })], l4.prototype, "label", void 0), l4 = e([n("esri.layers.support.VoxelIsosurface")], l4);
var i6 = l4;

// node_modules/@arcgis/core/layers/support/VoxelAlphaStop.js
var t4 = class extends l {
  constructor() {
    super(...arguments), this.alpha = 0, this.position = 0;
  }
};
e([d({ type: Number, json: { write: { enabled: true, isRequired: true } } })], t4.prototype, "alpha", void 0), e([d({ type: Number, json: { write: { enabled: true, isRequired: true } } })], t4.prototype, "position", void 0), t4 = e([n("esri.layers.support.VoxelAlphaStop")], t4);
var p8 = t4;

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

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

// node_modules/@arcgis/core/layers/support/VoxelTransferFunctionStyle.js
var n4 = class extends l {
  constructor(o2) {
    super(o2), this.interpolation = null, this.stretchRange = null, this.rangeFilter = null, this.colorStops = new j(), this.alphaStops = new j();
  }
  set colorStops(o2) {
    this._set("colorStops", n2(o2, this._get("colorStops"), j.ofType(c3)));
  }
  set alphaStops(o2) {
    this._set("alphaStops", n2(o2, this._get("alphaStops"), j.ofType(p8)));
  }
};
e([d({ type: ["linear", "nearest"], json: { write: true } })], n4.prototype, "interpolation", void 0), e([d({ type: [Number], json: { write: { enabled: true, isRequired: true } } })], n4.prototype, "stretchRange", void 0), e([d({ type: j.ofType(c3), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.colorStops && this.colorStops.length > 0 };
} } } })], n4.prototype, "colorStops", null), e([d({ type: j.ofType(p8), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.alphaStops && this.alphaStops.length > 0 };
} } } })], n4.prototype, "alphaStops", null), e([d({ type: p9, json: { write: true } })], n4.prototype, "rangeFilter", void 0), n4 = e([n("esri.layers.support.VoxelTransferFunctionStyle")], n4);
var c4 = n4;

// node_modules/@arcgis/core/layers/support/VoxelUniqueValue.js
var i8 = class extends l {
  constructor() {
    super(...arguments), this.color = null, this.value = 0, this.enabled = true, this.label = null;
  }
};
e([d({ type: l2, json: { type: [S], write: { enabled: true, isRequired: true } } })], i8.prototype, "color", void 0), e([d({ type: S, json: { write: { enabled: true, isRequired: true } } })], i8.prototype, "value", void 0), e([d({ type: Boolean, json: { default: true, write: true } })], i8.prototype, "enabled", void 0), e([d({ type: String, json: { write: true } })], i8.prototype, "label", void 0), i8 = e([n("esri.layers.support.VoxelUniqueValue")], i8);
var l5 = i8;

// node_modules/@arcgis/core/layers/support/VoxelVariableStyle.js
var c5 = class extends l3(l) {
  constructor(e2) {
    super(e2), this.variableId = 0, this.label = null, this.transferFunction = null, this.uniqueValues = new j(), this.isosurfaces = new j();
  }
  set uniqueValues(e2) {
    this._set("uniqueValues", n2(e2, this._get("uniqueValues"), j.ofType(l5)));
  }
  set isosurfaces(e2) {
    this._set("isosurfaces", n2(e2, this._get("isosurfaces"), j.ofType(i6)));
  }
};
e([d({ type: S, json: { write: { enabled: true, isRequired: true } } })], c5.prototype, "variableId", void 0), e([d({ type: String, json: { write: true } })], c5.prototype, "label", void 0), e([d({ type: c4, json: { write: { enabled: true, overridePolicy() {
  return { enabled: !this.uniqueValues || this.uniqueValues.length < 1 };
} } } })], c5.prototype, "transferFunction", void 0), e([d({ type: j.ofType(l5), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.uniqueValues && this.uniqueValues.length > 0 };
} } } })], c5.prototype, "uniqueValues", null), e([d({ type: j.ofType(i6), json: { write: { enabled: true, overridePolicy() {
  const e2 = !this.uniqueValues || this.uniqueValues.length < 1, s5 = !!this.isosurfaces && this.isosurfaces.length > 0;
  return { enabled: e2 && s5 };
} } } })], c5.prototype, "isosurfaces", null), c5 = e([n("esri.layers.support.VoxelVariableStyle")], c5);
var f2 = c5;

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

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

// node_modules/@arcgis/core/layers/support/VoxelDimension.js
var p12 = class extends l {
  constructor() {
    super(...arguments), this.irregularSpacing = null, this.isPositiveUp = null, this.isWrappedDateLine = null, this.label = null, this.name = null, this.quantity = null, this.regularSpacing = null, this.size = 0, this.unit = null;
  }
};
e([d({ type: p10, json: { write: true } })], p12.prototype, "irregularSpacing", void 0), e([d({ type: Boolean, json: { write: true } })], p12.prototype, "isPositiveUp", void 0), e([d({ type: Boolean, json: { write: true } })], p12.prototype, "isWrappedDateLine", void 0), e([d({ type: String, json: { write: true } })], p12.prototype, "label", void 0), e([d({ type: String, json: { write: true } })], p12.prototype, "name", void 0), e([d({ type: String, json: { write: true } })], p12.prototype, "quantity", void 0), e([d({ type: p11, json: { write: true } })], p12.prototype, "regularSpacing", void 0), e([d({ type: Number, json: { write: true } })], p12.prototype, "size", void 0), e([d({ type: String, json: { write: true } })], p12.prototype, "unit", void 0), p12 = e([n("esri.layers.support.VoxelDimension")], p12);
var n5 = p12;

// node_modules/@arcgis/core/layers/support/VoxelVolume.js
var t8 = class extends l {
  constructor() {
    super(...arguments), this.id = 0, this.dimensions = null;
  }
  getZDimension() {
    if (!this.dimensions)
      return -1;
    if (!Array.isArray(this.dimensions))
      return -1;
    if (this.dimensions.length !== 4)
      return -1;
    for (let s5 = 2; s5 < 4; ++s5)
      if (this.dimensions[s5].size > 0)
        return s5;
    return -1;
  }
  isVolumeValid() {
    return !!this.dimensions && (!!Array.isArray(this.dimensions) && (this.dimensions.length === 4 && (!(this.dimensions[0].size < 1 || this.dimensions[1].size < 1) && this.getZDimension() !== -1)));
  }
};
e([d({ type: Number, json: { write: { enabled: true, isRequired: true } } })], t8.prototype, "id", void 0), e([d({ type: [n5], json: { write: { enabled: true, isRequired: true } } })], t8.prototype, "dimensions", void 0), t8 = e([n("esri.layers.support.VoxelVolume")], t8);
var n6 = t8;

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

// node_modules/@arcgis/core/layers/support/VoxelVolumeStyle.js
var a2 = class extends l3(l) {
  constructor(e2) {
    super(e2), this.volumeId = 0, this.verticalExaggeration = 1, this.exaggerationMode = "scale-height", this.verticalOffset = 0, this.slices = new j(), this.dynamicSections = new j();
  }
  set slices(e2) {
    this._set("slices", n2(e2, this._get("slices"), j.ofType(i4)));
  }
  set dynamicSections(e2) {
    this._set("dynamicSections", n2(e2, this._get("dynamicSections"), j.ofType(i3)));
  }
};
e([d({ type: S, json: { write: { enabled: true, isRequired: true } } })], a2.prototype, "volumeId", void 0), e([d({ type: Number, json: { default: 1, write: true } })], a2.prototype, "verticalExaggeration", void 0), e([d({ type: ["scale-position", "scale-height"], json: { default: "scale-height", write: true } })], a2.prototype, "exaggerationMode", void 0), e([d({ type: Number, json: { default: 0, write: true } })], a2.prototype, "verticalOffset", void 0), e([d({ type: j.ofType(i4), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.slices && this.slices.length > 0 };
} } } })], a2.prototype, "slices", null), e([d({ type: j.ofType(i3), json: { write: { enabled: true, overridePolicy() {
  return { enabled: !!this.dynamicSections && this.dynamicSections.length > 0 };
} } } })], a2.prototype, "dynamicSections", null), a2 = e([n("esri.layers.support.VoxelVolumeStyle")], a2);
var m = a2;

// node_modules/@arcgis/core/layers/VoxelLayer.js
var A2 = s.getLogger(" esri.layers.VoxelLayer");
var J = class extends A(p2(c2(v(t2(O(i2(b))))))) {
  constructor(e2) {
    super(e2), this.serviceRoot = "", this.popupEnabled = true, this.operationalLayerType = "Voxel", this.legendEnabled = true, this.title = null, this.sections = new j(), 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.volumeStyles = new j(), this.variableStyles = new j();
  }
  set url(e2) {
    this._set("url", S2(e2, A2));
  }
  load(e2) {
    const i9 = r(e2) ? e2.signal : null, r3 = this.loadFromPortal({ supportedTypes: ["Scene Service"] }, e2).catch(w).then(() => this._fetchService(i9)).then(() => this.serviceRoot = this.url);
    return this.addResolvingPromise(r3), Promise.resolve(this);
  }
  readVersion(e2, i9) {
    return super.parseVersionString(e2);
  }
  validateLayer(e2) {
    if (e2.layerType && e2.layerType !== this.operationalLayerType)
      throw new s2("voxel-layer:layer-type-not-supported", "VoxelLayer does not support this layer type", { layerType: e2.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" });
  }
  getConfiguration() {
    const e2 = { 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.sections.toJSON(), style: { volumeStyles: this.volumeStyles.toJSON(), currentVariableId: this.currentVariableId, renderMode: this.renderMode, variableStyles: this.variableStyles.toJSON(), enableSections: this.enableSections, enableDynamicSections: this.enableDynamicSections, enableIsosurfaces: this.enableIsosurfaces, enableSlices: this.enableSlices, shading: this.shading } };
    return e2.index && this.index.isValid() ? JSON.stringify(e2) : "";
  }
  getVariableStyle(e2) {
    let i9 = -1;
    i9 = r(e2) ? e2 : this.currentVariableId;
    if (!this.variableStyles || i9 === -1)
      return null;
    const r3 = this.variableStyles.findIndex((e3) => e3.variableId === i9);
    return r3 < 0 ? null : this.variableStyles.getItemAt(r3);
  }
  getVariable(e2) {
    let i9 = -1;
    if (i9 = r(e2) ? e2 : this.currentVariableId, !this.variables || i9 === -1)
      return null;
    const r3 = this.variables.findIndex((e3) => e3.id === i9);
    return r3 < 0 ? null : this.variables.getItemAt(r3);
  }
  getSections() {
    const e2 = [];
    for (const i9 of this.sections)
      e2.push(new a({ enabled: i9.enabled, href: i9.href, id: i9.id, label: i9.label, normal: i9.normal, point: i9.point, sizeInPixel: i9.sizeInPixel, slices: i9.slices, timeId: i9.timeId, variableId: i9.variableId }));
    return e2;
  }
  getVolume(e2) {
    const i9 = this.getVariable(e2);
    return r(i9) ? this.volumes.find(({ id: e3 }) => e3 === i9.volumeId) : null;
  }
  getVolumeStyle(e2) {
    const i9 = this.getVariable(e2);
    return r(i9) ? this.volumeStyles.find(({ volumeId: e3 }) => e3 === i9.volumeId) : null;
  }
  getSlices() {
    const e2 = [], i9 = this.getVolume(null);
    if (t(i9) || !i9.isVolumeValid())
      return e2;
    const r3 = this.getVolumeStyle(null);
    if (t(r3))
      return e2;
    for (const t10 of r3.slices)
      this._isPlaneValid(t10, [0, 1, i9.getZDimension()], i9.dimensions) ? e2.push(new i4({ enabled: t10.enabled, label: t10.label, point: t10.point, normal: t10.normal })) : e2.push(new i4({ enabled: false, label: "invalid", point: t10.point, normal: t10.normal }));
    return e2;
  }
  getDynamicSections() {
    const e2 = [], i9 = this.getVolume(null);
    if (t(i9) || !i9.isVolumeValid())
      return e2;
    const r3 = this.getVolumeStyle(null);
    if (t(r3))
      return e2;
    for (const t10 of r3.dynamicSections)
      this._isPlaneValid(t10, [0, 1, i9.getZDimension()], i9.dimensions) ? e2.push(new i3({ enabled: t10.enabled, label: t10.label, point: t10.point, normal: t10.normal })) : e2.push(new i3({ enabled: false, label: "invalid", point: t10.point, normal: t10.normal }));
    return e2;
  }
  getVerticalExaggeration() {
    const e2 = 1, i9 = this.getVolumeStyle(null);
    return t(i9) ? e2 : i9.verticalExaggeration;
  }
  getVerticalOffset() {
    const e2 = 1, i9 = this.getVolumeStyle(null);
    return t(i9) ? e2 : i9.verticalOffset;
  }
  _isPlaneValid(e2, i9, r3) {
    if (!e2.point)
      return false;
    if (!Array.isArray(e2.point) || e2.point.length !== 3)
      return false;
    if (!e2.normal)
      return false;
    if (!Array.isArray(e2.normal) || e2.normal.length !== 3)
      return false;
    for (let s5 = 0; s5 < 3; ++s5) {
      const t11 = e2.point[s5];
      if (t11 < 0 || t11 >= r3[i9[s5]].size)
        return false;
    }
    const t10 = r2(e2.normal[0], e2.normal[1], e2.normal[2]);
    z(t10, t10);
    const o2 = 1e-6;
    return !(Math.abs(t10[0]) + Math.abs(t10[1]) + Math.abs(t10[2]) < o2) && (e2.normal[0] = t10[0], e2.normal[1] = t10[1], e2.normal[2] = t10[2], true);
  }
};
e([d(p)], J.prototype, "popupEnabled", void 0), e([d({ type: ["Voxel"] })], J.prototype, "operationalLayerType", void 0), e([d(c)], J.prototype, "legendEnabled", void 0), e([d({ json: { write: true } })], J.prototype, "title", void 0), e([d(f)], J.prototype, "url", null), e([d({ type: j.ofType(a), json: { origins: { "web-scene": { name: "layerDefinition.sections", write: true } } } })], J.prototype, "sections", void 0), e([d({ type: S, json: { origins: { "web-scene": { name: "layerDefinition.style.currentVariableId", write: { enabled: true, isRequired: true } }, service: { name: "style.currentVariableId" } } } })], J.prototype, "currentVariableId", void 0), e([d({ type: j.ofType(m), json: { origins: { "web-scene": { name: "layerDefinition.style.volumeStyles", write: true }, service: { name: "style.volumeStyles" } } } })], J.prototype, "volumeStyles", void 0), e([d({ type: ["volume", "surfaces"], json: { origins: { "web-scene": { name: "layerDefinition.style.renderMode", write: true }, service: { name: "style.renderMode" } } } })], J.prototype, "renderMode", void 0), e([d({ type: j.ofType(f2), json: { origins: { "web-scene": { name: "layerDefinition.style.variableStyles", write: true }, service: { name: "style.variableStyles" } } } })], J.prototype, "variableStyles", void 0), e([d({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableSlices", write: true }, service: { name: "style.enableSlices" } } } })], J.prototype, "enableSlices", void 0), e([d({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableSections", write: true }, service: { name: "style.enableSections" } } } })], J.prototype, "enableSections", void 0), e([d({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableDynamicSections", write: true }, service: { name: "style.enableDynamicSections" } } } })], J.prototype, "enableDynamicSections", void 0), e([d({ type: Boolean, json: { origins: { "web-scene": { name: "layerDefinition.style.enableIsosurfaces", write: true }, service: { name: "style.enableIsosurfaces" } } } })], J.prototype, "enableIsosurfaces", void 0), e([d({ type: p5, json: { origins: { "web-scene": { name: "layerDefinition.style.shading", write: true }, service: { name: "style.shading" } } } })], J.prototype, "shading", void 0), e([d({ type: ["show", "hide"] })], J.prototype, "listMode", void 0), e([d({ 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 } } } })], J.prototype, "opacity", void 0), e([d({ type: j.ofType(p7) })], J.prototype, "variables", void 0), e([d({ type: j.ofType(n6) })], J.prototype, "volumes", void 0), e([d({ type: p13 })], J.prototype, "index", void 0), e([d({ type: Number, json: { name: "layerDefinition.minScale", read: false, write: false, origins: { service: { read: false, write: false } } } })], J.prototype, "minScale", void 0), e([d({ type: Number, json: { name: "layerDefinition.maxScale", read: false, write: false, origins: { service: { read: false, write: false } } } })], J.prototype, "maxScale", void 0), e([d({ json: { read: false }, readOnly: true })], J.prototype, "type", void 0), e([d({ readOnly: true, json: { name: "serviceVersion" } })], J.prototype, "version", void 0), e([o("service", "version")], J.prototype, "readVersion", null), J = e([n("esri.layers.VoxelLayer")], J);
var R = J;
export {
  R as default
};
//# sourceMappingURL=VoxelLayer-VXHDUDBI.js.map