@agrotools1/at-components 0.6.16 → 0.6.18

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10_@floating-ui_utils@0.2.5/node_modules/@arcgis/core/views/3d/webgl-engine/lib/Object3D.js

@@ -0,0 +1,175 @@
+import { copy as u, multiply as g, hasIdentityRotation as L } from "../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { IDENTITY as C, create as d } from "../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { m as B, e as h, q as $, s as D, g as f, j as U, c as b } from "../../../../chunks/vec32.js";
+import { fromValues as _, create as l } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { g as p, c as W } from "../../../../chunks/sphere.js";
+import { maxScale as E } from "../../support/mathUtils.js";
+import { Object3DState as v } from "./basicInterfaces.js";
+import { ContentObject as G } from "./ContentObject.js";
+import { ContentObjectType as w } from "./ContentObjectType.js";
+import { Object3DStateID as y } from "./Object3DStateID.js";
+import { assert as I } from "./Util.js";
+import { affectsGeometry as N } from "./VertexAttribute.js";
+import { addObject3DStateID as S, removeObject3DStateID as O } from "../materials/renderers/utils.js";
+let it = class extends G {
+  get geometries() {
+    return this._geometries;
+  }
+  get transformation() {
+    return this._transformation ?? C;
+  }
+  set transformation(t) {
+    this._transformation = u(this._transformation ?? d(), t), this._invalidateBoundingVolume(), this._emit("transformationChanged", this);
+  }
+  get shaderTransformation() {
+    return this._shaderTransformation;
+  }
+  set shaderTransformation(t) {
+    this._shaderTransformation = t ? u(this._shaderTransformation ?? d(), t) : null, this._invalidateBoundingVolume(), this._emit("shaderTransformationChanged", this);
+  }
+  get effectiveTransformation() {
+    return this.shaderTransformation ?? this.transformation;
+  }
+  constructor(t = {}) {
+    super(), this.type = w.Object, this._shaderTransformation = null, this._parentLayer = null, this._visible = !0, this.castShadow = t.castShadow ?? !0, this.usesVerticalDistanceToGround = t.usesVerticalDistanceToGround ?? !1, this.graphicUid = t.graphicUid, this.layerUid = t.layerUid, t.isElevationSource && (this.lastValidElevationBB = new V()), this._geometries = t.geometries ? Array.from(t.geometries) : new Array();
+  }
+  dispose() {
+    this._geometries.length = 0;
+  }
+  get parentLayer() {
+    return this._parentLayer;
+  }
+  set parentLayer(t) {
+    I(this._parentLayer == null || t == null, "Object3D can only be added to a single Layer"), this._parentLayer = t;
+  }
+  addGeometry(t) {
+    t.visible = this._visible, this._geometries.push(t), this._emit("geometryAdded", { object: this, geometry: t }), this._invalidateBoundingVolume();
+  }
+  removeGeometry(t) {
+    const e = this._geometries.splice(t, 1)[0];
+    e && (this._emit("geometryRemoved", { object: this, geometry: e }), this._invalidateBoundingVolume());
+  }
+  removeAllGeometries() {
+    for (; this._geometries.length > 0; )
+      this.removeGeometry(0);
+  }
+  geometryVertexAttributeUpdated(t, e, m = !1) {
+    this._emit("attributesChanged", { object: this, geometry: t, attribute: e, sync: m }), N(e) && this._invalidateBoundingVolume();
+  }
+  get visible() {
+    return this._visible;
+  }
+  set visible(t) {
+    if (this._visible !== t) {
+      this._visible = t;
+      for (const e of this._geometries)
+        e.visible = this._visible;
+      this._emit("visibilityChanged", this);
+    }
+  }
+  maskOccludee() {
+    const t = new y(v.MaskOccludee);
+    for (const e of this._geometries)
+      e.occludees = S(e.occludees, t);
+    return this._emit("occlusionChanged", this), t;
+  }
+  removeOcclude(t) {
+    for (const e of this._geometries)
+      e.occludees = O(e.occludees, t);
+    this._emit("occlusionChanged", this);
+  }
+  highlight() {
+    const t = new y(v.Highlight);
+    for (const e of this._geometries)
+      e.highlights = S(e.highlights, t);
+    return this._emit("highlightChanged", this), t;
+  }
+  removeHighlight(t) {
+    for (const e of this._geometries)
+      e.highlights = O(e.highlights, t);
+    this._emit("highlightChanged", this);
+  }
+  getCombinedStaticTransformation(t, e) {
+    return g(e, this.transformation, t.transformation);
+  }
+  getCombinedShaderTransformation(t, e = d()) {
+    return g(e, this.effectiveTransformation, t.transformation);
+  }
+  get boundingVolumeWorldSpace() {
+    return this._bvWorldSpace || (this._bvWorldSpace = this._bvWorldSpace || new x(), this._validateBoundingVolume(this._bvWorldSpace, c.WorldSpace)), this._bvWorldSpace;
+  }
+  get boundingVolumeObjectSpace() {
+    return this._bvObjectSpace || (this._bvObjectSpace = this._bvObjectSpace || new x(), this._validateBoundingVolume(this._bvObjectSpace, c.ObjectSpace)), this._bvObjectSpace;
+  }
+  _validateBoundingVolume(t, e) {
+    const m = e === c.ObjectSpace;
+    for (const o of this._geometries) {
+      const i = o.boundingInfo;
+      i && X(i, t, m ? o.transformation : this.getCombinedShaderTransformation(o));
+    }
+    B(p(t.bounds), t.min, t.max, 0.5);
+    for (const o of this._geometries) {
+      const i = o.boundingInfo;
+      if (i == null)
+        continue;
+      const s = m ? o.transformation : this.getCombinedShaderTransformation(o), T = E(s);
+      h(j, i.center, s);
+      const A = $(j, p(t.bounds)), M = i.radius * T;
+      t.bounds[3] = Math.max(t.bounds[3], A + M);
+    }
+  }
+  _invalidateBoundingVolume() {
+    var e;
+    const t = (e = this._bvWorldSpace) == null ? void 0 : e.bounds;
+    this._bvObjectSpace = this._bvWorldSpace = void 0, this._parentLayer && t && this._parentLayer.notifyObjectBBChanged(this, t);
+  }
+  _emit(t, e) {
+    this._parentLayer && this._parentLayer.events.emit(t, e);
+  }
+  get test() {
+    const t = this;
+    return { hasGeometry: (e) => t._geometries.includes(e), getGeometryIndex: (e) => t._geometries.indexOf(e) };
+  }
+};
+class V {
+  constructor() {
+    this.min = _(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this.max = _(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+  }
+  isEmpty() {
+    return this.max[0] < this.min[0] && this.max[1] < this.min[1] && this.max[2] < this.min[2];
+  }
+}
+class x extends V {
+  constructor() {
+    super(...arguments), this.bounds = W();
+  }
+}
+function X(n, t, e) {
+  const m = n.bbMin, o = n.bbMax;
+  if (L(e)) {
+    const i = D(H, e[12], e[13], e[14]);
+    f(r, m, i), f(a, o, i);
+    for (let s = 0; s < 3; ++s)
+      t.min[s] = Math.min(t.min[s], r[s]), t.max[s] = Math.max(t.max[s], a[s]);
+  } else if (h(r, m, e), U(m, o))
+    for (let i = 0; i < 3; ++i)
+      t.min[i] = Math.min(t.min[i], r[i]), t.max[i] = Math.max(t.max[i], r[i]);
+  else {
+    h(a, o, e);
+    for (let i = 0; i < 3; ++i)
+      t.min[i] = Math.min(t.min[i], r[i], a[i]), t.max[i] = Math.max(t.max[i], r[i], a[i]);
+    for (let i = 0; i < 3; ++i) {
+      b(r, m), b(a, o), r[i] = o[i], a[i] = m[i], h(r, r, e), h(a, a, e);
+      for (let s = 0; s < 3; ++s)
+        t.min[s] = Math.min(t.min[s], r[s], a[s]), t.max[s] = Math.max(t.max[s], r[s], a[s]);
+    }
+  }
+}
+const H = l(), r = l(), a = l(), j = l();
+var c;
+(function(n) {
+  n[n.WorldSpace = 0] = "WorldSpace", n[n.ObjectSpace = 1] = "ObjectSpace";
+})(c || (c = {}));
+export {
+  it as Object3D
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10_@floating-ui_utils@0.2.5/node_modules/@arcgis/core/views/3d/webgl-engine/lib/Object3DStateSet.js

@@ -0,0 +1,57 @@
+import { Object3DState as c } from "./basicInterfaces.js";
+var s;
+(function(r) {
+  r[r.Object = 0] = "Object", r[r.RenderGeometry = 1] = "RenderGeometry", r[r.External = 2] = "External", r[r.COUNT = 3] = "COUNT";
+})(s || (s = {}));
+class i {
+  constructor() {
+    this._items = [];
+  }
+  addObject(e, t) {
+    this._items.push({ type: s.Object, objectStateId: t, object: e });
+  }
+  addRenderGeometry(e, t, o) {
+    this._items.push({ type: s.RenderGeometry, objectStateId: t, renderGeometry: e, owner: o });
+  }
+  addExternal(e, t) {
+    this._items.push({ type: s.External, objectStateId: t, remove: e });
+  }
+  remove(e) {
+    for (let t = this._items.length - 1; t >= 0; --t) {
+      const o = this._items[t];
+      o.objectStateId === e && (this._removeObjectStateItem(o), this._items.splice(t, 1));
+    }
+  }
+  removeObject(e) {
+    for (let t = this._items.length - 1; t >= 0; --t) {
+      const o = this._items[t];
+      o.type === s.Object && o.object === e && (this._removeObjectStateItem(o), this._items.splice(t, 1));
+    }
+  }
+  removeRenderGeometry(e) {
+    for (let t = this._items.length - 1; t >= 0; --t) {
+      const o = this._items[t];
+      o.type === s.RenderGeometry && o.renderGeometry === e && (this._removeObjectStateItem(o), this._items.splice(t, 1));
+    }
+  }
+  removeAll() {
+    this._items.forEach((e) => {
+      this._removeObjectStateItem(e);
+    }), this._items = [];
+  }
+  _removeObjectStateItem(e) {
+    switch (e.type) {
+      case s.Object:
+        e.objectStateId.channel === c.Highlight ? e.object.removeHighlight(e.objectStateId) : e.objectStateId.channel === c.MaskOccludee && e.object.removeOcclude(e.objectStateId);
+        break;
+      case s.RenderGeometry:
+        e.owner.removeRenderGeometryObjectState(e.renderGeometry, e.objectStateId);
+        break;
+      case s.External:
+        e.remove(e.objectStateId);
+    }
+  }
+}
+export {
+  i as Object3DStateSet
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10_@floating-ui_utils@0.2.5/node_modules/@arcgis/core/views/3d/webgl-engine/lib/Octree.js

@@ -0,0 +1,422 @@
+import it from "../../../../core/ObjectPool.js";
+import R from "../../../../core/PooledArray.js";
+import { h as P, g as q, a as J, c as V, m as st } from "../../../../chunks/vec32.js";
+import { create as K, fromValues as _ } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { intersectsSphere as F } from "../../../../geometry/support/frustum.js";
+import { wrap as G } from "../../../../geometry/support/ray.js";
+import { a as w, g as f, b as y, j as U, c as M } from "../../../../chunks/sphere.js";
+import { rayBoxTest as Z } from "./Util.js";
+class E {
+  get bounds() {
+    return this._root.bounds;
+  }
+  get halfSize() {
+    return this._root.halfSize;
+  }
+  get root() {
+    return this._root.node;
+  }
+  get maximumObjectsPerNode() {
+    return this._maximumObjectsPerNode;
+  }
+  get maximumDepth() {
+    return this._maximumDepth;
+  }
+  get objectCount() {
+    return this._objectCount;
+  }
+  constructor(t, e) {
+    this.objectToBoundingSphere = t, this._maximumObjectsPerNode = 10, this._maximumDepth = 20, this._degenerateObjects = /* @__PURE__ */ new Set(), this._root = new d(), this._objectCount = 0, e && (e.maximumObjectsPerNode !== void 0 && (this._maximumObjectsPerNode = e.maximumObjectsPerNode), e.maximumDepth !== void 0 && (this._maximumDepth = e.maximumDepth));
+  }
+  destroy() {
+    this._degenerateObjects.clear(), d.clearPool(), H[0] = null, T.prune(), z.prune();
+  }
+  add(t, e = t.length) {
+    this._objectCount += e, this._grow(t, e);
+    const o = d.acquire();
+    for (let n = 0; n < e; n++) {
+      const i = t[n];
+      this._isDegenerate(i) ? this._degenerateObjects.add(i) : (o.init(this._root), this._add(i, o));
+    }
+    d.release(o);
+  }
+  remove(t, e = null) {
+    this._objectCount -= t.length;
+    const o = d.acquire();
+    for (const n of t) {
+      const i = e ?? w(this.objectToBoundingSphere(n), lt);
+      A(i[3]) ? (o.init(this._root), this._remove(n, i, o)) : this._degenerateObjects.delete(n);
+    }
+    d.release(o), this._shrink();
+  }
+  update(t, e) {
+    if (!A(e[3]) && this._isDegenerate(t))
+      return;
+    const o = dt(t);
+    this.remove(o, e), this.add(o);
+  }
+  forEachAlongRay(t, e, o) {
+    const n = G(t, e);
+    this._forEachNode(this._root, (i) => {
+      if (!this._intersectsNode(n, i))
+        return !1;
+      const h = i.node;
+      return h.terminals.forAll((a) => {
+        this._intersectsObject(n, a) && o(a);
+      }), h.residents !== null && h.residents.forAll((a) => {
+        this._intersectsObject(n, a) && o(a);
+      }), !0;
+    });
+  }
+  forEachAlongRayWithVerticalOffset(t, e, o, n) {
+    const i = G(t, e);
+    this._forEachNode(this._root, (h) => {
+      if (!this._intersectsNodeWithOffset(i, h, n))
+        return !1;
+      const a = h.node;
+      return a.terminals.forAll((s) => {
+        this._intersectsObjectWithOffset(i, s, n) && o(s);
+      }), a.residents !== null && a.residents.forAll((s) => {
+        this._intersectsObjectWithOffset(i, s, n) && o(s);
+      }), !0;
+    });
+  }
+  forEach(t) {
+    this._forEachNode(this._root, (e) => {
+      const o = e.node;
+      return o.terminals.forAll(t), o.residents !== null && o.residents.forAll(t), !0;
+    }), this._degenerateObjects.forEach(t);
+  }
+  forEachDegenerateObject(t) {
+    this._degenerateObjects.forEach(t);
+  }
+  findClosest(t, e, o, n = () => !0, i = 1 / 0) {
+    let h = 1 / 0, a = 1 / 0, s = null;
+    const u = I(t, e), m = (l) => {
+      if (--i, !n(l))
+        return;
+      const p = this.objectToBoundingSphere(l);
+      if (!F(o, p))
+        return;
+      const O = j(t, e, f(p)), D = O - p[3], c = O + p[3];
+      D < h && (h = D, a = c, s = l);
+    };
+    return this._forEachNodeDepthOrdered(this._root, (l) => {
+      if (i <= 0 || !F(o, l.bounds) || (P(S, u, l.halfSize), q(S, S, f(l.bounds)), j(t, e, S) > a))
+        return !1;
+      const p = l.node;
+      return p.terminals.forAll((O) => m(O)), p.residents !== null && p.residents.forAll((O) => m(O)), !0;
+    }, t, e), s;
+  }
+  forEachInDepthRange(t, e, o, n, i, h, a) {
+    let s = -1 / 0, u = 1 / 0;
+    const m = { setRange: (c) => {
+      o === E.DepthOrder.FRONT_TO_BACK ? (s = Math.max(s, c.near), u = Math.min(u, c.far)) : (s = Math.max(s, -c.far), u = Math.min(u, -c.near));
+    } };
+    m.setRange(n);
+    const l = j(e, o, t), p = I(e, o), O = I(e, -o), D = (c) => {
+      if (!a(c))
+        return;
+      const N = this.objectToBoundingSphere(c), B = f(N), W = j(e, o, B) - l, ot = W - N[3], nt = W + N[3];
+      ot > u || nt < s || !F(h, N) || i(c, m);
+    };
+    this._forEachNodeDepthOrdered(this._root, (c) => {
+      if (!F(h, c.bounds) || (P(S, p, c.halfSize), q(S, S, f(c.bounds)), j(e, o, S) - l > u) || (P(S, O, c.halfSize), q(S, S, f(c.bounds)), j(e, o, S) - l < s))
+        return !1;
+      const N = c.node;
+      return N.terminals.forAll((B) => D(B)), N.residents !== null && N.residents.forAll((B) => D(B)), !0;
+    }, e, o);
+  }
+  forEachNode(t) {
+    this._forEachNode(this._root, (e) => t(e.node, e.bounds, e.halfSize, e.depth));
+  }
+  forEachNeighbor(t, e) {
+    const o = y(e), n = f(e), i = (s) => {
+      const u = this.objectToBoundingSphere(s), m = y(u), l = o + m;
+      return !(J(f(u), n) - l * l <= 0) || t(s);
+    };
+    let h = !0;
+    const a = (s) => {
+      h && (h = i(s));
+    };
+    this._forEachNode(this._root, (s) => {
+      const u = y(s.bounds), m = o + u;
+      if (J(f(s.bounds), n) - m * m > 0)
+        return !1;
+      const l = s.node;
+      return l.terminals.forAll(a), h && l.residents !== null && l.residents.forAll(a), h;
+    }), h && this.forEachDegenerateObject(a);
+  }
+  _intersectsNode(t, e) {
+    return v(f(e.bounds), 2 * -e.halfSize, b), v(f(e.bounds), 2 * e.halfSize, g), Z(t.origin, t.direction, b, g);
+  }
+  _intersectsNodeWithOffset(t, e, o) {
+    return v(f(e.bounds), 2 * -e.halfSize, b), v(f(e.bounds), 2 * e.halfSize, g), o.applyToMinMax(b, g), Z(t.origin, t.direction, b, g);
+  }
+  _intersectsObject(t, e) {
+    const o = this.objectToBoundingSphere(e);
+    return !(o[3] > 0) || U(o, t);
+  }
+  _intersectsObjectWithOffset(t, e, o) {
+    const n = this.objectToBoundingSphere(e);
+    return !(n[3] > 0) || U(o.applyToBoundingSphere(n), t);
+  }
+  _forEachNode(t, e) {
+    let o = d.acquire().init(t);
+    const n = [o];
+    for (; n.length !== 0; ) {
+      if (o = n.pop(), e(o) && !o.isLeaf())
+        for (let i = 0; i < o.node.children.length; i++)
+          o.node.children[i] && n.push(d.acquire().init(o).advance(i));
+      d.release(o);
+    }
+  }
+  _forEachNodeDepthOrdered(t, e, o, n = E.DepthOrder.FRONT_TO_BACK) {
+    let i = d.acquire().init(t);
+    const h = [i];
+    for (at(o, n, Y); h.length !== 0; ) {
+      if (i = h.pop(), e(i) && !i.isLeaf())
+        for (let a = 7; a >= 0; --a) {
+          const s = Y[a];
+          i.node.children[s] && h.push(d.acquire().init(i).advance(s));
+        }
+      d.release(i);
+    }
+  }
+  _remove(t, e, o) {
+    T.clear();
+    const n = o.advanceTo(e, (i, h) => {
+      T.push(i.node), T.push(h);
+    }) ? o.node.terminals : o.node.residents;
+    if (n.removeUnordered(t), n.length === 0)
+      for (let i = T.length - 2; i >= 0; i -= 2) {
+        const h = T.data[i], a = T.data[i + 1];
+        if (!this._purge(h, a))
+          break;
+      }
+  }
+  _nodeIsEmpty(t) {
+    if (t.terminals.length !== 0)
+      return !1;
+    if (t.residents !== null)
+      return t.residents.length === 0;
+    for (let e = 0; e < t.children.length; e++)
+      if (t.children[e])
+        return !1;
+    return !0;
+  }
+  _purge(t, e) {
+    return e >= 0 && (t.children[e] = null), !!this._nodeIsEmpty(t) && (t.residents === null && (t.residents = new R({ shrink: !0 })), !0);
+  }
+  _add(t, e) {
+    e.advanceTo(this.objectToBoundingSphere(t)) ? e.node.terminals.push(t) : (e.node.residents.push(t), e.node.residents.length > this._maximumObjectsPerNode && e.depth < this._maximumDepth && this._split(e));
+  }
+  _split(t) {
+    const e = t.node.residents;
+    t.node.residents = null;
+    for (let o = 0; o < e.length; o++) {
+      const n = d.acquire().init(t);
+      this._add(e.at(o), n), d.release(n);
+    }
+  }
+  _grow(t, e) {
+    if (e !== 0 && (Q(t, e, (o) => this.objectToBoundingSphere(o), x), A(x[3]) && !this._fitsInsideTree(x)))
+      if (this._nodeIsEmpty(this._root.node))
+        w(x, this._root.bounds), this._root.halfSize = 1.25 * this._root.bounds[3], this._root.updateBoundsRadiusFromHalfSize();
+      else {
+        const o = this._rootBoundsForRootAsSubNode(x);
+        this._placingRootViolatesMaxDepth(o) ? this._rebuildTree(x, o) : this._growRootAsSubNode(o), d.release(o);
+      }
+  }
+  _rebuildTree(t, e) {
+    V(f(k), f(e.bounds)), k[3] = e.halfSize, Q([t, k], 2, (n) => n, L);
+    const o = d.acquire().init(this._root);
+    this._root.initFrom(null, L, L[3]), this._root.increaseHalfSize(1.25), this._forEachNode(o, (n) => (this.add(n.node.terminals.data, n.node.terminals.length), n.node.residents !== null && this.add(n.node.residents.data, n.node.residents.length), !0)), d.release(o);
+  }
+  _placingRootViolatesMaxDepth(t) {
+    const e = Math.log(t.halfSize / this._root.halfSize) * Math.LOG2E;
+    let o = 0;
+    return this._forEachNode(this._root, (n) => (o = Math.max(o, n.depth), o + e <= this._maximumDepth)), o + e > this._maximumDepth;
+  }
+  _rootBoundsForRootAsSubNode(t) {
+    const e = t[3], o = t;
+    let n = -1 / 0;
+    const i = this._root.bounds, h = this._root.halfSize;
+    for (let s = 0; s < 3; s++) {
+      const u = i[s] - h - (o[s] - e), m = o[s] + e - (i[s] + h), l = Math.max(0, Math.ceil(u / (2 * h))), p = Math.max(0, Math.ceil(m / (2 * h))) + 1, O = 2 ** Math.ceil(Math.log(l + p) * Math.LOG2E);
+      n = Math.max(n, O), C[s].min = l, C[s].max = p;
+    }
+    for (let s = 0; s < 3; s++) {
+      let u = C[s].min, m = C[s].max;
+      const l = (n - (u + m)) / 2;
+      u += Math.ceil(l), m += Math.floor(l);
+      const p = i[s] - h - u * h * 2;
+      $[s] = p + (m + u) * h;
+    }
+    const a = n * h;
+    return $[3] = a * et, d.acquire().initFrom(null, $, a, 0);
+  }
+  _growRootAsSubNode(t) {
+    const e = this._root.node;
+    V(f(x), f(this._root.bounds)), x[3] = this._root.halfSize, this._root.init(t), t.advanceTo(x, null, !0), t.node.children = e.children, t.node.residents = e.residents, t.node.terminals = e.terminals;
+  }
+  _shrink() {
+    for (; ; ) {
+      const t = this._findShrinkIndex();
+      if (t === -1)
+        break;
+      this._root.advance(t), this._root.depth = 0;
+    }
+  }
+  _findShrinkIndex() {
+    if (this._root.node.terminals.length !== 0 || this._root.isLeaf())
+      return -1;
+    let t = null;
+    const e = this._root.node.children;
+    let o = 0, n = 0;
+    for (; n < e.length && t == null; )
+      o = n++, t = e[o];
+    for (; n < e.length; )
+      if (e[n++])
+        return -1;
+    return o;
+  }
+  _isDegenerate(t) {
+    return !A(this.objectToBoundingSphere(t)[3]);
+  }
+  _fitsInsideTree(t) {
+    const e = this._root.bounds, o = this._root.halfSize;
+    return t[3] <= o && t[0] >= e[0] - o && t[0] <= e[0] + o && t[1] >= e[1] - o && t[1] <= e[1] + o && t[2] >= e[2] - o && t[2] <= e[2] + o;
+  }
+  toJSON() {
+    const { maximumDepth: t, maximumObjectsPerNode: e, _objectCount: o } = this, n = this._nodeToJSON(this._root.node);
+    return { maximumDepth: t, maximumObjectsPerNode: e, objectCount: o, root: { bounds: this._root.bounds, halfSize: this._root.halfSize, depth: this._root.depth, node: n } };
+  }
+  _nodeToJSON(t) {
+    var i, h;
+    const e = t.children.map((a) => a ? this._nodeToJSON(a) : null), o = (i = t.residents) == null ? void 0 : i.map((a) => this.objectToBoundingSphere(a)), n = (h = t.terminals) == null ? void 0 : h.map((a) => this.objectToBoundingSphere(a));
+    return { children: e, residents: o, terminals: n };
+  }
+  static fromJSON(t) {
+    const e = new E((o) => o, { maximumDepth: t.maximumDepth, maximumObjectsPerNode: t.maximumObjectsPerNode });
+    return e._objectCount = t.objectCount, e._root.initFrom(t.root.node, t.root.bounds, t.root.halfSize, t.root.depth), e;
+  }
+}
+class d {
+  constructor() {
+    this.bounds = M(), this.halfSize = 0, this.initFrom(null, null, 0, 0);
+  }
+  init(t) {
+    return this.initFrom(t.node, t.bounds, t.halfSize, t.depth);
+  }
+  initFrom(t, e, o, n = this.depth) {
+    return this.node = t ?? d.createEmptyNode(), e && w(e, this.bounds), this.halfSize = o, this.depth = n, this;
+  }
+  increaseHalfSize(t) {
+    this.halfSize *= t, this.updateBoundsRadiusFromHalfSize();
+  }
+  updateBoundsRadiusFromHalfSize() {
+    this.bounds[3] = this.halfSize * et;
+  }
+  advance(t) {
+    let e = this.node.children[t];
+    e || (e = d.createEmptyNode(), this.node.children[t] = e), this.node = e, this.halfSize /= 2, this.depth++;
+    const o = tt[t];
+    return this.bounds[0] += o[0] * this.halfSize, this.bounds[1] += o[1] * this.halfSize, this.bounds[2] += o[2] * this.halfSize, this.updateBoundsRadiusFromHalfSize(), this;
+  }
+  advanceTo(t, e, o = !1) {
+    for (; ; ) {
+      if (this.isTerminalFor(t))
+        return e && e(this, -1), !0;
+      if (this.isLeaf()) {
+        if (!o)
+          return e && e(this, -1), !1;
+        this.node.residents = null;
+      }
+      const n = this._childIndex(t);
+      e && e(this, n), this.advance(n);
+    }
+  }
+  isLeaf() {
+    return this.node.residents != null;
+  }
+  isTerminalFor(t) {
+    return t[3] > this.halfSize / 2;
+  }
+  _childIndex(t) {
+    const e = this.bounds;
+    return (e[0] < t[0] ? 1 : 0) + (e[1] < t[1] ? 2 : 0) + (e[2] < t[2] ? 4 : 0);
+  }
+  static createEmptyNode() {
+    return { children: [null, null, null, null, null, null, null, null], terminals: new R({ shrink: !0 }), residents: new R({ shrink: !0 }) };
+  }
+  static acquire() {
+    return d._pool.acquire();
+  }
+  static release(t) {
+    d._pool.release(t);
+  }
+  static clearPool() {
+    d._pool.prune();
+  }
+}
+function rt(r, t) {
+  r[0] = Math.min(r[0], t[0] - t[3]), r[1] = Math.min(r[1], t[1] - t[3]), r[2] = Math.min(r[2], t[2] - t[3]);
+}
+function ht(r, t) {
+  r[0] = Math.max(r[0], t[0] + t[3]), r[1] = Math.max(r[1], t[1] + t[3]), r[2] = Math.max(r[2], t[2] + t[3]);
+}
+function v(r, t, e) {
+  e[0] = r[0] + t, e[1] = r[1] + t, e[2] = r[2] + t;
+}
+function Q(r, t, e, o) {
+  if (t === 1) {
+    const n = e(r[0]);
+    w(n, o);
+  } else {
+    b[0] = 1 / 0, b[1] = 1 / 0, b[2] = 1 / 0, g[0] = -1 / 0, g[1] = -1 / 0, g[2] = -1 / 0;
+    for (let n = 0; n < t; n++) {
+      const i = e(r[n]);
+      A(i[3]) && (rt(b, i), ht(g, i));
+    }
+    st(f(o), b, g, 0.5), o[3] = Math.max(g[0] - b[0], g[1] - b[1], g[2] - b[2]) / 2;
+  }
+}
+function at(r, t, e) {
+  if (!z.length)
+    for (let o = 0; o < 8; ++o)
+      z.push({ index: 0, distance: 0 });
+  for (let o = 0; o < 8; ++o) {
+    const n = tt[o];
+    z.data[o].index = o, z.data[o].distance = j(r, t, n);
+  }
+  z.sort((o, n) => o.distance - n.distance);
+  for (let o = 0; o < 8; ++o)
+    e[o] = z.data[o].index;
+}
+function I(r, t) {
+  let e, o = 1 / 0;
+  for (let n = 0; n < 8; ++n) {
+    const i = j(r, t, X[n]);
+    i < o && (o = i, e = X[n]);
+  }
+  return e;
+}
+function j(r, t, e) {
+  return t * (r[0] * e[0] + r[1] * e[1] + r[2] * e[2]);
+}
+function A(r) {
+  return !isNaN(r) && r !== -1 / 0 && r !== 1 / 0 && r > 0;
+}
+d._pool = new it(d), function(r) {
+  var t;
+  (t = r.DepthOrder || (r.DepthOrder = {}))[t.FRONT_TO_BACK = 1] = "FRONT_TO_BACK", t[t.BACK_TO_FRONT = -1] = "BACK_TO_FRONT";
+}(E || (E = {}));
+const tt = [_(-1, -1, -1), _(1, -1, -1), _(-1, 1, -1), _(1, 1, -1), _(-1, -1, 1), _(1, -1, 1), _(-1, 1, 1), _(1, 1, 1)], X = [_(-1, -1, -1), _(-1, -1, 1), _(-1, 1, -1), _(-1, 1, 1), _(1, -1, -1), _(1, -1, 1), _(1, 1, -1), _(1, 1, 1)], et = Math.sqrt(3), H = [null];
+function dt(r) {
+  return H[0] = r, H;
+}
+const $ = M(), S = K(), b = K(), g = K(), T = new R(), lt = M(), x = M(), k = M(), L = M(), C = [{ min: 0, max: 0 }, { min: 0, max: 0 }, { min: 0, max: 0 }], z = new R(), Y = [0, 0, 0, 0, 0, 0, 0, 0], St = E;
+export {
+  St as default
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10_@floating-ui_utils@0.2.5/node_modules/@arcgis/core/views/3d/webgl-engine/lib/Path.js

@@ -0,0 +1,40 @@
+import { estimateSize as m } from "../../../../core/typedArrayUtil.js";
+import { l as a, n as l, c as p } from "../../../../chunks/vec32.js";
+import { fromValues as R } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { newFloatArray as u } from "../../../../geometry/support/FloatArray.js";
+class x {
+  constructor(r, o, t, s) {
+    this.vertices = r, this.positionsES = o, this.offset = s;
+    const e = r.length, v = Math.floor(e / 2), h = this.offset + 3 * v, i = t[h], g = t[h + 1], f = t[h + 2];
+    this.origin = R(i, g, f), this.positions = u(3 * e);
+    const c = this.offset + 3 * e;
+    for (let n = this.offset; n < c; n += 3)
+      this.positions[n] = t[n] - i, this.positions[n + 1] = t[n + 1] - g, this.positions[n + 2] = t[n + 2] - f;
+    this.updatePathVertexInformation();
+  }
+  get usedMemory() {
+    return m(this.positions);
+  }
+  updatePathVertexInformation() {
+    const r = this.vertices.length, o = this.vertices[0];
+    let t = this.offset;
+    const s = this.positions;
+    o.vRight[0] = s[t + 3] - s[t], o.vRight[1] = s[t + 4] - s[t + 1], o.vRight[2] = s[t + 5] - s[t + 2], t += 3;
+    let e = a(o.vRight);
+    o.vMinSiblingLength = e, l(o.vRight, o.vRight);
+    let v = o;
+    for (let h = 1; h < r; ++h) {
+      const i = this.vertices[h];
+      if (i.vLeft = v.vRight, h < r - 1) {
+        i.vRight[0] = s[t + 3] - s[t], i.vRight[1] = s[t + 4] - s[t + 1], i.vRight[2] = s[t + 5] - s[t + 2];
+        const g = a(i.vRight);
+        i.vMinSiblingLength = Math.min(e, g), e = g, l(i.vRight, i.vRight);
+      } else
+        p(i.vRight, i.vLeft), i.vMinSiblingLength = e;
+      v = i, t += 3;
+    }
+  }
+}
+export {
+  x as Path
+};