@equinor/videx-3d 1.1.1 → 3.0.0

package/dist/chunk-BlPg4RjP.js

@@ -1,689 +0,0 @@
-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,
-  ut as e,
-  vt as f,
-  ot as m,
-  yt as t
-};