@agrotools1/at-components 0.2.3 → 0.2.4

package/dist/SceneLayerSnappingSource-f53ddd8a.js

@@ -0,0 +1,218 @@
+import { bt as _, M as C, e as o, y as s, c as w, S as f, b9 as k, dF as H, l as E, a as x, hw as v, gW as I, bJ as $, B as O } from "./index-f28919b2.js";
+import { h as L } from "./WorkerHandle-f6b5ac7b.js";
+import { t as m } from "./workerHelper-8fb7376f.js";
+import { f as A } from "./edgeProcessing-da003f69.js";
+import { B as V } from "./sphere-84d1e36b.js";
+import { c as R } from "./MeasurementWidgetContent-fc0c1569.js";
+import { c as B } from "./InteractiveAnalysisViewModel-d7dd665d.js";
+import { r as D } from "./VertexSnappingCandidate-c1e2992a.js";
+import "vue";
+import "./InterleavedLayout-ff67e161.js";
+import "./BufferView-2cfe8c7d.js";
+import "./vec42-1a7bd7a6.js";
+import "./types-adba9034.js";
+import "./Util-26f81cc4.js";
+import "./vec4f64-043e974c.js";
+import "./deduplicate-eabb5f9e.js";
+import "./Indices-2f9cf62d.js";
+import "./VertexAttribute-faad30bf.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./ObjectStack-bad354ab.js";
+import "./plane-2b39f8eb.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./projectVectorToVector-add01592.js";
+import "./projectPointToVector-1d9098bc.js";
+import "./elevationInfoUtils-e1edd62e.js";
+import "./unitConversionUtils-b0c2c156.js";
+import "./lengthUtils-8796ccf3.js";
+import "./meshVertexSpaceUtils-673c2055.js";
+import "./MeshLocalVertexSpace-59268d9e.js";
+import "./vec3-ab2339d6.js";
+import "./Scheduler-9db9a8cf.js";
+import "./RenderState-b244097f.js";
+import "./quantityUtils-afe6e5b7.js";
+import "./geometryEngineBase-8b327072.js";
+import "./colorUtils-6e9b620c.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-cbaefa65.js";
+import "./lineSegment-2790f546.js";
+import "./triangle-95e355d3.js";
+import "./DoubleArray-4f276822.js";
+import "./VertexArrayObject-5595c535.js";
+import "./Texture-c1f5f21b.js";
+import "./VertexColor.glsl-01eb58bb.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-f8f50ad7.js";
+import "./orientedBoundingBox-46d44acf.js";
+import "./quat-22f56b72.js";
+import "./computeTranslationToOriginAndRotation-0b0f32ad.js";
+import "./BufferObject-59880a47.js";
+import "./axisAngleDegrees-1c3d7520.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-2bc6800c.js";
+import "./MemCache-8f96824a.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-db89ec09.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-2772790a.js";
+import "./hydrated-219f2b0c.js";
+class P extends L {
+  constructor(e) {
+    super("EdgeProcessingWorker", "extract", { extract: (t) => [t.dataBuffer], extractComponentsEdgeLocations: (t) => [t.dataBuffer], extractEdgeLocations: (t) => [t.dataBuffer] }, e);
+  }
+  async process(e, t, i) {
+    if (i)
+      return A(e);
+    const a = await this.invoke(new g(e), t);
+    return this._unpackOutput(a);
+  }
+  async extractEdgeLocations(e, t) {
+    const i = await this.invokeMethod("extractEdgeLocations", new g(e), t);
+    return m(i);
+  }
+  async extractComponentsEdgeLocations(e, t) {
+    const i = await this.invokeMethod("extractComponentsEdgeLocations", new g(e), t);
+    return m(i);
+  }
+  _unpackOutput(e) {
+    return { regular: { instancesData: m(e.regular.instancesData), lodInfo: { lengths: new Float32Array(e.regular.lodInfo.lengths) } }, silhouette: { instancesData: m(e.silhouette.instancesData), lodInfo: { lengths: new Float32Array(e.silhouette.lodInfo.lengths) } }, averageEdgeLength: e.averageEdgeLength };
+  }
+}
+class g {
+  constructor(e) {
+    this.dataBuffer = e.data.buffer, this.writerSettings = e.writerSettings, this.skipDeduplicate = e.skipDeduplicate, this.indices = _(e.indices) ? e.indices : e.indices.buffer, this.indicesType = _(e.indices) ? "Array" : C(e.indices) ? "Uint32Array" : "Uint16Array", this.indicesLength = e.indicesLength;
+  }
+}
+let c = class extends f {
+  constructor(e) {
+    super(e), this.availability = 0, this._ids = /* @__PURE__ */ new Set();
+  }
+  destroy() {
+    this._workerHandle.destroy(), this._workerHandle = null;
+  }
+  initialize() {
+    this._workerHandle = new W(this.schedule, { fetchAllEdgeLocations: (e, t) => this._fetchAllEdgeLocations(e, t) });
+  }
+  async fetchCandidates(e, t) {
+    const i = e.coordinateHelper, { point: a } = e, n = j;
+    this.renderCoordsHelper.toRenderCoords(a, i.spatialReference, n);
+    const u = e.distance, p = typeof u == "number" ? u : u.distance, h = await this._workerHandle.invoke({ bounds: V(n[0], n[1], n[2], p), returnEdge: e.returnEdge, returnVertex: e.vertexMode !== "none" }, t);
+    return h.candidates.sort((y, b) => y.distance - b.distance), h.candidates.map((y) => this._convertCandidate(i, y));
+  }
+  async add(e, t) {
+    this._ids.add(e.id), await this._workerHandle.invokeMethod("add", e, t);
+  }
+  async remove(e, t) {
+    this._ids.delete(e.id), await this._workerHandle.invokeMethod("remove", e, t);
+  }
+  _convertCandidate(e, t) {
+    switch (t.type) {
+      case "edge":
+        return new B({ objectId: t.objectId, targetPoint: this._convertRenderCoordinate(e, t.target), edgeStart: this._convertRenderCoordinate(e, t.start), edgeEnd: this._convertRenderCoordinate(e, t.end), isDraped: !1 });
+      case "vertex":
+        return new D({ objectId: t.objectId, targetPoint: this._convertRenderCoordinate(e, t.target), isDraped: !1 });
+    }
+  }
+  _convertRenderCoordinate({ spatialReference: e }, t) {
+    const i = k();
+    return this.renderCoordsHelper.fromRenderCoords(t, i, e), R(i);
+  }
+  async _fetchAllEdgeLocations(e, t) {
+    const i = [], a = [];
+    for (const { id: n, uid: u } of e.components)
+      this._ids.has(n) && i.push((async () => {
+        const p = await this.fetchEdgeLocations(n, t.signal), h = p.locations.buffer;
+        return a.push(h), { id: n, uid: u, objectIds: p.objectIds, locations: h, origin: p.origin, type: p.type };
+      })());
+    return { result: { components: (await Promise.all(i)).filter(({ id: n }) => this._ids.has(n)) }, transferList: a };
+  }
+};
+o([s({ constructOnly: !0 })], c.prototype, "renderCoordsHelper", void 0), o([s({ constructOnly: !0 })], c.prototype, "fetchEdgeLocations", void 0), o([s({ constructOnly: !0 })], c.prototype, "schedule", void 0), o([s({ readOnly: !0 })], c.prototype, "availability", void 0), c = o([w("esri.views.interactive.snapping.featureSources.sceneLayerSource.SceneLayerSnappingSourceWorker")], c);
+class W extends L {
+  constructor(e, t) {
+    super("SceneLayerSnappingSourceWorker", "fetchCandidates", {}, e, { strategy: "dedicated", client: t });
+  }
+}
+const j = k();
+let d = class extends f {
+  get updating() {
+    return this._updatingHandles.updating;
+  }
+  constructor(r) {
+    super(r), this.availability = 1, this._updatingHandles = new H(), this._abortController = new AbortController();
+  }
+  destroy() {
+    this._tracker = E(this._tracker), this._abortController = x(this._abortController), this._updatingHandles.destroy();
+  }
+  initialize() {
+    const { view: r } = this, e = r.resourceController;
+    this._edgeWorker = new P(S(e)), this._workerHandle = new c({ renderCoordsHelper: this.view.renderCoordsHelper, schedule: S(e), fetchEdgeLocations: async (t, i) => {
+      if (this._tracker == null)
+        throw new Error("tracker-not-initialized");
+      return this._tracker.fetchEdgeLocations(t, this._edgeWorker, i);
+    } }), this._updatingHandles.addPromise(this._setupLayerView()), this.addHandles([v(this._workerHandle), v(this._edgeWorker)]);
+  }
+  async fetchCandidates(r, e) {
+    return this._workerHandle.fetchCandidates(r, e);
+  }
+  refresh() {
+  }
+  async _setupLayerView() {
+    var t;
+    if (this.destroyed)
+      return;
+    const r = (t = this._abortController) == null ? void 0 : t.signal, e = await this.getLayerView();
+    e == null || I(r) || (this._tracker = e.trackSnappingSources({ add: (i, a) => {
+      this._updatingHandles.addPromise(this._workerHandle.add({ id: i, bounds: a }, r));
+    }, remove: (i) => {
+      this._updatingHandles.addPromise(this._workerHandle.remove({ id: i }, r));
+    } }));
+  }
+};
+function S(r) {
+  return (e) => r.immediate.schedule(e);
+}
+o([s({ constructOnly: !0 })], d.prototype, "getLayerView", void 0), o([s({ constructOnly: !0 })], d.prototype, "view", void 0), o([s({ readOnly: !0 })], d.prototype, "updating", null), o([s({ readOnly: !0 })], d.prototype, "availability", void 0), d = o([w("esri.views.interactive.snapping.featureSources.I3SSnappingSource")], d);
+let l = class extends f {
+  get updating() {
+    return this._i3sSources.some((r) => r.updating);
+  }
+  constructor(r) {
+    super(r), this.availability = 1, this._i3sSources = [];
+  }
+  destroy() {
+    this._i3sSources.forEach((r) => r.destroy()), this._i3sSources.length = 0;
+  }
+  initialize() {
+    const { view: r } = this, e = this.layerSource.layer;
+    this._i3sSources = e.type === "building-scene" ? this._getBuildingSceneI3SSources(r, e) : [this._getSceneLayerI3SSource(r, e)];
+  }
+  async fetchCandidates(r, e) {
+    const t = await Promise.all(this._i3sSources.map((i) => i.fetchCandidates(r, e)));
+    return $(e), t.flat();
+  }
+  refresh() {
+    this._i3sSources.forEach((r) => r.refresh());
+  }
+  _getBuildingSceneI3SSources(r, e) {
+    return e.allSublayers.toArray().map((t) => t.type === "building-component" ? new d({ getLayerView: async () => (await r.whenLayerView(e)).whenSublayerView(t), view: r }) : null).filter(O);
+  }
+  _getSceneLayerI3SSource(r, e) {
+    return new d({ getLayerView: async () => {
+      const t = await r.whenLayerView(e);
+      return t.type === "scene-layer-graphics-3d" ? void 0 : t;
+    }, view: r });
+  }
+};
+o([s({ constructOnly: !0 })], l.prototype, "layerSource", void 0), o([s({ constructOnly: !0 })], l.prototype, "view", void 0), o([s({ readOnly: !0 })], l.prototype, "updating", null), o([s({ readOnly: !0 })], l.prototype, "availability", void 0), l = o([w("esri.views.interactive.snapping.featureSources.SceneLayerSnappingSource")], l);
+export {
+  l as SceneLayerSnappingSource
+};

