@equinor/videx-3d 1.0.0 → 1.0.2

package/dist/chunk-BolRQZt9.js

@@ -0,0 +1,687 @@
+import { lerp as Z } from "three/src/math/MathUtils.js";
+import { d as G, P as x, o as S, p as tt, a3 as N, E as st, F as et, aa as it, ag as nt, J as rt } from "./chunk-iY0wQ9Z6.js";
+import { BufferGeometry as K, BufferAttribute as L } from "three";
+function at(n, t) {
+  switch (t) {
+    case "Uint8Array":
+      return new Uint8Array(n);
+    case "Uint16Array":
+      return new Uint16Array(n);
+    case "Uint32Array":
+      return new Uint32Array(n);
+    case "Int8Array":
+      return new Int8Array(n);
+    case "Int16Array":
+      return new Int16Array(n);
+    case "Int32Array":
+      return new Int32Array(n);
+    case "Float32Array":
+      return new Float32Array(n);
+    case "Float64Array":
+      return new Float64Array(n);
+    default:
+      throw Error("Unsupported typed array!");
+  }
+}
+function ot(n, t = !1) {
+  if (!n.length) return null;
+  if (n.length === 1) return { geometry: n[0], groups: null };
+  const s = {
+    positions: Array.from(n[0].positions),
+    indices: Array.from(n[0].indices),
+    vertexCount: n[0].vertexCount,
+    indexCount: n[0].indexCount,
+    attributes: {}
+  };
+  for (const r in n[0].attributes)
+    s.attributes[r] = {
+      array: Array.from(n[0].attributes[r].array),
+      itemSize: n[0].attributes[r].itemSize,
+      type: n[0].attributes[r].type
+    };
+  const e = t ? [] : null;
+  let o = s.vertexCount, l = 0;
+  if (e) {
+    const r = s.indexCount;
+    e.push([l, r, e.length]), l += r;
+  }
+  for (let r = 1; r < n.length; r++) {
+    const i = n[r];
+    if (e) {
+      const a = i.indexCount;
+      e.push([l, a, e.length]), l += a;
+    }
+    s.positions = s.positions.concat(i.positions);
+    for (let a = 0; a < i.indices.length; a++)
+      s.indices.push(o + i.indices[a]);
+    s.vertexCount += i.vertexCount, s.indexCount += i.indexCount;
+    for (const a in s.attributes) {
+      if (!i.attributes || !i.attributes[a])
+        throw Error(`Attribute '${a}' missing in geometry`);
+      s.attributes[a].array = s.attributes[a].array.concat(i.attributes[a].array);
+    }
+    o += i.vertexCount, i.vertexCount = 0, i.indexCount = 0;
+  }
+  return { geometry: s, groups: e };
+}
+function ut(n, t = !1) {
+  const s = ot(n, t);
+  if (!s) return null;
+  const { geometry: e, groups: o } = s, l = new K();
+  o && o.forEach((i) => {
+    l.addGroup(i[0], i[1], i[2]);
+  }), l.setAttribute(
+    "position",
+    new L(Float32Array.from(e.positions), 3)
+  );
+  for (const i in e.attributes) {
+    const a = e.attributes[i], u = at(a.array, a.type);
+    l.setAttribute(i, new L(u, a.itemSize));
+  }
+  const r = e.indices.length < 65535 ? Uint16Array.from(e.indices) : Uint32Array.from(e.indices);
+  return l.setIndex(new L(r, 1)), l;
+}
+function D(n) {
+  const t = {
+    vertexCount: 0,
+    indexCount: 0,
+    positions: [],
+    indices: [],
+    attributes: {}
+  };
+  return n.computeNormals && (t.attributes.normal = {
+    array: [],
+    itemSize: 3,
+    type: "Float32Array"
+  }), n.computeLengths && (t.attributes.curveLength = {
+    array: [],
+    itemSize: 1,
+    type: "Float32Array"
+  }), n.computeRelativeLengths && (t.attributes.curveRelativeLength = {
+    array: [],
+    itemSize: 1,
+    type: "Float32Array"
+  }), n.computeCurveNormals && (t.attributes.curveNormal = {
+    array: [],
+    itemSize: 3,
+    type: "Float32Array"
+  }), n.computeCurveTangents && (t.attributes.curveTangent = {
+    array: [],
+    itemSize: 3,
+    type: "Float32Array"
+  }), n.computeCurveBinormals && (t.attributes.curveBinormal = {
+    array: [],
+    itemSize: 3,
+    type: "Float32Array"
+  }), n.computeCenterPoints && (t.attributes.centerPoint = {
+    array: [],
+    itemSize: 3,
+    type: "Float32Array"
+  }), n.computeUvs && (t.attributes.uv = {
+    array: [],
+    itemSize: 2,
+    type: "Float32Array"
+  }), t;
+}
+function U(n, t, s) {
+  if (t[0] === s[0]) return s[1];
+  const e = s[0] - t[0], o = G((n - t[0]) / e, 0, 1);
+  return Z(t[1], s[1], o);
+}
+function H(n, t, s, e, o, l, r, i) {
+  const a = [];
+  if (t === "none" || l.length === 0)
+    a.push([s, o], [e, o]);
+  else {
+    let d = [0, o], g = [1, o];
+    const b = l.findIndex((v) => v[0] > s);
+    b === -1 ? d = l[l.length - 1] : (b > 0 && (d = l[b - 1]), g = l[b]);
+    const y = t === "linear" ? U(s, d, g) : d[1];
+    a.push([s, y]);
+    for (let v = b; v >= 0 && v < l.length; v++) {
+      const p = l[v];
+      if (p[0] < e)
+        a.push(p);
+      else {
+        t === "linear" ? a.push([
+          e,
+          U(e, a[a.length - 1], p)
+        ]) : a.push([e, a[a.length - 1][1]]);
+        break;
+      }
+    }
+    a[a.length - 1][0] < e && (t === "linear" ? a.push([
+      e,
+      U(e, a[a.length - 1], [1, o])
+    ]) : a.push([e, a[a.length - 1][1]]));
+  }
+  const u = [], c = S(
+    n,
+    s,
+    e,
+    r,
+    i
+  );
+  let f = 0, h = c[f];
+  for (let d = 0; d < a.length - 1; d++) {
+    const g = d + 1, [b, y] = a[d], [v, p] = a[g], A = (v - b) * n.length, q = p - y, C = Math.atan2(q, A);
+    for (u.push([
+      b,
+      y,
+      t === "linear" ? C : 0
+    ]); h <= b && f < c.length - 1; )
+      h = c[++f];
+    for (; h < v && f < c.length; ) {
+      const z = t === "linear" ? U(h, a[d], a[g]) : y;
+      u.push([
+        h,
+        z,
+        t === "linear" ? C : 0
+      ]), h = c[f++];
+    }
+    if (g < a.length) {
+      if (t === "linear")
+        u.push([
+          v,
+          p,
+          t === "linear" ? C : 0
+        ]);
+      else if (t === "stepped") {
+        const z = C < 0 ? -x / 2 : x / 2;
+        u.push(
+          [v, y, 0],
+          [v, y, z],
+          [v, p, z]
+        );
+      }
+    }
+    g === a.length - 1 && t === "none" && u.push([v, p, C]);
+  }
+  const _ = tt(
+    n,
+    u.map((d) => d[0])
+  );
+  return u.map((d, g) => ({
+    radius: d[1],
+    theta: d[2],
+    ..._[g]
+  }));
+}
+function X(n, t, s, e, o, l, r = !0) {
+  const i = D(l), a = (u) => {
+    for (let c = 0; c <= t; c++) {
+      const f = c / t * x * 2, h = Math.sin(f), _ = -Math.cos(f), d = N([
+        _ * u.normal[0] + h * u.binormal[0],
+        _ * u.normal[1] + h * u.binormal[1],
+        _ * u.normal[2] + h * u.binormal[2]
+      ]), g = [
+        u.position[0] + u.radius * d[0],
+        u.position[1] + u.radius * d[1],
+        u.position[2] + u.radius * d[2]
+      ];
+      if (i.positions.push(...g), i.vertexCount++, i.attributes.normal) {
+        let b = st(d);
+        if (Number.isFinite(u.theta)) {
+          const y = N(
+            et(u.tangent, d)
+          );
+          b = it(d, y, u.theta);
+        }
+        i.attributes.normal.array.push(...b);
+      }
+      i.attributes.curveLength && i.attributes.curveLength.array.push(
+        u.curvePosition * e
+      ), i.attributes.curveRelativeLength && i.attributes.curveRelativeLength.array.push(
+        (u.curvePosition - o) * e
+      ), i.attributes.curveNormal && i.attributes.curveNormal.array.push(...u.normal), i.attributes.curveTangent && i.attributes.curveTangent.array.push(...u.tangent), i.attributes.curveBinormal && i.attributes.curveBinormal.array.push(...u.binormal), i.attributes.centerPoint && i.attributes.centerPoint.array.push(...u.position);
+    }
+  };
+  for (let u = 0; u < n.length; u++)
+    a(n[u]);
+  if (s && a(n[0]), i.attributes.uv)
+    for (let u = 0; u < n.length; u++)
+      for (let c = 0; c <= t; c++)
+        i.attributes.uv.array.push(
+          c / t,
+          u / (n.length - 1)
+        );
+  for (let u = 1; u < n.length; u++)
+    for (let c = 1; c <= t; c++) {
+      const f = (t + 1) * (u - 1) + (c - 1), h = (t + 1) * u + (c - 1), _ = (t + 1) * u + c, d = (t + 1) * (u - 1) + c;
+      i.indices.push(f, h, d), i.indices.push(h, _, d), i.indexCount += 6;
+    }
+  return r || i.indices.reverse(), i;
+}
+function Y(n, t, s = !0, e, o, l) {
+  const r = D(l), i = s ? [-n.tangent[0], -n.tangent[1], -n.tangent[2]] : n.tangent;
+  r.positions.push(...n.position), r.vertexCount++, r.attributes.normal && r.attributes.normal.array.push(...i), r.attributes.uv && r.attributes.uv.array.push(0.5, 0.5);
+  for (let c = 0; c <= t; c++) {
+    const f = c / t * x * 2, h = Math.sin(f), _ = -Math.cos(f), d = N([
+      _ * n.normal[0] + h * n.binormal[0],
+      _ * n.normal[1] + h * n.binormal[1],
+      _ * n.normal[2] + h * n.binormal[2]
+    ]);
+    if (r.positions.push(
+      n.position[0] + n.radius * d[0],
+      n.position[1] + n.radius * d[1],
+      n.position[2] + n.radius * d[2]
+    ), r.vertexCount++, r.attributes.normal && r.attributes.normal.array.push(...i), r.attributes.uv) {
+      const g = [(_ + 1) / 2, (h + 1) / 2];
+      s && (g[0] = 1 - g[0]), r.attributes.uv.array.push(...g);
+    }
+  }
+  const a = n.curvePosition * e, u = (n.curvePosition - o) * e;
+  for (let c = 0; c < r.vertexCount; c++)
+    r.attributes.curveLength && r.attributes.curveLength.array.push(a), r.attributes.curveRelativeLength && r.attributes.curveRelativeLength.array.push(u), r.attributes.curveNormal && r.attributes.curveNormal.array.push(...n.normal), r.attributes.curveTangent && r.attributes.curveTangent.array.push(...n.tangent), r.attributes.curveBinormal && r.attributes.curveBinormal.array.push(...n.binormal), r.attributes.centerPoint && r.attributes.centerPoint.array.push(...n.position);
+  for (let c = 1; c <= t; c++) {
+    let h, _;
+    s ? (h = c + 0, _ = c + 0 + 1) : (h = c + 0 + 1, _ = c + 0), r.indices.push(h, _, 0), r.indexCount += 3;
+  }
+  return r;
+}
+function J(n, t, s, e = !0, o, l, r) {
+  const i = D(r), a = e ? [
+    -n.tangent[0],
+    -n.tangent[1],
+    -n.tangent[2]
+  ] : [...n.tangent], u = t.radius / n.radius;
+  for (let h = 0; h <= s; h++) {
+    const _ = h / s * x * 2, d = Math.sin(_), g = -Math.cos(_), b = N([
+      g * n.normal[0] + d * n.binormal[0],
+      g * n.normal[1] + d * n.binormal[1],
+      g * n.normal[2] + d * n.binormal[2]
+    ]);
+    if (i.positions.push(
+      n.position[0] + n.radius * b[0],
+      n.position[1] + n.radius * b[1],
+      n.position[2] + n.radius * b[2]
+    ), i.positions.push(
+      t.position[0] + t.radius * b[0],
+      t.position[1] + t.radius * b[1],
+      t.position[2] + t.radius * b[2]
+    ), i.vertexCount += 2, i.attributes.normal && (i.attributes.normal.array.push(...a), i.attributes.normal.array.push(...a)), i.attributes.uv) {
+      const y = [(g + 1) / 2, (d + 1) / 2], v = [
+        (g * u + 1) / 2,
+        (d * u + 1) / 2
+      ];
+      e && (y[0] = 1 - y[0], v[0] = 1 - v[0]), i.attributes.uv.array.push(...y, ...v);
+    }
+  }
+  const c = n.curvePosition * o, f = (n.curvePosition - l) * o;
+  for (let h = 0; h < i.vertexCount; h++)
+    i.attributes.curveLength && i.attributes.curveLength.array.push(c), i.attributes.curveRelativeLength && i.attributes.curveRelativeLength.array.push(f), i.attributes.curveNormal && i.attributes.curveNormal.array.push(...n.normal), i.attributes.curveTangent && i.attributes.curveTangent.array.push(...n.tangent), i.attributes.curveBinormal && i.attributes.curveBinormal.array.push(...n.binormal), i.attributes.centerPoint && i.attributes.centerPoint.array.push(...n.position);
+  for (let h = 0; h < s; h++) {
+    const _ = h * 2, d = _ + 1, g = _ + 2, b = _ + 3;
+    e ? i.indices.push(_, g, d, d, g, b) : i.indices.push(g, _, d, d, b, g), i.indexCount += 6;
+  }
+  return i;
+}
+function ht(n, t = {}) {
+  const s = G(t.from || 0, 0, 1), e = G(t.to || 1);
+  if (e < s)
+    throw Error('Value of "from" must be less than the value of "to"!');
+  const o = [], l = t.radius || 1, r = t.radiusModifier?.steps || [], i = t.radialSegments || 8, a = t.startCap || !1, u = t.endCap || !1, c = n.closed, f = n.length;
+  r.sort((p, m) => p[0] - m[0]);
+  const h = t.segmentsPerMeter || 0.1, _ = t.radiusModifier?.type || "none", d = G(
+    t.simplificationThreshold || 0,
+    0,
+    1
+  ), g = H(
+    n,
+    _,
+    s,
+    e,
+    l,
+    r,
+    h,
+    d
+  );
+  o.push(
+    X(
+      g,
+      i,
+      c,
+      f,
+      s,
+      t,
+      !0
+    )
+  );
+  let b = null;
+  const y = t.innerRadius || 0, v = t.thickness || 0;
+  return (y > 0 || v > 0) && (v ? b = g.map((p) => ({
+    ...p,
+    radius: p.radius - v,
+    theta: p.theta - x
+  })) : b = H(
+    n,
+    "none",
+    s,
+    e,
+    y,
+    [],
+    h,
+    d
+  ).map((p) => ({
+    ...p,
+    theta: p.theta - x
+  })), o.push(
+    X(
+      b,
+      i,
+      c,
+      f,
+      s,
+      t,
+      !1
+    )
+  )), a && (!c || s > 0 || e < 1) && (b ? o.push(
+    J(
+      g[0],
+      b[0],
+      i,
+      !0,
+      f,
+      s,
+      t
+    )
+  ) : o.push(
+    Y(
+      g[0],
+      i,
+      !0,
+      f,
+      s,
+      t
+    )
+  )), u && (!c || s > 0 || e < 1) && (b ? o.push(
+    J(
+      g[g.length - 1],
+      b[b.length - 1],
+      i,
+      !1,
+      f,
+      s,
+      t
+    )
+  ) : o.push(
+    Y(
+      g[g.length - 1],
+      i,
+      !1,
+      f,
+      s,
+      t
+    )
+  )), o;
+}
+function gt(n, t = {}) {
+  const s = ht(n, t);
+  return ut(s, t.addGroups);
+}
+const $ = -1e3;
+class lt {
+  data;
+  width;
+  height;
+  coords = [];
+  // vertex coordinates (x, y)
+  triangles = [];
+  // mesh triangle indices
+  nullValue;
+  _queue = [];
+  _queueIndices = [];
+  _errors = [];
+  _halfedges = [];
+  _candidates = [];
+  _invalidPoints;
+  _rms = [];
+  _pending = [];
+  _pendingLen = 0;
+  _rmsSum = 0;
+  constructor(t, s, e = -1) {
+    this.data = t, this.width = s, this.height = this.data.length / s, this.nullValue = e, this._invalidPoints = /* @__PURE__ */ new Set();
+    const o = this.width - 1, l = this.height - 1, r = this._addPoint(0, 0), i = this._addPoint(o, 0), a = this._addPoint(0, l), u = this._addPoint(o, l), c = this._addTriangle(u, r, a, -1, -1, -1);
+    this._addTriangle(r, u, i, c, -1, -1), this._flush();
+  }
+  // refine the mesh until its maximum error gets below the given one
+  run(t = 1) {
+    for (; this.getMaxError() > t; )
+      this.refine();
+  }
+  // Removes triangles where one or more vertices contains a null value (nullValue)
+  removeInvalidTriangles() {
+    const t = [];
+    for (let s = 0; s < this.triangles.length; s += 3) {
+      const e = this.triangles[s], o = this.triangles[s + 1], l = this.triangles[s + 2];
+      !this._invalidPoints.has(e) && !this._invalidPoints.has(o) && !this._invalidPoints.has(l) && t.push(
+        this.triangles[s],
+        this.triangles[s + 1],
+        this.triangles[s + 2]
+      );
+    }
+    this.triangles = t;
+  }
+  // refine the mesh with a single point
+  refine() {
+    this._step(), this._flush();
+  }
+  // max error of the current mesh
+  getMaxError() {
+    return this._errors[0];
+  }
+  // root-mean-square deviation of the current mesh
+  getRMSD() {
+    return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
+  }
+  // height value at a given position
+  heightAt(t, s) {
+    const e = this.data[this.width * s + t];
+    return e === this.nullValue ? $ : e;
+  }
+  // rasterize a triangle, find its max error, and queue it for processing
+  _findCandidate(t, s, e, o, l, r, i) {
+    const a = Math.min(t, e, l), u = Math.min(s, o, r), c = Math.max(t, e, l), f = Math.max(s, o, r);
+    let h = P(e, o, l, r, a, u), _ = P(l, r, t, s, a, u), d = P(t, s, e, o, a, u);
+    const g = o - s, b = t - e, y = r - o, v = e - l, p = s - r, m = l - t, A = P(t, s, e, o, l, r), q = this.heightAt(t, s) / A, C = this.heightAt(e, o) / A, z = this.heightAt(l, r) / A;
+    let R = 0, M = 0, F = 0, k = 0;
+    for (let T = u; T <= f; T++) {
+      let w = 0;
+      h < 0 && y !== 0 && (w = Math.max(w, Math.floor(-h / y))), _ < 0 && p !== 0 && (w = Math.max(w, Math.floor(-_ / p))), d < 0 && g !== 0 && (w = Math.max(w, Math.floor(-d / g)));
+      let E = h + y * w, V = _ + p * w, j = d + g * w, O = !1;
+      for (let I = a + w; I <= c; I++) {
+        if (E >= 0 && V >= 0 && j >= 0) {
+          O = !0;
+          const Q = q * E + C * V + z * j, W = this.heightAt(I, T), B = Math.abs(Q - W);
+          k += B * B, B > R && (R = B, M = I, F = T);
+        } else if (O)
+          break;
+        E += y, V += p, j += g;
+      }
+      h += v, _ += m, d += b;
+    }
+    (M === t && F === s || M === e && F === o || M === l && F === r) && (R = 0), this._candidates[2 * i] = M, this._candidates[2 * i + 1] = F, this._rms[i] = k, this._queuePush(i, R, k);
+  }
+  // process the next triangle in the queue, splitting it with a new point
+  _step() {
+    const t = this._queuePop(), s = t * 3 + 0, e = t * 3 + 1, o = t * 3 + 2, l = this.triangles[s], r = this.triangles[e], i = this.triangles[o], a = this.coords[2 * l], u = this.coords[2 * l + 1], c = this.coords[2 * r], f = this.coords[2 * r + 1], h = this.coords[2 * i], _ = this.coords[2 * i + 1], d = this._candidates[2 * t], g = this._candidates[2 * t + 1], b = this._addPoint(d, g);
+    if (P(a, u, c, f, d, g) === 0)
+      this._handleCollinear(b, s);
+    else if (P(c, f, h, _, d, g) === 0)
+      this._handleCollinear(b, e);
+    else if (P(h, _, a, u, d, g) === 0)
+      this._handleCollinear(b, o);
+    else {
+      const y = this._halfedges[s], v = this._halfedges[e], p = this._halfedges[o], m = this._addTriangle(l, r, b, y, -1, -1, s), A = this._addTriangle(r, i, b, v, -1, m + 1), q = this._addTriangle(i, l, b, p, m + 2, A + 1);
+      this._legalize(m), this._legalize(A), this._legalize(q);
+    }
+  }
+  _addPoint(t, s) {
+    const e = this.coords.length >> 1;
+    return this.coords.push(t, s), this.heightAt(t, s) === $ && this._invalidPoints.add(e), e;
+  }
+  _addTriangle(t, s, e, o, l, r, i = this.triangles.length) {
+    const a = i / 3;
+    return this.triangles[i + 0] = t, this.triangles[i + 1] = s, this.triangles[i + 2] = e, this._halfedges[i + 0] = o, this._halfedges[i + 1] = l, this._halfedges[i + 2] = r, o >= 0 && (this._halfedges[o] = i + 0), l >= 0 && (this._halfedges[l] = i + 1), r >= 0 && (this._halfedges[r] = i + 2), this._candidates[2 * a + 0] = 0, this._candidates[2 * a + 1] = 0, this._queueIndices[a] = -1, this._rms[a] = 0, this._pending[this._pendingLen++] = a, i;
+  }
+  _flush() {
+    const t = this.coords;
+    for (let s = 0; s < this._pendingLen; s++) {
+      const e = this._pending[s], o = 2 * this.triangles[e * 3 + 0], l = 2 * this.triangles[e * 3 + 1], r = 2 * this.triangles[e * 3 + 2];
+      this._findCandidate(
+        t[o],
+        t[o + 1],
+        t[l],
+        t[l + 1],
+        t[r],
+        t[r + 1],
+        e
+      );
+    }
+    this._pendingLen = 0;
+  }
+  _legalize(t) {
+    const s = this._halfedges[t];
+    if (s < 0)
+      return;
+    const e = t - t % 3, o = s - s % 3, l = e + (t + 1) % 3, r = e + (t + 2) % 3, i = o + (s + 2) % 3, a = o + (s + 1) % 3, u = this.triangles[r], c = this.triangles[t], f = this.triangles[l], h = this.triangles[i], _ = this.coords;
+    if (!ct(
+      _[2 * u],
+      _[2 * u + 1],
+      _[2 * c],
+      _[2 * c + 1],
+      _[2 * f],
+      _[2 * f + 1],
+      _[2 * h],
+      _[2 * h + 1]
+    ))
+      return;
+    const d = this._halfedges[l], g = this._halfedges[r], b = this._halfedges[i], y = this._halfedges[a];
+    this._queueRemove(e / 3), this._queueRemove(o / 3);
+    const v = this._addTriangle(u, h, f, -1, b, d, e), p = this._addTriangle(h, u, c, v, g, y, o);
+    this._legalize(v + 1), this._legalize(p + 2);
+  }
+  _handleCollinear(t, s) {
+    const e = s - s % 3, o = e + (s + 1) % 3, l = e + (s + 2) % 3, r = this.triangles[l], i = this.triangles[s], a = this.triangles[o], u = this._halfedges[o], c = this._halfedges[l], f = this._halfedges[s];
+    if (f < 0) {
+      const q = this._addTriangle(t, r, i, -1, c, -1, e), C = this._addTriangle(r, t, a, q, -1, u);
+      this._legalize(q + 1), this._legalize(C + 2);
+      return;
+    }
+    const h = f - f % 3, _ = h + (f + 2) % 3, d = h + (f + 1) % 3, g = this.triangles[_], b = this._halfedges[_], y = this._halfedges[d];
+    this._queueRemove(h / 3);
+    const v = this._addTriangle(r, i, t, c, -1, -1, e), p = this._addTriangle(i, g, t, y, -1, v + 1, h), m = this._addTriangle(g, a, t, b, -1, p + 1), A = this._addTriangle(a, r, t, u, v + 2, m + 1);
+    this._legalize(v), this._legalize(p), this._legalize(m), this._legalize(A);
+  }
+  // priority queue methods
+  _queuePush(t, s, e) {
+    const o = this._queue.length;
+    this._queueIndices[t] = o, this._queue.push(t), this._errors.push(s), this._rmsSum += e, this._queueUp(o);
+  }
+  _queuePop() {
+    const t = this._queue.length - 1;
+    return this._queueSwap(0, t), this._queueDown(0, t), this._queuePopBack();
+  }
+  _queuePopBack() {
+    const t = this._queue.pop();
+    return this._errors.pop(), this._rmsSum -= this._rms[t], this._queueIndices[t] = -1, t;
+  }
+  _queueRemove(t) {
+    const s = this._queueIndices[t];
+    if (s < 0) {
+      const o = this._pending.indexOf(t);
+      if (o !== -1)
+        this._pending[o] = this._pending[--this._pendingLen];
+      else
+        throw new Error("Broken triangulation (something went wrong).");
+      return;
+    }
+    const e = this._queue.length - 1;
+    e !== s && (this._queueSwap(s, e), this._queueDown(s, e) || this._queueUp(s)), this._queuePopBack();
+  }
+  _queueLess(t, s) {
+    return this._errors[t] > this._errors[s];
+  }
+  _queueSwap(t, s) {
+    const e = this._queue[t], o = this._queue[s];
+    this._queue[t] = o, this._queue[s] = e, this._queueIndices[e] = s, this._queueIndices[o] = t;
+    const l = this._errors[t];
+    this._errors[t] = this._errors[s], this._errors[s] = l;
+  }
+  _queueUp(t) {
+    let s = t;
+    for (; ; ) {
+      const e = s - 1 >> 1;
+      if (e === s || !this._queueLess(s, e))
+        break;
+      this._queueSwap(e, s), s = e;
+    }
+  }
+  _queueDown(t, s) {
+    let e = t;
+    for (; ; ) {
+      const o = 2 * e + 1;
+      if (o >= s || o < 0)
+        break;
+      const l = o + 1;
+      let r = o;
+      if (l < s && this._queueLess(l, o) && (r = l), !this._queueLess(r, e))
+        break;
+      this._queueSwap(e, r), e = r;
+    }
+    return e > t;
+  }
+}
+function P(n, t, s, e, o, l) {
+  return (s - o) * (t - l) - (e - l) * (n - o);
+}
+function ct(n, t, s, e, o, l, r, i) {
+  const a = n - r, u = t - i, c = s - r, f = e - i, h = o - r, _ = l - i, d = a * a + u * u, g = c * c + f * f, b = h * h + _ * _;
+  return a * (f * b - g * _) - u * (c * b - g * h) + d * (c * _ - f * h) < 0;
+}
+function bt(n, t, s) {
+  const e = nt(n), o = new Array(e.length);
+  let l = null;
+  for (let f = 0; f < e.length; f++)
+    l !== null ? o[f] = o[l] + rt(e[l], e[f]) : o[f] = 0, l = f;
+  const r = o[o.length - 1], i = new K(), a = new Float32Array(e.length * 2 * 3), u = new Uint32Array((e.length - 1) * 6), c = new Float32Array(e.length * 2 * 2);
+  for (let f = 0; f < e.length; f++) {
+    const h = f * 6;
+    a[h] = e[f][0], a[h + 1] = t, a[h + 2] = e[f][1], a[h + 3] = e[f][0], a[h + 4] = s, a[h + 5] = e[f][1];
+    const _ = f * 4;
+    c[_] = o[f] / r, c[_ + 1] = 1, c[_ + 2] = o[f] / r, c[_ + 3] = 0;
+    const d = f * 2;
+    f < e.length - 1 && (u[h] = d, u[h + 1] = d + 1, u[h + 2] = d + 2, u[h + 3] = d + 2, u[h + 4] = d + 1, u[h + 5] = d + 3);
+  }
+  return i.setAttribute("position", new L(a, 3)), i.setAttribute("uv", new L(c, 2)), i.setIndex(new L(u, 1)), i.computeVertexNormals(), i;
+}
+function vt(n, t, s = 1, e = 1, o = -1, l = 5) {
+  const r = t, i = n.length / r;
+  console.time("delatin");
+  const a = new lt(n, r, o);
+  a.run(l), a.removeInvalidTriangles(), console.timeEnd("delatin");
+  const u = new Float32Array(a.coords.length * 1.5), c = new Float32Array(a.coords.length);
+  for (let h = 0, _ = 0; h < a.coords.length; h += 2)
+    c[h] = a.coords[h] / (r - 1), c[h + 1] = 1 - a.coords[h + 1] / (i - 1), _ = h * 1.5, u[_] = a.coords[h] * s, u[_ + 1] = a.heightAt(a.coords[h], a.coords[h + 1]), u[_ + 2] = a.coords[h + 1] * e;
+  const f = new Uint32Array(a.triangles);
+  return console.log(a.triangles.length / 3), { positions: u, uvs: c, indices: f };
+}
+function pt(n) {
+  let t = 0, s, e;
+  if (!n || n.length === 0) return t;
+  for (s = 0; s < n.length; s++)
+    e = n.charCodeAt(s), t = (t << 5) - t + e, t |= 0;
+  return t;
+}
+function yt(n) {
+  return n.replace(/(^|\s)\S/g, (t) => t.toUpperCase());
+}
+export {
+  lt as D,
+  bt as a,
+  ht as b,
+  pt as c,
+  gt as d,
+  vt as e,
+  yt as t
+};

package/dist/{chunk-BX-cez1_.js → chunk-DuRASjkF.js}

@@ -1,8 +1,4 @@
-const s = "casings", e = {
-  Shoe: 0,
-  Casing: 1,
-  Generic: 2
-}, a = "completionTools", n = {
+const o = "completionTools", e = {
   "blank pipe": 0,
   tube: 1,
   packer: 2,
@@ -16,8 +12,6 @@ const s = "casings", e = {
   unknown: 10
 };
 export {
-  a,
-  e as b,
-  s as c,
-  n as d
+  e as a,
+  o as c
 };