@agrotools1/at-components 0.2.1 → 0.2.3

package/dist/GroupLayer-7ae0a916.js

@@ -0,0 +1,147 @@
+import { fC as b, fD as c, cP as m, fE as v, k as f, o as y, cA as w, fF as g, bM as _, bO as I, e8 as L, ag as O, e as r, y as l, c2 as h, c5 as S, fG as A, H as V, eD as u, c as $, a_ as M, s as P } from "./index-01c737ed.js";
+import { m as C } from "./MultiOriginJSONSupport-bb258670.js";
+import { n as E } from "./BlendLayer-a792edf6.js";
+import { u as x } from "./OperationalLayer-55af27d6.js";
+import { j as T } from "./PortalLayer-07b3c53e.js";
+import { t as G } from "./ScaleRangeLayer-7ddf00b4.js";
+import { a as H } from "./lazyLayerLoader-8817000c.js";
+import { A as d } from "./interfaces-fac3cfda.js";
+import { r as j } from "./saveUtils-43fdc547.js";
+import "vue";
+import "./jsonUtils-913fa1bd.js";
+import "./parser-0701286c.js";
+import "./commonProperties-f9559903.js";
+import "./ElevationInfo-fad03d5e.js";
+import "./unitConversionUtils-f0ebaf75.js";
+import "./lengthUtils-695e744c.js";
+import "./portalItemUtils-4c4caad0.js";
+const F = Symbol("WebScene");
+let s = class extends E(G(x(T(b(c(C(M))))))) {
+  constructor(e) {
+    super(e), this.allLayers = new m({ getCollections: () => [this.layers], getChildrenFunction: (i) => "layers" in i ? i.layers : null }), this.allTables = v(this), this.fullExtent = void 0, this.operationalLayerType = "GroupLayer", this.spatialReference = void 0, this.type = "group", this._debouncedSaveOperations = f(async (i, t, o) => {
+      const { save: a, saveAs: n } = await import("./groupLayerUtils-ea9e6359.js");
+      switch (i) {
+        case d.SAVE:
+          return a(this, t);
+        case d.SAVE_AS:
+          return n(this, o, t);
+      }
+    });
+  }
+  initialize() {
+    this._enforceVisibility(this.visibilityMode, this.visible), this.addHandles([y(() => {
+      let e = this.parent;
+      for (; e && "parent" in e && e.parent; )
+        e = e.parent;
+      return e && F in e;
+    }, (e) => {
+      const i = "prevent-adding-tables";
+      this.removeHandles(i), e && (this.tables.removeAll(), this.addHandles(V(() => this.tables, "before-add", (t) => {
+        t.preventDefault(), P.getLogger(this).errorOnce("tables", "tables in group layers in a webscene are not supported. Please move the tables from the group layer to the webscene if you want to persist them.");
+      }), i));
+    }, A), y(() => this.visible, this._onVisibilityChange.bind(this), u)]);
+  }
+  destroy() {
+    this.allLayers.destroy(), this.allTables.destroy();
+  }
+  get sourceIsPortalItem() {
+    return this.portalItem && this.originIdOf("portalItem") === w.USER;
+  }
+  _writeLayers(e, i, t, o) {
+    const a = [];
+    if (!e)
+      return a;
+    e.forEach((n) => {
+      const p = g(n, o.webmap ? o.webmap.getLayerJSONFromResourceInfo(n) : null, o);
+      p != null && p.layerType && a.push(p);
+    }), i.layers = a;
+  }
+  set portalItem(e) {
+    this._set("portalItem", e);
+  }
+  readPortalItem(e, i, t) {
+    const { itemId: o, layerType: a } = i;
+    if (a === "GroupLayer" && o)
+      return new _({ id: o, portal: t == null ? void 0 : t.portal });
+  }
+  writePortalItem(e, i) {
+    e != null && e.id && (i.itemId = e.id);
+  }
+  set visibilityMode(e) {
+    const i = this._get("visibilityMode") !== e;
+    this._set("visibilityMode", e), i && this._enforceVisibility(e, this.visible);
+  }
+  async beforeSave() {
+    return j(this);
+  }
+  load(e) {
+    const i = this.loadFromPortal({ supportedTypes: ["Feature Service", "Feature Collection", "Group Layer", "Scene Service"], layerModuleTypeMap: H }, e).catch((t) => {
+      if (I(t), this.sourceIsPortalItem)
+        throw t;
+    });
+    return this.addResolvingPromise(i), Promise.resolve(this);
+  }
+  async loadAll() {
+    return L(this, (e) => {
+      e(this.layers, this.tables);
+    });
+  }
+  async save(e) {
+    return this._debouncedSaveOperations(d.SAVE, e);
+  }
+  async saveAs(e, i) {
+    return this._debouncedSaveOperations(d.SAVE_AS, i, e);
+  }
+  layerAdded(e) {
+    e.visible && this.visibilityMode === "exclusive" ? this._turnOffOtherLayers(e) : this.visibilityMode === "inherited" && (e.visible = this.visible), this.hasHandles(e.uid) ? console.error(`Layer read to Grouplayer: uid=${e.uid}`) : this.addHandles(y(() => e.visible, (i) => this._onChildVisibilityChange(e, i), u), e.uid);
+  }
+  layerRemoved(e) {
+    this.removeHandles(e.uid), this._enforceVisibility(this.visibilityMode, this.visible);
+  }
+  _turnOffOtherLayers(e) {
+    this.layers.forEach((i) => {
+      i !== e && (i.visible = !1);
+    });
+  }
+  _enforceVisibility(e, i) {
+    if (!O(this).initialized)
+      return;
+    const t = this.layers;
+    let o = t.find((a) => a.visible);
+    switch (e) {
+      case "exclusive":
+        t.length && !o && (o = t.at(0), o.visible = !0), this._turnOffOtherLayers(o);
+        break;
+      case "inherited":
+        t.forEach((a) => {
+          a.visible = i;
+        });
+    }
+  }
+  _onVisibilityChange(e) {
+    this.visibilityMode === "inherited" && this.layers.forEach((i) => {
+      i.visible = e;
+    });
+  }
+  _onChildVisibilityChange(e, i) {
+    switch (this.visibilityMode) {
+      case "exclusive":
+        i ? this._turnOffOtherLayers(e) : this._isAnyLayerVisible() || (e.visible = !0);
+        break;
+      case "inherited":
+        e.visible = this.visible;
+    }
+  }
+  _isAnyLayerVisible() {
+    return this.layers.some((e) => e.visible);
+  }
+};
+r([l({ readOnly: !0, dependsOn: [] })], s.prototype, "allLayers", void 0), r([l({ readOnly: !0 })], s.prototype, "allTables", void 0), r([l({ json: { read: !0, write: !0 } })], s.prototype, "blendMode", void 0), r([l()], s.prototype, "fullExtent", void 0), r([l({ readOnly: !0 })], s.prototype, "sourceIsPortalItem", null), r([l({ json: { read: !1, write: { ignoreOrigin: !0 } } })], s.prototype, "layers", void 0), r([h("layers")], s.prototype, "_writeLayers", null), r([l({ type: ["GroupLayer"] })], s.prototype, "operationalLayerType", void 0), r([l({ json: { origins: { "web-map": { read: !1, write: { overridePolicy(e, i, t) {
+  return { enabled: (e == null ? void 0 : e.type) === "Group Layer" && (t == null ? void 0 : t.initiator) !== this };
+} } }, "web-scene": { read: !1, write: !1 } } } })], s.prototype, "portalItem", null), r([S("web-map", "portalItem", ["itemId"])], s.prototype, "readPortalItem", null), r([h("web-map", "portalItem", { itemId: { type: String } })], s.prototype, "writePortalItem", null), r([l()], s.prototype, "spatialReference", void 0), r([l({ json: { read: !1 }, readOnly: !0, value: "group" })], s.prototype, "type", void 0), r([l({ type: ["independent", "inherited", "exclusive"], value: "independent", json: { write: !0, origins: { "web-map": { type: ["independent", "exclusive"], write: (e, i, t) => {
+  e !== "inherited" && (i[t] = e);
+} } } } })], s.prototype, "visibilityMode", null), s = r([$("esri.layers.GroupLayer")], s);
+const te = s;
+export {
+  te as default
+};

