@equinor/videx-3d 5.1.0-beta

package/dist/chunk-iY0wQ9Z6.js

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