package/dist/SceneLayerSnappingSourceWorker-80f48214.js

@@ -0,0 +1,112 @@
+import { fr as l, fs as h, bp as g, e as x, c as E, b9 as p, bJ as v, bl as m } from "./index-f28919b2.js";
+import { v as y, b as L, j as V } from "./lineSegment-2790f546.js";
+import { w as j, Z as _, s as b } from "./sphere-84d1e36b.js";
+import { W as C } from "./Octree-cbaefa65.js";
+import { m as P } from "./edgeProcessing-da003f69.js";
+import "vue";
+import "./ObjectStack-bad354ab.js";
+import "./plane-2b39f8eb.js";
+import "./vec42-1a7bd7a6.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./vec4f64-043e974c.js";
+import "./Util-26f81cc4.js";
+import "./deduplicate-eabb5f9e.js";
+import "./Indices-2f9cf62d.js";
+import "./InterleavedLayout-ff67e161.js";
+import "./BufferView-2cfe8c7d.js";
+import "./types-adba9034.js";
+import "./VertexAttribute-faad30bf.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+const S = 1e3;
+function I(t, e, o) {
+  const i = j(), n = _(i);
+  return l(n, n, t, 0.5), l(n, n, e, 0.5), i[3] = h(n, t), g(n, n, o), i;
+}
+let f = class {
+  constructor() {
+    this._idToComponent = /* @__PURE__ */ new Map(), this._components = new C((t) => t.bounds), this._edges = new C((t) => t.bounds), this._tmpLineSegment = y(), this._tmpP1 = p(), this._tmpP2 = p(), this._tmpP3 = p(), this.remoteClient = null;
+  }
+  async fetchCandidates(t, e) {
+    await Promise.resolve(), v(e), await this._ensureEdgeLocations(t, e);
+    const o = [];
+    return this._edges.forEachNeighbor((i) => (this._addCandidates(t, i, o), o.length < S), t.bounds), { result: { candidates: o } };
+  }
+  async _ensureEdgeLocations(t, e) {
+    const o = [];
+    if (this._components.forEachNeighbor((s) => {
+      if (s.info == null) {
+        const { id: c, uid: r } = s;
+        o.push({ id: c, uid: r });
+      }
+      return !0;
+    }, t.bounds), !o.length)
+      return;
+    const i = { components: o }, n = await this.remoteClient.invoke("fetchAllEdgeLocations", i, e ?? {});
+    for (const s of n.components)
+      this._setFetchEdgeLocations(s);
+  }
+  async add(t) {
+    const e = new u(t.id, t.bounds);
+    return this._idToComponent.set(e.id, e), this._components.add([e]), { result: {} };
+  }
+  async remove(t) {
+    const e = this._idToComponent.get(t.id);
+    if (e) {
+      const o = [];
+      this._edges.forEachNeighbor((i) => (i.component === e && o.push(i), !0), e.bounds), this._edges.remove(o), this._components.remove([e]), this._idToComponent.delete(e.id);
+    }
+    return { result: {} };
+  }
+  _setFetchEdgeLocations(t) {
+    const e = this._idToComponent.get(t.id);
+    if (e == null || t.uid !== e.uid)
+      return;
+    const o = P.createView(t.locations), i = new Array(o.count), n = p(), s = p();
+    for (let d = 0; d < o.count; d++) {
+      o.position0.getVec(d, n), o.position1.getVec(d, s);
+      const a = I(n, s, t.origin), w = new T(e, d, a);
+      i[d] = w;
+    }
+    this._edges.add(i);
+    const { objectIds: c, origin: r } = t;
+    e.info = { locations: o, objectIds: c, origin: r };
+  }
+  _addCandidates(t, e, o) {
+    const { info: i } = e.component, { origin: n, objectIds: s } = i, c = i.locations, r = c.position0.getVec(e.index, this._tmpP1), d = c.position1.getVec(e.index, this._tmpP2);
+    g(r, r, n), g(d, d, n);
+    const a = s[c.componentIndex.get(e.index)];
+    this._addEdgeCandidate(t, a, r, d, o), this._addVertexCandidate(t, a, r, o), this._addVertexCandidate(t, a, d, o);
+  }
+  _addEdgeCandidate(t, e, o, i, n) {
+    if (!t.returnEdge)
+      return;
+    const s = _(t.bounds), c = L(o, i, this._tmpLineSegment), r = V(c, s, this._tmpP3);
+    b(t.bounds, r) && n.push({ type: "edge", objectId: e, target: m(r), distance: h(s, r), start: m(o), end: m(i) });
+  }
+  _addVertexCandidate(t, e, o, i) {
+    if (!t.returnVertex || !b(t.bounds, o))
+      return;
+    const n = _(t.bounds);
+    i.push({ type: "vertex", objectId: e, target: m(o), distance: h(n, o) });
+  }
+};
+f = x([E("esri.views.interactive.snapping.featureSources.sceneLayerSource.SceneLayerSnappingSourceWorker")], f);
+const et = f;
+class u {
+  constructor(e, o) {
+    this.id = e, this.bounds = o, this.info = null, this.uid = ++u.uid;
+  }
+}
+u.uid = 0;
+class T {
+  constructor(e, o, i) {
+    this.component = e, this.index = o, this.bounds = i;
+  }
+}
+export {
+  et as default
+};