package/dist/GroupLayerView2D-ffcde606.js

@@ -0,0 +1,98 @@
+import { e as l, y as a, F as o, c as d, V as p, o as y, eD as h, E as V } from "./index-01c737ed.js";
+import { u as w, m as v } from "./LayerView-036988a9.js";
+import "vue";
+import "./scaleUtils-bdf8b6cb.js";
+import "./Container-ac97765a.js";
+import "./parser-0701286c.js";
+import "./highlightReasons-de432106.js";
+import "./definitions-a00a3a6c.js";
+import "./enums-2c166c09.js";
+import "./Texture-22a8cca5.js";
+let t = class extends w {
+  constructor(i) {
+    super(i), this.type = "group", this.layerViews = new p();
+  }
+  destroy() {
+    this.layerViews.length = 0;
+  }
+  _allLayerViewVisibility(i) {
+    this.layerViews.forEach((e) => {
+      e.visible = i;
+    });
+  }
+  initialize() {
+    this.addHandles([this.layerViews.on("change", (i) => this._layerViewsChangeHandler(i)), y(() => {
+      var i;
+      return (i = this.layer) == null ? void 0 : i.visibilityMode;
+    }, () => {
+      this.layer && this._applyVisibility(() => this._allLayerViewVisibility(this.visible), () => this._applyExclusiveVisibility(null));
+    }, h), y(() => this.visible, (i) => {
+      this._applyVisibility(() => this._allLayerViewVisibility(i), () => {
+      });
+    }, h)], "grouplayerview"), this._layerViewsChangeHandler({ target: null, added: this.layerViews.toArray(), removed: [], moved: [] });
+  }
+  set layerViews(i) {
+    this._set("layerViews", V(i, this._get("layerViews")));
+  }
+  get updatingProgress() {
+    return this.layerViews.length === 0 ? 1 : this.layerViews.reduce((i, e) => i + e.updatingProgress, 0) / this.layerViews.length;
+  }
+  isUpdating() {
+    return this.layerViews.some((i) => i.updating);
+  }
+  _hasLayerViewVisibleOverrides() {
+    return this.layerViews.some((i) => i._isOverridden("visible"));
+  }
+  _findLayerViewForLayer(i) {
+    return i && this.layerViews.find((e) => e.layer === i);
+  }
+  _firstVisibleOnLayerOrder() {
+    const i = this.layer.layers.find((e) => {
+      const s = this._findLayerViewForLayer(e);
+      return !!(s != null && s.visible);
+    });
+    return i && this._findLayerViewForLayer(i);
+  }
+  _applyExclusiveVisibility(i) {
+    i == null && (i = this._firstVisibleOnLayerOrder()) == null && this.layerViews.length > 0 && (i = this._findLayerViewForLayer(this.layer.layers.at(0))), this.layerViews.forEach((e) => {
+      e.visible = e === i;
+    });
+  }
+  _layerViewsChangeHandler(i) {
+    this.removeHandles("grouplayerview:visible"), this.addHandles(this.layerViews.map((s) => y(() => s.visible, (r) => this._applyVisibility(() => {
+      r !== this.visible && (s.visible = this.visible);
+    }, () => this._applyExclusiveVisibility(r ? s : null)), h)).toArray(), "grouplayerview:visible");
+    const e = i.added[i.added.length - 1];
+    this._applyVisibility(() => this._allLayerViewVisibility(this.visible), () => this._applyExclusiveVisibility(e != null && e.visible ? e : null));
+  }
+  _applyVisibility(i, e) {
+    var s, r;
+    this._hasLayerViewVisibleOverrides() && (((s = this.layer) == null ? void 0 : s.visibilityMode) === "inherited" ? i() : ((r = this.layer) == null ? void 0 : r.visibilityMode) === "exclusive" && e());
+  }
+};
+l([a({ cast: o })], t.prototype, "layerViews", null), l([a({ readOnly: !0 })], t.prototype, "updatingProgress", null), l([a()], t.prototype, "view", void 0), t = l([d("esri.views.layers.GroupLayerView")], t);
+const u = t;
+let n = class extends v(u) {
+  attach() {
+    this._updateStageChildren(), this.addAttachHandles(this.layerViews.on("after-changes", () => this._updateStageChildren()));
+  }
+  detach() {
+    this.container.removeAllChildren();
+  }
+  update(i) {
+  }
+  moveStart() {
+  }
+  viewChange() {
+  }
+  moveEnd() {
+  }
+  _updateStageChildren() {
+    this.container.removeAllChildren(), this.layerViews.forEach((i, e) => this.container.addChildAt(i.container, e));
+  }
+};
+n = l([d("esri.views.2d.layers.GroupLayerView2D")], n);
+const O = n;
+export {
+  O as default
+};

