videx-3d/dist/chunk-CkcLzcfd.js

React 3D component library designed for sub surface visualizations in the browser

var bt = Object.defineProperty;
var Tt = (t, n, r) => n in t ? bt(t, n, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[n] = r;
var Z = (t, n, r) => Tt(t, typeof n != "symbol" ? n + "" : n, r);
import { BufferGeometry as ut, BufferAttribute as C, Vector3 as E, Layers as Pt, MeshDepthMaterial as Ft, RGBADepthPacking as vt, WebGLRenderTarget as lt, UnsignedByteType as ft, ShaderMaterial as dt, OrthographicCamera as It, Scene as Et, PlaneGeometry as Ut, Mesh as Dt, RGBAFormat as Rt, DataTexture as pt, LinearFilter as k } from "three";
import "comlink";
import "p-limit";
import { CurveInterpolator as Vt, EPS as Bt } from "curve-interpolator";
import "three/src/math/MathUtils.js";
import "proj4";
async function ln(t, n, r, e) {
  const s = await r.get("formations", t) || [];
  e = e === void 0 ? -1 / 0 : e;
  const a = s.filter((o) => o.stratColumnId === n && o.exit.mdMsl > e);
  return a.sort((o, i) => o.entry.mdMsl - i.entry.mdMsl || o.level - i.level), a.length && a[0].entry.mdMsl < e && (a[0].entry.mdMsl = e), a;
}
function st(t, n, r) {
  return {
    mdMslFrom: n,
    mdMslTo: r,
    name: t.name,
    level: t.level,
    color: t.color,
    properties: { ...t.properties || {} }
  };
}
function fn(t) {
  if (!t.length) return [];
  let n = [];
  const r = [...t].sort(
    (e, s) => {
      var o, i, u, c, f, d;
      const a = s.level - e.level || e.entry.mdMsl - s.entry.mdMsl;
      if (a === 0 && ((o = e.properties) != null && o.updated || (i = s.properties) != null && i.updated)) {
        const l = (u = e.properties) != null && u.updated ? new Date((c = e.properties) == null ? void 0 : c.updated) : null, p = (f = s.properties) != null && f.updated ? new Date((d = s.properties) == null ? void 0 : d.updated) : null;
        return l === null ? 1 : p === null ? -1 : p.getTime() - l.getTime();
      }
      return a;
    }
  );
  for (let e = 0; e < r.length; e++) {
    const s = r[e];
    let a = s.entry.mdMsl;
    const o = [...n];
    for (let i = 0; i < n.length && a < s.exit.mdMsl; i++) {
      const u = n[i];
      if (a < u.mdMslFrom) {
        const c = Math.min(s.exit.mdMsl, u.mdMslFrom);
        o.push(st(s, a, c));
      }
      a = Math.max(a, u.mdMslTo);
    }
    a < s.exit.mdMsl && o.push(st(s, a, s.exit.mdMsl)), n = o.sort((i, u) => i.mdMslFrom - u.mdMslFrom);
  }
  return n;
}
function dn(t) {
  const n = [], r = [...t].sort(
    (a, o) => a.entry.mdMsl - o.entry.mdMsl || o.level - a.level
  );
  let e = null, s = -1 / 0;
  for (let a = 0; a < r.length; a++) {
    const o = r[a];
    o.entry.mdMsl > s && (s = o.entry.mdMsl, e && e.exit.mdMsl < s && n.push({
      color: e.color,
      name: e.name,
      type: "base",
      mdMsl: e.exit.mdMsl,
      tvdMsl: e.exit.tvdMsl,
      level: e.level
    }), n.push({
      color: o.color,
      name: o.name,
      type: "top",
      mdMsl: s,
      tvdMsl: o.entry.tvdMsl,
      level: o.level
    }), e = o);
  }
  return e && n.push({
    color: e.color,
    name: e.name,
    type: "base",
    mdMsl: e.exit.mdMsl,
    tvdMsl: e.exit.tvdMsl,
    level: e.level
  }), n;
}
function G(t, n = 0, r = 1) {
  return t < n ? n : t > r ? r : t;
}
function zt(t, n, r) {
  return r = G(r, 0, 1), (1 - r) * t + r * n;
}
function Ct(t, n, r) {
  return (t - n) / (r - n);
}
function pn(t, n, r, e, s) {
  const a = Ct(t, n, r);
  return zt(e, s, a);
}
const kt = (t) => {
  if (t < 0) return [0, 0, 0];
  if (t > 16777.215) throw Error("Value out of range!");
  const n = Math.round(t * 1e3), r = Math.floor(n / 65536), e = Math.floor(n / 256) - r * 256, s = Math.floor(n) - r * 65536 - e * 256;
  return [r, e, s];
}, mn = Math.PI, at = 2 * Math.PI, Lt = Math.PI / 2, gn = Math.PI / 4, hn = Math.PI / 8;
function yn(t, n) {
  for (; n < -Math.PI; )
    n += at;
  for (; n > Math.PI; )
    n -= at;
  const r = Math.atan2(t[1], t[0]), e = Math.tan(n);
  let s;
  n > -r && n <= r ? s = 1 : n > r && n <= Math.PI - r ? s = 2 : n > Math.PI - r || n <= -(Math.PI - r) ? s = 3 : s = 4;
  const a = [0, 0];
  let o = 1, i = 1;
  switch (s) {
    case 1:
      i = -1;
      break;
    case 2:
      i = -1;
      break;
    case 3:
      o = -1;
      break;
    case 4:
      o = -1;
      break;
  }
  return s === 1 || s === 3 ? (a[0] += o * (t[0] / 2), a[1] += i * (t[0] / 2) * e) : (a[0] += o * (t[1] / (2 * e)), a[1] += i * (t[1] / 2)), a;
}
function An(t) {
  return t[0] = -t[0], t[1] = -t[1], t[2] = -t[2], t;
}
function Mn(t, n) {
  return [t[n], t[n + 1], t[n + 2]];
}
function xn(t, n, r) {
  t[n] = r[0], t[n + 1] = r[1], t[n + 2] = r[2];
}
function wn(t, n) {
  return [t[0] + n[0], t[1] + n[1], t[2] + n[2]];
}
function ot(t, n) {
  return [t[0] - n[0], t[1] - n[1], t[2] - n[2]];
}
function bn(t, n) {
  return t[0] = t[0] * n, t[1] = t[1] * n, t[2] = t[2] * n, t;
}
function Nt(t) {
  const n = t[0] ** 2 + t[1] ** 2 + t[2] ** 2;
  return n > 0 ? Math.sqrt(n) : 0;
}
function T(t, n) {
  return [
    t[1] * n[2] - t[2] * n[1],
    t[2] * n[0] - t[0] * n[2],
    t[0] * n[1] - t[1] * n[0]
  ];
}
function Q(t, n) {
  return t[0] * n[0] + t[1] * n[1] + t[2] * n[2];
}
function L(t) {
  const n = Math.sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
  return t[0] = t[0] / n, t[1] = t[1] / n, t[2] = t[2] / n, t;
}
function Tn(t, n, r = 0.5) {
  const e = 1 - r;
  return [
    t[0] * e + n[0] * r,
    t[1] * e + n[1] * r,
    t[2] * e + n[2] * r
  ];
}
function St(t) {
  return [
    t[0],
    t[1],
    t[2]
  ];
}
function Pn(t, n) {
  const r = Math.sqrt((t[0] ** 2 + t[1] ** 2 + t[2] ** 2) * (n[0] ** 2 + n[1] ** 2 + n[2] ** 2));
  if (r === 0) return Lt;
  const e = Q(t, n) / r;
  return Math.acos(G(e, -1, 1));
}
function mt(t, n = [0, 1, 0], r = 0) {
  const e = Math.cos(r), s = Math.sin(r), a = 1 - e, o = t[0], i = t[1], u = t[2], c = n[0], f = n[1], d = n[2], l = a * c, p = a * f;
  return [
    (l * c + e) * o + (l * f - s * d) * i + (l * d + s * f) * u,
    (l * f + s * d) * o + (p * f + e) * i + (p * d - s * c) * u,
    (l * d - s * f) * o + (p * d + s * c) * i + (a * d * d + e) * u
  ];
}
function Fn(t, n) {
  return [t[n], t[n + 1]];
}
function vn(t, n, r) {
  t[n] = r[0], t[n + 1] = r[1];
}
function In(t) {
  const n = Math.sqrt(t[0] * t[0] + t[1] * t[1]);
  return t[0] = t[0] / n, t[1] = t[1] / n, t;
}
function En(t, n) {
  return [t[0] + n[0], t[1] + n[1]];
}
function Un(t, n) {
  return [t[0] - n[0], t[1] - n[1]];
}
function Dn(t) {
  return t[0] = -t[0], t[1] = -t[1], t;
}
function Rn(t, n) {
  return t[0] = t[0] * n, t[1] = t[1] * n, t;
}
function Vn(t) {
  const n = t[0] ** 2 + t[1] ** 2;
  return n > 0 ? Math.sqrt(n) : 0;
}
function Bn(t, n, r = 0.5) {
  const e = 1 - r;
  return [
    t[0] * e + n[0] * r,
    t[1] * e + n[1] * r
  ];
}
function Gt(t, n = !1) {
  const r = {
    alpha: 1,
    tension: 0,
    closed: n
  }, e = new Vt(t, r);
  return {
    getPointAt: (a) => e.getPointAt(a),
    getPoints: (a, o = 0, i = 1) => e.getPoints(a, null, o, i),
    getTangentAt: (a) => e.getTangentAt(a),
    getNormalAt: (a) => e.getNormalAt(a),
    getBoundingBox: (a = 0, o = 1) => {
      const i = e.getBoundingBox(a, o);
      return {
        min: i.min,
        max: i.max
      };
    },
    nearest: (a) => {
      const o = e.getNearestPosition(a);
      return {
        position: o.u,
        point: o.point,
        distance: o.distance
      };
    },
    get length() {
      return e.length;
    },
    closed: n
  };
}
function zn(t, n) {
  const r = n.length, e = new Array(r);
  if (!e.length) return [];
  n.forEach((c, f) => {
    e[f] = {
      curvePosition: c,
      position: t.getPointAt(c),
      tangent: t.getTangentAt(c),
      normal: [0, 0, 0],
      binormal: [0, 0, 0]
    };
  });
  let s = [0, 1, 0], a = Math.abs(e[0].tangent[1]);
  const o = Math.abs(e[0].tangent[0]), i = Math.abs(e[0].tangent[2]);
  o <= a && (a = o, s = [1, 0, 0]), i <= a && (s = [0, 0, 1]);
  let u = L(T(e[0].tangent, s));
  e[0].normal = T(e[0].tangent, u), e[0].binormal = T(e[0].tangent, e[0].normal);
  for (let c = 1; c < n.length; c++) {
    if (u = T(e[c - 1].tangent, e[c].tangent), e[c].normal = St(e[c - 1].normal), Nt(u) > Bt) {
      L(u);
      const f = Math.acos(G(Q(e[c - 1].tangent, e[c].tangent), -1, 1));
      e[c].normal = mt(e[c - 1].normal, u, f);
    }
    e[c].binormal = T(e[c].tangent, e[c].normal);
  }
  return e;
}
function Cn(t, n = 0, r = 1, e = 0.1, s = 0) {
  const a = [], o = t.length, i = Math.ceil(e * o), u = 1 / i, c = 1 / (o * 0.01);
  s && (s *= 0.1), a.push(n);
  let f = s ? t.getTangentAt(n) : null;
  const d = Math.floor(n * i);
  let l = n;
  for (let p = d; p <= i; p++) {
    const x = p * u, y = x - l, w = s ? t.getTangentAt(x) : null;
    x > n && x < r && (y >= c || !s || Math.abs(Q(f, w)) < 1 - s) && (a.push(x), f = w, l = x);
  }
  return a.push(r), a;
}
function N(t) {
  if (t.constructor === Uint8Array) return "Uint8Array";
  if (t.constructor === Uint16Array) return "Uint16Array";
  if (t.constructor === Uint32Array) return "Uint32Array";
  if (t.constructor === Int8Array) return "Int8Array";
  if (t.constructor === Int16Array) return "Int16Array";
  if (t.constructor === Int32Array) return "Int32Array";
  if (t.constructor === Float32Array) return "Float32Array";
  if (t.constructor === Float64Array) return "Float64Array";
  throw Error("Unsupported typed array!");
}
function S(t, n) {
  switch (n) {
    case "Uint8Array":
      return new Uint8Array(t);
    case "Uint16Array":
      return new Uint16Array(t);
    case "Uint32Array":
      return new Uint32Array(t);
    case "Int8Array":
      return new Int8Array(t);
    case "Int16Array":
      return new Int16Array(t);
    case "Int32Array":
      return new Int32Array(t);
    case "Float32Array":
      return new Float32Array(t);
    case "Float64Array":
      return new Float64Array(t);
    default:
      throw Error("Unsupported typed array!");
  }
}
function _t(t, n = 1) {
  return { buffer: t.buffer, attributeType: N(t), itemSize: n };
}
function kn(t) {
  const n = [], r = {
    drawRange: t.drawRange || { start: 0, count: 1 / 0 },
    groups: t.groups || [],
    attributes: {},
    index: t.index,
    indexType: t.index ? N(t.index) : void 0,
    userData: t.userData ? structuredClone(t.userData) : void 0
  };
  for (const e in t.attributes)
    r.attributes[e] = _t(t.attributes[e].array, t.attributes[e].itemSize), n.push(r.attributes[e].buffer);
  return [r, n];
}
function jt(t) {
  const n = [], r = {
    drawRange: t.drawRange,
    groups: t.groups,
    attributes: {},
    index: void 0,
    indexType: void 0
  }, e = t.getIndex();
  e && (r.index = e.array.buffer, r.indexType = N(e.array));
  for (const s in t.attributes) {
    const a = t.getAttribute(s);
    r.attributes[s] = { buffer: a.array.buffer, attributeType: N(a.array), itemSize: a.itemSize }, n.push(r.attributes[s].buffer);
  }
  return t.userData && (r.userData = structuredClone(t.userData)), [r, n];
}
function Ln(t) {
  const n = {}, r = [];
  for (const e in t) {
    const s = t[e], a = jt(s);
    n[e] = a[0], a[1].length && r.push(...a[1]);
  }
  return { data: n, transferrables: r };
}
function Nn(t) {
  const n = new ut();
  if (t.index) {
    const r = S(t.index, t.indexType || "Uint32Array"), e = new C(r, 1);
    n.setIndex(e);
  }
  for (const r in t.attributes) {
    const e = new C(
      S(t.attributes[r].buffer, t.attributes[r].attributeType),
      t.attributes[r].itemSize
    );
    n.setAttribute(r, e);
  }
  return n.drawRange = t.drawRange, n.groups = t.groups, t.userData && (n.userData = t.userData), n;
}
function Sn(t) {
  const n = {};
  for (const r in t) {
    const e = new ut();
    if (t[r].index) {
      const s = S(t[r].index, t[r].indexType || "Uint32Array"), a = new C(s, 1);
      e.setIndex(a);
    }
    for (const s in t[r].attributes) {
      const a = new C(
        S(t[r].attributes[s].buffer, t[r].attributes[s].attributeType),
        t[r].attributes[s].itemSize
      );
      e.setAttribute(s, a);
    }
    e.drawRange = t[r].drawRange, e.groups = t[r].groups, n[r] = e;
  }
  return n;
}
const Y = "camera-set-position", H = "camera-focus-point";
class Gn extends CustomEvent {
  constructor(n) {
    super(Y, { detail: n });
  }
}
class _n extends CustomEvent {
  constructor(n) {
    super(H, { detail: n });
  }
}
const g = new E(), m = new E(), P = new E(), F = new E(), it = new E();
async function qt(t, n, r) {
  const e = Math.min(r.distance, n);
  return g.set(...t), r.getPosition(m), P.subVectors(g, m), n = Math.min(P.length() * 1.5, e), P.normalize(), m.copy(g).addScaledVector(P, -e), r.setLookAt(
    m.x,
    m.y,
    m.z,
    g.x,
    g.y,
    g.z,
    !0
  );
}
function Ot(t, n) {
  F.set(...t), n.getTarget(g), it.subVectors(g, F), n.getPosition(m), m.sub(it), n.setPosition(m.x, m.y, m.z), n.setTarget(F.x, F.y, F.z);
}
class jn {
  constructor() {
    Z(this, "controls", null);
    Z(this, "removeEventlisteners", null);
    this.setControls = this.setControls.bind(this);
  }
  addEventListeners() {
    const n = (e) => {
      this.controls && Ot(e.detail, this.controls);
    }, r = (e) => {
      if (this.controls) {
        const s = e.detail.callback;
        qt(
          e.detail.point,
          e.detail.distance || 200,
          this.controls
        ).then(() => {
          s && s();
        });
      }
    };
    addEventListener(Y, n), addEventListener(H, r), this.removeEventlisteners = () => {
      removeEventListener(Y, n), removeEventListener(H, r);
    };
  }
  async setTarget(n) {
    const r = this.controls;
    return r ? (g.set(...n), r.getPosition(m), P.subVectors(g, m), P.normalize(), r.setLookAt(
      m.x,
      m.y,
      m.z,
      g.x,
      g.y,
      g.z,
      !0
    )) : null;
  }
  setControls(n) {
    this.controls = n, this.removeEventlisteners && this.removeEventlisteners(), this.addEventListeners();
  }
  dispose() {
    this.controls = null, this.removeEventlisteners && this.removeEventlisteners();
  }
}
const Wt = {
  NOT_EMITTER: 29,
  // can be used to exclude an object from being used as an event emitter
  EMITTER: 30,
  // used internally to flag an object as an event emitter
  OCCLUDER: 31
  // object will be considered in occlusion checks in the annotations system
};
function qn(...t) {
  const n = new Pt();
  return t.forEach((r) => n.enable(r)), n;
}
const $t = new Ft({ depthPacking: vt }), D = 255 / 256, R = new Float32Array([
  D,
  D / 256,
  D / 256 ** 2,
  D / 256 ** 3
]);
function Zt(t, n, r, e) {
  return t / 255 * R[0] + n / 255 * R[1] + r / 255 * R[2] + e / 255 * R[3];
}
let A = null, b = null, v = null;
async function On(t, n, r, e, s) {
  const a = r.layers.mask;
  if (r.layers.disableAll(), r.layers.set(Wt.OCCLUDER), (!A || A.width !== e || A.height !== s) && (A == null || A.dispose(), b = new Uint8Array(4 * e * s), v = new Float32Array(e * s), A = new lt(e, s, {
    type: ft
  })), t.setRenderTarget(A), n.overrideMaterial = $t, t.clear(), t.render(n, r), n.overrideMaterial = null, t.setRenderTarget(null), r.layers.mask = a, await t.readRenderTargetPixelsAsync(
    A,
    0,
    0,
    e,
    s,
    b
  ), b && v)
    for (let o = 0; o < v.length; o++) {
      const i = o * 4, u = Zt(
        b[i],
        b[i + 1],
        b[i + 2],
        b[i + 3]
      );
      v[o] = u * 2 - 1;
    }
  return v;
}
var Yt = `#include <common>

varying vec2 vUv;

void main() {
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}`, Ht = `#include <common>
#include <packing>

varying vec2 vUv;
uniform sampler2D depthTexture;
uniform float cameraFar;
uniform float cameraNear;

float linearizeDepth(in float depth) {
    float a = cameraFar / (cameraFar - cameraNear);
  float b = cameraFar * cameraNear / (cameraNear - cameraFar);
  return a + b / depth;
}

float reconstructDepth(const in float depth) {
  return pow(2.0, depth * log2(cameraFar + 1.0)) - 1.0;
}

float getDepth(vec2 uv) {
  float depth = texture2D(depthTexture, uv).x;
  #if defined( USE_LOGDEPTHBUF )
      return linearizeDepth(reconstructDepth(depth));
  #else
      return texture2D(depthTexture, uv).x;
  #endif
}

void main() {
	gl_FragColor = packDepthToRGBA(getDepth(vUv));
}`;
class Qt extends dt {
  constructor() {
    super({
      vertexShader: Yt,
      fragmentShader: Ht,
      uniforms: {
        cameraNear: { value: 0 },
        cameraFar: { value: 1 },
        depthTexture: { value: null },
        cameraWasPerspective: { value: null }
      },
      toneMapped: !1,
      depthWrite: !1,
      depthTest: !1
    });
  }
}
const V = 255 / 256, B = new Float32Array([
  V,
  V / 256,
  V / 256 ** 2,
  V / 256 ** 3
]);
function ct(t) {
  return t[0] / 255 * B[0] + t[1] / 255 * B[1] + t[2] / 255 * B[2] + t[3] / 255 * B[3];
}
const Jt = new It(-1, 1, 1, -1, 0, 1), I = new Qt(), gt = new Et(), Kt = new Ut(2, 2), Xt = new Dt(Kt, I);
let M = null, h = null;
gt.add(Xt);
async function Wn(t, n, r, e) {
  if (!t) return null;
  try {
    const { width: s, height: a } = t.image;
    if ((!M || !h || M.width !== s || M.height !== a) && (M == null || M.dispose(), h = new Uint8Array(4 * s * a), M = new lt(s, a, {
      type: ft,
      format: Rt,
      depthBuffer: !1,
      stencilBuffer: !1
    })), I.uniforms.depthTexture.value = t, I.uniforms.cameraNear.value = r.near, I.uniforms.cameraFar.value = r.far, I.uniforms.cameraWasPerspective.value = r.isPerspectiveCamera, n.setRenderTarget(M), n.clear(), n.render(gt, Jt), n.setRenderTarget(null), await n.readRenderTargetPixelsAsync(
      M,
      0,
      // x
      0,
      // y  
      s,
      a,
      h
    ), e !== void 0 && Number.isFinite(e)) {
      const o = [
        h[e],
        h[e + 1],
        h[e + 2],
        h[e + 3]
      ];
      return ct(o) * 2 - 1;
    } else {
      const o = new Array(h.length / 4);
      for (let i = 0; i < o.length; i++) {
        const u = i * 4, c = [
          h[u],
          h[u + 1],
          h[u + 2],
          h[u + 3]
        ];
        o[i] = ct(c) * 2 - 1;
      }
      return o;
    }
  } catch (s) {
    return console.error(s), null;
  }
}
function z(t, n, r) {
  const e = ot(t, n), s = ot(t, r);
  return L(T(e, s));
}
function $n(t, n = -1) {
  const r = new Uint8Array(t.length * 4);
  for (let e = 0; e < t.length; e++) {
    const s = t[e], a = s === n ? [0, 0, 0] : kt(s), o = e * 4;
    r[o] = a[0], r[o + 1] = a[1], r[o + 2] = a[2], r[o + 3] = s === -1 ? 0 : 255;
  }
  return r;
}
function Zn(t, n, r, e, s = 0, a = -1) {
  const o = t.length / n, i = n - 1, u = o - 1, c = new Uint8Array(i * u * 4);
  let f = 0;
  const d = (l, p) => t[p * n + l];
  for (let l = 0; l < u; l++) {
    const p = l + 1, x = l + 0.5;
    for (let y = 0; y < i; y++) {
      const w = y + 1, ht = y + 0.5, _ = d(y, l);
      if (_ !== a) {
        const J = d(y, p), K = d(w, l), X = d(w, p), yt = (_ + J + K + X) / 4, tt = [y * r, l * e, _], nt = [y * r, p * e, J], et = [w * r, l * e, K], rt = [w * r, p * e, X], U = [ht * r, x * e, yt], j = z(U, tt, et), q = z(U, et, rt), O = z(U, rt, nt), W = z(U, nt, tt), At = L([
          j[0] + q[0] + O[0] + W[0],
          j[2] + q[2] + O[2] + W[2],
          j[1] + q[1] + O[1] + W[1]
        ]), $ = mt(At, [0, 1, 0], s * (Math.PI / 180)), Mt = Math.floor(($[0] + 1) / 2 * 255), xt = Math.floor(($[1] + 1) / 2 * 255), wt = Math.floor(($[2] + 1) / 2 * 255);
        c[f] = Mt, c[f + 1] = xt, c[f + 2] = wt, c[f + 3] = 255;
      } else
        c[f] = 0, c[f + 1] = 0, c[f + 2] = 0, c[f + 3] = 0;
      f += 4;
    }
  }
  return c;
}
function Yn(t, n, r) {
  const e = new pt(t, n, r);
  return e.minFilter = k, e.magFilter = k, e.flipY = !0, e.anisotropy = 4, e.needsUpdate = !0, e;
}
function Hn(t, n, r) {
  const e = new pt(t, n, r);
  return e.minFilter = k, e.magFilter = k, e.needsUpdate = !0, e.flipY = !0, e;
}
function Qn(t, n) {
  if (!n || n.length < 2 * 4) return null;
  const [r, , e] = n, s = new Array(n.length / 4);
  for (let d = 0, l = 0; d < s.length; d++, l += 4)
    s[d] = [
      n[l] - r,
      -n[l + 1],
      e - n[l + 2]
    ];
  const a = Gt(s, !1);
  if (!a) return null;
  const o = n[3], i = n[n.length - 1], u = i - o, c = (d, l = !1) => {
    let p = (d - o) / u;
    return l && (p = G(p, 0, 1)), p < 0 || p > 1 ? null : p;
  };
  return {
    id: t,
    curve: a,
    get measuredLength() {
      return u;
    },
    get measuredTop() {
      return o;
    },
    get measuredBottom() {
      return i;
    },
    getPositionAtDepth: c,
    getPointAtDepth: (d, l = !1) => {
      const p = c(d, l);
      return p !== null ? a.getPointAt(p) : null;
    }
  };
}
var tn = `varying vec2 vUv;

void main() {
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);

}`, nn = `varying vec2 vUv;

void main() {
  
  gl_FragColor = vec4(vUv, 1.0, 1.0);

}`;
const Jn = new dt({
  vertexShader: tn,
  fragmentShader: nn
});
export {
  Tn as $,
  S as A,
  _t as B,
  Gn as C,
  kn as D,
  jt as E,
  Ln as F,
  Sn as G,
  jn as H,
  z as I,
  $n as J,
  Zn as K,
  Wt as L,
  zt as M,
  Ct as N,
  pn as O,
  gn as P,
  kt as Q,
  An as R,
  Mn as S,
  at as T,
  xn as U,
  wn as V,
  ot as W,
  bn as X,
  Nt as Y,
  T as Z,
  Q as _,
  Lt as a,
  St as a0,
  Pn as a1,
  mt as a2,
  Fn as a3,
  vn as a4,
  En as a5,
  Dn as a6,
  Rn as a7,
  Vn as a8,
  Qt as a9,
  Jn as aa,
  mn as b,
  hn as c,
  G as d,
  yn as e,
  L as f,
  On as g,
  ln as h,
  fn as i,
  Qn as j,
  qn as k,
  Hn as l,
  Bn as m,
  In as n,
  Yn as o,
  Y as p,
  H as q,
  Wn as r,
  Un as s,
  Cn as t,
  Nn as u,
  zn as v,
  _n as w,
  dn as x,
  Gt as y,
  N as z
};