gl-draw 0.15.20 → 0.15.21

package/dist/WebGPULineSegments2.module.js

@@ -0,0 +1,1014 @@
+var Pt = Object.defineProperty, It = Object.defineProperties;
+var Dt = Object.getOwnPropertyDescriptors;
+var k = Object.getOwnPropertySymbols;
+var it = Object.prototype.hasOwnProperty, st = Object.prototype.propertyIsEnumerable;
+var nt = Math.pow, et = (n, t, e) => t in n ? Pt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, L = (n, t) => {
+  for (var e in t || (t = {}))
+    it.call(t, e) && et(n, e, t[e]);
+  if (k)
+    for (var e of k(t))
+      st.call(t, e) && et(n, e, t[e]);
+  return n;
+}, q = (n, t) => It(n, Dt(t));
+var rt = (n, t) => {
+  var e = {};
+  for (var i in n)
+    it.call(n, i) && t.indexOf(i) < 0 && (e[i] = n[i]);
+  if (n != null && k)
+    for (var i of k(n))
+      t.indexOf(i) < 0 && st.call(n, i) && (e[i] = n[i]);
+  return e;
+};
+var ot = (n, t, e) => new Promise((i, s) => {
+  var a = (c) => {
+    try {
+      r(e.next(c));
+    } catch (o) {
+      s(o);
+    }
+  }, l = (c) => {
+    try {
+      r(e.throw(c));
+    } catch (o) {
+      s(o);
+    }
+  }, r = (c) => c.done ? i(c.value) : Promise.resolve(c.value).then(a, l);
+  r((e = e.apply(n, t)).next());
+});
+import { Material as at, Object3D as R, Texture as ct, VideoTexture as Bt, BufferGeometry as J, Float32BufferAttribute as G, PointsMaterial as zt, Points as H, InstancedMesh as wt, Vector3 as I, Quaternion as Tt, Group as _t, Mesh as St, Sprite as lt, Box3 as jt, REVISION as Et, ShaderChunk as W, ShaderMaterial as Lt, Vector2 as K, Color as ut, Vector4 as O, Matrix4 as Ot, Line3 as Vt, Sphere as kt, InstancedInterleavedBuffer as Wt, InterleavedBufferAttribute as ft, MathUtils as Nt } from "three";
+import { CSS2DObject as Ut } from "three/examples/jsm/renderers/CSS2DRenderer";
+import { CSS3DObject as Rt, CSS3DSprite as Gt } from "three/examples/jsm/renderers/CSS3DRenderer";
+import { geoBounds as At, geoContains as $t, geoDistance as Ft, geoInterpolate as qt } from "d3-geo";
+import "d3-geo-projection";
+import { p as dt, a as Kt } from "./parseVector.module.js";
+import { merge as tt, mean as Qt, extent as ht } from "d3-array";
+import Xt, { flatten as Ct } from "earcut";
+import Yt from "@turf/boolean-clockwise";
+import Zt from "delaunator";
+import Jt from "@turf/boolean-point-in-polygon";
+import { geoVoronoi as Ht } from "d3-geo-voronoi";
+import { scaleLinear as pt } from "d3-scale";
+import { LineSegmentsGeometry as te } from "three/examples/jsm/lines/LineSegmentsGeometry";
+const ee = 0, _e = 1, ie = 2, Ee = !1;
+class se {
+  constructor() {
+    this.resources = /* @__PURE__ */ new Set(), this.disposeMaterial = !0, this.disposeVideo = !0;
+  }
+  track(t) {
+    if (!t)
+      return t;
+    if (Array.isArray(t))
+      return t.forEach((e) => this.track(e)), t;
+    if (!this.disposeMaterial && t instanceof at)
+      return t;
+    if (t instanceof mt ? (t.disposeTrack && t.object3d ? this.track(t.object3d) : this.resources.add(t), Object.values(t.materialList).map((e) => this.track(e))) : (t instanceof R || Reflect.has(t, "dispose")) && this.resources.add(t), t instanceof mt)
+      t.children.forEach((e) => {
+        e.disposeTrack = !1;
+      }), this.track(t.children);
+    else if (t instanceof R) {
+      const e = t;
+      this.track(e.geometry), this.track(e.material), this.track(e.children);
+    } else if (t instanceof at) {
+      for (const i of Object.values(t))
+        i instanceof ct && this.track(i);
+      const e = t;
+      if (e.uniforms) {
+        for (const i of Object.values(e.uniforms))
+          if (i) {
+            const s = i.value;
+            (s instanceof ct || Array.isArray(s)) && this.track(s);
+          }
+      }
+    } else this.disposeVideo && t instanceof Bt && t.source.data && this.resources.add(t.source.data);
+    return t;
+  }
+  dispose() {
+    const t = [];
+    for (const e of this.resources)
+      e instanceof R ? t.push(e) : e instanceof HTMLVideoElement && e.pause(), Reflect.has(e, "dispose") && e.dispose();
+    t.forEach((e) => {
+      e.removeFromParent();
+    }), t.length = 0, this.resources.clear();
+  }
+}
+const ne = (n, t = 1) => {
+  const e = new J();
+  e.setAttribute(
+    "position",
+    new G(new Array(t * 3).fill(0), 3)
+  ), e.setAttribute(
+    "scaleAtt",
+    new G(new Array(t).fill(1), 1)
+  );
+  const i = n.material, s = new zt({
+    size: 10,
+    map: i.map,
+    alphaMap: i.alphaMap,
+    color: i.color,
+    blending: i.blending,
+    depthTest: i.depthTest,
+    depthWrite: !1,
+    opacity: i.opacity,
+    transparent: !0,
+    alphaTest: i.alphaTest,
+    sizeAttenuation: !1
+  });
+  return s.onBeforeCompile = (a) => {
+    a.vertexShader = `
+            attribute float scaleAtt;
+              ${a.vertexShader.replace(
+      "gl_PointSize = size;",
+      "gl_PointSize = size * scaleAtt;"
+    )}
+            `;
+  }, new H(e, s);
+}, re = (n, t) => {
+  const e = new R();
+  t.forEach((i, s) => {
+    const a = dt(i.position), l = dt(i.scale || [1, 1, 1]);
+    e.position.copy(a), e.scale.copy(l), e.updateMatrix();
+    const r = e.matrix.clone();
+    if (n instanceof wt || n.isInstantiate)
+      n.setMatrixAt(s, r);
+    else if (n instanceof H || n.type === "Points") {
+      const o = n.geometry, h = o.attributes.position.array, f = o.attributes.scaleAtt.array, p = new I(), u = new I(), m = new Tt(), d = s * 3, v = s * 1;
+      r.decompose(p, m, u), h[d] = p.x, h[d + 1] = p.y, h[d + 2] = p.z, f[v] = Math.max(u.x, u.y, u.z), o.attributes.position.needsUpdate = !0, o.attributes.scaleAtt.needsUpdate = !0;
+    }
+  });
+};
+class oe {
+  constructor() {
+    this.onPointerIndex = [];
+  }
+  onPointerEvent(t, e) {
+    const i = this.lead.handlePick([this], t, e);
+    this.onPointerIndex.push(i);
+  }
+  onClick(t) {
+    this.onPointerEvent("click", t);
+  }
+  onPointerEnter(t) {
+    this.onPointerEvent("enter", t);
+  }
+  onPointerLeave(t) {
+    this.onPointerEvent("leave", t);
+  }
+  onPointerMove(t) {
+    this.onPointerEvent("move", t);
+  }
+  onPointerDown(t) {
+    this.onPointerEvent("down", t);
+  }
+  dispose() {
+    this.onPointerIndex.forEach((t) => {
+      this.lead.removePick(t);
+    });
+  }
+}
+class ae extends oe {
+  constructor() {
+    super(...arguments), this.userData = {}, this.materialList = {}, this.useMaterialType = "origin", this.disposeMaterialIfNotUsed = !0;
+  }
+  cloneMaterial() {
+    const t = this.object3d;
+    if (!t || !t.material)
+      return;
+    const e = t.material;
+    if (Array.isArray(e))
+      return e.map((i) => {
+        const s = i.userData;
+        i.userData = {};
+        const a = i.clone();
+        return i.userData = s, a;
+      });
+    {
+      const i = e.userData;
+      e.userData = {};
+      const s = e.clone();
+      return e.userData = i, s;
+    }
+  }
+  setMaterialList(t, e) {
+    const i = this.object3d;
+    if (!i || !i.material)
+      return;
+    this.materialList.origin || (this.materialList.origin = i.material);
+    const s = e === "clone" ? this.cloneMaterial() : Array.isArray(e) ? e.slice() : e;
+    return this.materialList[t] = s, s;
+  }
+  useMaterial(t) {
+    const e = this.object3d;
+    !e || !e.material || this.useMaterialType === t || !this.materialList[t] || (this.useMaterialType = t, e.material = this.materialList[t]);
+  }
+  useMListById(t, e) {
+    if (!this.mList)
+      return;
+    const i = this.mList.get(t);
+    if (!i)
+      return;
+    const s = this.object3d;
+    Array.isArray(s.material) && e !== void 0 ? s.material[e] = i : s.material = i;
+  }
+  useMListByName(t, e) {
+    if (!this.mList)
+      return;
+    const i = this.mList.getKeyByName(t);
+    i && this.useMListById(i, e);
+  }
+  dispose() {
+    super.dispose(), this.mList.rmBaseObjectMap(
+      this,
+      void 0,
+      this.disposeMaterialIfNotUsed
+    );
+  }
+}
+class mt extends ae {
+  constructor() {
+    super(...arguments), this.objectType = "BaseObject", this.userData = {}, this.prefab = !1, this.isInstantiate = !1, this.isBloom = !1, this.disposeTrack = !0;
+  }
+  get parent() {
+    const t = this.object3d.parent;
+    return t && this.lead.objMap.get(t) || null;
+  }
+  get children() {
+    return this.object3d.children.map((t) => this.lead.objMap.get(t)).filter((t) => !!t);
+  }
+  get position() {
+    return this.object3d.position;
+  }
+  get rotation() {
+    return this.object3d.rotation;
+  }
+  get scale() {
+    return this.object3d.scale;
+  }
+  get lookAt() {
+    return this.object3d.lookAt;
+  }
+  add(...t) {
+    [...t].forEach((e) => {
+      this.lead.objMap.get(e) ? this.object3d.add(e) : this.lead.createBaseObject(e, {
+        target: this
+      });
+    });
+  }
+  remove(...t) {
+    [...t].forEach((e) => {
+      var i;
+      this.lead.objMap.get(e) ? (i = this.lead.objMap.get(e)) == null || i.erase() : this.object3d.remove(e);
+    });
+  }
+  get visible() {
+    return this.object3d.visible;
+  }
+  get visibleWithAncestors() {
+    if (this.visible) {
+      let t = this.parent;
+      for (; t; ) {
+        if (!t.visible)
+          return !1;
+        t = t.parent;
+      }
+      return !0;
+    } else
+      return !1;
+  }
+  create() {
+    this.createGroup();
+  }
+  render() {
+  }
+  update(t, e) {
+  }
+  resize(t, e) {
+  }
+  show() {
+    return this.object3d.visible = !0, this.object3d.layers.set(ee), this;
+  }
+  hide() {
+    return this.object3d.visible = !1, this.object3d.layers.set(ie), this;
+  }
+  createGroup() {
+    return this.object3d = new _t(), this;
+  }
+  createMesh(...t) {
+    return this.object3d = new St(...t), this;
+  }
+  createPoints(...t) {
+    return this.object3d = new H(...t), this;
+  }
+  createCSS2DObject(t) {
+    return this.object3d = new Ut(t), this;
+  }
+  createCSS3DObject(t) {
+    return this.object3d = new Rt(t), this;
+  }
+  createCSS3DSprite(t) {
+    return this.object3d = new Gt(t), this;
+  }
+  createSprite(t) {
+    return this.object3d = new lt(t), this;
+  }
+  attach(...t) {
+    return [...t].forEach((e) => {
+      this.object3d.attach(e.object3d);
+    }), this;
+  }
+  getSize() {
+    const t = new jt().setFromObject(this.object3d);
+    return {
+      min: t.min,
+      max: t.max,
+      size: t.getSize(new I()),
+      center: t.getCenter(new I())
+    };
+  }
+  setTop(t) {
+    this.object3d && (this.object3d.renderOrder = t);
+  }
+  traverse(t) {
+    t(this), this.children.forEach((e) => {
+      e.traverse(t);
+    });
+  }
+  instantiate(t) {
+    return ot(this, null, function* () {
+      var c;
+      const e = (c = t == null ? void 0 : t.recursive) != null ? c : !0, { objectType: i, objectOptions: s } = this, [, a] = i.split("#");
+      let l = t == null ? void 0 : t.create;
+      l === void 0 && (l = (o) => {
+        var h;
+        if (this.object3d) {
+          if ((h = t == null ? void 0 : t.instancedAttr) != null && h.length) {
+            const f = t.instancedAttr.length;
+            if (this.object3d instanceof lt)
+              o.object3d = ne(this.object3d, f);
+            else {
+              const p = this.object3d, u = this.cloneMaterial();
+              o.object3d = new wt(p.geometry, u, f);
+            }
+            re(o.object3d, t == null ? void 0 : t.instancedAttr);
+          } else
+            o.object3d = this.object3d.clone(!1), o.object3d.material && (o.object3d.material = this.cloneMaterial());
+          o.object3d.userData.prefab && delete o.object3d.userData.prefab;
+        }
+      });
+      const r = yield this.lead.draw(a, q(L({}, s || {}), {
+        create: l,
+        prefab: !1,
+        key: (t == null ? void 0 : t.key) || (s == null ? void 0 : s.key),
+        target: (t == null ? void 0 : t.target) || (s == null ? void 0 : s.target)
+      }));
+      return this.isBloom && r.enableBloom(), e && (yield Promise.all(
+        this.children.map(
+          (o) => o.instantiate({
+            target: r
+          })
+        )
+      )), r.isInstantiate = !0, r;
+    });
+  }
+  erase() {
+    this.lead.erase(this);
+  }
+  handleMaterialChange(t) {
+  }
+  enableBloom() {
+    var t;
+    (t = this.pencil.composerController) == null || t.setBloomSelection(this, !0), this.isBloom = !0;
+  }
+  disableBloom() {
+    var t;
+    (t = this.pencil.composerController) == null || t.setBloomSelection(this, !1), this.isBloom = !1;
+  }
+  dispose() {
+    var t;
+    if (super.dispose(), (t = this.pencil.composerController) == null || t.bloomSelection.delete(this), this.lead && (this.lead.objects.delete(this.key), this.lead.objectWrapChindIdMap.delete(this), this.object3d && this.lead.objMap.delete(this.object3d)), this.disposeTrack) {
+      const e = new se();
+      e.disposeMaterial = !1, e.track(this), e.dispose();
+    }
+  }
+}
+function ce(n, t) {
+  return n.map((e) => {
+    const i = [];
+    let s;
+    return e.forEach((a) => {
+      if (s) {
+        const l = Ft(a, s) * 180 / Math.PI;
+        if (l > t) {
+          const r = qt(s, a), c = 1 / Math.ceil(l / t);
+          let o = c;
+          for (; o < 1; )
+            i.push(r(o)), o += c;
+        }
+      }
+      i.push(s = a);
+    }), i;
+  });
+}
+function le(n, { minLng: t, maxLng: e, minLat: i, maxLat: s } = {}) {
+  const a = Math.round(nt(360 / n, 2) / Math.PI), l = (1 + Math.sqrt(5)) / 2, r = (u) => u / l * 360 % 360 - 180, c = (u) => Math.acos(2 * u / a - 1) / Math.PI * 180 - 90, o = (u) => a * (Math.cos((u + 90) * Math.PI / 180) + 1) / 2, h = [
+    s !== void 0 ? Math.ceil(o(s)) : 0,
+    i !== void 0 ? Math.floor(o(i)) : a - 1
+  ], f = t === void 0 && e === void 0 ? () => !0 : t === void 0 ? (u) => u <= e : e === void 0 ? (u) => u >= t : e >= t ? (u) => u >= t && u <= e : (u) => u >= t || u <= e, p = [];
+  for (let u = h[0]; u <= h[1]; u++) {
+    const m = r(u);
+    f(m) && p.push([m, c(u)]);
+  }
+  return p;
+}
+function Z(n, t, e = !1) {
+  return e ? $t(t, n) : Jt(n, t);
+}
+function ue(n, t) {
+  const e = { type: "Polygon", coordinates: n }, [[i, s], [a, l]] = At(e);
+  if (Math.min(Math.abs(a - i), Math.abs(l - s)) < t)
+    return [];
+  const r = i > a || l >= 89 || s <= -89;
+  return le(t, {
+    minLng: i,
+    maxLng: a,
+    minLat: s,
+    maxLat: l
+  }).filter(
+    (c) => Z(c, e, r)
+  );
+}
+function fe(n, { resolution: t = 1 / 0, bbox: e, projection: i } = {}) {
+  const s = ce(n, t), a = tt(s), l = ue(n, t), r = [...a, ...l], c = { type: "Polygon", coordinates: n }, [[o, h], [f, p]] = At(c), u = o > f || // crosses antimeridian
+  p >= 89 || // crosses north pole
+  h <= -89;
+  let m = [];
+  if (u) {
+    const y = Ht(r).triangles(), x = new Map(
+      r.map(([A, C], _) => [`${A}-${C}`, _])
+    );
+    y.features.forEach((A) => {
+      const C = A.geometry.coordinates[0].slice(0, 3).reverse(), _ = [];
+      if (C.forEach(([P, F]) => {
+        const V = `${P}-${F}`;
+        x.has(V) && _.push(x.get(V));
+      }), _.length === 3) {
+        if (_.some((P) => P < a.length)) {
+          const P = A.properties.circumcenter;
+          if (!Z(
+            P,
+            c,
+            u
+          ))
+            return;
+        }
+        m.push(..._);
+      }
+    });
+  } else if (l.length) {
+    const y = Zt.from(r);
+    for (let x = 0, A = y.triangles.length; x < A; x += 3) {
+      const C = [2, 1, 0].map((P) => y.triangles[x + P]), _ = C.map((P) => r[P]);
+      if (C.some((P) => P < a.length)) {
+        const P = [0, 1].map(
+          (F) => Qt(_, (V) => V[F])
+        );
+        if (!Z(
+          P,
+          c,
+          u
+        ))
+          continue;
+      }
+      m.push(...C);
+    }
+  } else {
+    const { vertices: y, holes: x = [] } = Ct(s);
+    m = Xt(y, x, 2);
+  }
+  let d = e ? [e[0], e[2]] : ht(r, (y) => y[0]), v = e ? [e[1], e[3]] : ht(r, (y) => y[1]);
+  if (i) {
+    const [y, x] = i([d[0], v[0]]), [A, C] = i([d[1], v[1]]);
+    d = [y, A], v = [-x, -C];
+  }
+  const w = pt(d, [0, 1]), S = pt(v, [0, 1]), D = r.map(([y, x]) => {
+    if (i) {
+      const [A, C] = i([y, x]);
+      return [w(A), S(-C)];
+    } else
+      return [w(y), S(x)];
+  });
+  return { contour: s, triangles: { points: r, indices: m, uvs: D } };
+}
+const vt = new J().setAttribute ? "setAttribute" : "addAttribute";
+function $(n, t, e, i) {
+  const s = n.map(
+    (a) => a.map(([l, r]) => {
+      if (i) {
+        const [c, o] = i([l, r]);
+        return [c, -o, t];
+      }
+      return e ? Kt(l, r, t) : [l, r, t];
+    })
+  );
+  return Ct(s);
+}
+function de(n, t, e, i, s) {
+  const { vertices: a, holes: l } = $(
+    n,
+    t,
+    i,
+    s
+  ), { vertices: r } = $(
+    n,
+    e,
+    i,
+    s
+  ), c = tt([r, a]), o = Math.round(r.length / 3), h = new Set(l);
+  let f = 0;
+  const p = [];
+  for (let m = 0; m < o; m++) {
+    let d = m + 1;
+    if (d === o)
+      d = f;
+    else if (h.has(d)) {
+      const v = d;
+      d = f, f = v;
+    }
+    p.push(m, m + o, d + o), p.push(d + o, d, m);
+  }
+  const u = [];
+  for (let m = 1; m >= 0; m--)
+    for (let d = 0; d < o; d += 1) u.push(d / (o - 1), m);
+  return { indices: p, vertices: c, uvs: u, topVerts: r };
+}
+function yt(n, t, e, i, s, a) {
+  return {
+    indices: i ? n.indices : n.indices.slice().reverse(),
+    vertices: $(
+      [n.points],
+      t,
+      s,
+      a
+    ).vertices,
+    uvs: e
+  };
+}
+const he = ({
+  polygonGeoJson: n,
+  startHeight: t,
+  endHeight: e,
+  curvatureResolution: i = 1,
+  cartesian: s = !0,
+  hasSide: a = !0,
+  hasBottom: l = !1,
+  hasTop: r = !1,
+  projection: c,
+  bbox: o
+}) => {
+  n.forEach((w) => {
+    Yt(w) || w.reverse();
+  });
+  const { contour: h, triangles: f } = fe(n, {
+    resolution: i,
+    bbox: o,
+    projection: c
+  });
+  let p = {}, u;
+  a && (p = de(
+    h,
+    t != null ? t : e,
+    e != null ? e : t,
+    s,
+    c
+  ), u = p.topVerts);
+  let m = [];
+  (l || r) && (m = tt(f.uvs));
+  let d = {};
+  l && (d = yt(
+    f,
+    t,
+    m,
+    !1,
+    s,
+    c
+  ));
+  let v = {};
+  return r && (v = yt(
+    f,
+    e,
+    m,
+    !0,
+    s,
+    c
+  )), { contour: h, triangles: f, sideTorso: p, bottomCap: d, topCap: v, topVerts: u };
+};
+class Le extends J {
+  constructor(t, e = {}) {
+    super(), this.type = "PolygonBufferGeometry", this.parameters = L({
+      polygonGeoJson: t,
+      startHeight: 0,
+      endHeight: 1,
+      hasTop: !0,
+      topFirst: !1,
+      hasBottom: !0,
+      hasSide: !0,
+      curvatureResolution: 1,
+      cartesian: !0,
+      userDataRsoOffset: 0
+    }, e);
+    const {
+      endHeight: i,
+      hasTop: s,
+      topFirst: a,
+      hasBottom: l,
+      hasSide: r,
+      cartesian: c,
+      userDataRsoOffset: o,
+      projection: h
+    } = this.parameters, { contour: f, sideTorso: p, topVerts: u, bottomCap: m, topCap: d } = he(L({}, this.parameters));
+    let v = [], w = [], S = [], D = 0;
+    const j = (y) => {
+      const x = Math.round(v.length / 3), A = S.length;
+      v = v.concat(y.vertices), w = w.concat(y.uvs), S = S.concat(
+        x ? y.indices.map((C) => C + x) : y.indices
+      ), this.addGroup(A, S.length - A, D++);
+    };
+    s && a && j(d), r && (j(p), this.userData.topVerts = o ? $(
+      f,
+      i + o,
+      c,
+      h
+    ).vertices : u), l && j(m), s && !a && j(d), this.setIndex(S), this[vt]("position", new G(v, 3)), this[vt]("uv", new G(w, 2)), this.computeVertexNormals();
+  }
+}
+const pe = `
+#include <fog_pars_fragment>
+#include <logdepthbuf_pars_fragment>
+
+uniform float useDash;
+uniform float dashArray;
+uniform float dashOffset;
+uniform float dashRatio;
+uniform sampler2D alphaMap;
+uniform float useAlphaMap;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying float vCounters;
+
+uniform sampler2D map;
+uniform float useMap;
+uniform vec2 repeat;
+uniform float offsetLoop;
+uniform float alphaTest;
+
+
+
+void main()	{
+	#include <logdepthbuf_fragment>
+
+	vec4 c = vColor;
+
+	if( useMap == 1. ) c *= texture2D( map, vUV * repeat );
+	if( useAlphaMap == 1. ) c.a *= texture2D( alphaMap, vUV * repeat ).r;
+	if(offsetLoop!=1.0){
+      if(vUV.x>1.0 || vUV.x<0.0){
+        c.a = 0.0;
+      }
+    }
+  if (c.a < alphaTest) discard;
+	if( useDash == 1. ){
+			c.a *= ceil(mod(vCounters + dashOffset, dashArray) - (dashArray * dashRatio));
+	}
+	gl_FragColor = c;
+	#include <fog_fragment>
+	#include <${parseInt(Et) < 154 ? "encodings_fragment" : "colorspace_fragment"}>
+}
+`, me = `
+    #include <common>
+    ${W.logdepthbuf_pars_vertex}
+    ${W.fog_pars_vertex}
+
+    attribute vec3 previous;
+    attribute vec3 next;
+    attribute float side;
+    attribute float width;
+    attribute float counters;
+
+    uniform vec2 resolution;
+    uniform float lineWidth;
+    uniform vec3 color;
+    uniform float opacity;
+    uniform float sizeAttenuation;
+    uniform float scaleDown;
+    uniform vec2 offset;
+
+    varying vec2 vUV;
+    varying vec4 vColor;
+    varying float vCounters;
+
+    vec2 intoScreen(vec4 i) {
+        return resolution * (0.5 * i.xy / i.w + 0.5);
+    }
+
+    void main() {
+        float aspect = resolution.y / resolution.x;
+
+        mat4 m = projectionMatrix * modelViewMatrix;
+
+        vec4 currentClip = m * vec4( position, 1.0 );
+        vec4 prevClip = m * vec4( previous, 1.0 );
+        vec4 nextClip = m * vec4( next, 1.0 );
+
+        vec4 currentNormed = currentClip / currentClip.w;
+        vec4 prevNormed = prevClip / prevClip.w;
+        vec4 nextNormed = nextClip / nextClip.w;
+
+        vec2 currentScreen = intoScreen(currentNormed);
+        vec2 prevScreen = intoScreen(prevNormed);
+        vec2 nextScreen = intoScreen(nextNormed);
+
+        float actualWidth = lineWidth * width;
+
+        vec2 dir;
+        if(nextScreen == currentScreen) {
+            dir = normalize( currentScreen - prevScreen );
+        } else if(prevScreen == currentScreen) {
+            dir = normalize( nextScreen - currentScreen );
+        } else {
+            vec2 inDir = currentScreen - prevScreen;
+            vec2 outDir = nextScreen - currentScreen;
+            vec2 fullDir = nextScreen - prevScreen;
+
+            if(length(fullDir) > 0.0) {
+                dir = normalize(fullDir);
+            } else if(length(inDir) > 0.0){
+                dir = normalize(inDir);
+            } else {
+                dir = normalize(outDir);
+            }
+        }
+
+        vec2 normal = vec2(-dir.y, dir.x);
+
+        if(sizeAttenuation != 0.0) {
+            normal /= currentClip.w;
+            normal *= min(resolution.x, resolution.y);
+        }
+
+        if (scaleDown > 0.0) {
+            float dist = length(nextNormed - prevNormed);
+            normal *= smoothstep(0.0, scaleDown, dist);
+        }
+
+        vec2 offsetInScreen = actualWidth * normal * side * 0.5;
+
+        vec2 withOffsetScreen = currentScreen + offsetInScreen;
+        vec3 withOffsetNormed = vec3((2.0 * withOffsetScreen/resolution - 1.0), currentNormed.z);
+
+        vCounters = counters;
+        vColor = vec4( color, opacity );
+        vUV = uv;
+         vUV=uv+offset;
+
+        gl_Position = currentClip.w * vec4(withOffsetNormed, 1.0);
+
+        ${W.logdepthbuf_vertex}
+        ${W.fog_vertex}
+    }
+`;
+class Oe extends Lt {
+  constructor(t = {}) {
+    const S = t, {
+      lineWidth: e = 1,
+      color: i = "#ffffff",
+      opacity: s = 1,
+      map: a = null,
+      dashOffset: l = 0,
+      dashArray: r = 0,
+      dashRatio: c = 0,
+      sizeAttenuation: o = !0,
+      offsetLoop: h = !0,
+      offset: f = new K(0, 0),
+      scaleDown: p = 0,
+      alphaMap: u = void 0,
+      alphaTest: m = 0,
+      repeat: d = new K(1, 1),
+      resolution: v = new K(1, 1)
+    } = S, w = rt(S, [
+      "lineWidth",
+      "color",
+      "opacity",
+      "map",
+      "dashOffset",
+      "dashArray",
+      "dashRatio",
+      "sizeAttenuation",
+      "offsetLoop",
+      "offset",
+      "scaleDown",
+      "alphaMap",
+      "alphaTest",
+      "repeat",
+      "resolution"
+    ]);
+    super(q(L({}, w), {
+      uniforms: {
+        lineWidth: { value: e },
+        color: { value: new ut(i) },
+        opacity: { value: s },
+        map: { value: a },
+        useMap: { value: a ? 1 : 0 },
+        resolution: { value: v },
+        sizeAttenuation: { value: o ? 1 : 0 },
+        offset: { value: f },
+        offsetLoop: { value: h ? 1 : 0 },
+        dashArray: { value: r },
+        dashOffset: { value: l },
+        dashRatio: { value: c },
+        useDash: { value: r > 0 ? 1 : 0 },
+        scaleDown: { value: p / 10 },
+        alphaTest: { value: m },
+        alphaMap: { value: u },
+        useAlphaMap: { value: u ? 1 : 0 },
+        repeat: { value: d }
+      },
+      vertexShader: me,
+      fragmentShader: pe
+    })), this.type = "MeshLineMaterial";
+  }
+  // Getter and setter for color
+  get color() {
+    return this.uniforms.color.value;
+  }
+  set color(t) {
+    this.uniforms.color.value = new ut(t);
+  }
+  get opacity() {
+    var t;
+    return ((t = this.uniforms) == null ? void 0 : t.opacity.value) || 1;
+  }
+  set opacity(t) {
+    this.uniforms && (this.uniforms.opacity.value = t);
+  }
+  // Getter and setter for map
+  get map() {
+    return this.uniforms.map.value;
+  }
+  set map(t) {
+    this.uniforms.map.value = t, this.uniforms.useMap.value = t ? 1 : 0;
+  }
+  get repeat() {
+    return this.uniforms.repeat.value;
+  }
+  set repeat(t) {
+    this.uniforms.repeat.value.copy(t);
+  }
+  // Getter and setter for lineWidth
+  get lineWidth() {
+    return this.uniforms.lineWidth.value;
+  }
+  set lineWidth(t) {
+    this.uniforms.lineWidth.value = t;
+  }
+  // Getter and setter for sizeAttenuation
+  get sizeAttenuation() {
+    return this.uniforms.sizeAttenuation.value === 1;
+  }
+  set sizeAttenuation(t) {
+    this.uniforms.sizeAttenuation.value = t ? 1 : 0;
+  }
+}
+const Q = new O(), gt = new I(), bt = new I(), g = new O(), b = new O(), B = new O(), X = new I(), Y = new Ot(), M = new Vt(), Mt = new I(), N = new jt(), U = new kt(), z = new O();
+let T, E;
+function xt(n, t, e) {
+  return z.set(0, 0, -t, 1).applyMatrix4(n.projectionMatrix), z.multiplyScalar(1 / z.w), z.x = E / e.width, z.y = E / e.height, z.applyMatrix4(n.projectionMatrixInverse), z.multiplyScalar(1 / z.w), Math.abs(Math.max(z.x, z.y));
+}
+function ve(n, t) {
+  const e = n.matrixWorld, i = n.geometry, s = i.attributes.instanceStart, a = i.attributes.instanceEnd, l = Math.min(i.instanceCount, s.count);
+  for (let r = 0, c = l; r < c; r++) {
+    M.start.fromBufferAttribute(s, r), M.end.fromBufferAttribute(a, r), M.applyMatrix4(e);
+    const o = new I(), h = new I();
+    T.distanceSqToSegment(M.start, M.end, h, o), h.distanceTo(o) < E * 0.5 && t.push({
+      point: h,
+      pointOnLine: o,
+      distance: T.origin.distanceTo(h),
+      object: n,
+      face: null,
+      faceIndex: r,
+      uv: null,
+      uv1: null
+    });
+  }
+}
+function ye(n, t, e) {
+  const i = t.projectionMatrix, a = n.material.resolution, l = n.matrixWorld, r = n.geometry, c = r.attributes.instanceStart, o = r.attributes.instanceEnd, h = Math.min(r.instanceCount, c.count), f = -t.near;
+  T.at(1, B), B.w = 1, B.applyMatrix4(t.matrixWorldInverse), B.applyMatrix4(i), B.multiplyScalar(1 / B.w), B.x *= a.x / 2, B.y *= a.y / 2, B.z = 0, X.copy(B), Y.multiplyMatrices(t.matrixWorldInverse, l);
+  for (let p = 0, u = h; p < u; p++) {
+    if (g.fromBufferAttribute(c, p), b.fromBufferAttribute(o, p), g.w = 1, b.w = 1, g.applyMatrix4(Y), b.applyMatrix4(Y), g.z > f && b.z > f)
+      continue;
+    if (g.z > f) {
+      const D = g.z - b.z, j = (g.z - f) / D;
+      g.lerp(b, j);
+    } else if (b.z > f) {
+      const D = b.z - g.z, j = (b.z - f) / D;
+      b.lerp(g, j);
+    }
+    g.applyMatrix4(i), b.applyMatrix4(i), g.multiplyScalar(1 / g.w), b.multiplyScalar(1 / b.w), g.x *= a.x / 2, g.y *= a.y / 2, b.x *= a.x / 2, b.y *= a.y / 2, M.start.copy(g), M.start.z = 0, M.end.copy(b), M.end.z = 0;
+    const d = M.closestPointToPointParameter(X, !0);
+    M.at(d, Mt);
+    const v = Nt.lerp(g.z, b.z, d), w = v >= -1 && v <= 1, S = X.distanceTo(Mt) < E * 0.5;
+    if (w && S) {
+      M.start.fromBufferAttribute(c, p), M.end.fromBufferAttribute(o, p), M.start.applyMatrix4(l), M.end.applyMatrix4(l);
+      const D = new I(), j = new I();
+      T.distanceSqToSegment(M.start, M.end, j, D), e.push({
+        point: j,
+        pointOnLine: D,
+        distance: T.origin.distanceTo(j),
+        object: n,
+        face: null,
+        faceIndex: p,
+        uv: null,
+        uv1: null
+      });
+    }
+  }
+}
+class Ve extends St {
+  constructor(t = new te(), e) {
+    super(t, e), this.isLineSegments2 = !0, this.type = "LineSegments2";
+  }
+  // for backwards-compatibility, but could be a method of LineSegmentsGeometry...
+  computeLineDistances() {
+    const t = this.geometry, e = t.attributes.instanceStart, i = t.attributes.instanceEnd, s = new Float32Array(2 * e.count);
+    for (let l = 0, r = 0, c = e.count; l < c; l++, r += 2)
+      gt.fromBufferAttribute(e, l), bt.fromBufferAttribute(i, l), s[r] = r === 0 ? 0 : s[r - 1], s[r + 1] = s[r] + gt.distanceTo(bt);
+    const a = new Wt(
+      s,
+      2,
+      1
+    );
+    return t.setAttribute(
+      "instanceDistanceStart",
+      new ft(a, 1, 0)
+    ), t.setAttribute(
+      "instanceDistanceEnd",
+      new ft(a, 1, 1)
+    ), this;
+  }
+  raycast(t, e) {
+    const i = this.material.worldUnits, s = t.camera;
+    s === null && !i && console.error(
+      'LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.'
+    );
+    const a = t.params.Line2 !== void 0 && t.params.Line2.threshold || 0;
+    T = t.ray;
+    const l = this.matrixWorld, r = this.geometry, c = this.material;
+    E = c.linewidth + a, r.boundingSphere === null && r.computeBoundingSphere(), U.copy(r.boundingSphere).applyMatrix4(l);
+    let o;
+    if (i)
+      o = E * 0.5;
+    else {
+      const f = Math.max(
+        s.near,
+        U.distanceToPoint(T.origin)
+      );
+      o = xt(
+        s,
+        f,
+        c.resolution
+      );
+    }
+    if (U.radius += o, T.intersectsSphere(U) === !1)
+      return;
+    r.boundingBox === null && r.computeBoundingBox(), N.copy(r.boundingBox).applyMatrix4(l);
+    let h;
+    if (i)
+      h = E * 0.5;
+    else {
+      const f = Math.max(
+        s.near,
+        N.distanceToPoint(T.origin)
+      );
+      h = xt(
+        s,
+        f,
+        c.resolution
+      );
+    }
+    N.expandByScalar(h), T.intersectsBox(N) !== !1 && (i ? ve(this, e) : ye(this, s, e));
+  }
+  onBeforeRender(t) {
+    const e = this.material.uniforms;
+    e && e.resolution && (t.getViewport(Q), this.material.uniforms.resolution.value.set(Q.z, Q.w));
+  }
+}
+export {
+  _e as B,
+  Ee as I,
+  Ve as L,
+  Oe as M,
+  Le as P,
+  se as R,
+  mt as a,
+  he as g
+};