package/dist/HUDMaterial.glsl-b0a3e0ce.js

@@ -0,0 +1,65 @@
+import "./index-01c737ed.js";
+import "./vec4f64-043e974c.js";
+import "./VertexColor.glsl-e415cf02.js";
+import "./mat4f64-cce69db4.js";
+import "./BindType-5e76c8e1.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./VertexAttribute-faad30bf.js";
+import "./vec42-36edeb73.js";
+import { F as co, D as lo } from "./InteractiveAnalysisViewModel-b046fcb9.js";
+import "vue";
+import "./enums-2c166c09.js";
+import "./Texture-22a8cca5.js";
+import "./Util-002f5109.js";
+import "./mat3f64-03233387.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./Indices-e6dc3b15.js";
+import "./triangle-8a3a2ba8.js";
+import "./ObjectStack-10d91171.js";
+import "./lineSegment-3aa941f5.js";
+import "./plane-3398eec1.js";
+import "./quatf64-bec1af25.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./lengthUtils-695e744c.js";
+import "./requestImageUtils-37d79281.js";
+import "./sphere-908cd9aa.js";
+import "./orientedBoundingBox-554ccdc6.js";
+import "./quat-a508aed3.js";
+import "./computeTranslationToOriginAndRotation-4876cb93.js";
+import "./BufferView-004ad517.js";
+import "./geometryEngineBase-527e8b63.js";
+import "./colorUtils-54f4b662.js";
+import "./projectVectorToVector-5163db7a.js";
+import "./projectPointToVector-7dc831a9.js";
+import "./elevationInfoUtils-5456a079.js";
+import "./unitConversionUtils-f0ebaf75.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-78797046.js";
+import "./DoubleArray-5076283e.js";
+import "./glUtil-8f8bce6b.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-32973c8a.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-07998745.js";
+import "./BufferObject-cbd0168e.js";
+import "./axisAngleDegrees-32643b7c.js";
+import "./RenderState-b244097f.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-516d7961.js";
+import "./MemCache-a9232ec2.js";
+import "./Scheduler-eacc84bb.js";
+import "./vec3f32-304a6a9c.js";
+import "./MeasurementWidgetContent-e4888ef2.js";
+import "./meshVertexSpaceUtils-6efe3dcc.js";
+import "./MeshLocalVertexSpace-00151564.js";
+import "./vec3-f79c600d.js";
+import "./quantityUtils-5cd4cf90.js";
+import "./FeatureFilter-8c5e44b1.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-d3bb2fd6.js";
+import "./hydrated-0e1c7565.js";
+export {
+  co as build,
+  lo as calculateAnchorPosForRendering
+};

