@equinor/videx-3d 1.1.0 → 2.0.0

package/dist/chunk-61X6qE5N.js

@@ -0,0 +1,981 @@
+import { EPS as Pt, CurveInterpolator as Ft } from "curve-interpolator";
+import { BufferGeometry as mt, BufferAttribute as G, Vector3 as D, ShaderMaterial as pt, OrthographicCamera as Et, Scene as It, PlaneGeometry as Rt, Mesh as Ut, WebGLRenderTarget as Vt, RGBAFormat as Dt, UnsignedByteType as ht, DataTexture as nt, RedFormat as Ct, FloatType as Bt, LinearFilter as U, RGFormat as Lt } from "three";
+import "comlink";
+import "p-limit";
+import "three/src/math/MathUtils.js";
+import "proj4";
+async function ie(t, e, r, n) {
+  const s = await r.get("formations", t) || [];
+  n = n === void 0 ? -1 / 0 : n;
+  const o = s.filter(
+    (a) => a.stratColumnId === e && a.exit.mdMsl > n
+  );
+  return o.sort(
+    (a, i) => a.entry.mdMsl - i.entry.mdMsl || a.level - i.level
+  ), o.length && o[0].entry.mdMsl < n && (o[0].entry.mdMsl = n), o;
+}
+function it(t, e, r) {
+  return {
+    mdMslFrom: e,
+    mdMslTo: r,
+    name: t.name,
+    level: t.level,
+    color: t.color,
+    properties: { ...t.properties || {} }
+  };
+}
+function ce(t) {
+  if (!t.length) return [];
+  let e = [];
+  const r = [...t].sort((n, s) => {
+    const o = s.level - n.level || n.entry.mdMsl - s.entry.mdMsl;
+    if (o === 0 && (n.properties?.updated || s.properties?.updated)) {
+      const a = n.properties?.updated ? new Date(n.properties?.updated) : null, i = s.properties?.updated ? new Date(s.properties?.updated) : null;
+      return a === null ? 1 : i === null ? -1 : i.getTime() - a.getTime();
+    }
+    return o;
+  });
+  for (let n = 0; n < r.length; n++) {
+    const s = r[n];
+    let o = s.entry.mdMsl;
+    const a = [...e];
+    for (let i = 0; i < e.length && o < s.exit.mdMsl; i++) {
+      const c = e[i];
+      if (o < c.mdMslFrom) {
+        const l = Math.min(s.exit.mdMsl, c.mdMslFrom);
+        a.push(it(s, o, l));
+      }
+      o = Math.max(o, c.mdMslTo);
+    }
+    o < s.exit.mdMsl && a.push(
+      it(s, o, s.exit.mdMsl)
+    ), e = a.sort((i, c) => i.mdMslFrom - c.mdMslFrom);
+  }
+  return e;
+}
+function le(t) {
+  const e = [], r = [...t].sort(
+    (o, a) => o.entry.mdMsl - a.entry.mdMsl || a.level - o.level
+  );
+  let n = null, s = -1 / 0;
+  for (let o = 0; o < r.length; o++) {
+    const a = r[o];
+    a.entry.mdMsl > s && (s = a.entry.mdMsl, n && n.exit.mdMsl < s && e.push({
+      color: n.color,
+      name: n.name,
+      type: "base",
+      mdMsl: n.exit.mdMsl,
+      tvdMsl: n.exit.tvdMsl,
+      level: n.level
+    }), e.push({
+      color: a.color,
+      name: a.name,
+      type: "top",
+      mdMsl: s,
+      tvdMsl: a.entry.tvdMsl,
+      level: a.level
+    }), n = a);
+  }
+  return n && e.push({
+    color: n.color,
+    name: n.name,
+    type: "base",
+    mdMsl: n.exit.mdMsl,
+    tvdMsl: n.exit.tvdMsl,
+    level: n.level
+  }), e;
+}
+function Z(t, e = 0, r = 1) {
+  return t < e ? e : t > r ? r : t;
+}
+function zt(t, e, r) {
+  return r = Z(r, 0, 1), (1 - r) * t + r * e;
+}
+function kt(t, e, r) {
+  return (t - e) / (r - e);
+}
+function ue(t, e, r, n, s) {
+  const o = kt(t, e, r);
+  return zt(n, s, o);
+}
+const de = (t) => {
+  if (t < 0) return [0, 0, 0];
+  if (t > 16777.215) throw Error("Value out of range!");
+  const e = Math.round(t * 1e3), r = Math.floor(e / 65536), n = Math.floor(e / 256) - r * 256, s = Math.floor(e) - r * 65536 - n * 256;
+  return [r, n, s];
+}, fe = Math.PI, ct = 2 * Math.PI, Nt = Math.PI / 2, me = Math.PI / 4, pe = Math.PI / 8;
+function he(t, e, r) {
+  for (; e < -Math.PI; )
+    e += ct;
+  for (; e > Math.PI; )
+    e -= ct;
+  const n = Math.atan2(t[1], t[0]), s = Math.tan(e);
+  let o;
+  e > -n && e <= n ? o = 1 : e > n && e <= Math.PI - n ? o = 2 : e > Math.PI - n || e <= -(Math.PI - n) ? o = 3 : o = 4;
+  const a = r || [0, 0];
+  a[0] = 0, a[1] = 0;
+  let i = 1, c = 1;
+  switch (o) {
+    case 1:
+      c = -1;
+      break;
+    case 2:
+      c = -1;
+      break;
+    case 3:
+      i = -1;
+      break;
+    case 4:
+      i = -1;
+      break;
+  }
+  return o === 1 || o === 3 ? (a[0] += i * (t[0] / 2), a[1] += c * (t[0] / 2) * s) : (a[0] += i * (t[1] / (2 * s)), a[1] += c * (t[1] / 2)), a;
+}
+function ge(t) {
+  return t[0] = -t[0], t[1] = -t[1], t[2] = -t[2], t;
+}
+function ye(t, e) {
+  return [t[e], t[e + 1], t[e + 2]];
+}
+function Me(t, e, r) {
+  t[e] = r[0], t[e + 1] = r[1], t[e + 2] = r[2];
+}
+function be(t, e) {
+  return [t[0] + e[0], t[1] + e[1], t[2] + e[2]];
+}
+function j(t, e) {
+  return [t[0] - e[0], t[1] - e[1], t[2] - e[2]];
+}
+function Ae(t, e) {
+  return t[0] = t[0] * e, t[1] = t[1] * e, t[2] = t[2] * e, t;
+}
+function gt(t) {
+  const e = t[0] ** 2 + t[1] ** 2 + t[2] ** 2;
+  return e > 0 ? Math.sqrt(e) : 0;
+}
+function P(t, e) {
+  return [
+    t[1] * e[2] - t[2] * e[1],
+    t[2] * e[0] - t[0] * e[2],
+    t[0] * e[1] - t[1] * e[0]
+  ];
+}
+function rt(t, e) {
+  return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
+}
+function V(t) {
+  const e = Math.sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
+  return e ? (t[0] = t[0] / e, t[1] = t[1] / e, t[2] = t[2] / e, t) : [0, 0, 0];
+}
+function xe(t, e, r = 0.5) {
+  const n = 1 - r;
+  return [
+    t[0] * n + e[0] * r,
+    t[1] * n + e[1] * r,
+    t[2] * n + e[2] * r
+  ];
+}
+function Wt(t) {
+  return [t[0], t[1], t[2]];
+}
+function we(t, e) {
+  const r = Math.sqrt(
+    (t[0] ** 2 + t[1] ** 2 + t[2] ** 2) * (e[0] ** 2 + e[1] ** 2 + e[2] ** 2)
+  );
+  if (r === 0) return Nt;
+  const n = rt(t, e) / r;
+  return Math.acos(Z(n, -1, 1));
+}
+function yt(t, e = [0, 1, 0], r = 0) {
+  const n = Math.cos(r), s = Math.sin(r), o = 1 - n, a = t[0], i = t[1], c = t[2], l = e[0], u = e[1], m = e[2], f = o * l, d = o * u;
+  return [
+    (f * l + n) * a + (f * u - s * m) * i + (f * m + s * u) * c,
+    (f * u + s * m) * a + (d * u + n) * i + (d * m - s * l) * c,
+    (f * m - s * u) * a + (d * m + s * l) * i + (o * m * m + n) * c
+  ];
+}
+function ve(t, e) {
+  return V(j(e, t));
+}
+function Te(t, e) {
+  return gt(j(e, t));
+}
+function Pe(t, e) {
+  return [t[e], t[e + 1]];
+}
+function Fe(t, e, r) {
+  t[e] = r[0], t[e + 1] = r[1];
+}
+function Mt(t) {
+  const e = Math.sqrt(t[0] * t[0] + t[1] * t[1]);
+  return e ? (t[0] = t[0] / e, t[1] = t[1] / e, t) : [0, 0];
+}
+function lt(t, e) {
+  return [t[0] + e[0], t[1] + e[1]];
+}
+function ot(t, e) {
+  return [t[0] - e[0], t[1] - e[1]];
+}
+function bt(t, e) {
+  return t[0] * e[0] + t[1] * e[1];
+}
+function Ee(t) {
+  return t[0] = -t[0], t[1] = -t[1], t;
+}
+function Ie(t, e) {
+  return t[0] = t[0] * e, t[1] = t[1] * e, t;
+}
+function Gt(t) {
+  const e = t[0] ** 2 + t[1] ** 2;
+  return e > 0 ? Math.sqrt(e) : 0;
+}
+function Re(t, e, r = 0.5) {
+  const n = 1 - r;
+  return [t[0] * n + e[0] * r, t[1] * n + e[1] * r];
+}
+function Q(t, e) {
+  return Mt(ot(e, t));
+}
+function J(t, e) {
+  return Gt(ot(e, t));
+}
+function jt(t, e = !1) {
+  const r = {
+    alpha: 1,
+    tension: 0,
+    closed: e
+  }, n = new Ft(t, r);
+  return {
+    getPointAt: (o) => n.getPointAt(o),
+    getPoints: (o, a = 0, i = 1) => n.getPoints(o, null, a, i),
+    getTangentAt: (o) => n.getTangentAt(o),
+    getNormalAt: (o) => n.getNormalAt(o),
+    getBoundingBox: (o = 0, a = 1) => {
+      const i = n.getBoundingBox(o, a);
+      return {
+        min: i.min,
+        max: i.max
+      };
+    },
+    nearest: (o) => {
+      const a = n.getNearestPosition(o);
+      return {
+        position: a.u,
+        point: a.point,
+        distance: a.distance
+      };
+    },
+    get length() {
+      return n.length;
+    },
+    closed: e
+  };
+}
+function Ue(t, e) {
+  const r = e.length, n = new Array(r);
+  if (!n.length) return [];
+  e.forEach((l, u) => {
+    n[u] = {
+      curvePosition: l,
+      position: t.getPointAt(l),
+      tangent: t.getTangentAt(l),
+      normal: [0, 0, 0],
+      binormal: [0, 0, 0]
+    };
+  });
+  let s = [0, 1, 0], o = Math.abs(n[0].tangent[1]);
+  const a = Math.abs(n[0].tangent[0]), i = Math.abs(n[0].tangent[2]);
+  a <= o && (o = a, s = [1, 0, 0]), i <= o && (s = [0, 0, 1]);
+  let c = V(P(n[0].tangent, s));
+  n[0].normal = P(n[0].tangent, c), n[0].binormal = P(n[0].tangent, n[0].normal);
+  for (let l = 1; l < e.length; l++) {
+    if (c = P(n[l - 1].tangent, n[l].tangent), n[l].normal = Wt(n[l - 1].normal), gt(c) > Pt) {
+      V(c);
+      const u = Math.acos(
+        Z(rt(n[l - 1].tangent, n[l].tangent), -1, 1)
+      );
+      n[l].normal = yt(n[l - 1].normal, c, u);
+    }
+    n[l].binormal = P(n[l].tangent, n[l].normal);
+  }
+  return n;
+}
+function Ve(t, e = 0, r = 1, n = 0.1, s = 0) {
+  const o = [], a = t.length, i = Math.ceil(n * a), c = 1 / i, l = 1 / (a * 0.01);
+  s && (s *= 0.1), o.push(e);
+  let u = s ? t.getTangentAt(e) : null;
+  const m = Math.floor(e * i);
+  let f = e;
+  for (let d = m; d <= i; d++) {
+    const g = d * c, h = g - f, p = s ? t.getTangentAt(g) : null;
+    g > e && g < r && (h >= l || !s || Math.abs(rt(u, p)) < 1 - s) && (o.push(g), u = p, f = g);
+  }
+  return o.push(r), o;
+}
+function De(t, e) {
+  if (!e || e.length < 8) return null;
+  const [r, , n] = e, s = new Array(e.length / 4);
+  for (let m = 0, f = 0; m < s.length; m++, f += 4)
+    s[m] = [
+      e[f] - r,
+      -e[f + 1],
+      n - e[f + 2]
+    ];
+  const o = jt(s, !1);
+  if (!o) return null;
+  const a = e[3], i = e[e.length - 1], c = i - a, l = (m, f = !1) => {
+    let d = (m - a) / c;
+    return f && (d = Z(d, 0, 1)), d < 0 || d > 1 ? null : d;
+  };
+  return {
+    id: t,
+    curve: o,
+    get measuredLength() {
+      return c;
+    },
+    get measuredTop() {
+      return a;
+    },
+    get measuredBottom() {
+      return i;
+    },
+    getPositionAtDepth: l,
+    getPointAtDepth: (m, f = !1) => {
+      const d = l(m, f);
+      return d !== null ? o.getPointAt(d) : null;
+    }
+  };
+}
+function Ce(t, e = (n) => n, r = 1e-7) {
+  if (t.length <= 2) return t;
+  let n = e(t[0]), s = [0, 0];
+  const o = [t[0]];
+  for (let a = 1; a < t.length - 1; a++) {
+    const i = e(t[a]), c = Mt(ot(i, n));
+    Math.abs(bt(s, c)) < 1 - r && (o.push(t[a]), s = c, n = i);
+  }
+  return o.push(t[t.length - 1]), o;
+}
+function Be(t, e, r = 1e3, n = 2e3, s = 0) {
+  if (!t || t.length < 1) return null;
+  const o = [];
+  let a = 0;
+  const i = [t[0][0], t[0][2]];
+  let c = t[0][1], l = c, u = 1;
+  o.push(i);
+  let m = o[o.length - 1];
+  for (; u < t.length; ) {
+    const d = [t[u][0], t[u][2]];
+    t[u][1] > c && (c = t[u][1]), t[u][1] < l && (l = t[u][1]);
+    const g = J(m, d);
+    if (g < e)
+      u === t.length - 1 && o.length > 1 && (a += g, o.push(d)), u++;
+    else if (a += e, g > e) {
+      const h = Q(m, d), p = [
+        m[0] + h[0] * e,
+        m[1] + h[1] * e
+      ];
+      o.push(p), m = p;
+    } else
+      o.push(d), m = d, u++;
+  }
+  const f = o.length;
+  if (r || a < n) {
+    let d = 0, g = r;
+    a + r / 2 < n && (d = (n - a) / 2, g = d);
+    let h = [
+      Math.cos(s),
+      Math.sin(s)
+    ];
+    if (g) {
+      f > 1 && (h = Q(
+        o[o.length - 2],
+        o[o.length - 1]
+      ));
+      const p = o[o.length - 1], F = Math.floor(g / e), v = [
+        h[0] * e,
+        h[1] * e
+      ], A = [
+        p[0] + h[0] * g,
+        p[1] + h[1] * g
+      ];
+      let b = p;
+      for (let T = 0; T < F; T++)
+        b = lt(b, v), o.push(b);
+      J(b, A) && o.push(A);
+    }
+    if (d) {
+      let p;
+      f > 1 ? p = Q(o[1], o[0]) : p = [
+        -Math.cos(s),
+        -Math.sin(s)
+      ], (a < 100 || Math.abs(bt(h, p)) > 0.95) && (p = [
+        -h[0],
+        -h[1]
+      ]);
+      const F = Math.floor(d / e), v = [
+        p[0] * e,
+        p[1] * e
+      ], A = [
+        i[0] + p[0] * d,
+        i[1] + p[1] * d
+      ];
+      let b = i;
+      for (let T = 0; T < F; T++)
+        b = lt(b, v), o.unshift(b);
+      J(
+        b,
+        A
+      ) && o.unshift(A);
+    }
+  }
+  return {
+    positions: o,
+    top: c,
+    bottom: l,
+    length: a
+  };
+}
+function _(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 q(t, e) {
+  switch (e) {
+    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, e = 1) {
+  return {
+    buffer: t.buffer,
+    attributeType: _(t),
+    itemSize: e
+  };
+}
+function Le(t) {
+  const e = [], r = {
+    drawRange: t.drawRange || { start: 0, count: 1 / 0 },
+    groups: t.groups || [],
+    attributes: {},
+    index: t.index,
+    indexType: t.index ? _(t.index) : void 0,
+    userData: t.userData ? structuredClone(t.userData) : void 0
+  };
+  for (const n in t.attributes)
+    r.attributes[n] = _t(
+      t.attributes[n].array,
+      t.attributes[n].itemSize
+    ), e.push(r.attributes[n].buffer);
+  return [r, e];
+}
+function qt(t) {
+  const e = [], r = {
+    drawRange: t.drawRange,
+    groups: t.groups,
+    attributes: {},
+    index: void 0,
+    indexType: void 0
+  }, n = t.getIndex();
+  n && (r.index = n.array.buffer, r.indexType = _(n.array));
+  for (const s in t.attributes) {
+    const o = t.getAttribute(s);
+    r.attributes[s] = {
+      buffer: o.array.buffer,
+      attributeType: _(o.array),
+      itemSize: o.itemSize
+    }, e.push(r.attributes[s].buffer);
+  }
+  return t.userData && (r.userData = structuredClone(t.userData)), [r, e];
+}
+function ze(t) {
+  const e = {}, r = [];
+  for (const n in t) {
+    const s = t[n], o = qt(s);
+    e[n] = o[0], o[1].length && r.push(...o[1]);
+  }
+  return { data: e, transferrables: r };
+}
+function ke(t) {
+  const e = new mt();
+  if (t.index) {
+    const r = q(
+      t.index,
+      t.indexType || "Uint32Array"
+    ), n = new G(r, 1);
+    e.setIndex(n);
+  }
+  for (const r in t.attributes) {
+    const n = new G(
+      q(
+        t.attributes[r].buffer,
+        t.attributes[r].attributeType
+      ),
+      t.attributes[r].itemSize
+    );
+    e.setAttribute(r, n);
+  }
+  return e.drawRange = t.drawRange, e.groups = t.groups, t.userData && (e.userData = t.userData), e;
+}
+function Ne(t) {
+  const e = {};
+  for (const r in t) {
+    const n = new mt();
+    if (t[r].index) {
+      const s = q(
+        t[r].index,
+        t[r].indexType || "Uint32Array"
+      ), o = new G(s, 1);
+      n.setIndex(o);
+    }
+    for (const s in t[r].attributes) {
+      const o = new G(
+        q(
+          t[r].attributes[s].buffer,
+          t[r].attributes[s].attributeType
+        ),
+        t[r].attributes[s].itemSize
+      );
+      n.setAttribute(s, o);
+    }
+    n.drawRange = t[r].drawRange, n.groups = t[r].groups, e[r] = n;
+  }
+  return e;
+}
+const K = "camera-set-position", X = "camera-focus-point";
+class We extends CustomEvent {
+  constructor(e) {
+    super(K, { detail: e });
+  }
+}
+class Ge extends CustomEvent {
+  constructor(e) {
+    super(X, { detail: e });
+  }
+}
+const x = new D(), M = new D(), R = new D(), B = new D(), ut = new D();
+async function Zt(t, e, r) {
+  r.normalizeRotations();
+  const n = Math.min(r.distance, e);
+  return x.set(...t), r.getPosition(M), R.subVectors(x, M), e = Math.min(R.length() * 1.5, n), R.normalize(), M.copy(x).addScaledVector(R, -n), r.setLookAt(
+    M.x,
+    M.y,
+    M.z,
+    x.x,
+    x.y,
+    x.z,
+    !0
+  );
+}
+function St(t, e) {
+  e.normalizeRotations(), B.set(...t), e.getTarget(x), ut.subVectors(x, B), e.getPosition(M), M.sub(ut), e.setPosition(M.x, M.y, M.z), e.setTarget(B.x, B.y, B.z);
+}
+class je {
+  controls = null;
+  removeEventlisteners = null;
+  constructor() {
+    this.setControls = this.setControls.bind(this);
+  }
+  addEventListeners() {
+    const e = (n) => {
+      this.controls && St(n.detail, this.controls);
+    }, r = (n) => {
+      if (this.controls) {
+        const s = n.detail.callback;
+        Zt(
+          n.detail.point,
+          n.detail.distance || 200,
+          this.controls
+        ).then(() => {
+          s && s();
+        });
+      }
+    };
+    addEventListener(K, e), addEventListener(X, r), this.removeEventlisteners = () => {
+      removeEventListener(K, e), removeEventListener(X, r);
+    };
+  }
+  async setTarget(e) {
+    const r = this.controls;
+    return r ? (x.set(...e), r.getPosition(M), R.subVectors(x, M), R.normalize(), r.setLookAt(
+      M.x,
+      M.y,
+      M.z,
+      x.x,
+      x.y,
+      x.z,
+      !0
+    )) : null;
+  }
+  setControls(e) {
+    this.controls = e, this.removeEventlisteners && this.removeEventlisteners(), this.addEventListeners();
+  }
+  dispose() {
+    this.controls = null, this.removeEventlisteners && this.removeEventlisteners();
+  }
+}
+const Ot = "wellbore-selected", tt = "wellbore-added", et = "wellbore-removed";
+class _e extends CustomEvent {
+  constructor(e) {
+    super(Ot, { detail: e });
+  }
+}
+class qe extends CustomEvent {
+  constructor(e) {
+    super(tt, { detail: e });
+  }
+}
+class Ze extends CustomEvent {
+  constructor(e) {
+    super(et, { detail: e });
+  }
+}
+const dt = new D();
+class Se {
+  map = /* @__PURE__ */ new Map();
+  constructor() {
+    this.onWellboreAdded = this.onWellboreAdded.bind(this), this.onWellboreRemoved = this.onWellboreRemoved.bind(this), addEventListener(tt, this.onWellboreAdded), addEventListener(et, this.onWellboreRemoved);
+  }
+  onWellboreAdded(e) {
+    this.map.set(e.detail.id, {
+      wellboreId: e.detail.id,
+      object: e.detail.object
+    });
+  }
+  onWellboreRemoved(e) {
+    this.map.delete(e.detail.id);
+  }
+  getInfo(e) {
+    const r = this.map.get(e);
+    if (r)
+      return r.object.getWorldPosition(dt), {
+        ...r,
+        position: dt.toArray()
+      };
+  }
+  dispose() {
+    removeEventListener(tt, this.onWellboreAdded), removeEventListener(et, this.onWellboreRemoved);
+  }
+}
+function Oe(t) {
+  return t / 3.28084;
+}
+function He(t) {
+  return t * (Math.PI / 180);
+}
+const Ye = (t, e = 1, r = 1) => [t[0] / e * 2 - 1, -(t[1] / r) * 2 + 1], $e = (t, e = 1, r = 1) => [(t[0] + 1) / 2 * e, (1 - t[1]) / 2 * r];
+var Ht = `#include <common>
+
+varying vec2 vUv;
+
+void main() {
+  vUv = uv;
+  gl_Position = vec4(position, 1.0);
+}`, Yt = `#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 linearizeLogDepth(in float depth) {
+  float z = exp2(depth * log2(cameraFar + 1.0)) - 1.0;
+  return linearizeDepth(z);
+}
+
+void main() {
+  float depth = texture(depthTexture, vUv).r;
+  float viewZ;
+  #if defined( USE_LOGARITHMIC_DEPTH_BUFFER ) || defined( USE_LOGDEPTHBUF ) 
+  viewZ = linearizeLogDepth(depth);
+  #else
+  viewZ = depth;
+  #endif
+
+  gl_FragColor = packDepthToRGBA(viewZ);
+}`;
+class $t extends pt {
+  constructor() {
+    super({
+      vertexShader: Ht,
+      fragmentShader: Yt,
+      uniforms: {
+        cameraNear: { value: 0 },
+        cameraFar: { value: 1 },
+        depthTexture: { value: null },
+        cameraWasPerspective: { value: null }
+      },
+      toneMapped: !1,
+      depthWrite: !1,
+      depthTest: !1
+    });
+  }
+}
+const k = 255 / 256, N = new Float32Array([
+  k,
+  k / 256,
+  k / 256 ** 2,
+  k / 256 ** 3
+]);
+function ft(t, e, r, n) {
+  return t / 255 * N[0] + e / 255 * N[1] + r / 255 * N[2] + n / 255 * N[3];
+}
+const Qt = new Et(-1, 1, 1, -1, 0, 1), L = new $t(), At = new It(), Jt = new Rt(2, 2), Kt = new Ut(Jt, L);
+let I = null, w = null;
+At.add(Kt);
+async function Qe(t, e, r, n) {
+  if (!t) return null;
+  try {
+    const { width: s, height: o } = t;
+    if ((!I || !w || I.width !== s || I.height !== o) && (I?.dispose(), w = new Uint8Array(4 * s * o), I = new Vt(s, o, {
+      type: ht,
+      format: Dt,
+      depthBuffer: !1,
+      stencilBuffer: !1
+    })), L.uniforms.depthTexture.value = t, L.uniforms.cameraNear.value = r.near, L.uniforms.cameraFar.value = r.far, L.uniforms.cameraWasPerspective.value = r.isPerspectiveCamera, e.setRenderTarget(I), e.clear(), e.render(At, Qt), e.setRenderTarget(null), await e.readRenderTargetPixelsAsync(
+      I,
+      0,
+      // x
+      0,
+      // y
+      s,
+      o,
+      w
+    ), n !== void 0 && Number.isFinite(n))
+      return ft(
+        w[n],
+        w[n + 1],
+        w[n + 2],
+        w[n + 3]
+      ) * 2 - 1;
+    {
+      const a = new Array(w.length / 4);
+      for (let i = 0; i < a.length; i++) {
+        const c = i * 4;
+        a[i] = ft(
+          w[c],
+          w[c + 1],
+          w[c + 2],
+          w[c + 3]
+        ) * 2 - 1;
+      }
+      return a;
+    }
+  } catch (s) {
+    return console.error(s), null;
+  }
+}
+function W(t, e, r) {
+  const n = j(t, e), s = j(t, r);
+  return V(P(n, s));
+}
+function Je(t, e, r, n, s = 0, o = -1) {
+  const a = t.length / e, i = e - 1, c = a - 1, l = new Uint8Array(i * c * 4);
+  let u = 0;
+  const m = (f, d) => t[d * e + f];
+  for (let f = 0; f < c; f++) {
+    const d = f + 1, g = f + 0.5;
+    for (let h = 0; h < i; h++) {
+      const p = h + 1, F = h + 0.5, v = m(h, f);
+      if (v !== o) {
+        const A = m(h, d), b = m(p, f), E = m(p, d), T = (v + A + b + E) / 4, C = [h * r, f * n, v], y = [h * r, d * n, A], st = [p * r, f * n, b], at = [p * r, d * n, E], z = [F * r, g * n, T], S = W(z, C, st), O = W(z, st, at), H = W(z, at, y), Y = W(z, y, C), xt = V([
+          S[0] + O[0] + H[0] + Y[0],
+          S[2] + O[2] + H[2] + Y[2],
+          S[1] + O[1] + H[1] + Y[1]
+        ]), $ = yt(xt, [0, 1, 0], s * (Math.PI / 180)), wt = Math.floor(($[0] + 1) / 2 * 255), vt = Math.floor(($[1] + 1) / 2 * 255), Tt = Math.floor(($[2] + 1) / 2 * 255);
+        l[u] = wt, l[u + 1] = vt, l[u + 2] = Tt, l[u + 3] = 255;
+      } else
+        l[u] = 0, l[u + 1] = 0, l[u + 2] = 0, l[u + 3] = 0;
+      u += 4;
+    }
+  }
+  return l;
+}
+function Ke(t, e, r) {
+  const n = new nt(t, e, r);
+  return n.minFilter = U, n.magFilter = U, n.flipY = !0, n.anisotropy = 4, n.needsUpdate = !0, n;
+}
+function Xe(t, e, r) {
+  const n = new nt(
+    t,
+    e,
+    r,
+    Ct,
+    Bt
+  );
+  return n.minFilter = U, n.magFilter = U, n.needsUpdate = !0, n.flipY = !0, n;
+}
+function tn(t, e, r, n, s) {
+  const o = new Uint8Array(e * r * 2), a = (i, c) => {
+    const l = i < 0 ? 0 : i >= r ? r - 1 : i, u = c < 0 ? 0 : c >= e ? e - 1 : c;
+    return t[l * e + u];
+  };
+  for (let i = 0; i < r; i++)
+    for (let c = 0; c < e; c++) {
+      const l = i * e + c, u = t[l];
+      let m = 0, f = 1e-4, d = 0;
+      if (u >= 0) {
+        const p = a(i - 1, c - 1), F = a(i - 1, c + 1), v = a(i + 1, c - 1), A = a(i + 1, c + 1), b = [-n, p - u, -s], E = [n, F - u, -s], T = [-n, v - u, s], C = [n, A - u, s];
+        if (p >= 0 && F >= 0) {
+          const y = P(E, b);
+          m += y[0], f += y[1], d += y[2];
+        }
+        if (F >= 0 && A >= 0) {
+          const y = P(C, E);
+          m += y[0], f += y[1], d += y[2];
+        }
+        if (v >= 0 && A >= 0) {
+          const y = P(T, C);
+          m += y[0], f += y[1], d += y[2];
+        }
+        if (A >= 0 && p >= 0) {
+          const y = P(b, T);
+          m += y[0], f += y[1], d += y[2];
+        }
+      }
+      const g = V([m, f, d]), h = l * 2;
+      o[h] = Math.round((g[0] + 1) / 2 * 255), o[h + 1] = Math.round((g[2] + 1) / 2 * 255);
+    }
+  return o;
+}
+function en(t, e, r) {
+  const n = new nt(
+    t,
+    e,
+    r,
+    Lt,
+    ht
+  );
+  return n.minFilter = U, n.magFilter = U, n.flipY = !0, n.needsUpdate = !0, n;
+}
+var Xt = `varying vec2 vUv;
+
+void main() {
+  vUv = uv;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+
+}`, te = `varying vec2 vUv;
+
+void main() {
+  
+  gl_FragColor = vec4(vUv, 1.0, 1.0);
+
+}`;
+const nn = new pt({
+  vertexShader: Xt,
+  fragmentShader: te
+});
+export {
+  ye as $,
+  lt as A,
+  be as B,
+  Ge as C,
+  $t as D,
+  we as E,
+  tn as F,
+  Wt as G,
+  Ke as H,
+  P as I,
+  He as J,
+  Q as K,
+  ve as L,
+  J as M,
+  Te as N,
+  bt as O,
+  fe as P,
+  rt as Q,
+  Je as R,
+  Oe as S,
+  ct as T,
+  le as U,
+  Be as V,
+  qe as W,
+  jt as X,
+  q as Y,
+  _ as Z,
+  Pe as _,
+  me as a,
+  kt as a0,
+  Gt as a1,
+  gt as a2,
+  zt as a3,
+  Re as a4,
+  xe as a5,
+  Ee as a6,
+  ge as a7,
+  V as a8,
+  _t as a9,
+  ze as aa,
+  qt as ab,
+  Le as ac,
+  Qe as ad,
+  ue as ae,
+  yt as af,
+  Ie as ag,
+  Ae as ah,
+  Ye as ai,
+  Fe as aj,
+  Me as ak,
+  Ce as al,
+  j as am,
+  de as an,
+  W as ao,
+  Ne as ap,
+  nn as aq,
+  Nt as b,
+  pe as c,
+  Z as d,
+  he as e,
+  $e as f,
+  ie as g,
+  De as h,
+  Xe as i,
+  en as j,
+  Ze as k,
+  K as l,
+  ce as m,
+  Mt as n,
+  X as o,
+  Ve as p,
+  Ue as q,
+  We as r,
+  ot as s,
+  _e as t,
+  ke as u,
+  et as v,
+  tt as w,
+  Ot as x,
+  je as y,
+  Se as z
+};