gl-draw 0.17.0-beta.3 → 0.17.0-beta.31

package/dist/index.module2.js

@@ -0,0 +1,1097 @@
+var Oe = Object.defineProperty, De = Object.defineProperties;
+var Te = Object.getOwnPropertyDescriptors;
+var W = Object.getOwnPropertySymbols;
+var se = Object.prototype.hasOwnProperty, re = Object.prototype.propertyIsEnumerable;
+var ne = Math.pow, ie = (n, e, t) => e in n ? Oe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, L = (n, e) => {
+  for (var t in e || (e = {}))
+    se.call(e, t) && ie(n, t, e[t]);
+  if (W)
+    for (var t of W(e))
+      re.call(e, t) && ie(n, t, e[t]);
+  return n;
+}, q = (n, e) => De(n, Te(e));
+var oe = (n, e) => {
+  var t = {};
+  for (var i in n)
+    se.call(n, i) && e.indexOf(i) < 0 && (t[i] = n[i]);
+  if (n != null && W)
+    for (var i of W(n))
+      e.indexOf(i) < 0 && re.call(n, i) && (t[i] = n[i]);
+  return t;
+};
+var ae = (n, e, t) => new Promise((i, s) => {
+  var o = (a) => {
+    try {
+      r(t.next(a));
+    } catch (l) {
+      s(l);
+    }
+  }, c = (a) => {
+    try {
+      r(t.throw(a));
+    } catch (l) {
+      s(l);
+    }
+  }, r = (a) => a.done ? i(a.value) : Promise.resolve(a.value).then(o, c);
+  r((t = t.apply(n, e)).next());
+});
+import { merge as H, mean as ke, extent as ce } from "d3-array";
+import ze, { flatten as Ce } from "earcut";
+import { Material as le, Object3D as R, Texture as ue, BufferGeometry as ee, Float32BufferAttribute as G, PointsMaterial as Ee, Points as te, InstancedMesh as Pe, Vector3 as S, Quaternion as Le, Group as Ve, Mesh as Ae, Sprite as de, Box3 as Ie, ShaderMaterial as Ne, Vector2 as K, Color as he, Vector4 as V, Matrix4 as We, Line3 as Ue, Sphere as _e, InstancedInterleavedBuffer as Re, InterleavedBufferAttribute as fe, MathUtils as Ge } from "three";
+import $e from "@turf/boolean-clockwise";
+import { p as pe, a as Fe } from "./polar2Cartesian.module.js";
+import qe from "delaunator";
+import Ke from "@turf/boolean-point-in-polygon";
+import { geoBounds as Be, geoContains as Qe, geoDistance as Xe, geoInterpolate as Ye } from "d3-geo";
+import { geoVoronoi as Ze } from "d3-geo-voronoi";
+import { scaleLinear as me } from "d3-scale";
+import { LineSegmentsGeometry as Je } from "three/examples/jsm/lines/LineSegmentsGeometry";
+import { CSS2DObject as He } from "three/examples/jsm/renderers/CSS2DRenderer";
+import { CSS3DObject as et, CSS3DSprite as tt } from "three/examples/jsm/renderers/CSS3DRenderer";
+import "d3-geo-projection";
+const ve = 0, be = 1, Tt = !1;
+class it {
+  constructor() {
+    this.resources = /* @__PURE__ */ new Set(), this.disposeMaterial = !0, this.disposeVideo = !0;
+  }
+  track(e) {
+    if (!e)
+      return e;
+    if (Array.isArray(e))
+      return e.forEach((t) => this.track(t)), e;
+    if (!this.disposeMaterial && e instanceof le)
+      return e;
+    if (e instanceof Z ? (e.disposeTrack && e.object3d ? this.track(e.object3d) : this.resources.add(e), Object.values(e.materialList).map((t) => this.track(t))) : (e instanceof R || Reflect.has(e, "dispose")) && this.resources.add(e), e instanceof Z)
+      e.children.forEach((t) => {
+        t.disposeTrack = !1;
+      }), this.track(e.children);
+    else if (e instanceof R) {
+      const t = e;
+      this.track(t.geometry), this.track(t.material), this.track(t.children);
+    } else if (e instanceof le) {
+      for (const i of Object.values(e))
+        i instanceof ue && this.track(i);
+      const t = e;
+      if (t.uniforms) {
+        for (const i of Object.values(t.uniforms))
+          if (i) {
+            const s = i.value;
+            (s instanceof ue || Array.isArray(s)) && this.track(s);
+          }
+      }
+    } else this.disposeVideo && e.isVideoTexture && e.source.data && this.resources.add(e.source.data);
+    return e;
+  }
+  dispose() {
+    const e = [];
+    for (const t of this.resources)
+      t instanceof R ? e.push(t) : t instanceof HTMLVideoElement && t.pause(), Reflect.has(t, "dispose") && t.dispose();
+    e.forEach((t) => {
+      t.removeFromParent();
+    }), e.length = 0, this.resources.clear();
+  }
+}
+const st = (n, e = 1) => {
+  const t = new ee();
+  t.setAttribute(
+    "position",
+    new G(new Array(e * 3).fill(0), 3)
+  ), t.setAttribute(
+    "scaleAtt",
+    new G(new Array(e).fill(1), 1)
+  );
+  const i = n.material, s = new Ee({
+    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 = (o) => {
+    o.vertexShader = `
+            attribute float scaleAtt;
+              ${o.vertexShader.replace(
+      "gl_PointSize = size;",
+      "gl_PointSize = size * scaleAtt;"
+    )}
+            `;
+  }, new te(t, s);
+}, rt = (n, e) => {
+  const t = new R();
+  e.forEach((i, s) => {
+    const o = pe(i.position), c = pe(i.scale || [1, 1, 1]);
+    t.position.copy(o), t.scale.copy(c), t.updateMatrix();
+    const r = t.matrix.clone();
+    if (n instanceof Pe || n.isInstantiate)
+      n.setMatrixAt(s, r);
+    else if (n instanceof te || n.type === "Points") {
+      const l = n.geometry, m = l.attributes.position.array, u = l.attributes.scaleAtt.array, f = new S(), d = new S(), p = new Le(), h = s * 3, v = s * 1;
+      r.decompose(f, p, d), m[h] = f.x, m[h + 1] = f.y, m[h + 2] = f.z, u[v] = Math.max(d.x, d.y, d.z), l.attributes.position.needsUpdate = !0, l.attributes.scaleAtt.needsUpdate = !0;
+    }
+  });
+};
+class nt {
+  constructor() {
+    this.onPointerIndex = [];
+  }
+  onPointerEvent(e, t) {
+    const i = this.lead.handlePick([this], e, t);
+    this.onPointerIndex.push(i);
+  }
+  onClick(e) {
+    this.onPointerEvent("click", e);
+  }
+  onPointerEnter(e) {
+    this.onPointerEvent("enter", e);
+  }
+  onPointerEnterOnStop(e) {
+    this.onPointerEvent("enterOnStop", e);
+  }
+  onPointerLeave(e) {
+    this.onPointerEvent("leave", e);
+  }
+  onPointerMove(e) {
+    this.onPointerEvent("move", e);
+  }
+  onPointerDown(e) {
+    this.onPointerEvent("down", e);
+  }
+  dispose() {
+    this.onPointerIndex.forEach((e) => {
+      this.lead.removePick(e);
+    });
+  }
+}
+class ot extends nt {
+  constructor() {
+    super(...arguments), this.userData = {}, this.materialList = {}, this.useMaterialType = "origin", this.disposeMaterialIfNotUsed = !0;
+  }
+  cloneMaterial() {
+    const e = this.object3d;
+    if (!e || !e.material)
+      return;
+    const t = e.material;
+    if (Array.isArray(t))
+      return t.map((i) => {
+        const s = i.userData;
+        i.userData = {};
+        const o = i.clone();
+        return i.userData = s, o;
+      });
+    {
+      const i = t.userData;
+      t.userData = {};
+      const s = t.clone();
+      return t.userData = i, s;
+    }
+  }
+  setMaterialList(e, t) {
+    const i = this.object3d;
+    if (!i || !i.material)
+      return;
+    this.materialList.origin || (this.materialList.origin = i.material);
+    const s = t === "clone" ? this.cloneMaterial() : Array.isArray(t) ? t.slice() : t;
+    return this.materialList[e] = s, s;
+  }
+  useMaterial(e) {
+    const t = this.object3d;
+    !t || !t.material || this.useMaterialType === e || !this.materialList[e] || (this.useMaterialType = e, t.material = this.materialList[e]);
+  }
+  useMListById(e, t) {
+    if (!this.mList)
+      return;
+    const i = this.mList.get(e);
+    if (!i)
+      return;
+    const s = this.object3d;
+    Array.isArray(s.material) && t !== void 0 ? s.material[t] = i : s.material = i;
+  }
+  useMListByName(e, t) {
+    if (!this.mList)
+      return;
+    const i = this.mList.getKeyByName(e);
+    i && this.useMListById(i, t);
+  }
+  dispose() {
+    super.dispose(), this.mList.rmBaseObjectMap(
+      this,
+      void 0,
+      this.disposeMaterialIfNotUsed
+    );
+  }
+}
+class Z extends ot {
+  constructor() {
+    super(...arguments), this.key = "", this.objectType = "BaseObject", this.userData = {}, this.isPrefab = !1, this.isInstantiate = !1, this.isBloom = !1, this.isBaseObject = !0, this.disposeTrack = !0, this.isDispose = !1;
+  }
+  get parent() {
+    const e = this.object3d.parent;
+    return e && this.lead.objMap.get(e) || null;
+  }
+  get children() {
+    return this.object3d.children.map((e) => this.lead.objMap.get(e)).filter((e) => !!e);
+  }
+  get position() {
+    return this.object3d.position;
+  }
+  get rotation() {
+    return this.object3d.rotation;
+  }
+  get scale() {
+    return this.object3d.scale;
+  }
+  lookAt(e) {
+    const t = e instanceof S ? e : new S(...e);
+    this.object3d.lookAt(t);
+  }
+  add(...e) {
+    [...e].forEach((t) => {
+      this.lead.objMap.get(t) ? this.object3d.add(t) : this.lead.createBaseObject(t, {
+        target: this
+      });
+    });
+  }
+  remove(...e) {
+    [...e].forEach((t) => {
+      var i;
+      this.lead.objMap.get(t) ? (i = this.lead.objMap.get(t)) == null || i.erase() : this.object3d.remove(t);
+    });
+  }
+  get visible() {
+    return this.object3d.visible;
+  }
+  create() {
+    this.createGroup();
+  }
+  render() {
+  }
+  update(e, t) {
+  }
+  resize(e, t) {
+  }
+  show() {
+    return this.object3d.visible = !0, this.traverse((e) => {
+      var t;
+      (t = e.object3d) == null || t.layers.enable(ve);
+    }), this;
+  }
+  hide() {
+    return this.object3d.visible = !1, this.traverse((e) => {
+      var t;
+      (t = e.object3d) == null || t.layers.disable(ve);
+    }), this;
+  }
+  createGroup() {
+    return this.object3d = new Ve(), this;
+  }
+  createMesh(...e) {
+    return this.object3d = new Ae(...e), this;
+  }
+  createPoints(...e) {
+    return this.object3d = new te(...e), this;
+  }
+  createCSS2DObject(e) {
+    return this.object3d = new He(e), this;
+  }
+  createCSS3DObject(e) {
+    return this.object3d = new et(e), this;
+  }
+  createCSS3DSprite(e) {
+    return this.object3d = new tt(e), this;
+  }
+  createSprite(e) {
+    return this.object3d = new de(e), this;
+  }
+  attach(...e) {
+    return [...e].forEach((t) => {
+      this.object3d.attach(t.object3d);
+    }), this;
+  }
+  getSize() {
+    const e = new Ie().setFromObject(this.object3d);
+    return {
+      min: e.min,
+      max: e.max,
+      size: e.getSize(new S()),
+      center: e.getCenter(new S())
+    };
+  }
+  setTop(e) {
+    this.object3d && (this.object3d.renderOrder = e);
+  }
+  traverse(e) {
+    e(this), this.children.forEach((t) => {
+      t.traverse(e);
+    });
+  }
+  instantiate(e) {
+    return ae(this, null, function* () {
+      var l, m;
+      const t = (l = e == null ? void 0 : e.recursive) != null ? l : !0, i = (m = e == null ? void 0 : e.cloneMaterial) != null ? m : !1, { objectType: s, objectOptions: o } = this;
+      let c = e == null ? void 0 : e.create, r, a = (e == null ? void 0 : e.target) || this.parent;
+      return a === this.lead.prefabGroup && (a = this.lead.group), this.objectType === "BaseObject" ? r = this.lead.createBaseObject(this.object3d.clone(!1), {
+        target: a
+      }) : (c === void 0 && (c = (u) => {
+        var f;
+        if (this.object3d) {
+          if ((f = e == null ? void 0 : e.instancedAttr) != null && f.length) {
+            const d = e.instancedAttr.length;
+            if (this.object3d instanceof de)
+              u.object3d = st(this.object3d, d);
+            else {
+              const p = this.object3d, h = i ? this.cloneMaterial() : p.material;
+              u.object3d = new Pe(
+                p.geometry,
+                h,
+                d
+              );
+            }
+            rt(u.object3d, e == null ? void 0 : e.instancedAttr);
+          } else
+            u.object3d = this.object3d.clone(!1), i && u.object3d.material && (u.object3d.material = this.cloneMaterial());
+          u.object3d.userData.prefab && delete u.object3d.userData.prefab;
+        }
+      }), r = yield this.lead.draw(s, q(L({}, o || {}), {
+        create: c,
+        prefab: !1,
+        keyType: this.keyType,
+        key: (e == null ? void 0 : e.key) || this.keyName,
+        uId: (e == null ? void 0 : e.uId) || this.keyUId,
+        target: a
+      }))), this.isBloom && r.enableBloom(), t && (yield Promise.all(
+        this.children.map(
+          (u) => u.instantiate({
+            key: u.keyUId && u.keyName ? `${u.keyName}-${u.keyUId}` : u.keyName,
+            uId: e == null ? void 0 : e.uId,
+            cloneMaterial: i,
+            target: r
+          })
+        )
+      )), r.isInstantiate = !0, r;
+    });
+  }
+  erase() {
+    this.lead.erase(this);
+  }
+  handleMaterialChange(e) {
+  }
+  enableBloom(e = !0) {
+    var t, i, s;
+    if (!((t = this.pencil.composerController) != null && t.bloomComposer)) {
+      console.warn("err:pencil.options.bloom");
+      return;
+    }
+    if (e) {
+      this.traverse((o) => {
+        o.enableBloom(!1);
+      });
+      return;
+    }
+    this.object3d && ((i = this.pencil.composerController) == null || i.bloomSelection.add(this), this.object3d.layers.enable(be)), (s = this.pencil.composerController) == null || s.checkBloomComposerActive(), this.isBloom = !0;
+  }
+  disableBloom(e = !0) {
+    var t, i, s;
+    if (!((t = this.pencil.composerController) != null && t.bloomComposer)) {
+      console.warn("err:pencil.options.bloom");
+      return;
+    }
+    if (e) {
+      this.traverse((o) => {
+        o.disableBloom(!1);
+      });
+      return;
+    }
+    this.object3d && ((i = this.pencil.composerController) == null || i.bloomSelection.delete(this), this.object3d.layers.disable(be)), (s = this.pencil.composerController) == null || s.checkBloomComposerActive(), this.isBloom = !1;
+  }
+  dispose() {
+    var e, t;
+    if (!this.isDispose && (this.isDispose = !0, super.dispose(), this.isBloom && (this.disableBloom(!1), (e = this.pencil.composerController) == null || e.checkBloomComposerActive()), (t = this.lead) == null || t.disableCursor(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 i = new it();
+      i.disposeMaterial = !1, i.track(this), i.dispose();
+    }
+  }
+}
+function at(n, e) {
+  return n.map((t) => {
+    const i = [];
+    let s;
+    return t.forEach((o) => {
+      if (s) {
+        const c = Xe(o, s) * 180 / Math.PI;
+        if (c > e) {
+          const r = Ye(s, o), a = 1 / Math.ceil(c / e);
+          let l = a;
+          for (; l < 1; )
+            i.push(r(l)), l += a;
+        }
+      }
+      i.push(s = o);
+    }), i;
+  });
+}
+function ct(n, { minLng: e, maxLng: t, minLat: i, maxLat: s } = {}) {
+  const o = Math.round(ne(360 / n, 2) / Math.PI), c = (1 + Math.sqrt(5)) / 2, r = (d) => d / c * 360 % 360 - 180, a = (d) => Math.acos(2 * d / o - 1) / Math.PI * 180 - 90, l = (d) => o * (Math.cos((d + 90) * Math.PI / 180) + 1) / 2, m = [
+    s !== void 0 ? Math.ceil(l(s)) : 0,
+    i !== void 0 ? Math.floor(l(i)) : o - 1
+  ], u = e === void 0 && t === void 0 ? () => !0 : e === void 0 ? (d) => d <= t : t === void 0 ? (d) => d >= e : t >= e ? (d) => d >= e && d <= t : (d) => d >= e || d <= t, f = [];
+  for (let d = m[0]; d <= m[1]; d++) {
+    const p = r(d);
+    u(p) && f.push([p, a(d)]);
+  }
+  return f;
+}
+function J(n, e, t = !1) {
+  return t ? Qe(e, n) : Ke(n, e);
+}
+function lt(n, e) {
+  const t = { type: "Polygon", coordinates: n }, [[i, s], [o, c]] = Be(t);
+  if (Math.min(Math.abs(o - i), Math.abs(c - s)) < e)
+    return [];
+  const r = i > o || c >= 89 || s <= -89;
+  return ct(e, {
+    minLng: i,
+    maxLng: o,
+    minLat: s,
+    maxLat: c
+  }).filter(
+    (a) => J(a, t, r)
+  );
+}
+function ut(n, { resolution: e = 1 / 0, bbox: t, projection: i } = {}) {
+  const s = at(n, e), o = H(s), c = lt(n, e), r = [...o, ...c], a = { type: "Polygon", coordinates: n }, [[l, m], [u, f]] = Be(a), d = l > u || // crosses antimeridian
+  f >= 89 || // crosses north pole
+  m <= -89;
+  let p = [];
+  if (d) {
+    const y = Ze(r).triangles(), x = new Map(
+      r.map(([A, I], z) => [`${A}-${I}`, z])
+    );
+    y.features.forEach((A) => {
+      const I = A.geometry.coordinates[0].slice(0, 3).reverse(), z = [];
+      if (I.forEach(([B, F]) => {
+        const N = `${B}-${F}`;
+        x.has(N) && z.push(x.get(N));
+      }), z.length === 3) {
+        if (z.some((B) => B < o.length)) {
+          const B = A.properties.circumcenter;
+          if (!J(
+            B,
+            a,
+            d
+          ))
+            return;
+        }
+        p.push(...z);
+      }
+    });
+  } else if (c.length) {
+    const y = qe.from(r);
+    for (let x = 0, A = y.triangles.length; x < A; x += 3) {
+      const I = [2, 1, 0].map((B) => y.triangles[x + B]), z = I.map((B) => r[B]);
+      if (I.some((B) => B < o.length)) {
+        const B = [0, 1].map(
+          (F) => ke(z, (N) => N[F])
+        );
+        if (!J(
+          B,
+          a,
+          d
+        ))
+          continue;
+      }
+      p.push(...I);
+    }
+  } else {
+    const { vertices: y, holes: x = [] } = Ce(s);
+    p = ze(y, x, 2);
+  }
+  let h = t ? [t[0], t[2]] : ce(r, (y) => y[0]), v = t ? [t[1], t[3]] : ce(r, (y) => y[1]);
+  if (i) {
+    const [y, x] = i([h[0], v[0]]), [A, I] = i([h[1], v[1]]);
+    h = [y, A], v = [-x, -I];
+  }
+  const j = me(h, [0, 1]), C = me(v, [0, 1]), O = r.map(([y, x]) => {
+    if (i) {
+      const [A, I] = i([y, x]);
+      return [j(A), C(-I)];
+    } else
+      return [j(y), C(x)];
+  });
+  return { contour: s, triangles: { points: r, indices: p, uvs: O } };
+}
+const ye = new ee().setAttribute ? "setAttribute" : "addAttribute";
+function $(n, e, t, i) {
+  const s = n.map(
+    (o) => o.map(([c, r]) => {
+      if (i) {
+        const [a, l] = i([c, r]);
+        return [a, -l, e];
+      }
+      return t ? Fe(c, r, e) : [c, r, e];
+    })
+  );
+  return Ce(s);
+}
+function dt(n, e, t, i, s) {
+  const { vertices: o, holes: c } = $(
+    n,
+    e,
+    i,
+    s
+  ), { vertices: r } = $(
+    n,
+    t,
+    i,
+    s
+  ), a = H([r, o]), l = Math.round(r.length / 3), m = new Set(c);
+  let u = 0;
+  const f = [];
+  for (let p = 0; p < l; p++) {
+    let h = p + 1;
+    if (h === l)
+      h = u;
+    else if (m.has(h)) {
+      const v = h;
+      h = u, u = v;
+    }
+    f.push(p, p + l, h + l), f.push(h + l, h, p);
+  }
+  const d = [];
+  for (let p = 1; p >= 0; p--)
+    for (let h = 0; h < l; h += 1) d.push(h / (l - 1), p);
+  return { indices: f, vertices: a, uvs: d, topVerts: r };
+}
+function ge(n, e, t, i, s, o) {
+  return {
+    indices: i ? n.indices : n.indices.slice().reverse(),
+    vertices: $(
+      [n.points],
+      e,
+      s,
+      o
+    ).vertices,
+    uvs: t
+  };
+}
+const ht = ({
+  polygonGeoJson: n,
+  startHeight: e,
+  endHeight: t,
+  curvatureResolution: i = 1,
+  cartesian: s = !0,
+  hasSide: o = !0,
+  hasBottom: c = !1,
+  hasTop: r = !1,
+  projection: a,
+  bbox: l
+}) => {
+  n.forEach((j) => {
+    $e(j) || j.reverse();
+  });
+  const { contour: m, triangles: u } = ut(n, {
+    resolution: i,
+    bbox: l,
+    projection: a
+  });
+  let f = {}, d;
+  o && (f = dt(
+    m,
+    e != null ? e : t,
+    t != null ? t : e,
+    s,
+    a
+  ), d = f.topVerts);
+  let p = [];
+  (c || r) && (p = H(u.uvs));
+  let h = {};
+  c && (h = ge(
+    u,
+    e,
+    p,
+    !1,
+    s,
+    a
+  ));
+  let v = {};
+  return r && (v = ge(
+    u,
+    t,
+    p,
+    !0,
+    s,
+    a
+  )), { contour: m, triangles: u, sideTorso: f, bottomCap: h, topCap: v, topVerts: d };
+};
+class kt extends ee {
+  constructor(e, t = {}) {
+    super(), this.type = "PolygonBufferGeometry", this.parameters = L({
+      polygonGeoJson: e,
+      startHeight: 0,
+      endHeight: 1,
+      hasTop: !0,
+      topFirst: !1,
+      hasBottom: !0,
+      hasSide: !0,
+      curvatureResolution: 1,
+      cartesian: !0,
+      userDataRsoOffset: 0
+    }, t);
+    const {
+      endHeight: i,
+      hasTop: s,
+      topFirst: o,
+      hasBottom: c,
+      hasSide: r,
+      cartesian: a,
+      userDataRsoOffset: l,
+      projection: m
+    } = this.parameters, { contour: u, sideTorso: f, topVerts: d, bottomCap: p, topCap: h } = ht(L({}, this.parameters));
+    let v = [], j = [], C = [], O = 0;
+    const P = (y) => {
+      const x = Math.round(v.length / 3), A = C.length;
+      v = v.concat(y.vertices), j = j.concat(y.uvs), C = C.concat(
+        x ? y.indices.map((I) => I + x) : y.indices
+      ), this.addGroup(A, C.length - A, O++);
+    };
+    s && o && P(h), r && (P(f), this.userData.topVerts = l ? $(
+      u,
+      i + l,
+      a,
+      m
+    ).vertices : d), c && P(p), s && !o && P(h), this.setIndex(C), this[ye]("position", new G(v, 3)), this[ye]("uv", new G(j, 2)), this.computeVertexNormals();
+  }
+}
+const ft = `
+  #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 <tonemapping_fragment>
+	#include <colorspace_fragment>
+}
+`, pt = `
+    #include <common>
+    #include <logdepthbuf_pars_vertex>
+    #include <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);
+
+        #include <logdepthbuf_vertex>
+        #include <fog_vertex>
+    }
+`;
+class zt extends Ne {
+  constructor(e = {}) {
+    const C = e, {
+      lineWidth: t = 1,
+      color: i = "#ffffff",
+      opacity: s = 1,
+      map: o = null,
+      dashOffset: c = 0,
+      dashArray: r = 0,
+      dashRatio: a = 0,
+      sizeAttenuation: l = !0,
+      offsetLoop: m = !0,
+      offset: u = new K(0, 0),
+      scaleDown: f = 0,
+      alphaMap: d = void 0,
+      alphaTest: p = 0,
+      repeat: h = new K(1, 1),
+      resolution: v = new K(1, 1)
+    } = C, j = oe(C, [
+      "lineWidth",
+      "color",
+      "opacity",
+      "map",
+      "dashOffset",
+      "dashArray",
+      "dashRatio",
+      "sizeAttenuation",
+      "offsetLoop",
+      "offset",
+      "scaleDown",
+      "alphaMap",
+      "alphaTest",
+      "repeat",
+      "resolution"
+    ]);
+    super(q(L({}, j), {
+      uniforms: {
+        lineWidth: { value: t },
+        color: { value: new he(i) },
+        opacity: { value: s },
+        map: { value: o },
+        useMap: { value: o ? 1 : 0 },
+        resolution: { value: v },
+        sizeAttenuation: { value: l ? 1 : 0 },
+        offset: { value: u },
+        offsetLoop: { value: m ? 1 : 0 },
+        dashArray: { value: r },
+        dashOffset: { value: c },
+        dashRatio: { value: a },
+        useDash: { value: r > 0 ? 1 : 0 },
+        scaleDown: { value: f / 10 },
+        alphaTest: { value: p },
+        alphaMap: { value: d },
+        useAlphaMap: { value: d ? 1 : 0 },
+        repeat: { value: h }
+      },
+      vertexShader: pt,
+      fragmentShader: ft
+    })), this.type = "MeshLineMaterial";
+  }
+  // Getter and setter for color
+  get color() {
+    return this.uniforms.color.value;
+  }
+  set color(e) {
+    this.uniforms.color.value = new he(e);
+  }
+  get opacity() {
+    var e;
+    return ((e = this.uniforms) == null ? void 0 : e.opacity.value) || 1;
+  }
+  set opacity(e) {
+    this.uniforms && (this.uniforms.opacity.value = e);
+  }
+  get alphaTest() {
+    return this.uniforms.alphaTest.value;
+  }
+  set alphaTest(e) {
+    this.uniforms && (this.uniforms.alphaTest.value = e);
+  }
+  // Getter and setter for map
+  get map() {
+    return this.uniforms.map.value;
+  }
+  set map(e) {
+    this.uniforms.map.value = e, this.uniforms.useMap.value = e ? 1 : 0;
+  }
+  get repeat() {
+    return this.uniforms.repeat.value;
+  }
+  set repeat(e) {
+    this.uniforms.repeat.value.copy(e);
+  }
+  // Getter and setter for lineWidth
+  get lineWidth() {
+    return this.uniforms.lineWidth.value;
+  }
+  set lineWidth(e) {
+    this.uniforms.lineWidth.value = e;
+  }
+  // Getter and setter for sizeAttenuation
+  get sizeAttenuation() {
+    return this.uniforms.sizeAttenuation.value === 1;
+  }
+  set sizeAttenuation(e) {
+    this.uniforms.sizeAttenuation.value = e ? 1 : 0;
+  }
+}
+const Q = new V(), Me = new S(), we = new S(), g = new V(), M = new V(), D = new V(), X = new S(), Y = new We(), w = new Ue(), xe = new S(), U = new Ie(), _ = new _e(), T = new V();
+let k, E;
+function Se(n, e, t) {
+  return T.set(0, 0, -e, 1).applyMatrix4(n.projectionMatrix), T.multiplyScalar(1 / T.w), T.x = E / t.width, T.y = E / t.height, T.applyMatrix4(n.projectionMatrixInverse), T.multiplyScalar(1 / T.w), Math.abs(Math.max(T.x, T.y));
+}
+function mt(n, e) {
+  const t = n.matrixWorld, i = n.geometry, s = i.attributes.instanceStart, o = i.attributes.instanceEnd, c = Math.min(i.instanceCount, s.count);
+  for (let r = 0, a = c; r < a; r++) {
+    w.start.fromBufferAttribute(s, r), w.end.fromBufferAttribute(o, r), w.applyMatrix4(t);
+    const l = new S(), m = new S();
+    k.distanceSqToSegment(w.start, w.end, m, l), m.distanceTo(l) < E * 0.5 && e.push({
+      point: m,
+      pointOnLine: l,
+      distance: k.origin.distanceTo(m),
+      object: n,
+      face: null,
+      faceIndex: r,
+      uv: null,
+      uv1: null
+    });
+  }
+}
+function vt(n, e, t) {
+  const i = e.projectionMatrix, o = n.material.resolution, c = n.matrixWorld, r = n.geometry, a = r.attributes.instanceStart, l = r.attributes.instanceEnd, m = Math.min(r.instanceCount, a.count), u = -e.near;
+  k.at(1, D), D.w = 1, D.applyMatrix4(e.matrixWorldInverse), D.applyMatrix4(i), D.multiplyScalar(1 / D.w), D.x *= o.x / 2, D.y *= o.y / 2, D.z = 0, X.copy(D), Y.multiplyMatrices(e.matrixWorldInverse, c);
+  for (let f = 0, d = m; f < d; f++) {
+    if (g.fromBufferAttribute(a, f), M.fromBufferAttribute(l, f), g.w = 1, M.w = 1, g.applyMatrix4(Y), M.applyMatrix4(Y), g.z > u && M.z > u)
+      continue;
+    if (g.z > u) {
+      const O = g.z - M.z, P = (g.z - u) / O;
+      g.lerp(M, P);
+    } else if (M.z > u) {
+      const O = M.z - g.z, P = (M.z - u) / O;
+      M.lerp(g, P);
+    }
+    g.applyMatrix4(i), M.applyMatrix4(i), g.multiplyScalar(1 / g.w), M.multiplyScalar(1 / M.w), g.x *= o.x / 2, g.y *= o.y / 2, M.x *= o.x / 2, M.y *= o.y / 2, w.start.copy(g), w.start.z = 0, w.end.copy(M), w.end.z = 0;
+    const h = w.closestPointToPointParameter(X, !0);
+    w.at(h, xe);
+    const v = Ge.lerp(g.z, M.z, h), j = v >= -1 && v <= 1, C = X.distanceTo(xe) < E * 0.5;
+    if (j && C) {
+      w.start.fromBufferAttribute(a, f), w.end.fromBufferAttribute(l, f), w.start.applyMatrix4(c), w.end.applyMatrix4(c);
+      const O = new S(), P = new S();
+      k.distanceSqToSegment(w.start, w.end, P, O), t.push({
+        point: P,
+        pointOnLine: O,
+        distance: k.origin.distanceTo(P),
+        object: n,
+        face: null,
+        faceIndex: f,
+        uv: null,
+        uv1: null
+      });
+    }
+  }
+}
+class Et extends Ae {
+  constructor(e = new Je(), t) {
+    super(e, t), this.isLineSegments2 = !0, this.type = "LineSegments2";
+  }
+  // for backwards-compatibility, but could be a method of LineSegmentsGeometry...
+  computeLineDistances() {
+    const e = this.geometry, t = e.attributes.instanceStart, i = e.attributes.instanceEnd, s = new Float32Array(2 * t.count);
+    for (let c = 0, r = 0, a = t.count; c < a; c++, r += 2)
+      Me.fromBufferAttribute(t, c), we.fromBufferAttribute(i, c), s[r] = r === 0 ? 0 : s[r - 1], s[r + 1] = s[r] + Me.distanceTo(we);
+    const o = new Re(
+      s,
+      2,
+      1
+    );
+    return e.setAttribute(
+      "instanceDistanceStart",
+      new fe(o, 1, 0)
+    ), e.setAttribute(
+      "instanceDistanceEnd",
+      new fe(o, 1, 1)
+    ), this;
+  }
+  raycast(e, t) {
+    const i = this.material.worldUnits, s = e.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 o = e.params.Line2 !== void 0 && e.params.Line2.threshold || 0;
+    k = e.ray;
+    const c = this.matrixWorld, r = this.geometry, a = this.material;
+    E = a.linewidth + o, r.boundingSphere === null && r.computeBoundingSphere(), _.copy(r.boundingSphere).applyMatrix4(c);
+    let l;
+    if (i)
+      l = E * 0.5;
+    else {
+      const u = Math.max(
+        s.near,
+        _.distanceToPoint(k.origin)
+      );
+      l = Se(
+        s,
+        u,
+        a.resolution
+      );
+    }
+    if (_.radius += l, k.intersectsSphere(_) === !1)
+      return;
+    r.boundingBox === null && r.computeBoundingBox(), U.copy(r.boundingBox).applyMatrix4(c);
+    let m;
+    if (i)
+      m = E * 0.5;
+    else {
+      const u = Math.max(
+        s.near,
+        U.distanceToPoint(k.origin)
+      );
+      m = Se(
+        s,
+        u,
+        a.resolution
+      );
+    }
+    U.expandByScalar(m), k.intersectsBox(U) !== !1 && (i ? mt(this, t) : vt(this, s, t));
+  }
+  onBeforeRender(e) {
+    const t = this.material.uniforms;
+    t && t.resolution && (e.getViewport(Q), this.material.uniforms.resolution.value.set(Q.z, Q.w));
+  }
+}
+const b = class b extends Z {
+  constructor(e) {
+    super(), this.objectType = "Node", this.onNodePointerIndex = [], this.options = L({
+      type: "2d"
+    }, e);
+  }
+  create() {
+    const { position: e, children: t } = this.options, i = document.createElement("div");
+    this.element = i, t && i.appendChild(t), this.options.type === "3d" ? this.createCSS3DObject(i) : this.options.type === "3dSprite" ? this.createCSS3DSprite(i) : this.createCSS2DObject(i), e && this.object3d.position.copy(e);
+  }
+  setChildren(e) {
+    this.options.children = e, this.element.innerHTML = "", this.element.appendChild(e);
+  }
+  showAndEnsureVisible() {
+    const e = this.options.children;
+    e && (e.style.visibility = "hidden", this.show(), setTimeout(() => {
+      e.style.visibility = "", this.ensureVisible();
+    }));
+  }
+  moveElementToViewport() {
+    const e = this.options.children;
+    if (!e) return;
+    const t = e.getBoundingClientRect(), i = window.innerWidth, s = window.innerHeight, o = t.width, c = t.height;
+    let r = 0, a = 0;
+    o > i ? t.left > 0 && (r = -t.left) : t.left < 0 ? r = -t.left : t.right > i && (r = i - t.right, t.left + r < 0 && (r = -t.left)), c > s ? t.top > 0 && (a = -t.top) : t.top < 0 ? a = -t.top : t.bottom > s && (a = s - t.bottom, t.top + a < 0 && (a = -t.top)), (r !== 0 || a !== 0) && (e.style.transform = `translate(${r}px, ${a}px)`);
+  }
+  ensureVisible() {
+    const e = this.options.children;
+    e && (e.style.transform && (e.style.transform = ""), !b.observerMap.has(e) && (b.sharedObserver || (b.sharedObserver = new IntersectionObserver((t) => {
+      t.forEach((i) => {
+        const s = i.target, o = b.observerMap.get(s);
+        o && i.isIntersecting && (o.moveElementToViewport(), b.observerMap.delete(s), b.sharedObserver && (b.sharedObserver.unobserve(s), b.observerMap.size === 0 && (b.sharedObserver.disconnect(), b.sharedObserver = void 0)));
+      });
+    })), b.observerMap.set(e, this), b.sharedObserver.observe(e)));
+  }
+  onPointerEvent(e, t) {
+    const i = this.lead.handlePickNode([this], e, t);
+    this.onNodePointerIndex.push(i);
+  }
+  dispose() {
+    const e = this.options.children;
+    e && b.sharedObserver && (b.observerMap.delete(e), b.sharedObserver.unobserve(e), b.observerMap.size === 0 && (b.sharedObserver.disconnect(), b.sharedObserver = void 0)), this.onNodePointerIndex.forEach((t) => {
+      this.lead.removePickNode(t);
+    }), super.dispose();
+  }
+};
+b.observerMap = /* @__PURE__ */ new Map();
+let je = b;
+export {
+  be as B,
+  Tt as I,
+  Et as L,
+  zt as M,
+  je as N,
+  kt as P,
+  it as R,
+  Z as a,
+  ht as g
+};