package/dist/HighlightCounter-e18f0179.js

@@ -0,0 +1,41 @@
+import { l as r } from "./highlightReasons-de432106.js";
+class l {
+  constructor() {
+    this._idToCounters = /* @__PURE__ */ new Map();
+  }
+  get empty() {
+    return this._idToCounters.size === 0;
+  }
+  addReason(s, t) {
+    for (const o of s) {
+      let e = this._idToCounters.get(o);
+      e || (e = /* @__PURE__ */ new Map(), this._idToCounters.set(o, e)), e.set(t, (e.get(t) || 0) + 1);
+    }
+  }
+  deleteReason(s, t) {
+    for (const o of s) {
+      const e = this._idToCounters.get(o);
+      if (!e)
+        continue;
+      let n = e.get(t);
+      if (n == null)
+        return;
+      n--, n > 0 ? e.set(t, n) : e.delete(t), e.size === 0 && this._idToCounters.delete(o);
+    }
+  }
+  getHighestReason(s) {
+    const t = this._idToCounters.get(s);
+    if (!t)
+      return null;
+    let o = null;
+    for (const e of r)
+      t.get(e) && (o = e);
+    return o || null;
+  }
+  ids() {
+    return this._idToCounters.keys();
+  }
+}
+export {
+  l as t
+};

package/dist/HighlightGraphicContainer-fd774cea.js

@@ -0,0 +1,18 @@
+import { e as i, c as s } from "./index-01c737ed.js";
+import { E as a, a as h, R as o } from "./Container-ac97765a.js";
+import { i as n } from "./AGraphicContainer-98a4c8a4.js";
+let t = class extends n {
+  get hasHighlight() {
+    return this.children.some((e) => e.hasData);
+  }
+  renderChildren(e) {
+    this.attributeView.update(), e.drawPhase === a.HIGHLIGHT && this.children.some((r) => r.hasData) && (super.renderChildren(e), e.context.setColorMask(!0, !0, !0, !0), h(e, !0, (r) => {
+      this._renderChildren(r, o.All);
+    }));
+  }
+};
+t = i([s("esri.views.2d.layers.support.HighlightGraphicContainer")], t);
+const m = t;
+export {
+  m as h
+};

package/dist/I3SBinaryReader-190e99de.js

