@equinor/videx-3d 1.0.3 → 1.1.1

package/dist/sdk.js

@@ -1,10 +1,12 @@
-import { wrap as Z } from "comlink";
-import $ from "p-limit";
-import { x as ct, D as ft, P as ut, b as dt, a as gt, c as pt, T as wt, y as yt, z as mt, A as xt, B as bt, p as vt, d as _t, E as Mt, F as At, G as Ft, H as Lt, I as St, J as Vt, K as It, L as Bt, M as Tt, e as Et, N as Dt, o as qt, O as zt, Q as Gt, R as kt, i as Pt, S as jt, U as Nt, V as Ct, X as Qt, g as Ut, Y as Wt, Z as Ht, _ as Zt, $ as $t, h as Jt, m as Kt, a0 as Ot, a1 as Xt, a2 as Yt, n as Rt, a3 as te, f as ee, a4 as se, a5 as ie, a6 as re, a7 as ne, a8 as ae, a9 as le, aa as oe, ab as he, ac as ce, ad as fe, ae as ue, af as de, ag as ge, s as pe, ah as we, ai as ye, aj as me, u as xe, ak as be } from "./chunk-iY0wQ9Z6.js";
-import { C as _e, T as Me, c as Ae, b as Fe, a as Le, d as Se, e as Ve, g as Ie, f as Be, t as Te, h as Ee, w as De } from "./chunk-CnY6Tmof.js";
-import { D as ze, c as Ge, a as ke, b as Pe, d as je, t as Ne, e as Ce } from "./chunk-BolRQZt9.js";
-const J = 10, K = 25;
-class Y {
+import { wrap as Y } from "comlink";
+import R from "p-limit";
+import { d as K } from "./chunk-iY0wQ9Z6.js";
+import { x as xt, D as bt, P as vt, b as Mt, a as Ct, c as Et, T as Bt, y as At, z as zt, A as Ft, B as It, p as St, E as Lt, F as Vt, G as Tt, H as Pt, I as Dt, J as Gt, K as qt, L as jt, M as kt, e as Nt, N as Ot, o as Qt, O as Ut, Q as Wt, R as Ht, i as Zt, S as $t, U as Jt, V as Kt, X as Xt, g as Yt, Y as Rt, Z as te, _ as ee, $ as se, h as ie, m as ne, a0 as re, a1 as ae, a2 as oe, n as le, a3 as he, f as ce, a4 as fe, a5 as ue, a6 as de, a7 as ge, a8 as me, a9 as pe, aa as ye, ab as _e, ac as we, ad as xe, ae as be, af as ve, ag as Me, s as Ce, ah as Ee, ai as Be, aj as Ae, u as ze, ak as Fe } from "./chunk-iY0wQ9Z6.js";
+import { C as Se, T as Le, c as Ve, b as Te, a as Pe, d as De, e as Ge, g as qe, f as je, t as ke, h as Ne, w as Oe } from "./chunk-CnY6Tmof.js";
+import { D as Ue, c as We, a as He, b as Ze, d as $e, m as Je, t as Ke, e as Xe, f as Ye } from "./chunk-BlPg4RjP.js";
+import { Vector2 as N, Shape as tt, Path as et } from "three";
+const st = 10, it = 25;
+class lt {
   store;
   config;
   cached = /* @__PURE__ */ new Map();
@@ -12,7 +14,7 @@ class Y {
   _batchqueue = /* @__PURE__ */ new Map();
   _flushScheduled = null;
   constructor(t, e = {}) {
-    this.store = t, this.config = { ...e }, this.config.batched && (this.config.batchSize === void 0 && (this.config.batchSize = J), this.config.batchMaxDelay === void 0 && (this.config.batchMaxDelay = K)), this._flushScheduled = null;
+    this.store = t, this.config = { ...e }, this.config.batched && (this.config.batchSize === void 0 && (this.config.batchSize = st), this.config.batchMaxDelay === void 0 && (this.config.batchMaxDelay = it)), this._flushScheduled = null;
   }
   async init(...t) {
     if (this.config.init)
@@ -40,30 +42,30 @@ class Y {
     if (this._batchqueue.has(t))
       return this._batchqueue.get(t).promise;
     let e = null;
-    const i = new Promise((n) => {
-      e = n;
-    }), r = {
+    const s = new Promise((r) => {
+      e = r;
+    }), i = {
       key: t,
-      promise: i,
+      promise: s,
       _resolve: e
     };
-    return this._batchqueue.set(t, r), this._flushScheduled || (this._flushScheduled = setTimeout(() => {
+    return this._batchqueue.set(t, i), this._flushScheduled || (this._flushScheduled = setTimeout(() => {
       this._processBatchQueue();
-    }, this.config.batchMaxDelay)), i;
+    }, this.config.batchMaxDelay)), s;
   }
   async _processBatch(t) {
-    const e = t.map((i) => i.key);
+    const e = t.map((s) => s.key);
     if (!this.config.batchLoad) return null;
-    this.config.batchLoad(e).then((i) => {
-      Array.isArray(i) && i.forEach(([r, n]) => {
-        this.set(r, n);
+    this.config.batchLoad(e).then((s) => {
+      Array.isArray(s) && s.forEach(([i, r]) => {
+        this.set(i, r);
       });
-    }).catch((i) => {
-      console.warn("Batch load failed", i);
+    }).catch((s) => {
+      console.warn("Batch load failed", s);
     }).finally(() => {
-      t.forEach((i) => {
-        const r = this.cached.get(i.key) || null;
-        i._resolve(r);
+      t.forEach((s) => {
+        const i = this.cached.get(s.key) || null;
+        s._resolve(i);
       });
     });
   }
@@ -80,21 +82,21 @@ class Y {
     if (!this.config.batched && this.config.load) {
       if (this.config.noCache)
         return this.config.load(t, e);
-      let i = this._activeLoaders[t];
-      if (!i) {
+      let s = this._activeLoaders[t];
+      if (!s) {
         if (e)
           throw Error(
             "DataLoader: A load function with additional args may not be cached. Set noCache to true in config."
           );
-        i = this.config.load(t).then((r) => {
-          r && this.cached.set(t, r);
-        }).catch((r) => {
-          console.warn("Load failed", r);
+        s = this.config.load(t).then((i) => {
+          i && this.cached.set(t, i);
+        }).catch((i) => {
+          console.warn("Load failed", i);
         }).finally(() => {
           delete this._activeLoaders[t];
-        }), this._activeLoaders[t] = i;
+        }), this._activeLoaders[t] = s;
       }
-      return await i, this.config.transform ? this.config.transform(this.cached.get(t)) : this.cached.get(t);
+      return await s, this.config.transform ? this.config.transform(this.cached.get(t)) : this.cached.get(t);
     }
     return this.config.batched && this.config.batchLoad ? this._enqueueRequest(t) : null;
   }
@@ -105,7 +107,7 @@ class Y {
     this.cached.clear();
   }
 }
-class R {
+class ht {
   store = null;
   config;
   generators = /* @__PURE__ */ new Map();
@@ -117,17 +119,17 @@ class R {
   }
   setStore(t) {
     if (t && this.config.concurrentStoreCalls) {
-      const e = $(this.config.concurrentStoreCalls), i = {
-        get: (r, n, s) => e(() => t.get(r, n, s)),
-        all: (r) => e(() => t.all(r)),
-        query: (r, n) => e(() => t.query(r, n))
+      const e = R(this.config.concurrentStoreCalls), s = {
+        get: (i, r, n) => e(() => t.get(i, r, n)),
+        all: (i) => e(() => t.all(i)),
+        query: (i, r) => e(() => t.query(i, r))
       };
-      this.store = i;
+      this.store = s;
     } else
       this.store = t;
   }
   async connectRemoteStore(t) {
-    const e = Z(t);
+    const e = Y(t);
     this.setStore(e);
   }
   async invoke(t, ...e) {
@@ -137,96 +139,262 @@ class R {
     return this.generators.get(t).bind(this.store)(...e);
   }
 }
-function tt(u, t, e = 1, i = 1, r = (n) => n) {
+class W {
+  type;
+  coordinates;
+  _min = null;
+  _max = null;
+  _size = null;
+  _offset = [0, 0];
+  constructor(t, e, s) {
+    this.type = t, this.coordinates = e, s && (this._offset[0] = s[0], this._offset[1] = s[1]);
+  }
+  static fromPointCoordinates(t, e) {
+    const s = e ? t.map(e) : t;
+    return new H(s);
+  }
+  static fromLineCoordinates(t, e) {
+    const s = e ? t.map((i) => i.map(e)) : t;
+    return new Z(s);
+  }
+  static fromPolygonCoordinates(t, e) {
+    const s = e ? t.map((i) => i.map((r) => r.map(e))) : t;
+    return new $(s);
+  }
+  _calculateBounds() {
+    const t = [1 / 0, 1 / 0], e = [-1 / 0, -1 / 0], s = (i) => {
+      i[0] < t[0] && (t[0] = i[0]), i[0] > e[0] && (e[0] = i[0]), i[1] < t[1] && (t[1] = i[1]), i[1] > e[1] && (e[1] = i[1]);
+    };
+    this.forEachCoordinate(s), this._min = t, this._max = e, this._size = [e[0] - t[0], e[1] - t[1]];
+  }
+  get min() {
+    return this._min || this._calculateBounds(), [...this._min];
+  }
+  get max() {
+    return this._max || this._calculateBounds(), [...this._max];
+  }
+  get center() {
+    return (!this._min || !this._max || !this._size) && this._calculateBounds(), [
+      this.min[0] + this.size[0] / 2,
+      this.min[1] + this.size[1] / 2
+    ];
+  }
+  get size() {
+    return this._size || this._calculateBounds(), [...this._size];
+  }
+  get offset() {
+    return [...this._offset];
+  }
+  setOffset(t) {
+    this.forEachCoordinate((e) => {
+      e[0] -= t[0], e[1] -= t[1];
+    }), this._min && (this._min[0] -= t[0], this._min[1] -= t[1]), this._max && (this._max[0] -= t[0], this._max[1] -= t[1]), this._offset[0] += t[0], this._offset[1] += t[1];
+  }
+  removeOffset() {
+    (this._offset[0] !== 0 || this._offset[1] !== 0) && (this.forEachCoordinate((t) => {
+      t[0] += this._offset[0], t[1] += this._offset[1];
+    }), this._min = null, this._max = null, this._size = null, this._offset = [0, 0]);
+  }
+  centralize() {
+    this.setOffset(this.center);
+  }
+  normalize(t = [1, 1], e = [0, 0]) {
+    this.centralize();
+    const s = this.getBounds();
+    this.forEachCoordinate((i) => {
+      i[0] = K((i[0] - s.min[0]) / s.size[0]) * t[0] + e[0], i[1] = K((i[1] - s.min[1]) / s.size[1]) * t[1] + e[1];
+    });
+  }
+  transform(t) {
+    (this._offset[0] !== 0 || this._offset[1] !== 0) && this.removeOffset(), this.forEachCoordinate((e) => {
+      const s = t(e);
+      e[0] = s[0], e[1] = s[1];
+    }), this._min = null, this._max = null, this._size = null;
+  }
+  toObject() {
+    return {
+      type: this.type.toString(),
+      coordinates: structuredClone(this.coordinates),
+      offset: this.offset
+    };
+  }
+  getPointsFlattened() {
+    const t = [];
+    return this.forEachCoordinate((e) => {
+      t.push(new N(e[0], e[1]));
+    }), t;
+  }
+  getBounds() {
+    return {
+      min: this.min,
+      max: this.max,
+      size: this.size
+    };
+  }
+}
+class H extends W {
+  constructor(t, e) {
+    super("point2d", t, e);
+  }
+  forEachCoordinate(t) {
+    this.coordinates.forEach((s) => t(s));
+  }
+  getPoints() {
+    return this.coordinates.map((e) => [new N(e[0], e[1])]);
+  }
+  clone() {
+    return new H(
+      structuredClone(this.coordinates),
+      this.offset
+    );
+  }
+}
+class Z extends W {
+  constructor(t, e) {
+    super("line2d", t, e);
+  }
+  forEachCoordinate(t) {
+    this.coordinates.forEach((s) => s.forEach((i) => t(i)));
+  }
+  getPoints() {
+    return this.coordinates.map((e) => e.map((s) => new N(s[0], s[1])));
+  }
+  clone() {
+    return new Z(
+      structuredClone(this.coordinates),
+      this.offset
+    );
+  }
+}
+class $ extends W {
+  constructor(t, e) {
+    super("polygon2d", t, e);
+  }
+  forEachCoordinate(t) {
+    this.coordinates.forEach((s) => s.forEach((i) => i.forEach((r) => t(r))));
+  }
+  getPoints() {
+    return this.coordinates.map(
+      (e) => e.reduce(
+        (s, i) => s.concat(i.map((r) => new N(r[0], r[1]))),
+        []
+      )
+    );
+  }
+  clone() {
+    return new $(
+      structuredClone(this.coordinates),
+      this._offset
+    );
+  }
+  toShapes() {
+    const t = [], e = (i, r) => {
+      i.moveTo(r[0][0], r[0][1]);
+      for (let n = 1; n < r.length; n++)
+        i.lineTo(r[n][0], r[n][1]);
+      i.closePath();
+    };
+    return this.coordinates.forEach((i) => {
+      const r = new tt(), n = i[0];
+      e(r, n);
+      for (let a = 1; a < i.length; a++) {
+        const c = new et();
+        e(c, i[a]), r.holes.push(c);
+      }
+      t.push(r);
+    }), t;
+  }
+}
+function ct(u, t, e = 1, s = 1, i = (r) => r) {
   console.time("triangulate");
-  const n = [], s = [], a = [], c = [], h = u.length / t;
-  let l, o, d, g, v, y, m, _, A, S, b, V, M, F, L, k, f, C, D, q, z, p, x, Q, H = 0, U = 0, W = 0, B = new Array(t).fill(null), P = new Array(t).fill(null);
-  const w = new Array(t - 1).fill(null);
-  function j(I, E, G) {
-    return n.push({ x: I * e, y: G, z: E * i, edge: null }), a.push(I / (t - 1), 1 - E / (h - 1)), H++;
-  }
-  function T(I, E, G) {
-    D = {
+  const r = [], n = [], a = [], c = [], h = u.length / t;
+  let o, l, d, g, b, y, _, v, C, A, x, z, M, E, B, G, f, O, V, T, P, m, w, Q, X = 0, U = 0, J = 0, I = new Array(t).fill(null), q = new Array(t).fill(null);
+  const p = new Array(t - 1).fill(null);
+  function j(F, L, D) {
+    return r.push({ x: F * e, y: D, z: L * s, edge: null }), a.push(F / (t - 1), 1 - L / (h - 1)), X++;
+  }
+  function S(F, L, D) {
+    V = {
       index: U++,
-      tail: I,
-      head: E,
+      tail: F,
+      head: L,
       twin: null,
       prev: null,
       next: null
-    }, q = {
+    }, T = {
       index: U++,
-      tail: E,
-      head: G,
+      tail: L,
+      head: D,
       twin: null,
       prev: null,
       next: null
-    }, z = {
+    }, P = {
       index: U++,
-      tail: G,
-      head: I,
+      tail: D,
+      head: F,
       twin: null,
       prev: null,
       next: null
-    }, D.next = q, q.next = z, z.next = D, D.prev = z, q.prev = D, z.prev = q, n[I].edge || (n[I].edge = D), n[E].edge || (n[E].edge = q), n[G].edge || (n[G].edge = z), s.push(D, q, z), c.push(I, E, G);
+    }, V.next = T, T.next = P, P.next = V, V.prev = P, T.prev = V, P.prev = T, r[F].edge || (r[F].edge = V), r[L].edge || (r[L].edge = T), r[D].edge || (r[D].edge = P), n.push(V, T, P), c.push(F, L, D);
   }
-  for (k = 1; k < h - 1; k++) {
+  for (G = 1; G < h - 1; G++) {
     Q = !1;
-    const I = B;
-    for (B = P, P = I.fill(null), p = null, C = k - 1, W += t, L = 1; L < t - 1; L++)
-      f = L - 1, S = W + L, A = S - 1, _ = S - t, m = _ - 1, b = r(u[m]), V = r(u[_]), M = r(u[A]), F = r(u[S]), b !== null && V !== null && M !== null && F !== null ? x = 1 : b !== null && V !== null && M !== null ? x = 2 : b !== null && V !== null && F !== null ? x = 3 : b !== null && M !== null && F !== null ? x = 4 : V !== null && M !== null && F !== null ? x = 5 : x = 0, d = null, g = null, x !== 0 ? (Q ? (l = B[f], d = P[f]) : (x !== 5 && (B[f] === null ? (l = j(f, C, b), B[f] = l) : l = B[f]), x !== 3 && (d = j(f, k, M)), P[f] = d), x !== 4 && (B[L] === null ? (o = j(L, C, V), B[L] = o) : o = B[L]), x !== 2 && (g = j(L, k, F)), x === 1 ? (v = Math.abs(n[l].y - n[g].y), y = Math.abs(n[o].y - n[d].y), v < y ? (T(l, d, g), p !== null && (s[s.length - 3].twin = p, p.twin = s[s.length - 3]), T(g, o, l), w[f] !== null && (s[s.length - 2].twin = w[f], w[f].twin = s[s.length - 2]), s[s.length - 4].twin = s[s.length - 1], s[s.length - 1].twin = s[s.length - 4], w[f] = s[s.length - 5], p = s[s.length - 3]) : (T(l, d, o), w[f] !== null && (s[s.length - 1].twin = w[f], w[f].twin = s[s.length - 1]), p !== null && (s[s.length - 3].twin = p, p.twin = s[s.length - 3]), T(o, d, g), s[s.length - 5].twin = s[s.length - 3], s[s.length - 3].twin = s[s.length - 5], w[f] = s[s.length - 2], p = s[s.length - 1])) : x === 2 ? (T(l, d, o), w[f] !== null && (s[s.length - 1].twin = w[f], w[f].twin = s[s.length - 1]), p !== null && (s[s.length - 3].twin = p, p.twin = s[s.length - 3]), w[f] = null, p = null) : x === 5 ? (T(o, d, g), w[f] = s[s.length - 2], p = s[s.length - 1]) : x === 3 ? (T(o, l, g), w[f] !== null && (s[s.length - 3].twin = w[f], w[f].twin = s[s.length - 3]), w[f] = null, p = s[s.length - 1]) : (T(l, d, g), p !== null && (s[s.length - 3].twin = p, p.twin = s[s.length - 3]), w[f] = s[s.length - 2], p = null)) : (w[f] = null, p = null), P[L] = g, Q = !!x;
+    const F = I;
+    for (I = q, q = F.fill(null), m = null, O = G - 1, J += t, B = 1; B < t - 1; B++)
+      f = B - 1, A = J + B, C = A - 1, v = A - t, _ = v - 1, x = i(u[_]), z = i(u[v]), M = i(u[C]), E = i(u[A]), x !== null && z !== null && M !== null && E !== null ? w = 1 : x !== null && z !== null && M !== null ? w = 2 : x !== null && z !== null && E !== null ? w = 3 : x !== null && M !== null && E !== null ? w = 4 : z !== null && M !== null && E !== null ? w = 5 : w = 0, d = null, g = null, w !== 0 ? (Q ? (o = I[f], d = q[f]) : (w !== 5 && (I[f] === null ? (o = j(f, O, x), I[f] = o) : o = I[f]), w !== 3 && (d = j(f, G, M)), q[f] = d), w !== 4 && (I[B] === null ? (l = j(B, O, z), I[B] = l) : l = I[B]), w !== 2 && (g = j(B, G, E)), w === 1 ? (b = Math.abs(r[o].y - r[g].y), y = Math.abs(r[l].y - r[d].y), b < y ? (S(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), S(g, l, o), p[f] !== null && (n[n.length - 2].twin = p[f], p[f].twin = n[n.length - 2]), n[n.length - 4].twin = n[n.length - 1], n[n.length - 1].twin = n[n.length - 4], p[f] = n[n.length - 5], m = n[n.length - 3]) : (S(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), S(l, d, g), n[n.length - 5].twin = n[n.length - 3], n[n.length - 3].twin = n[n.length - 5], p[f] = n[n.length - 2], m = n[n.length - 1])) : w === 2 ? (S(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = null, m = null) : w === 5 ? (S(l, d, g), p[f] = n[n.length - 2], m = n[n.length - 1]) : w === 3 ? (S(l, o, g), p[f] !== null && (n[n.length - 3].twin = p[f], p[f].twin = n[n.length - 3]), p[f] = null, m = n[n.length - 1]) : (S(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = n[n.length - 2], m = null)) : (p[f] = null, m = null), q[B] = g, Q = !!w;
   }
-  return console.timeEnd("triangulate"), console.log(c.length / 3), { vertices: n, indices: c, uvs: a, edges: s };
+  return console.timeEnd("triangulate"), console.log(c.length / 3), { vertices: r, indices: c, uvs: a, edges: n };
 }
-const et = (u) => `#${u.toString(16).padStart(6, "0")}`;
-function st() {
+const ft = (u) => `#${u.toString(16).padStart(6, "0")}`;
+function ut() {
   const u = "123456789ABCDEF";
   let t = "#";
   for (let e = 0; e < 6; e++)
     t += u[Math.floor(Math.random() * 16)];
   return t;
 }
-async function it(u, t = -1, e = null) {
-  const i = await u.arrayBuffer(), r = new DataView(i), n = {
-    ny: r.getInt32(8, !1),
-    xori: r.getFloat32(12, !1),
-    xmax: r.getFloat32(16, !1),
-    yori: r.getFloat32(20, !1),
-    ymax: r.getFloat32(24, !1),
-    xinc: r.getFloat32(28, !1),
-    yinc: r.getFloat32(32, !1),
-    nx: r.getInt32(44, !1),
-    rot: r.getFloat32(48, !1)
-  }, s = 1e30, a = 1e-30, c = new Float32Array(n.nx * n.ny);
-  let h, l, o, d, g, v = 0, y = 100;
-  for (; y < r.byteLength; ) {
-    l = r.getInt32(y), y += 4;
-    for (let m = 0; m < l; m += 4)
-      h = r.getFloat32(y + m, !1), o = v % n.nx, d = n.ny - Math.floor(v / n.nx), g = (d - 1) * n.nx + o, c[g] = h < a || h > s ? t : e ? e - h : h, v++;
-    y += l + 4;
-  }
-  return { header: n, data: c };
+async function dt(u, t = -1, e = null) {
+  const s = await u.arrayBuffer(), i = new DataView(s), r = {
+    ny: i.getInt32(8, !1),
+    xori: i.getFloat32(12, !1),
+    xmax: i.getFloat32(16, !1),
+    yori: i.getFloat32(20, !1),
+    ymax: i.getFloat32(24, !1),
+    xinc: i.getFloat32(28, !1),
+    yinc: i.getFloat32(32, !1),
+    nx: i.getInt32(44, !1),
+    rot: i.getFloat32(48, !1)
+  }, n = 1e30, a = 1e-30, c = new Float32Array(r.nx * r.ny);
+  let h, o, l, d, g, b = 0, y = 100;
+  for (; y < i.byteLength; ) {
+    o = i.getInt32(y), y += 4;
+    for (let _ = 0; _ < o; _ += 4)
+      h = i.getFloat32(y + _, !1), l = b % r.nx, d = r.ny - Math.floor(b / r.nx), g = (d - 1) * r.nx + l, c[g] = h < a || h > n ? t : e ? e - h : h, b++;
+    y += o + 4;
+  }
+  return { header: r, data: c };
 }
-function rt(u) {
+function gt(u) {
   return u.map((t) => -t);
 }
-function nt(u, t) {
+function mt(u, t) {
   return u.map((e) => e * t);
 }
-function at(u, t, e) {
-  const i = (r) => {
-    if (r.userData[u] && r.userData[u] === t)
-      return r;
-    if (r.children && r.children.length)
-      for (let n = 0; n < r.children.length; n++) {
-        const s = i(r.children[n]);
-        if (s)
-          return s;
+function pt(u, t, e) {
+  const s = (i) => {
+    if (i.userData[u] && i.userData[u] === t)
+      return i;
+    if (i.children && i.children.length)
+      for (let r = 0; r < i.children.length; r++) {
+        const n = s(i.children[r]);
+        if (n)
+          return n;
       }
     return null;
   };
-  return i(e);
+  return s(e);
 }
-class N {
+class k {
   data;
   columns;
   rows;
@@ -234,45 +402,45 @@ class N {
   _rowLength;
   _lerpFn = [];
   arrayConstructor;
-  constructor(t, e, i = 1) {
-    this.data = t, this.columns = e, this.stride = i, this._rowLength = e * i, this.rows = this.data.length / this._rowLength, this.arrayConstructor = (r) => new this.data.constructor(
-      r
+  constructor(t, e, s = 1) {
+    this.data = t, this.columns = e, this.stride = s, this._rowLength = e * s, this.rows = this.data.length / this._rowLength, this.arrayConstructor = (i) => new this.data.constructor(
+      i
     );
   }
-  static readWriteBlock(t, e, i, r, n, s, a, c, h, l, o = null) {
-    if (!(t instanceof N && s instanceof N))
+  static readWriteBlock(t, e, s, i, r, n, a, c, h, o, l = null) {
+    if (!(t instanceof k && n instanceof k))
       throw Error("Source and target must be of type Typed2dArray");
-    if (a < 0 || a + h > s.columns || c < 0 || c + l > s.rows)
+    if (a < 0 || a + h > n.columns || c < 0 || c + o > n.rows)
       throw Error("Invalid target block dimensions!");
-    if (e < 0 || e + r > t.columns || i < 0 || i + n > t.rows)
+    if (e < 0 || e + i > t.columns || s < 0 || s + r > t.rows)
       throw Error("Invalid source block dimensions!");
-    const d = Math.max(1, h - 1), g = Math.max(1, l - 1), v = Math.max(1, r - 1), y = Math.max(1, n - 1);
-    for (let m = 0; m < l; m++) {
-      const _ = s.index(0, m + c), A = m / g * y + i;
-      for (let S = 0; S < h; S++) {
-        const b = _ + (S + a) * s.stride, V = S / d * v + e;
-        let M = t.valueAt(V, A);
-        if (o && (M = o(M)), s.stride === 1)
-          s.data[b] = M;
+    const d = Math.max(1, h - 1), g = Math.max(1, o - 1), b = Math.max(1, i - 1), y = Math.max(1, r - 1);
+    for (let _ = 0; _ < o; _++) {
+      const v = n.index(0, _ + c), C = _ / g * y + s;
+      for (let A = 0; A < h; A++) {
+        const x = v + (A + a) * n.stride, z = A / d * b + e;
+        let M = t.valueAt(z, C);
+        if (l && (M = l(M)), n.stride === 1)
+          n.data[x] = M;
         else if (Array.isArray(M))
-          for (let F = 0; F < M.length; F++)
-            s.data[b + F] = M[F];
+          for (let E = 0; E < M.length; E++)
+            n.data[x + E] = M[E];
       }
     }
     return this;
   }
   // built-in interpolation methods
-  static logInterp(t, e, i, r, n, s) {
-    const a = (e * e - t * t) * n + t * t, c = (r * r - i * i) * n + i * i;
-    return Math.sqrt((c - a) * s + a);
+  static logInterp(t, e, s, i, r, n) {
+    const a = (e * e - t * t) * r + t * t, c = (i * i - s * s) * r + s * s;
+    return Math.sqrt((c - a) * n + a);
   }
-  static linearInterp(t, e, i, r, n, s) {
-    const a = (e - t) * n + t;
-    return ((r - i) * n + i - a) * s + a;
+  static linearInterp(t, e, s, i, r, n) {
+    const a = (e - t) * r + t;
+    return ((i - s) * r + s - a) * n + a;
   }
-  static nearestInterp(t, e, i, r, n, s) {
-    const a = n <= 0.5 ? t : e, c = n <= 0.5 ? i : r;
-    return s <= 0.5 ? a : c;
+  static nearestInterp(t, e, s, i, r, n) {
+    const a = r <= 0.5 ? t : e, c = r <= 0.5 ? s : i;
+    return n <= 0.5 ? a : c;
   }
   // // create a new Typed2DArray instance using an existing data array
   // static from<ArrayType>(source: ArrayType, columns: number, stride = 1, copyData = false) {
@@ -301,8 +469,8 @@ class N {
   // get the column and row at the beginning of the item according to stride from an index into the data array
   positionOf(t) {
     if (t < 0 || t > this.data.length) return;
-    const e = t % this.stride, i = Math.floor((t - e) / this._rowLength), r = Math.floor((t - i * this._rowLength) / this.stride);
-    return { row: i, col: r };
+    const e = t % this.stride, s = Math.floor((t - e) / this._rowLength), i = Math.floor((t - s * this._rowLength) / this.stride);
+    return { row: s, col: i };
   }
   // allow you to set a custom interpolation function per component, which are used when interpolating values
   setInterpolator(...t) {
@@ -310,7 +478,7 @@ class N {
   }
   // get the configured interpolation function for the given component index
   getInterpolator(t) {
-    return this._lerpFn.length > 0 ? this._lerpFn[Math.min(t, this._lerpFn.length - 1)] : N.linearInterp;
+    return this._lerpFn.length > 0 ? this._lerpFn[Math.min(t, this._lerpFn.length - 1)] : k.linearInterp;
   }
   // convenience function for reading an entire column
   col(t, e) {
@@ -326,37 +494,37 @@ class N {
   }
   // convenience function for reading an entire row
   row(t, e) {
-    const i = this.index(0, Math.floor(t));
+    const s = this.index(0, Math.floor(t));
     if (e) {
-      for (let r = 0; r < this._rowLength; r++)
-        e[r] = this.data[i + r];
+      for (let i = 0; i < this._rowLength; i++)
+        e[i] = this.data[s + i];
       return e;
     }
-    return this.data.subarray(i, i + this._rowLength);
+    return this.data.subarray(s, s + this._rowLength);
   }
   // set a single value into the provided column and row
-  setValue(t, e, ...i) {
-    const r = this.index(t, e);
-    for (let n = 0; n < Math.min(i.length, this.stride); n++)
-      this.data[r + n] = i[n];
+  setValue(t, e, ...s) {
+    const i = this.index(t, e);
+    for (let r = 0; r < Math.min(s.length, this.stride); r++)
+      this.data[i + r] = s[r];
     return this;
   }
   // read all the values within the provided block dimension
-  readBlock(t, e, i, r, n, s, a) {
-    if (t < 0 || t + i > this.columns || e < 0 || e + r > this.rows)
+  readBlock(t, e, s, i, r, n, a) {
+    if (t < 0 || t + s > this.columns || e < 0 || e + i > this.rows)
       throw Error("Invalid block dimensions!");
-    n = Number.isFinite(n) ? n : i, s = Number.isFinite(s) ? s : r, a = a || this.arrayConstructor(n * s * this.stride);
-    const c = Math.max(1, n - 1), h = Math.max(1, s - 1), l = Math.max(1, i - 1), o = Math.max(1, r - 1);
+    r = Number.isFinite(r) ? r : s, n = Number.isFinite(n) ? n : i, a = a || this.arrayConstructor(r * n * this.stride);
+    const c = Math.max(1, r - 1), h = Math.max(1, n - 1), o = Math.max(1, s - 1), l = Math.max(1, i - 1);
     let d = 0;
-    for (let g = 0; g < s; g++) {
-      const v = g / h * o + e;
-      for (let y = 0; y < n; y++) {
-        const m = y / c * l + t, _ = this.valueAt(m, v);
+    for (let g = 0; g < n; g++) {
+      const b = g / h * l + e;
+      for (let y = 0; y < r; y++) {
+        const _ = y / c * o + t, v = this.valueAt(_, b);
         if (this.stride === 1)
-          a[d++] = _;
-        else if (Array.isArray(_))
-          for (let A = 0; A < _.length; A++)
-            a[d++] = _[A];
+          a[d++] = v;
+        else if (Array.isArray(v))
+          for (let C = 0; C < v.length; C++)
+            a[d++] = v[C];
       }
     }
     return a;
@@ -367,7 +535,7 @@ class N {
       throw Error(
         "New column and row size must be equal or bigger than the current sizes!"
       );
-    const i = this.readBlock(
+    const s = this.readBlock(
       0,
       0,
       this.columns,
@@ -375,114 +543,114 @@ class N {
       t,
       e
     );
-    return this.columns = t, this.rows = e, this._rowLength = t * this.stride, this.data = i, this;
+    return this.columns = t, this.rows = e, this._rowLength = t * this.stride, this.data = s, this;
   }
   // write values into a given block dimension
-  writeBlock(t, e, i, r, n) {
-    if (n.length !== i * r * this.stride)
+  writeBlock(t, e, s, i, r) {
+    if (r.length !== s * i * this.stride)
       throw Error("Incorrect number of values");
-    if (t < 0 || t + i > this.columns || e < 0 || e + r > this.rows)
+    if (t < 0 || t + s > this.columns || e < 0 || e + i > this.rows)
       throw Error("Invalid block dimensions!");
-    let s = 0;
-    for (let a = e; a < e + r; a++) {
+    let n = 0;
+    for (let a = e; a < e + i; a++) {
       const c = this.index(t, a);
-      for (let h = 0; h < i; h++) {
-        const l = c + h * this.stride;
-        for (let o = 0; o < this.stride; o++)
-          this.data[l + o] = n[s++];
+      for (let h = 0; h < s; h++) {
+        const o = c + h * this.stride;
+        for (let l = 0; l < this.stride; l++)
+          this.data[o + l] = r[n++];
       }
     }
     return this;
   }
   // fills the block with a single value
-  fillBlock(t, e, i, r, n) {
-    if (t < 0 || t + i > this.columns || e < 0 || e + r > this.rows)
+  fillBlock(t, e, s, i, r) {
+    if (t < 0 || t + s > this.columns || e < 0 || e + i > this.rows)
       throw Error("Invalid block dimensions!");
-    let s = (a, c, h) => {
-      this.data[h] = n;
+    let n = (a, c, h) => {
+      this.data[h] = r;
     };
-    typeof n == "function" ? s = (a, c, h) => {
-      const l = n(a, c, h);
-      if (Array.isArray(l) && l.length && l.length > 0)
-        for (let o = 0; o < Math.min(l.length, this.stride); o++)
-          this.data[h + o] = l[o];
+    typeof r == "function" ? n = (a, c, h) => {
+      const o = r(a, c, h);
+      if (Array.isArray(o) && o.length && o.length > 0)
+        for (let l = 0; l < Math.min(o.length, this.stride); l++)
+          this.data[h + l] = o[l];
       else
-        this.data[h] = l;
-    } : this.stride > 1 && Array.isArray(n) && (s = (a, c, h) => {
-      for (let l = 0; l < Math.min(n.length, this.stride); l++)
-        this.data[h + l] = n[l];
+        this.data[h] = o;
+    } : this.stride > 1 && Array.isArray(r) && (n = (a, c, h) => {
+      for (let o = 0; o < Math.min(r.length, this.stride); o++)
+        this.data[h + o] = r[o];
     });
-    for (let a = e; a < e + r; a++) {
+    for (let a = e; a < e + i; a++) {
       const c = this.index(t, a);
-      for (let h = 0; h < i; h++) {
-        const l = c + h * this.stride;
-        s(h, a, l);
+      for (let h = 0; h < s; h++) {
+        const o = c + h * this.stride;
+        n(h, a, o);
       }
     }
     return this;
   }
   // get the value corresponding to the specified index according to stride
   valueOf(t, e) {
-    const { stride: i, data: r } = this;
-    if (i > 1) {
-      t = t % i, e = e || this.arrayConstructor(i);
-      for (let n = 0; n < i; n++)
-        e[n] = r[t + n];
+    const { stride: s, data: i } = this;
+    if (s > 1) {
+      t = t % s, e = e || this.arrayConstructor(s);
+      for (let r = 0; r < s; r++)
+        e[r] = i[t + r];
       return e;
     }
-    return r[t];
+    return i[t];
   }
   // get the calue at the requested column and row, which may be given as fractions, which in case
   // bilinear filtering will be applied to interpolate values (for each component) in between columns and rows
-  valueAt(t, e, i) {
-    const { columns: r, rows: n, stride: s, data: a } = this, c = t % 1, h = e % 1;
+  valueAt(t, e, s) {
+    const { columns: i, rows: r, stride: n, data: a } = this, c = t % 1, h = e % 1;
     if (c > 0 || h > 0) {
-      const o = (t < 0 ? 0 : t >= r ? r - 1 : t) | 0, d = (e < 0 ? 0 : e >= n ? n - 1 : e) | 0, g = o === r - 1 ? o : o + 1, v = d === n - 1 ? d : d + 1;
-      let y = this.index(o, d), m = this.index(g, d), _ = this.index(o, v), A = this.index(g, v);
-      if (s > 1) {
-        i = i || this.arrayConstructor(s);
-        for (let b = 0; b < s; b++) {
-          const V = this.getInterpolator(b);
-          i[b] = V(a[y++], a[m++], a[_++], a[A++], c, h);
+      const l = (t < 0 ? 0 : t >= i ? i - 1 : t) | 0, d = (e < 0 ? 0 : e >= r ? r - 1 : e) | 0, g = l === i - 1 ? l : l + 1, b = d === r - 1 ? d : d + 1;
+      let y = this.index(l, d), _ = this.index(g, d), v = this.index(l, b), C = this.index(g, b);
+      if (n > 1) {
+        s = s || this.arrayConstructor(n);
+        for (let x = 0; x < n; x++) {
+          const z = this.getInterpolator(x);
+          s[x] = z(a[y++], a[_++], a[v++], a[C++], c, h);
         }
-        return i;
+        return s;
       }
-      return this.getInterpolator(0)(a[y], a[m], a[_], a[A], c, h);
+      return this.getInterpolator(0)(a[y], a[_], a[v], a[C], c, h);
     }
-    const l = this.index(t, e);
-    if (s > 1) {
-      i = i || this.arrayConstructor(s);
-      for (let o = 0; o < s; o++)
-        i[o] = a[l + o];
-      return i;
+    const o = this.index(t, e);
+    if (n > 1) {
+      s = s || this.arrayConstructor(n);
+      for (let l = 0; l < n; l++)
+        s[l] = a[o + l];
+      return s;
     }
-    return a[l];
+    return a[o];
   }
   // swap all values from one row with all values from another row
-  swapRows(t, e, i) {
-    i = i || this.arrayConstructor(this._rowLength), this.row(t, i);
-    const r = this.index(0, t), n = this.index(0, e);
-    for (let s = 0; s < this._rowLength; s++)
-      this.data[r + s] = this.data[n + s], this.data[n + s] = i[s];
+  swapRows(t, e, s) {
+    s = s || this.arrayConstructor(this._rowLength), this.row(t, s);
+    const i = this.index(0, t), r = this.index(0, e);
+    for (let n = 0; n < this._rowLength; n++)
+      this.data[i + n] = this.data[r + n], this.data[r + n] = s[n];
     return this;
   }
   // invert all rows (top-bottom to bottom-top)
   invertRows() {
     const t = Math.floor(this.rows / 2), e = this.arrayConstructor(this._rowLength);
-    for (let i = this.rows - 1, r = 0; i > t; i--, r++)
-      this.swapRows(i, r, e);
+    for (let s = this.rows - 1, i = 0; s > t; s--, i++)
+      this.swapRows(s, i, e);
     return this;
   }
-  copyInto(t, e = 0, i = 0, r = this.columns - e, n = this.rows - i) {
-    if (t.length !== r * n * this.stride)
+  copyInto(t, e = 0, s = 0, i = this.columns - e, r = this.rows - s) {
+    if (t.length !== i * r * this.stride)
       throw Error("Target is not of the correct size!");
-    let s = 0;
-    for (let a = i; a < i + n; a++) {
+    let n = 0;
+    for (let a = s; a < s + r; a++) {
       const c = this.index(0, a);
-      for (let h = e; h < e + r; h++) {
-        const l = c + h * this.stride;
-        for (let o = 0; o < this.stride; o++)
-          t[s++] = this.data[l + o];
+      for (let h = e; h < e + i; h++) {
+        const o = c + h * this.stride;
+        for (let l = 0; l < this.stride; l++)
+          t[n++] = this.data[o + l];
       }
     }
     return this;
@@ -491,121 +659,127 @@ class N {
   toJsArray() {
     const t = new Array(this.rows);
     for (let e = 0; e < this.rows; e++) {
-      const i = this.index(0, e);
+      const s = this.index(0, e);
       t[e] = new Array(this.columns);
-      for (let r = 0; r < this.columns; r++)
+      for (let i = 0; i < this.columns; i++)
         if (this.stride > 1) {
-          t[e][r] = new Array(this.stride);
-          for (let n = 0; n < this.stride; n++)
-            t[e][r][n] = this.data[i + r * this.stride + n];
+          t[e][i] = new Array(this.stride);
+          for (let r = 0; r < this.stride; r++)
+            t[e][i][r] = this.data[s + i * this.stride + r];
         } else
-          t[e][r] = this.data[i + r * this.stride];
+          t[e][i] = this.data[s + i * this.stride];
     }
     return t;
   }
 }
-function lt(u) {
+function yt(u) {
   const t = new Float32Array(u.length * 3);
   for (let e = 0; e < u.length; e++) {
-    const i = e * 3;
-    t[i + 0] = u[e][0], t[i + 1] = u[e][1], t[i + 2] = u[e][2];
+    const s = e * 3;
+    t[s + 0] = u[e][0], t[s + 1] = u[e][1], t[s + 2] = u[e][2];
   }
   return t;
 }
 export {
-  _e as CRS,
-  ct as CameraManager,
-  Y as DataLoader,
-  ze as Delatin,
-  ft as DepthReadMaterial,
-  R as GeneratorRegistry,
-  ut as PI,
-  dt as PI2,
-  gt as PI4,
-  pt as PI8,
-  wt as TAU,
-  Me as TubeMaterial,
-  N as Typed2DArray,
-  yt as WellboreManager,
-  mt as addVec2,
-  xt as addVec3,
-  bt as angleVec3,
-  vt as calculateFrenetFrames,
-  Ge as calculateHashValue,
-  Ae as calculateWellSegments,
-  _t as clamp,
-  Mt as copyVec3,
-  Fe as createConfig,
-  Le as createElevationTexture,
-  ke as createFenceGeometry,
-  Se as createNormalTexture,
-  Pe as createTubeGeometries,
-  je as createTubeGeometry,
-  At as crossVec3,
-  Ft as degreesToRadians,
-  Lt as directionVec2,
-  St as directionVec3,
-  Vt as distanceVec2,
-  It as distanceVec3,
-  Bt as dotVec2,
-  Tt as dotVec3,
-  Et as edgeOfRectangle,
-  Ve as elevationMapNormalsToRGBA,
-  Dt as feetToMeters,
-  qt as getCurvePositions,
-  zt as getFormationMarkers,
-  at as getObjectByCustomProperty,
-  Gt as getProjectedTrajectory,
-  Ie as getProjectionDefFromUtmZone,
-  kt as getSplineCurve,
-  Pt as getTrajectory,
-  jt as getTypedArrayFromBuffer,
-  Nt as getTypedArrayType,
-  Be as getUtmZoneFromLatLng,
-  Ct as getVec2,
-  Qt as getVec3,
-  Ut as getWellboreFormations,
-  et as idToHexColor,
-  Wt as inverseLerp,
-  Ht as lengthVec2,
-  Zt as lengthVec3,
-  $t as lerp,
-  Jt as mergeFormationIntervals,
-  Kt as mixVec2,
-  Ot as mixVec3,
-  nt as multiply,
-  rt as negate,
-  Xt as negateVec2,
-  Yt as negateVec3,
-  Rt as normalizeVec2,
-  te as normalizeVec3,
-  ee as normalizedDeviceToScreen,
-  se as packAttribute,
-  ie as packBufferGeometries,
-  re as packBufferGeometry,
-  ne as packBufferGeometryLike,
-  it as parseIrapbin,
-  st as randomColor,
-  ae as readDepth,
-  le as remap,
-  oe as rotateVec3,
-  he as scaleVec2,
-  ce as scaleVec3,
-  fe as screenToNormalizedDevice,
-  ue as setVec2,
-  de as setVec3,
-  ge as simplifyCurve2D,
-  pe as subVec2,
-  we as subVec3,
-  Ne as titleCase,
-  lt as toFloat32Array,
-  ye as toRGB,
-  Te as toSegments,
-  Ee as triangleNormal,
-  tt as triangulateGrid,
-  Ce as triangulateGridDelaunay,
-  me as unpackBufferGeometries,
-  xe as unpackBufferGeometry,
-  be as uvMaterial,
-  De as wgs84Def
+  Se as CRS,
+  xt as CameraManager,
+  lt as DataLoader,
+  Ue as Delatin,
+  bt as DepthReadMaterial,
+  ht as GeneratorRegistry,
+  vt as PI,
+  Mt as PI2,
+  Ct as PI4,
+  Et as PI8,
+  W as PlanarGeometry,
+  Z as PlanarLineGeometry,
+  H as PlanarPointGeometry,
+  $ as PlanarPolygonGeometry,
+  Bt as TAU,
+  Le as TubeMaterial,
+  k as Typed2DArray,
+  At as WellboreManager,
+  zt as addVec2,
+  Ft as addVec3,
+  It as angleVec3,
+  St as calculateFrenetFrames,
+  We as calculateHashValue,
+  Ve as calculateWellSegments,
+  K as clamp,
+  Lt as copyVec3,
+  Te as createConfig,
+  Pe as createElevationTexture,
+  He as createFenceGeometry,
+  De as createNormalTexture,
+  Ze as createTubeGeometries,
+  $e as createTubeGeometry,
+  Vt as crossVec3,
+  Tt as degreesToRadians,
+  Pt as directionVec2,
+  Dt as directionVec3,
+  Gt as distanceVec2,
+  qt as distanceVec3,
+  jt as dotVec2,
+  kt as dotVec3,
+  Nt as edgeOfRectangle,
+  Ge as elevationMapNormalsToRGBA,
+  Ot as feetToMeters,
+  Qt as getCurvePositions,
+  Ut as getFormationMarkers,
+  pt as getObjectByCustomProperty,
+  Wt as getProjectedTrajectory,
+  qe as getProjectionDefFromUtmZone,
+  Ht as getSplineCurve,
+  Zt as getTrajectory,
+  $t as getTypedArrayFromBuffer,
+  Jt as getTypedArrayType,
+  je as getUtmZoneFromLatLng,
+  Kt as getVec2,
+  Xt as getVec3,
+  Yt as getWellboreFormations,
+  ft as idToHexColor,
+  Rt as inverseLerp,
+  te as lengthVec2,
+  ee as lengthVec3,
+  se as lerp,
+  ie as mergeFormationIntervals,
+  Je as mergeGeometries,
+  ne as mixVec2,
+  re as mixVec3,
+  mt as multiply,
+  gt as negate,
+  ae as negateVec2,
+  oe as negateVec3,
+  le as normalizeVec2,
+  he as normalizeVec3,
+  ce as normalizedDeviceToScreen,
+  fe as packAttribute,
+  ue as packBufferGeometries,
+  de as packBufferGeometry,
+  ge as packBufferGeometryLike,
+  dt as parseIrapbin,
+  ut as randomColor,
+  me as readDepth,
+  pe as remap,
+  ye as rotateVec3,
+  _e as scaleVec2,
+  we as scaleVec3,
+  xe as screenToNormalizedDevice,
+  be as setVec2,
+  ve as setVec3,
+  Me as simplifyCurve2D,
+  Ce as subVec2,
+  Ee as subVec3,
+  Ke as titleCase,
+  Xe as toBufferGeometry,
+  yt as toFloat32Array,
+  Be as toRGB,
+  ke as toSegments,
+  Ne as triangleNormal,
+  ct as triangulateGrid,
+  Ye as triangulateGridDelaunay,
+  Ae as unpackBufferGeometries,
+  ze as unpackBufferGeometry,
+  Fe as uvMaterial,
+  Oe as wgs84Def
 };