@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/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/node_modules/@arcgis/core/views/3d/webgl-engine/lib/Octree.js

@@ -229,7 +229,7 @@ class E {
       }
   }
   _rebuildTree(t, e) {
-    V(f($), f(e.bounds)), $[3] = e.halfSize, Q([t, $], 2, (n) => n, L);
+    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);
   }
@@ -251,10 +251,10 @@ class E {
       const l = (n - (u + m)) / 2;
       u += Math.ceil(l), m += Math.floor(l);
       const p = i[s] - h - u * h * 2;
-      k[s] = p + (m + u) * h;
+      $[s] = p + (m + u) * h;
     }
     const a = n * h;
-    return k[3] = a * et, d.acquire().initFrom(null, k, a, 0);
+    return $[3] = a * et, d.acquire().initFrom(null, $, a, 0);
   }
   _growRootAsSubNode(t) {
     const e = this._root.node;
@@ -416,7 +416,7 @@ const tt = [_(-1, -1, -1), _(1, -1, -1), _(-1, 1, -1), _(1, 1, -1), _(-1, -1, 1)
 function dt(r) {
   return H[0] = r, H;
 }
-const k = M(), S = K(), b = K(), g = K(), T = new R(), lt = M(), x = M(), $ = 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;
+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/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
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathBuilder.js

@@ -0,0 +1,62 @@
+import { estimateSize as A } from "../../../../core/typedArrayUtil.js";
+import { newFloatArray as x, floatSubArray as d } from "../../../../geometry/support/FloatArray.js";
+import { newIntArray as g, compactIndices as f } from "../../../../geometry/support/Indices.js";
+class b {
+  constructor(h, s, r, i, o, e = {}) {
+    this.path = h, this.profile = s, this.extruder = r, this.startCap = i, this.endCap = o, this.options = e, this._extrusionVertexCount = 0;
+    const t = this.path.vertices.length - 2;
+    this.numExtrusionProfiles = r.numProfilesPerJoin() * t + 2, this.numVerticesTotal = s.vertices.length * this.numExtrusionProfiles, this.startCap.vertexBufferStart = this.numVerticesTotal;
+    const n = this.startCap.numVertices;
+    this.numVerticesTotal += n, this.endCap.vertexBufferStart = this.numVerticesTotal;
+    const p = this.endCap.numVertices;
+    this.numVerticesTotal += p, this.pathVertexData = g(1 * this.numVerticesTotal), this.profileRightAxes = x(4 * this.numVerticesTotal), this.profileUpAxes = x(4 * this.numVerticesTotal), this.profileVertexAndNormals = x(4 * this.numVerticesTotal), this.positions = d(h.positions, h.offset, 3 * h.vertices.length), this._rebuildGeometry(), this.buildTopology();
+  }
+  get usedMemory() {
+    return A(this.pathVertexData, this.profileRightAxes, this.profileUpAxes, this.profileVertexAndNormals) + this.path.usedMemory + this.profile.usedMemory;
+  }
+  emitVertex(h, s, r, i, o) {
+    const e = 4 * this._extrusionVertexCount;
+    if (this.profileRightAxes[e] = s.right[0], this.profileRightAxes[e + 1] = s.right[1], this.profileRightAxes[e + 2] = s.right[2], this.profileUpAxes[e] = s.up[0], this.profileUpAxes[e + 1] = s.up[1], this.profileUpAxes[e + 2] = s.up[2], this.profileVertexAndNormals[e] = r[0], this.profileVertexAndNormals[e + 1] = r[1], this.profileVertexAndNormals[e + 2] = i[0], this.profileVertexAndNormals[e + 3] = i[1], this.pathVertexData[this._extrusionVertexCount] = h, o) {
+      const t = this.path.vertices[h], n = t.maxStretchDistance;
+      this.profileRightAxes[e + 3] = t.rotationRight[0] * n, this.profileUpAxes[e + 3] = t.rotationRight[1] * n;
+    } else
+      this.profileRightAxes[e + 3] = 0, this.profileUpAxes[e + 3] = 0;
+    ++this._extrusionVertexCount;
+  }
+  emitCapVertex(h, s, r, i, o, e) {
+    const t = 4 * this._extrusionVertexCount;
+    this.profileRightAxes[t] = s.right[0], this.profileRightAxes[t + 1] = s.right[1], this.profileRightAxes[t + 2] = s.right[2], this.profileRightAxes[t + 3] = o, this.profileUpAxes[t] = s.up[0], this.profileUpAxes[t + 1] = s.up[1], this.profileUpAxes[t + 2] = s.up[2], this.profileUpAxes[t + 3] = e, this.profileVertexAndNormals[t] = r[0], this.profileVertexAndNormals[t + 1] = r[1], this.profileVertexAndNormals[t + 2] = i[0], this.profileVertexAndNormals[t + 3] = i[1], this.pathVertexData[this._extrusionVertexCount] = h, ++this._extrusionVertexCount;
+  }
+  _rebuildGeometry() {
+    this._extrusionVertexCount = 0;
+    const { positions: h, offset: s, vertices: r } = this.path;
+    this.positions = d(h, s, 3 * r.length);
+    let i = 0;
+    const o = (t, n, p, a, l) => this.emitCapVertex(i, t, n, p, a, l), e = (t, n, p, a) => this.emitVertex(i, t, n, p, a);
+    for (this.startCap.rebuildConnectingProfileGeometry(r[i], this.profile, o), i = 1; i < r.length - 1; ++i)
+      this.extruder.extrude(r[i], this.profile, e);
+    this.endCap.rebuildConnectingProfileGeometry(r[i], this.profile, o), i = 0, this.startCap.rebuildCapGeometry(r[i], o), i = r.length - 1, this.endCap.rebuildCapGeometry(r[i], o);
+  }
+  buildTopology() {
+    const h = this.profile.vertices.length, s = this.profile.numSegments, r = this.numExtrusionProfiles - 1;
+    let i = 3 * (2 * (s * r));
+    this.startCap.indexBufferStart = i, this.startCap.firstProfileVertexIndex = 0, i += this.startCap.numIndices, this.endCap.indexBufferStart = i, this.endCap.firstProfileVertexIndex = h * (this.numExtrusionProfiles - 1);
+    const o = new Array(), e = new Array(), t = new Array(), n = (p, a, l) => {
+      o.push(p), o.push(a), o.push(l), e.push(p), e.push(a), e.push(l), t.push(this.pathVertexData[p]), t.push(this.pathVertexData[a]), t.push(this.pathVertexData[l]);
+    };
+    for (let p = 0; p < s; ++p) {
+      const a = this.profile.indices[2 * p], l = this.profile.indices[2 * p + 1];
+      for (let u = 0; u < r; ++u) {
+        const m = u * h + a, c = (u + 1) * h + l, V = u * h + l;
+        n(m, (u + 1) * h + a, c), n(m, c, V);
+      }
+    }
+    this.startCap.buildTopology(this.path.vertices[0], n), this.endCap.buildTopology(this.path.vertices[this.path.vertices.length - 1], n), this.vertexIndices = f(o), this.normalIndices = f(e), this.pathVertexIndices = f(t);
+  }
+  onPathChanged() {
+    this._rebuildGeometry();
+  }
+}
+export {
+  b as PathBuilder
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathCapBuilder.js

@@ -0,0 +1,100 @@
+import { set as b, subtract as I, scale as v, add as S, normalize as C } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as x } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+class d {
+  rebuildConnectingProfileGeometry(s, t, e) {
+    for (let i = 0; i < t.vertices.length; ++i)
+      e(s.frame, t.vertices[i], t.normals[i], 0, 0);
+  }
+}
+class k extends d {
+  constructor() {
+    super(), this.numVertices = 0, this.numIndices = 0;
+  }
+  rebuildCapGeometry() {
+  }
+  buildTopology() {
+  }
+}
+class G extends d {
+  constructor(s, t = 0, e = !1) {
+    super(), this.profile = s, this.profilePlaneOffset = t, this.flip = e;
+  }
+  get numVertices() {
+    return this.profile.vertices.length;
+  }
+  get numIndices() {
+    return 3 * this.profile.numSegments;
+  }
+  rebuildConnectingProfileGeometry(s, t, e) {
+    const i = this.profilePlaneOffset;
+    for (let r = 0; r < t.vertices.length; ++r)
+      e(s.frame, t.vertices[r], t.normals[r], i, 0);
+  }
+  rebuildCapGeometry(s, t) {
+    const e = this.profile, i = this.flip ? 1 : -1, r = this.profilePlaneOffset, n = B;
+    b(n, 0, 0);
+    for (let l = 0; l < e.vertices.length; ++l)
+      t(s.frame, e.vertices[l], n, r, i);
+  }
+  buildTopology(s, t) {
+    const e = this.profile, i = this.vertexBufferStart + e.indices[0];
+    for (let r = 1; r < e.numSegments; ++r) {
+      const n = e.indices[2 * r], l = e.indices[2 * r + 1], o = this.vertexBufferStart + n, f = this.vertexBufferStart + l;
+      this.flip ? t(f, o, i) : t(i, o, f);
+    }
+  }
+}
+class $ extends d {
+  constructor(s) {
+    super(), this.flip = !1, this.sign = 0, this.breakNormals = !1, this.numSegments = 3, this.profile = s.profile, this.flip = s.flip, this.sign = this.flip ? 1 : -1, this.breakNormals = s.breakNormals, this.numSegments = s.subdivisions;
+  }
+  get numVertices() {
+    let s = this.profile.vertices.length * (this.numSegments - 1) + this.profile.poles.length;
+    return this.breakNormals && (s += this.profile.vertices.length), s;
+  }
+  get numIndices() {
+    let s = 0;
+    const t = this.profile;
+    s += 2 * t.numSegments * (this.numSegments - 1);
+    for (let e = 0; e < t.numSegments; ++e) {
+      const i = t.indices[2 * e], r = t.indices[2 * e + 1];
+      t.poleIndices[i] === t.poleIndices[r] ? s += 1 : s += 2;
+    }
+    return 3 * s;
+  }
+  rebuildCapGeometry(s, t) {
+    const e = this.profile, i = s.frame, r = 0.5 * this.sign, n = y, l = B;
+    b(l, 0, 0);
+    for (const o of e.poles)
+      o.normal ? t(i, o.position, o.normal, r, 0) : t(i, o.position, l, r, this.sign);
+    if (this.breakNormals)
+      for (let o = 0; o < e.vertices.length; ++o)
+        t(i, e.vertices[o], e.normals[o], 0, 0);
+    for (let o = 0; o < this.numSegments - 1; ++o) {
+      const f = (1 - (o + 1) / this.numSegments) * Math.PI * 0.5, m = Math.sin(f), c = Math.cos(f);
+      for (let h = 0; h < e.vertices.length; ++h) {
+        const a = e.poles[e.poleIndices[h]];
+        I(n, e.vertices[h], a.position), v(n, n, m), a.normal ? (S(n, n, a.position), t(i, n, a.normal, r * c, 0)) : (C(l, n), v(l, l, m), S(n, n, a.position), t(i, n, l, r * c, this.sign * c));
+      }
+    }
+  }
+  buildTopology(s, t) {
+    const e = this.profile, i = this.breakNormals ? this.vertexBufferStart + e.poles.length : this.firstProfileVertexIndex, r = this.breakNormals ? this.vertexBufferStart + e.poles.length + e.vertices.length : this.vertexBufferStart + e.poles.length;
+    for (let n = 0; n < e.numSegments; ++n) {
+      const l = e.indices[2 * n], o = e.indices[2 * n + 1], f = this.vertexBufferStart + e.poleIndices[l], m = this.vertexBufferStart + e.poleIndices[o];
+      let c = i + l, h = i + o;
+      for (let a = 0; a < this.numSegments - 1; ++a) {
+        const p = r + a * e.vertices.length + l, g = r + a * e.vertices.length + o;
+        this.flip ? (t(p, h, c), t(h, p, g)) : (t(c, h, p), t(g, p, h)), c = p, h = g;
+      }
+      this.flip ? (t(f, h, c), f !== m && t(f, m, h)) : (t(c, h, f), f !== m && t(h, m, f));
+    }
+  }
+}
+const y = x(), B = x();
+export {
+  k as NoCapBuilder,
+  d as PathCapBuilder,
+  $ as RoundCapBuilder,
+  G as TriangulationCapBuilder
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathExtruder.js

@@ -0,0 +1,53 @@
+import { fromRotation as v } from "../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as g } from "../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { dot as u } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as S } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { e as f } from "../../../../chunks/vec32.js";
+import { create as h } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+class J {
+  numProfilesPerJoin() {
+    return 1;
+  }
+  extrude(r, t, n) {
+    for (let o = 0; o < t.vertices.length; ++o)
+      n(r.frame, t.vertices[o], t.normals[o], !1);
+  }
+}
+class R {
+  constructor(r, t) {
+    this.cutoffAngle = r, this.numBendSubdivisions = t;
+  }
+  numProfilesPerJoin() {
+    return this.numBendSubdivisions + 1;
+  }
+  extrude(r, t, n) {
+    const o = B, { rotationAngle: a, rotationRight: l, frame: m } = r;
+    if (Math.abs(a) >= this.cutoffAngle) {
+      const c = r.rotationFrameUp;
+      for (let e = 0; e < this.numBendSubdivisions + 1; ++e) {
+        v(d, 0.5 * -a + e * a / this.numBendSubdivisions, c), x(o, m, d);
+        for (let i = 0; i < t.vertices.length; ++i)
+          u(t.vertices[i], l) * a >= 0 ? n(o, t.vertices[i], t.normals[i], !1) : n(m, r.applyMiterStretch(p, t.vertices[i]), t.normals[i], !0);
+      }
+    } else
+      for (let c = 0; c < this.numBendSubdivisions + 1; ++c)
+        for (let e = 0; e < t.vertices.length; ++e) {
+          const i = u(t.vertices[e], l) * a >= 0;
+          n(m, r.applyMiterStretch(p, t.vertices[e]), t.normals[e], !i);
+        }
+  }
+}
+class b {
+  constructor() {
+    this.up = h(), this.right = h();
+  }
+}
+function x(s, r, t) {
+  f(s.up, r.up, t), f(s.right, r.right, t);
+}
+const p = S(), d = g(), B = new b();
+export {
+  b as Frame2D,
+  R as MiterExtruder,
+  J as SimpleExtruder
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathGeometry.js

@@ -0,0 +1,19 @@
+import { ContentObjectType as h } from "./ContentObjectType.js";
+import { Geometry as m } from "./Geometry.js";
+class l extends m {
+  constructor(o, r, s, n, a, i) {
+    super(o, r, null, h.Mesh, i), this.path = s, this.geometrySR = n, this.stencilWidth = a;
+  }
+}
+var e;
+function u(t) {
+  return "path" in t;
+}
+(function(t) {
+  t[t.World = 0] = "World", t[t.Path = 1] = "Path";
+})(e || (e = {}));
+export {
+  l as PathGeometry,
+  e as UpVectorAlignment,
+  u as isPathGeometry
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathGeometryData.js

@@ -0,0 +1,94 @@
+import { set as I, length as S, normalize as U, dot as y, scale as E, add as z } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as D } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { s as V, b as k } from "../../../../chunks/vec32.js";
+import { create as C } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { fromValues as j } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { newFloatArray as L } from "../../../../geometry/support/FloatArray.js";
+import { getZeroIndexArray as q } from "../../../../geometry/support/Indices.js";
+import { Attribute as c, Vertices as H } from "./Attribute.js";
+import { compressNormal as X } from "./Normals.js";
+import { VertexAttribute as l } from "./VertexAttribute.js";
+import { intersectTriangles as Z } from "../materials/internal/MaterialUtil.js";
+class M {
+  constructor(t) {
+    this.builder = t;
+  }
+  onPathChanged(t) {
+    this.builder.onPathChanged();
+  }
+}
+class _ extends M {
+  constructor(t) {
+    super(t), this.vertexAttributeColor = j(255, 255, 255, 255), this.size = new Array(), this.vertexAttributePosition = L(3 * this.builder.numVerticesTotal), this.vertexAttributeNormal = new Int16Array(2 * this.builder.numVerticesTotal);
+  }
+  bakeVertexColors(t) {
+    this.vertexAttributeColor[0] = 255 * t[0], this.vertexAttributeColor[1] = 255 * t[1], this.vertexAttributeColor[2] = 255 * t[2], this.vertexAttributeColor[3] = 255 * (t.length > 3 ? t[3] : 1);
+  }
+  bake(t) {
+    this.size = t;
+    const { numVerticesTotal: s, pathVertexData: o, path: n, positions: e, profileRightAxes: i, profileUpAxes: p, profileVertexAndNormals: f } = this.builder;
+    for (let v = 0; v < s; ++v) {
+      let d = o[v];
+      const F = d === 0 || d === n.vertices.length - 1;
+      d *= 3;
+      const u = Q;
+      let P = 0, g = 0;
+      const r = 4 * v, b = V(W, i[r], i[r + 1], i[r + 2]), m = V(Y, p[r], p[r + 1], p[r + 2]), h = I(T, f[r] * t[0], f[r + 1] * t[1]);
+      if (F)
+        k(u, m, b), P = i[r + 3] * t[0], g = p[r + 3];
+      else {
+        const a = B, x = J;
+        I(a, i[r + 3], p[r + 3]);
+        const R = S(a);
+        U(a, a);
+        const $ = y(h, a);
+        if (Math.abs($) > R) {
+          I(x, -a[1], a[0]);
+          const G = y(h, x);
+          E(a, a, R * Math.sign($)), E(x, x, G), z(h, a, x);
+        }
+        V(u, 0, 0, 0);
+      }
+      const O = V(K, b[0] * h[0] + m[0] * h[1], b[1] * h[0] + m[1] * h[1], b[2] * h[0] + m[2] * h[1]), w = 3 * v;
+      this.vertexAttributePosition[w] = e[d] + O[0] + u[0] * P, this.vertexAttributePosition[w + 1] = e[d + 1] + O[1] + u[1] * P, this.vertexAttributePosition[w + 2] = e[d + 2] + O[2] + u[2] * P;
+      const A = I(T, f[r + 2], f[r + 3]);
+      X(this.vertexAttributeNormal, v, b[0] * A[0] + m[0] * A[1] + u[0] * g, b[1] * A[0] + m[1] * A[1] + u[1] * g, b[2] * A[0] + m[2] * A[1] + u[2] * g);
+    }
+  }
+  createGeometryData() {
+    const t = this.builder.vertexIndices.length, { normalIndices: s, vertexIndices: o } = this.builder;
+    return [[l.POSITION, new c(this.vertexAttributePosition, o, 3, !0)], [l.NORMALCOMPRESSED, new c(this.vertexAttributeNormal, s, 2, !0)], [l.COLOR, new c(this.vertexAttributeColor, q(t), 4)]];
+  }
+  onPathChanged(t) {
+    super.onPathChanged(t), this.bake(this.size);
+  }
+  intersect(t, s, o) {
+    const n = this.builder.vertexIndices, e = new H(this.vertexAttributePosition, 3), i = n.length / 3;
+    Z(t, s, 0, i, n, e, void 0, void 0, o);
+  }
+}
+class ct extends M {
+  constructor(t, s, o, n) {
+    super(t), this.sizeAttributeValue = s, this.colorAttributeValue = o, this.opacityAttributeValue = n, this.vvData = null, this.baked = new _(t), this.vvData = L(4 * this.builder.path.vertices.length);
+    for (let e = 0; e < this.builder.path.vertices.length; ++e) {
+      this.vvData[4 * e] = s, this.vvData[4 * e + 1] = o, this.vvData[4 * e + 2] = n;
+      const i = e === 0 || e === this.builder.path.vertices.length - 1;
+      this.vvData[4 * e + 3] = i ? 1 : 0;
+    }
+  }
+  createGeometryData() {
+    const { positions: t, profileRightAxes: s, profileUpAxes: o, profileVertexAndNormals: n, pathVertexIndices: e, vertexIndices: i } = this.builder;
+    return [[l.POSITION, new c(t, e, 3, !0)], [l.PROFILERIGHT, new c(s, i, 4, !0)], [l.PROFILEUP, new c(o, i, 4, !0)], [l.PROFILEVERTEXANDNORMAL, new c(n, i, 4, !0)], [l.FEATUREVALUE, new c(this.vvData, e, 4, !0)]];
+  }
+  onPathChanged(t) {
+    super.onPathChanged(t);
+    const s = t.getMutableAttribute(l.POSITION);
+    s && (s.data = this.builder.positions);
+  }
+}
+const T = D(), B = D(), J = D(), K = C(), Q = C(), W = C(), Y = C();
+export {
+  ct as FastUpdatePathGeometry,
+  M as PathGeometryData,
+  _ as StaticPathGeometry
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathProfile.js

@@ -0,0 +1,62 @@
+import { estimateSize as g } from "../../../../core/typedArrayUtil.js";
+import { fromValues as s, clone as m } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { pathNumCircleProfileSubdivisions as V } from "../../layers/graphics/Graphics3DPathSymbolLayerConstants.js";
+class P {
+  constructor() {
+    this.vertices = new Array(), this.normals = new Array(), this.indices = new Array(), this.poles = new Array(), this.poleIndices = new Array();
+  }
+  addVertex(o, t) {
+    return this.vertices.push(m(o)), this.normals.push(m(t)), this.vertices.length - 1;
+  }
+  addPole(o, t = null) {
+    return this.poles.push({ position: m(o), normal: t ? m(t) : null }), this.poles.length - 1;
+  }
+  addSegment(o, t = null) {
+    this.indices.push(o.v0), this.indices.push(o.v1), t && (this.poleIndices.push(t.v0), this.poleIndices.push(t.v1));
+  }
+  get numSegments() {
+    return this.indices.length / 2;
+  }
+  translate(o, t) {
+    for (const e of this.vertices)
+      e[0] += o, e[1] += t;
+    for (const e of this.poles)
+      e.position[0] += o, e.position[1] += t;
+  }
+  get usedMemory() {
+    return this.vertices.length * g(this.vertices[0]) * 2 + g(this.indices);
+  }
+}
+const x = { top: [0, -0.5], bottom: [0, 0.5] };
+function p(i) {
+  const t = V, e = new P(), a = { v0: 0, v1: 0 };
+  e.addPole(s(0, 0));
+  for (let r = 0; r < t; ++r) {
+    const n = 2 * r * Math.PI / t, d = Math.cos(n), c = Math.sin(n), l = s(d * 0.5, c * 0.5), v = s(d, c);
+    e.addVertex(l, v);
+  }
+  for (let r = 0; r < t - 1; ++r) {
+    const n = { v0: r, v1: r + 1 };
+    e.addSegment(n, a);
+  }
+  const h = { v0: t - 1, v1: 0 };
+  if (e.addSegment(h, a), i !== "center") {
+    const r = x[i];
+    e.translate(r[0], r[1]);
+  }
+  return e;
+}
+const b = { center: p("center"), top: p("top"), bottom: p("bottom") }, y = { center: u("center"), top: u("top"), bottom: u("bottom") };
+function u(i) {
+  const e = new P(), a = s(0.5 * -1, 0.5 * -1), h = s(0.5 * 1, 0.5 * -1), r = s(0.5 * 1, 0.5 * 1), n = s(0.5 * -1, 0.5 * 1), d = s(0, -1), c = s(1, 0), l = s(0, 1), v = s(-1, 0);
+  if (e.addPole(s(0, 0.5 * 1), l), e.addPole(s(0, 0.5 * 1)), e.addPole(s(0, 0.5 * -1)), e.addPole(s(0, 0.5 * -1), d), e.addVertex(a, d), e.addVertex(h, d), e.addSegment({ v0: 0, v1: 1 }, { v0: 3, v1: 3 }), e.addVertex(h, c), e.addVertex(r, c), e.addSegment({ v0: 2, v1: 3 }, { v0: 2, v1: 1 }), e.addVertex(r, l), e.addVertex(n, l), e.addSegment({ v0: 4, v1: 5 }, { v0: 0, v1: 0 }), e.addVertex(n, v), e.addVertex(a, v), e.addSegment({ v0: 6, v1: 7 }, { v0: 1, v1: 2 }), i !== "center") {
+    const f = x[i];
+    e.translate(f[0], f[1]);
+  }
+  return e;
+}
+export {
+  P as PathProfile,
+  b as circleProfiles,
+  y as quadProfiles
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/PathVertex.js

@@ -0,0 +1,81 @@
+import { acosClamped as P, reciprocalClamped as v } from "../../../../core/mathUtils.js";
+import { set as I } from "../../../../core/libs/gl-matrix-2/math/mat2.js";
+import { create as D } from "../../../../core/libs/gl-matrix-2/factories/mat2f64.js";
+import { set as x, transformMat2 as V } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { UNIT_X as y, create as j } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { h as f, k as i, f as R, F as S, n as c, b as L, g as U, c as k } from "../../../../chunks/vec32.js";
+import { create as e } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { Frame2D as C } from "./PathExtruder.js";
+import { UpVectorAlignment as A } from "./PathGeometry.js";
+class $ {
+  constructor() {
+    this.vLeft = e(), this.vRight = e(), this.vMinSiblingLength = 0, this.frame = new C();
+  }
+  setFrameFromUpVector(t) {
+    k(this.frame.up, t), U(u, this.vLeft, this.vRight), c(u, u), f(F, this.frame.up, i(u, this.frame.up)), R(l, u, F), c(l, l), L(this.frame.right, l, this.frame.up);
+  }
+  get foldingAngle() {
+    return Math.PI - this.rotationAngle;
+  }
+}
+class _ extends $ {
+  get rotationFrameUp() {
+    return this.frame.up;
+  }
+  get rotationRight() {
+    return y;
+  }
+  get rotationAngle() {
+    return f(a, this.frame.up, i(this.frame.up, this.vLeft)), R(a, this.vLeft, a), S(a, a), c(a, a), f(m, this.frame.up, i(this.frame.up, this.vRight)), R(m, this.vRight, m), c(m, m), L(M, this.rotationFrameUp, this.vLeft), Math.sign(i(M, this.vRight)) * (Math.PI - P(i(a, m)));
+  }
+  get maxStretchDistance() {
+    return Math.abs(this.vMinSiblingLength / Math.cos(0.5 * this.foldingAngle));
+  }
+  applyMiterStretch(t, r) {
+    const h = this.rotationAngle;
+    if (Math.abs(h) <= 0)
+      return r;
+    const o = v(Math.cos(0.5 * h));
+    return x(t, (o - 1 + 1) * r[0], r[1]);
+  }
+}
+class z extends $ {
+  get rotationFrameUp() {
+    const t = Math.sign(i(this.frame.right, this.vRight));
+    return L(p, this.vRight, this.vLeft), f(p, p, t), c(p, p);
+  }
+  get rotationRight() {
+    const t = this.rotationFrameUp, r = i(t, this.frame.up), h = i(t, this.frame.right);
+    return f(g, this.frame.up, -h), f(d, this.frame.right, r), U(g, g, d), c(g, g), E(b, this.frame, g), b;
+  }
+  get rotationAngle() {
+    const t = Math.sign(i(this.frame.right, this.vRight));
+    return S(M, this.vLeft), -t * (Math.PI - P(i(M, this.vRight)));
+  }
+  get maxStretchDistance() {
+    return Math.abs(this.vMinSiblingLength * v(Math.cos(0.5 * this.foldingAngle)));
+  }
+  applyMiterStretch(t, r) {
+    const h = this.rotationAngle;
+    if (Math.abs(h) === 0)
+      return r;
+    const o = v(Math.cos(0.5 * h)), s = this.rotationRight, w = I(N, 1 + (o - 1) * s[0] * s[0], (o - 1) * s[0] * s[1], (o - 1) * s[0] * s[1], 1 + (o - 1) * s[1] * s[1]);
+    return V(t, r, w);
+  }
+}
+function E(n, t, r) {
+  x(n, i(r, t.right), i(r, t.up));
+}
+function O(n) {
+  switch (n) {
+    case A.World:
+      return new _();
+    case A.Path:
+      return new z();
+  }
+}
+const p = e(), b = j(), g = e(), d = e(), M = e(), a = e(), m = e(), F = e(), u = e(), l = e(), N = D();
+export {
+  $ as PathVertex,
+  O as newPathVertex
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/TextHelperCanvas.js

@@ -0,0 +1,6 @@
+function t(a, e, n) {
+  return a.canvas || (a.canvas = document.createElement("canvas")), a.canvas.width = e, a.canvas.height = n, a.canvas;
+}
+export {
+  t as getTextHelperCanvas
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/TextRenderParameters.js

@@ -0,0 +1,46 @@
+import s from "../../../../Color.js";
+import { isCachedFontFace as x, loadFont as k } from "../../../../core/fontUtils.js";
+import z from "../../../../core/Logger.js";
+import { pt2px as p } from "../../../../core/screenUtils.js";
+import { ZEROS as l } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+class y {
+  constructor(o) {
+    this.definition = o, this.key = JSON.stringify(o), this.haloSize = Math.round(o.halo.size), this.textStyle = this._colorToRGBA(o.color), this.haloStyle = this._colorToRGB(o.halo.color), this.backgroundStyle = o.background.color[3] !== 0 ? this._colorToRGBA(o.background.color) : null;
+  }
+  fontString(o) {
+    const t = this.definition.font, r = "sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol, Noto Color Emoji";
+    return `${t.style} ${t.weight} ${o}px ${t.family}, ${r}`;
+  }
+  setFontProperties(o, t) {
+    o.font = this.fontString(t), o.textAlign = "left", o.textBaseline = "alphabetic";
+  }
+  _colorToRGB(o) {
+    return `rgb(${o.slice(0, 3).map((t) => Math.floor(255 * t)).toString()})`;
+  }
+  _colorToRGBA(o) {
+    return `rgba(${o.slice(0, 3).map((t) => Math.floor(255 * t)).toString()},${o[3]})`;
+  }
+  static async fromSymbol(o, t) {
+    var c, f, m, g, u;
+    const r = (c = o == null ? void 0 : o.material) == null ? void 0 : c.color, b = s.toUnitRGBA(r) ?? l, i = o.size != null ? p(o.size) : 12, S = o.lineHeight, R = o.background != null ? s.toUnitRGBA(o.background.color) : l, w = { family: ((f = o.font) == null ? void 0 : f.family) ?? "sans-serif", decoration: ((m = o.font) == null ? void 0 : m.decoration) ?? "none", weight: ((g = o.font) == null ? void 0 : g.weight) ?? "normal", style: ((u = o.font) == null ? void 0 : u.style) ?? "normal" }, e = o.halo, $ = (e == null ? void 0 : e.color) != null && e.size > 0 ? { size: p(e.size), color: s.toUnitRGBA(e.color) } : { size: 0, color: l }, a = new y({ color: b, size: i, background: { color: R, padding: o.background != null ? [0.65 * i, 0.5 * i] : [0, 0], borderRadius: o.background != null ? i * (6 / 16) : 0 }, lineSpacingFactor: S, font: w, halo: $, pixelRatio: t });
+    if (o.font) {
+      let d = !1;
+      const h = a.fontString(i);
+      try {
+        d = (await document.fonts.load(h)).some((n) => !x(n));
+      } catch {
+        z.getLogger("esri.views.3d.webgl-engine.lib.TextRenderParameters").warnOnce(`Failed to preload font '${h}'. Some text symbology may be rendered using the default browser font.`);
+      }
+      if (!d && !A.has(o.font.family))
+        try {
+          await k(o.font);
+        } catch {
+        }
+    }
+    return a;
+  }
+}
+const A = /* @__PURE__ */ new Set(["Arial", "Times New Roman", "Courier New", "serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "math", "emoji", "fangsong"]);
+export {
+  y as TextRenderParameters
+};