@@ -0,0 +1,310 @@
+import { W as f, s as D, bz as S } from "./index-01c737ed.js";
+import { e as U } from "./VertexAttribute-faad30bf.js";
+const d = !0, m = { identifierOffset: 0, identifierLength: 10, versionOffset: 10, checksumOffset: 12, byteCount: 16 };
+function L(t, e, r) {
+  return { identifier: String.fromCharCode.apply(null, new Uint8Array(t, r + m.identifierOffset, m.identifierLength)), version: e.getUint16(r + m.versionOffset, d), checksum: e.getUint32(r + m.checksumOffset, d) };
+}
+const w = { sizeLo: 0, sizeHi: 4, minX: 8, minY: 16, minZ: 24, maxX: 32, maxY: 40, maxZ: 48, errorX: 56, errorY: 64, errorZ: 72, count: 80, reserved: 84, byteCount: 88 };
+function k(t, e) {
+  return { sizeLo: t.getUint32(e + w.sizeLo, d), sizeHi: t.getUint32(e + w.sizeHi, d), minX: t.getFloat64(e + w.minX, d), minY: t.getFloat64(e + w.minY, d), minZ: t.getFloat64(e + w.minZ, d), maxX: t.getFloat64(e + w.maxX, d), maxY: t.getFloat64(e + w.maxY, d), maxZ: t.getFloat64(e + w.maxZ, d), errorX: t.getFloat64(e + w.errorX, d), errorY: t.getFloat64(e + w.errorY, d), errorZ: t.getFloat64(e + w.errorZ, d), count: t.getUint32(e + w.count, d), reserved: t.getUint32(e + w.reserved, d) };
+}
+function q(t) {
+  const e = new DataView(t, 0);
+  let r = 0;
+  const { identifier: c, version: o } = L(t, e, r);
+  if (r += m.byteCount, c !== "LEPCC     ")
+    throw new f("lepcc-decode-error", "Bad identifier");
+  if (o > 1)
+    throw new f("lepcc-decode-error", "Unknown version");
+  const n = k(e, r);
+  if (r += w.byteCount, n.sizeHi * 2 ** 32 + n.sizeLo !== t.byteLength)
+    throw new f("lepcc-decode-error", "Bad size");
+  const s = new Float64Array(3 * n.count), a = [], i = [], u = [], l = [];
+  if (r = I(t, r, a), r = I(t, r, i), r = I(t, r, u), r = I(t, r, l), r !== t.byteLength)
+    throw new f("lepcc-decode-error", "Bad length");
+  let g = 0, y = 0;
+  for (let b = 0; b < a.length; b++) {
+    y += a[b];
+    let v = 0;
+    for (let C = 0; C < i[b]; C++) {
+      v += u[g];
+      const P = l[g];
+      s[3 * g] = Math.min(n.maxX, n.minX + 2 * n.errorX * v), s[3 * g + 1] = Math.min(n.maxY, n.minY + 2 * n.errorY * y), s[3 * g + 2] = Math.min(n.maxZ, n.minZ + 2 * n.errorZ * P), g++;
+    }
+  }
+  return { errorX: n.errorX, errorY: n.errorY, errorZ: n.errorZ, result: s };
+}
+function I(t, e, r) {
+  const c = [];
+  e = z(t, e, c);
+  const o = [];
+  for (let n = 0; n < c.length; n++) {
+    o.length = 0, e = z(t, e, o);
+    for (let s = 0; s < o.length; s++)
+      r.push(o[s] + c[n]);
+  }
+  return e;
+}
+function z(t, e, r) {
+  const c = new DataView(t, e), o = c.getUint8(0), n = 31 & o, s = !!(32 & o), a = (192 & o) >> 6;
+  let i = 0;
+  if (a === 0)
+    i = c.getUint32(1, d), e += 5;
+  else if (a === 1)
+    i = c.getUint16(1, d), e += 3;
+  else {
+    if (a !== 2)
+      throw new f("lepcc-decode-error", "Bad count type");
+    i = c.getUint8(1), e += 2;
+  }
+  if (s)
+    throw new f("lepcc-decode-error", "LUT not implemented");
+  const u = Math.ceil(i * n / 8), l = new Uint8Array(t, e, u);
+  let g = 0, y = 0, b = 0;
+  const v = -1 >>> 32 - n;
+  for (let C = 0; C < i; C++) {
+    for (; y < n; )
+      g |= l[b] << y, y += 8, b += 1;
+    r[C] = g & v, g >>>= n, y -= n, y + n > 32 && (g |= l[b - 1] >> 8 - y);
+  }
+  return e + b;
+}
+const h = { sizeLo: 0, sizeHi: 4, count: 8, colorMapCount: 12, lookupMethod: 14, compressionMethod: 15, byteCount: 16 };
+function Y(t, e) {
+  return { sizeLo: t.getUint32(e + h.sizeLo, d), sizeHi: t.getUint32(e + h.sizeHi, d), count: t.getUint32(e + h.count, d), colorMapCount: t.getUint16(e + h.colorMapCount, d), lookupMethod: t.getUint8(e + h.lookupMethod), compressionMethod: t.getUint8(e + h.compressionMethod) };
+}
+function V(t) {
+  const e = new DataView(t, 0);
+  let r = 0;
+  const { identifier: c, version: o } = L(t, e, r);
+  if (r += m.byteCount, c !== "ClusterRGB")
+    throw new f("lepcc-decode-error", "Bad identifier");
+  if (o > 1)
+    throw new f("lepcc-decode-error", "Unknown version");
+  const n = Y(e, r);
+  if (r += h.byteCount, n.sizeHi * 2 ** 32 + n.sizeLo !== t.byteLength)
+    throw new f("lepcc-decode-error", "Bad size");
+  if ((n.lookupMethod === 2 || n.lookupMethod === 1) && n.compressionMethod === 0) {
+    if (3 * n.colorMapCount + n.count + r !== t.byteLength || n.colorMapCount > 256)
+      throw new f("lepcc-decode-error", "Bad count");
+    const s = new Uint8Array(t, r, 3 * n.colorMapCount), a = new Uint8Array(t, r + 3 * n.colorMapCount, n.count), i = new Uint8Array(3 * n.count);
+    for (let u = 0; u < n.count; u++) {
+      const l = a[u];
+      i[3 * u] = s[3 * l], i[3 * u + 1] = s[3 * l + 1], i[3 * u + 2] = s[3 * l + 2];
+    }
+    return i;
+  }
+  if (n.lookupMethod === 0 && n.compressionMethod === 0) {
+    if (3 * n.count + r !== t.byteLength || n.colorMapCount !== 0)
+      throw new f("lepcc-decode-error", "Bad count");
+    return new Uint8Array(t, r).slice();
+  }
+  if (n.lookupMethod <= 2 && n.compressionMethod === 1) {
+    if (r + 3 !== t.byteLength || n.colorMapCount !== 1)
+      throw new f("lepcc-decode-error", "Bad count");
+    const s = e.getUint8(r), a = e.getUint8(r + 1), i = e.getUint8(r + 2), u = new Uint8Array(3 * n.count);
+    for (let l = 0; l < n.count; l++)
+      u[3 * l] = s, u[3 * l + 1] = a, u[3 * l + 2] = i;
+    return u;
+  }
+  throw new f("lepcc-decode-error", "Bad method " + n.lookupMethod + "," + n.compressionMethod);
+}
+const p = { sizeLo: 0, sizeHi: 4, count: 8, scaleFactor: 12, bitsPerPoint: 14, reserved: 15, byteCount: 16 };
+function $(t, e) {
+  return { sizeLo: t.getUint32(e + p.sizeLo, d), sizeHi: t.getUint32(e + p.sizeHi, d), count: t.getUint32(e + p.count, d), scaleFactor: t.getUint16(e + p.scaleFactor, d), bitsPerPoint: t.getUint8(e + p.bitsPerPoint), reserved: t.getUint8(e + p.reserved) };
+}
+function X(t) {
+  const e = new DataView(t, 0);
+  let r = 0;
+  const { identifier: c, version: o } = L(t, e, r);
+  if (r += m.byteCount, c !== "Intensity ")
+    throw new f("lepcc-decode-error", "Bad identifier");
+  if (o > 1)
+    throw new f("lepcc-decode-error", "Unknown version");
+  const n = $(e, r);
+  if (r += p.byteCount, n.sizeHi * 2 ** 32 + n.sizeLo !== t.byteLength)
+    throw new f("lepcc-decode-error", "Bad size");
+  const s = new Uint16Array(n.count);
+  if (n.bitsPerPoint === 8) {
+    if (n.count + r !== t.byteLength)
+      throw new f("lepcc-decode-error", "Bad size");
+    const a = new Uint8Array(t, r, n.count);
+    for (let i = 0; i < n.count; i++)
+      s[i] = a[i] * n.scaleFactor;
+  } else if (n.bitsPerPoint === 16) {
+    if (2 * n.count + r !== t.byteLength)
+      throw new f("lepcc-decode-error", "Bad size");
+    const a = new Uint16Array(t, r, n.count);
+    for (let i = 0; i < n.count; i++)
+      s[i] = a[i] * n.scaleFactor;
+  } else {
+    const a = [];
+    if (z(t, r, a) !== t.byteLength)
+      throw new f("lepcc-decode-error", "Bad size");
+    for (let i = 0; i < n.count; i++)
+      s[i] = a[i] * n.scaleFactor;
+  }
+  return s;
+}
+const M = () => D.getLogger("esri.views.3d.layers.i3s.I3SBinaryReader");
+function Z(t, e, r) {
+  let c = "", o = 0;
+  for (; o < r; ) {
+    const n = t[e + o];
+    if (n < 128)
+      c += String.fromCharCode(n), o++;
+    else if (n >= 192 && n < 224) {
+      if (o + 1 >= r)
+        throw new f("utf8-decode-error", "UTF-8 Decode failed. Two byte character was truncated.");
+      const s = (31 & n) << 6 | 63 & t[e + o + 1];
+      c += String.fromCharCode(s), o += 2;
+    } else if (n >= 224 && n < 240) {
+      if (o + 2 >= r)
+        throw new f("utf8-decode-error", "UTF-8 Decode failed. Multi byte character was truncated.");
+      const s = (15 & n) << 12 | (63 & t[e + o + 1]) << 6 | 63 & t[e + o + 2];
+      c += String.fromCharCode(s), o += 3;
+    } else {
+      if (!(n >= 240 && n < 248))
+        throw new f("utf8-decode-error", "UTF-8 Decode failed. Invalid multi byte sequence.");
+      {
+        if (o + 3 >= r)
+          throw new f("utf8-decode-error", "UTF-8 Decode failed. Multi byte character was truncated.");
+        const s = (7 & n) << 18 | (63 & t[e + o + 1]) << 12 | (63 & t[e + o + 2]) << 6 | 63 & t[e + o + 3];
+        if (s >= 65536) {
+          const a = 55296 + (s - 65536 >> 10), i = 56320 + (1023 & s);
+          c += String.fromCharCode(a, i);
+        } else
+          c += String.fromCharCode(s);
+        o += 4;
+      }
+    }
+  }
+  return c;
+}
+function B(t, e) {
+  const r = { byteOffset: 0, byteCount: 0, fields: /* @__PURE__ */ Object.create(null) };
+  let c = 0;
+  for (let o = 0; o < e.length; o++) {
+    const n = e[o], s = n.valueType || n.type, a = _[s];
+    r.fields[n.property] = a(t, c), c += O[s].BYTES_PER_ELEMENT;
+  }
+  return r.byteCount = c, r;
+}
+function H(t, e, r) {
+  return T(t, e, r).map((c) => {
+    const o = c ? Date.parse(c) : null;
+    return o && !Number.isNaN(o) ? o : null;
+  });
+}
+function T(t, e, r) {
+  const c = [];
+  let o, n, s = 0;
+  for (n = 0; n < t; n += 1) {
+    if (o = e[n], o > 0) {
+      if (c.push(Z(r, s, o - 1)), r[s + o - 1] !== 0)
+        throw new f("string-array-error", "Invalid string array: missing null termination.");
+    } else
+      c.push(null);
+    s += o;
+  }
+  return c;
+}
+function F(t, e) {
+  return new O[e.valueType](t, e.byteOffset, e.count * e.valuesPerElement);
+}
+function N(t, e) {
+  return new Uint8Array(t, e.byteOffset, e.byteCount);
+}
+function j(t, e, r) {
+  const c = e.header != null ? B(t, e.header) : { byteOffset: 0, byteCount: 0, fields: { count: r } }, o = { header: c, byteOffset: c.byteCount, byteCount: 0, entries: /* @__PURE__ */ Object.create(null) };
+  let n = c.byteCount;
+  for (let s = 0; s < e.ordering.length; s++) {
+    const a = e.ordering[s], i = S(e[a]);
+    if (i.count = c.fields.count ?? 0, i.valueType === "String") {
+      if (i.byteOffset = n, i.byteCount = c.fields[a + "ByteCount"], i.encoding !== "UTF-8")
+        throw new f("unsupported-encoding", "Unsupported String encoding.", { encoding: i.encoding });
+      if (i.timeEncoding && i.timeEncoding !== "ECMA_ISO8601")
+        throw new f("unsupported-time-encoding", "Unsupported time encoding.", { timeEncoding: i.timeEncoding });
+    } else {
+      if (!x(i.valueType))
+        throw new f("unsupported-value-type", "Unsupported binary valueType", { valueType: i.valueType });
+      {
+        const u = A(i.valueType);
+        n += n % u != 0 ? u - n % u : 0, i.byteOffset = n, i.byteCount = u * i.valuesPerElement * i.count;
+      }
+    }
+    n += i.byteCount ?? 0, o.entries[a] = i;
+  }
+  return o.byteCount = n - o.byteOffset, o;
+}
+function E(t, e, r) {
+  if (e !== t && M().error(`Invalid ${r} buffer size
+ expected: ${t}, actual: ${e})`), e < t)
+    throw new f("buffer-too-small", "Binary buffer is too small", { expectedSize: t, actualSize: e });
+}
+function J(t, e) {
+  const r = B(t, e && e.header);
+  let c = r.byteCount;
+  const o = { isDraco: !1, header: r, byteOffset: r.byteCount, byteCount: 0, vertexAttributes: {} }, n = r.fields, s = n.vertexCount != null ? n.vertexCount : n.count;
+  for (const u of e.ordering) {
+    if (!e.vertexAttributes[u])
+      continue;
+    const l = { ...e.vertexAttributes[u], byteOffset: c, count: s }, g = R[u] || "_" + u;
+    o.vertexAttributes[g] = l, c += A(l.valueType) * l.valuesPerElement * s;
+  }
+  const a = n.faceCount;
+  if (e.faces && a) {
+    o.faces = {};
+    for (const u of e.ordering) {
+      if (!e.faces[u])
+        continue;
+      const l = { ...e.faces[u], byteOffset: c, count: a };
+      o.faces[u] = l, c += A(l.valueType) * l.valuesPerElement * a;
+    }
+  }
+  const i = n.featureCount;
+  if (e.featureAttributes && e.featureAttributeOrder && i) {
+    o.featureAttributes = {};
+    for (const u of e.featureAttributeOrder) {
+      if (!e.featureAttributes[u])
+        continue;
+      const l = { ...e.featureAttributes[u], byteOffset: c, count: i };
+      o.featureAttributes[u] = l, c += (l.valueType === "UInt64" ? 8 : A(l.valueType)) * l.valuesPerElement * i;
+    }
+  }
+  return E(c, t.byteLength, "geometry"), o.byteCount = c - o.byteOffset, o;
+}
+const R = { position: U.POSITION, normal: U.NORMAL, color: U.COLOR, uv0: U.UV0, region: U.UVREGION };
+function K(t, e, r) {
+  if (t.encoding === "lepcc-rgb")
+    return V(e);
+  if (t.encoding === "lepcc-intensity")
+    return X(e);
+  if (t.encoding != null && t.encoding !== "")
+    throw new f("unknown-attribute-storage-info-encoding", "Unknown Attribute Storage Info Encoding");
+  t["attributeByteCounts "] && !t.attributeByteCounts && (M().warn("Warning: Trailing space in 'attributeByteCounts '."), t.attributeByteCounts = t["attributeByteCounts "]), t.ordering[0] === "ObjectIds" && t.hasOwnProperty("objectIds") && (M().warn("Warning: Case error in objectIds"), t.ordering[0] = "objectIds");
+  const c = j(e, t, r);
+  E(c.byteOffset + c.byteCount, e.byteLength, "attribute");
+  const o = c.entries.attributeValues || c.entries.objectIds;
+  if (o) {
+    if (o.valueType === "String") {
+      const n = c.entries.attributeByteCounts, s = F(e, n), a = N(e, o);
+      return o.timeEncoding ? H(n.count, s, a) : T(n.count, s, a);
+    }
+    return F(e, o);
+  }
+  throw new f("bad-attribute-storage-info", "Bad attributeStorageInfo specification.");
+}
+const O = { Float32: Float32Array, Float64: Float64Array, UInt8: Uint8Array, Int8: Int8Array, UInt16: Uint16Array, Int16: Int16Array, UInt32: Uint32Array, Int32: Int32Array }, _ = { Float32: (t, e) => new DataView(t, 0).getFloat32(e, !0), Float64: (t, e) => new DataView(t, 0).getFloat64(e, !0), UInt8: (t, e) => new DataView(t, 0).getUint8(e), Int8: (t, e) => new DataView(t, 0).getInt8(e), UInt16: (t, e) => new DataView(t, 0).getUint16(e, !0), Int16: (t, e) => new DataView(t, 0).getInt16(e, !0), UInt32: (t, e) => new DataView(t, 0).getUint32(e, !0), Int32: (t, e) => new DataView(t, 0).getInt32(e, !0) };
+function x(t) {
+  return O.hasOwnProperty(t);
+}
+function A(t) {
+  return x(t) ? O[t].BYTES_PER_ELEMENT : 0;
+}
+export {
+  K as I,
+  q as c,
+  F as l,
+  J as w
+};