@equinor/videx-3d 1.0.0 → 1.0.2

package/dist/chunk-MFzFdEWm.js

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