package/dist/SceneLayerWorker-bab8aeb0.js

@@ -0,0 +1,164 @@
+import { h0 as K, bR as D } from "./index-f28919b2.js";
+import { y as Q } from "./DoubleArray-4f276822.js";
+import { i as W, a as X } from "./MeshLocalVertexSpace-59268d9e.js";
+import { n as Z, s as ee } from "./vec3-ab2339d6.js";
+import "./vec4f64-043e974c.js";
+import "./sphere-84d1e36b.js";
+import "./I3SUtil-ab1a91f5.js";
+import "vue";
+import "./vec42-1a7bd7a6.js";
+import "./ObjectStack-bad354ab.js";
+import "./plane-2b39f8eb.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./computeTranslationToOriginAndRotation-0b0f32ad.js";
+import "./projectVectorToVector-add01592.js";
+import "./projectPointToVector-1d9098bc.js";
+import "./I3SBinaryReader-d3a26893.js";
+import "./VertexAttribute-faad30bf.js";
+import "./symbolColorUtils-45615b74.js";
+import "./orientedBoundingBox-46d44acf.js";
+import "./quat-22f56b72.js";
+var S, $;
+(function(e) {
+  e[e.None = 0] = "None", e[e.Int16 = 1] = "Int16", e[e.Int32 = 2] = "Int32";
+})(S || (S = {})), function(e) {
+  e[e.Replace = 0] = "Replace", e[e.Outside = 1] = "Outside", e[e.Inside = 2] = "Inside", e[e.Finished = 3] = "Finished";
+}($ || ($ = {}));
+function te() {
+  return x || (x = new Promise((e) => import("./i3s-b5ed4851.js").then((t) => t.i).then(({ default: t }) => {
+    const n = t({ locateFile: ne, onRuntimeInitialized: () => e(n) });
+    delete n.then;
+  })).catch((e) => {
+    throw e;
+  })), x;
+}
+function ne(e) {
+  return K(`esri/libs/i3s/${e}`);
+}
+let x;
+var B, g, j, k, H;
+(function(e) {
+  e[e.Unmodified = 0] = "Unmodified", e[e.Culled = 1] = "Culled", e[e.NotChecked = 2] = "NotChecked";
+})(B || (B = {})), function(e) {
+  e[e.Unmodified = 0] = "Unmodified", e[e.PotentiallyModified = 1] = "PotentiallyModified", e[e.Culled = 2] = "Culled", e[e.Unknown = 3] = "Unknown", e[e.NotChecked = 4] = "NotChecked";
+}(g || (g = {}));
+(function(e) {
+  e[e.Unknown = 0] = "Unknown", e[e.Uncached = 1] = "Uncached", e[e.Cached = 2] = "Cached";
+})(j || (j = {})), function(e) {
+  e[e.None = 0] = "None", e[e.MaxScreenThreshold = 1] = "MaxScreenThreshold", e[e.ScreenSpaceRelative = 2] = "ScreenSpaceRelative", e[e.RemovedFeatureDiameter = 3] = "RemovedFeatureDiameter", e[e.DistanceRangeFromDefaultCamera = 4] = "DistanceRangeFromDefaultCamera";
+}(k || (k = {})), function(e) {
+  e[e.Hole = 0] = "Hole", e[e.Leaf = 1] = "Leaf";
+}(H || (H = {}));
+async function Me(e) {
+  r = await w();
+  const t = [e.geometryBuffer];
+  return { result: Y(r, e, t), transferList: t };
+}
+async function Pe(e) {
+  var m;
+  r = await w();
+  const t = [e.geometryBuffer], { geometryBuffer: n } = e, a = n.byteLength, i = r._malloc(a), u = new Uint8Array(r.HEAPU8.buffer, i, a);
+  u.set(new Uint8Array(n));
+  const f = r.dracoDecompressPointCloudData(i, u.byteLength);
+  if (r._free(i), f.error.length > 0)
+    throw new Error(`i3s.wasm: ${f.error}`);
+  const l = ((m = f.featureIds) == null ? void 0 : m.length) > 0 ? f.featureIds.slice() : null, s = f.positions.slice();
+  return l && t.push(l.buffer), t.push(s.buffer), { result: { positions: s, featureIds: l }, transferList: t };
+}
+async function _e(e) {
+  await w(), re(e);
+  const t = { buffer: e.buffer };
+  return { result: t, transferList: [t.buffer] };
+}
+async function xe(e) {
+  await w(), oe(e);
+}
+async function Fe(e) {
+  r = await w(), r.setLegacySchema(e.context, e.jsonSchema);
+}
+async function Oe(e) {
+  const { localMatrix: t, origin: n, positions: a, vertexSpace: i, localMode: u } = e, f = D.fromJSON(e.inSpatialReference), l = D.fromJSON(e.outSpatialReference);
+  let s;
+  if (i.type === "georeferenced" && i.origin == null) {
+    const [{ projectBuffer: c }, { initializeProjection: b }] = await Promise.all([import("./index-f28919b2.js").then((d) => d.m9), import("./index-f28919b2.js").then((d) => d.ma)]);
+    await b(f, l), s = new Float64Array(a.length), c(a, f, 0, s, l, 0, s.length / 3);
+  } else {
+    const c = i.type === "georeferenced" ? W.fromJSON(i) : X.fromJSON(i), { project: b } = await import("./georeference-f6f67e9b.js").then((d) => d.g);
+    s = Q(b({ positions: a, transform: t ? { localMatrix: t } : void 0, vertexSpace: c, inSpatialReference: f, outSpatialReference: l, localMode: u }));
+  }
+  const m = s.length, [U, R, M] = n;
+  for (let c = 0; c < m; c += 3)
+    s[c] -= U, s[c + 1] -= R, s[c + 2] -= M;
+  return { result: { projected: s, original: a }, transferList: [s.buffer, a.buffer] };
+}
+async function Ce({ normalMatrix: e, normals: t }) {
+  const n = new Float32Array(t.length);
+  return Z(n, t, e), ee(n, n), { result: { transformed: n, original: t }, transferList: [n.buffer, t.buffer] };
+}
+function Ne(e) {
+  J(e);
+}
+let A, r;
+function oe(e) {
+  if (!r)
+    return;
+  const t = e.modifications, n = r._malloc(8 * t.length), a = new Float64Array(r.HEAPU8.buffer, n, t.length);
+  for (let i = 0; i < t.length; ++i)
+    a[i] = t[i];
+  r.setModifications(e.context, n, t.length, e.isGeodetic), r._free(n);
+}
+function Y(e, t, n) {
+  const { context: a, localOrigin: i, globalTrafo: u, mbs: f, obbData: l, elevationOffset: s, geometryBuffer: m, geometryDescriptor: U, indexToVertexProjector: R, vertexToRenderProjector: M } = t, c = e._malloc(m.byteLength), b = 33, d = e._malloc(b * Float64Array.BYTES_PER_ELEMENT), F = new Uint8Array(e.HEAPU8.buffer, c, m.byteLength);
+  F.set(new Uint8Array(m));
+  const p = new Float64Array(e.HEAPU8.buffer, d, b);
+  L(p, i);
+  let E = p.byteOffset + 3 * p.BYTES_PER_ELEMENT, I = new Float64Array(p.buffer, E);
+  L(I, u), E += 16 * p.BYTES_PER_ELEMENT, I = new Float64Array(p.buffer, E), L(I, f), E += 4 * p.BYTES_PER_ELEMENT, l && (I = new Float64Array(p.buffer, E), L(I, l));
+  const O = U, z = { isDraco: !1, isLegacy: !1, color: t.layouts.some((y) => y.some((h) => h.name === "color")), normal: t.needNormals && t.layouts.some((y) => y.some((h) => h.name === "normalCompressed")), uv0: t.layouts.some((y) => y.some((h) => h.name === "uv0")), uvRegion: t.layouts.some((y) => y.some((h) => h.name === "uvRegion")), featureIndex: O.featureIndex }, o = e.process(a, !!t.obbData, c, F.byteLength, O, z, d, s, R, M, t.normalReferenceFrame);
+  if (e._free(d), e._free(c), o.error.length > 0)
+    throw new Error(`i3s.wasm: ${o.error}`);
+  if (o.discarded)
+    return null;
+  const P = o.componentOffsets.length > 0 ? o.componentOffsets.slice() : null, _ = o.featureIds.length > 0 ? o.featureIds.slice() : null, V = o.anchorIds.length > 0 ? Array.from(o.anchorIds) : null, G = o.anchors.length > 0 ? Array.from(o.anchors) : null, C = o.interleavedVertedData.slice().buffer, N = o.indicesType === S.Int16 ? new Uint16Array(o.indices.buffer, o.indices.byteOffset, o.indices.byteLength / 2).slice() : new Uint32Array(o.indices.buffer, o.indices.byteOffset, o.indices.byteLength / 4).slice(), v = o.positions.slice(), T = o.positionIndicesType === S.Int16 ? new Uint16Array(o.positionIndices.buffer, o.positionIndices.byteOffset, o.positionIndices.byteLength / 2).slice() : new Uint32Array(o.positionIndices.buffer, o.positionIndices.byteOffset, o.positionIndices.byteLength / 4).slice(), q = { layout: t.layouts[0], interleavedVertexData: C, indices: N, hasColors: o.hasColors, hasModifications: o.hasModifications, positionData: { data: v, indices: T } };
+  return _ && n.push(_.buffer), P && n.push(P.buffer), n.push(C), n.push(N.buffer), n.push(v.buffer), n.push(T.buffer), { componentOffsets: P, featureIds: _, anchorIds: V, anchors: G, transformedGeometry: q, obb: o.obb };
+}
+function ve(e) {
+  return e === 0 ? g.Unmodified : e === 1 ? g.PotentiallyModified : e === 2 ? g.Culled : g.Unknown;
+}
+function re(e) {
+  if (!r)
+    return;
+  const { context: t, buffer: n } = e, a = r._malloc(n.byteLength), i = n.byteLength / Float64Array.BYTES_PER_ELEMENT, u = new Float64Array(r.HEAPU8.buffer, a, i), f = new Float64Array(n);
+  u.set(f), r.filterOBBs(t, a, i), f.set(u), r._free(a);
+}
+function J(e) {
+  r && r.destroy(e) === 0 && (r = null);
+}
+function L(e, t) {
+  for (let n = 0; n < t.length; ++n)
+    e[n] = t[n];
+}
+async function Te() {
+  r || await w();
+}
+function w() {
+  return r ? Promise.resolve(r) : (A || (A = te().then((e) => (r = e, A = null, r))), A);
+}
+const De = { transform: (e, t) => r && Y(r, e, t), destroy: J };
+export {
+  Ne as destroyContext,
+  Pe as dracoDecompressPointCloudData,
+  _e as filterObbsForModifications,
+  re as filterObbsForModificationsSync,
+  Te as initialize,
+  ve as interpretObbModificationResults,
+  Me as process,
+  Oe as project,
+  Fe as setLegacySchema,
+  xe as setModifications,
+  oe as setModificationsSync,
+  De as test,
+  Ce as transformNormals
+};