gl-draw 0.17.0-beta.4 → 0.17.0-beta.41

package/dist/index.module2.js

@@ -0,0 +1,1183 @@
+var Re = Object.defineProperty, _e = Object.defineProperties;
+var Ne = Object.getOwnPropertyDescriptors;
+var R = Object.getOwnPropertySymbols;
+var oe = Object.prototype.hasOwnProperty, ae = Object.prototype.propertyIsEnumerable;
+var ce = Math.pow, re = (r, e, t) => e in r ? Re(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, k = (r, e) => {
+  for (var t in e || (e = {}))
+    oe.call(e, t) && re(r, t, e[t]);
+  if (R)
+    for (var t of R(e))
+      ae.call(e, t) && re(r, t, e[t]);
+  return r;
+}, X = (r, e) => _e(r, Ne(e));
+var le = (r, e) => {
+  var t = {};
+  for (var i in r)
+    oe.call(r, i) && e.indexOf(i) < 0 && (t[i] = r[i]);
+  if (r != null && R)
+    for (var i of R(r))
+      e.indexOf(i) < 0 && ae.call(r, i) && (t[i] = r[i]);
+  return t;
+};
+var ue = (r, e, t) => new Promise((i, s) => {
+  var o = (a) => {
+    try {
+      n(t.next(a));
+    } catch (h) {
+      s(h);
+    }
+  }, c = (a) => {
+    try {
+      n(t.throw(a));
+    } catch (h) {
+      s(h);
+    }
+  }, n = (a) => a.done ? i(a.value) : Promise.resolve(a.value).then(o, c);
+  n((t = t.apply(r, e)).next());
+});
+import { merge as ie, mean as Ue, extent as he } from "d3-array";
+import Ge, { flatten as Oe } from "earcut";
+import { Material as de, Object3D as G, Texture as fe, Vector3 as S, Matrix4 as De, Ray as $e, Sphere as ze, BufferGeometry as se, Float32BufferAttribute as $, PointsMaterial as Fe, Points as ne, InstancedMesh as Ee, Quaternion as qe, Group as Xe, Mesh as Le, Sprite as pe, Box3 as ke, ShaderMaterial as Ke, Vector2 as K, Color as me, Vector4 as V, Line3 as Qe, InstancedInterleavedBuffer as Ye, InterleavedBufferAttribute as ve, MathUtils as Ze } from "three";
+import Je from "@turf/boolean-clockwise";
+import { p as be, W as Q, c as ye } from "./cartographicToCartesian.module.js";
+import He from "delaunator";
+import et from "@turf/boolean-point-in-polygon";
+import { geoBounds as Ve, geoContains as tt, geoDistance as it, geoInterpolate as st } from "d3-geo";
+import { geoVoronoi as nt } from "d3-geo-voronoi";
+import { scaleLinear as ge } from "d3-scale";
+import { LineSegmentsGeometry as rt } from "three/examples/jsm/lines/LineSegmentsGeometry";
+import { CSS2DObject as ot } from "three/examples/jsm/renderers/CSS2DRenderer";
+import { CSS3DObject as at, CSS3DSprite as ct } from "three/examples/jsm/renderers/CSS3DRenderer";
+import "d3-geo-projection";
+const Me = 0, xe = 1, _t = !1;
+class lt {
+  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 de)
+      return e;
+    if (e instanceof ee ? (e.disposeTrack && e.object3d ? this.track(e.object3d) : this.resources.add(e), Object.values(e.materialList).map((t) => this.track(t))) : (e instanceof G || Reflect.has(e, "dispose")) && this.resources.add(e), e instanceof ee)
+      e.children.forEach((t) => {
+        t.disposeTrack = !1;
+      }), this.track(e.children);
+    else if (e instanceof G) {
+      const t = e;
+      this.track(t.geometry), this.track(t.material), this.track(t.children);
+    } else if (e instanceof de) {
+      for (const i of Object.values(e))
+        i instanceof fe && 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 fe || 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 G ? 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 we = /* @__PURE__ */ new De(), We = /* @__PURE__ */ new $e(), Y = /* @__PURE__ */ new ze(), _ = /* @__PURE__ */ new S();
+function ut(r, e) {
+  const t = this.geometry, i = this.matrixWorld, s = r.params.Points.threshold, o = t.drawRange;
+  t.boundingSphere === null && t.computeBoundingSphere(), Y.copy(t.boundingSphere), Y.applyMatrix4(i), Y.radius += s, we.copy(i).invert(), We.copy(r.ray).applyMatrix4(we);
+  const c = s / ((this.scale.x + this.scale.y + this.scale.z) / 3), n = t.index, h = t.attributes.position;
+  if (n !== null) {
+    const d = Math.max(0, o.start), u = Math.min(n.count, o.start + o.count);
+    for (let f = d, l = u; f < l; f++) {
+      const p = n.getX(f);
+      _.fromBufferAttribute(h, p), Se(
+        _,
+        p,
+        c,
+        i,
+        r,
+        e,
+        this
+      );
+    }
+  } else {
+    const d = Math.max(0, o.start), u = Math.min(
+      h.count,
+      o.start + o.count
+    );
+    for (let f = d, l = u; f < l; f++)
+      _.fromBufferAttribute(h, f), Se(
+        _,
+        f,
+        c,
+        i,
+        r,
+        e,
+        this
+      );
+  }
+}
+function Se(r, e, t, i, s, o, c) {
+  const n = new S();
+  We.closestPointToPoint(r, n), n.applyMatrix4(i);
+  const a = s.ray.origin.distanceTo(r), h = n.distanceTo(r), d = Math.asin(
+    h / a
+  );
+  if (d < t) {
+    if (a < s.near || a > s.far)
+      return;
+    o.push({
+      distance: a,
+      distanceToRay: h,
+      angleToRay: d,
+      point: n,
+      index: e,
+      face: null,
+      object: c
+    });
+  }
+}
+const ht = (r, e = 1) => {
+  const t = new se();
+  t.setAttribute(
+    "position",
+    new $(new Array(e * 3).fill(0), 3)
+  ), t.setAttribute(
+    "scaleAtt",
+    new $(new Array(e).fill(1), 1)
+  );
+  const i = r.material, s = new Fe({
+    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
+  });
+  s.onBeforeCompile = (c) => {
+    c.vertexShader = `
+            attribute float scaleAtt;
+              ${c.vertexShader.replace(
+      "gl_PointSize = size;",
+      "gl_PointSize = size * scaleAtt;"
+    )}
+            `;
+  };
+  const o = new ne(t, s);
+  return o.raycast = ut, o;
+}, dt = (r, e) => {
+  const t = new G();
+  e.forEach((i, s) => {
+    const o = be(i.position), c = be(i.scale || [1, 1, 1]);
+    t.position.copy(o), t.scale.copy(c), t.updateMatrix();
+    const n = t.matrix.clone();
+    if (r instanceof Ee || r.isInstantiate)
+      r.setMatrixAt(s, n);
+    else if (r instanceof ne || r.type === "Points") {
+      const h = r.geometry, d = h.attributes.position.array, u = h.attributes.scaleAtt.array, f = new S(), l = new S(), p = new qe(), m = s * 3, b = s * 1;
+      n.decompose(f, p, l), d[m] = f.x, d[m + 1] = f.y, d[m + 2] = f.z, u[b] = Math.max(l.x, l.y, l.z), h.attributes.position.needsUpdate = !0, h.attributes.scaleAtt.needsUpdate = !0;
+    }
+  });
+};
+class ft {
+  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 pt extends ft {
+  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 ee extends pt {
+  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;
+  }
+  /**
+   * 检查是否实际可见（自己和所有祖先都 visible）
+   */
+  isActuallyVisible() {
+    if (!this.object3d.visible) return !1;
+    const e = this.parent;
+    return e ? e.isActuallyVisible() : !0;
+  }
+  create() {
+    this.createGroup();
+  }
+  render() {
+  }
+  update(e, t) {
+  }
+  resize(e, t) {
+  }
+  show() {
+    return this.object3d.visible = !0, this.isActuallyVisible() && this._enableLayersRecursive(), this;
+  }
+  hide() {
+    return this.object3d.visible = !1, this._disableLayersRecursive(), this;
+  }
+  /**
+   * 递归禁用 layers（不管子级自己的 visible 状态，全部 disable）
+   */
+  _disableLayersRecursive() {
+    var e;
+    (e = this.object3d) == null || e.layers.disable(Me), this.children.forEach((t) => {
+      t._disableLayersRecursive();
+    });
+  }
+  /**
+   * 递归启用 layers（只有自己 visible=true 时才 enable 并继续递归）
+   */
+  _enableLayersRecursive() {
+    var e;
+    this.object3d.visible && ((e = this.object3d) == null || e.layers.enable(Me), this.children.forEach((t) => {
+      t._enableLayersRecursive();
+    }));
+  }
+  createGroup() {
+    return this.object3d = new Xe(), this;
+  }
+  createMesh(...e) {
+    return this.object3d = new Le(...e), this;
+  }
+  createPoints(...e) {
+    return this.object3d = new ne(...e), this;
+  }
+  createCSS2DObject(e) {
+    return this.object3d = new ot(e), this;
+  }
+  createCSS3DObject(e) {
+    return this.object3d = new at(e), this;
+  }
+  createCSS3DSprite(e) {
+    return this.object3d = new ct(e), this;
+  }
+  createSprite(e) {
+    return this.object3d = new pe(e), this;
+  }
+  attach(...e) {
+    return [...e].forEach((t) => {
+      this.object3d.attach(t.object3d);
+    }), this;
+  }
+  getSize() {
+    const e = new ke().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 ue(this, null, function* () {
+      var h, d;
+      const t = (h = e == null ? void 0 : e.recursive) != null ? h : !0, i = (d = e == null ? void 0 : e.cloneMaterial) != null ? d : !1, { objectType: s, objectOptions: o } = this;
+      let c = e == null ? void 0 : e.create, n, a = (e == null ? void 0 : e.target) || this.parent;
+      return a === this.lead.prefabGroup && (a = this.lead.group), this.objectType === "BaseObject" ? n = 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 l = e.instancedAttr.length;
+            if (this.object3d instanceof pe)
+              u.object3d = ht(this.object3d, l);
+            else {
+              const p = this.object3d, m = i ? this.cloneMaterial() : p.material;
+              u.object3d = new Ee(
+                p.geometry,
+                m,
+                l
+              );
+            }
+            dt(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;
+        }
+      }), n = yield this.lead.draw(s, X(k({}, 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 && n.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: n
+          })
+        )
+      )), n.isInstantiate = !0, n;
+    });
+  }
+  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(xe)), (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(xe)), (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 lt();
+      i.disposeMaterial = !1, i.track(this), i.dispose();
+    }
+  }
+}
+function mt(r, e) {
+  return r.map((t) => {
+    const i = [];
+    let s;
+    return t.forEach((o) => {
+      if (s) {
+        const c = it(o, s) * 180 / Math.PI;
+        if (c > e) {
+          const n = st(s, o), a = 1 / Math.ceil(c / e);
+          let h = a;
+          for (; h < 1; )
+            i.push(n(h)), h += a;
+        }
+      }
+      i.push(s = o);
+    }), i;
+  });
+}
+function vt(r, { minLng: e, maxLng: t, minLat: i, maxLat: s } = {}) {
+  const o = Math.round(ce(360 / r, 2) / Math.PI), c = (1 + Math.sqrt(5)) / 2, n = (l) => l / c * 360 % 360 - 180, a = (l) => Math.acos(2 * l / o - 1) / Math.PI * 180 - 90, h = (l) => o * (Math.cos((l + 90) * Math.PI / 180) + 1) / 2, d = [
+    s !== void 0 ? Math.ceil(h(s)) : 0,
+    i !== void 0 ? Math.floor(h(i)) : o - 1
+  ], u = e === void 0 && t === void 0 ? () => !0 : e === void 0 ? (l) => l <= t : t === void 0 ? (l) => l >= e : t >= e ? (l) => l >= e && l <= t : (l) => l >= e || l <= t, f = [];
+  for (let l = d[0]; l <= d[1]; l++) {
+    const p = n(l);
+    u(p) && f.push([p, a(l)]);
+  }
+  return f;
+}
+function te(r, e, t = !1) {
+  return t ? tt(e, r) : et(r, e);
+}
+function bt(r, e) {
+  const t = { type: "Polygon", coordinates: r }, [[i, s], [o, c]] = Ve(t);
+  if (Math.min(Math.abs(o - i), Math.abs(c - s)) < e)
+    return [];
+  const n = i > o || c >= 89 || s <= -89;
+  return vt(e, {
+    minLng: i,
+    maxLng: o,
+    minLat: s,
+    maxLat: c
+  }).filter(
+    (a) => te(a, t, n)
+  );
+}
+function yt(r, { resolution: e = 1 / 0, bbox: t, projection: i } = {}) {
+  const s = mt(r, e), o = ie(s), c = bt(r, e), n = [...o, ...c], a = { type: "Polygon", coordinates: r }, [[h, d], [u, f]] = Ve(a), l = h > u || // crosses antimeridian
+  f >= 89 || // crosses north pole
+  d <= -89;
+  let p = [];
+  if (l) {
+    const y = nt(n).triangles(), w = new Map(
+      n.map(([I, T], E) => [`${I}-${T}`, E])
+    );
+    y.features.forEach((I) => {
+      const T = I.geometry.coordinates[0].slice(0, 3).reverse(), E = [];
+      if (T.forEach(([A, q]) => {
+        const W = `${A}-${q}`;
+        w.has(W) && E.push(w.get(W));
+      }), E.length === 3) {
+        if (E.some((A) => A < o.length)) {
+          const A = I.properties.circumcenter;
+          if (!te(
+            A,
+            a,
+            l
+          ))
+            return;
+        }
+        p.push(...E);
+      }
+    });
+  } else if (c.length) {
+    const y = He.from(n);
+    for (let w = 0, I = y.triangles.length; w < I; w += 3) {
+      const T = [2, 1, 0].map((A) => y.triangles[w + A]), E = T.map((A) => n[A]);
+      if (T.some((A) => A < o.length)) {
+        const A = [0, 1].map(
+          (q) => Ue(E, (W) => W[q])
+        );
+        if (!te(
+          A,
+          a,
+          l
+        ))
+          continue;
+      }
+      p.push(...T);
+    }
+  } else {
+    const { vertices: y, holes: w = [] } = Oe(s);
+    p = Ge(y, w, 2);
+  }
+  let m = t ? [t[0], t[2]] : he(n, (y) => y[0]), b = t ? [t[1], t[3]] : he(n, (y) => y[1]);
+  if (i) {
+    const [y, w] = i([m[0], b[0]]), [I, T] = i([m[1], b[1]]);
+    m = [y, I], b = [-w, -T];
+  }
+  const j = ge(m, [0, 1]), z = ge(b, [0, 1]), C = n.map(([y, w]) => {
+    if (i) {
+      const [I, T] = i([y, w]);
+      return [j(I), z(-T)];
+    } else
+      return [j(y), z(w)];
+  });
+  return { contour: s, triangles: { points: n, indices: p, uvs: C } };
+}
+const je = new se().setAttribute ? "setAttribute" : "addAttribute";
+function F(r, e, t) {
+  const i = r.map(
+    (s) => s.map(([o, c]) => {
+      if (t === "cesium") {
+        const n = 1 / Q.a, a = e / n, h = Math.max(0, a - Q.a), d = ye(o, c, h, n, !1);
+        return [d.x, d.y, d.z];
+      }
+      if (t === "sphere") {
+        const n = ye(
+          o,
+          c,
+          e - Q.a,
+          1,
+          !0
+        );
+        return [n.x, n.y, n.z];
+      }
+      if (typeof t == "function") {
+        const [n, a] = t([o, c]);
+        return [n, -a, e];
+      }
+      return [o, c, e];
+    })
+  );
+  return Oe(i);
+}
+function gt(r, e, t, i) {
+  const { vertices: s, holes: o } = F(
+    r,
+    e,
+    i
+  ), { vertices: c } = F(
+    r,
+    t,
+    i
+  ), n = ie([c, s]), a = Math.round(c.length / 3), h = new Set(o);
+  let d = 0;
+  const u = [];
+  for (let l = 0; l < a; l++) {
+    let p = l + 1;
+    if (p === a)
+      p = d;
+    else if (h.has(p)) {
+      const m = p;
+      p = d, d = m;
+    }
+    u.push(l, l + a, p + a), u.push(p + a, p, l);
+  }
+  const f = [];
+  for (let l = 1; l >= 0; l--)
+    for (let p = 0; p < a; p += 1) f.push(p / (a - 1), l);
+  return { indices: u, vertices: n, uvs: f, topVerts: c };
+}
+function Ce(r, e, t, i, s) {
+  return {
+    indices: i ? r.indices : r.indices.slice().reverse(),
+    vertices: F(
+      [r.points],
+      e,
+      s
+    ).vertices,
+    uvs: t
+  };
+}
+const Mt = ({
+  polygonGeoJson: r,
+  startHeight: e,
+  endHeight: t,
+  curvatureResolution: i = 1,
+  hasSide: s = !0,
+  hasBottom: o = !1,
+  hasTop: c = !1,
+  projection: n = "sphere",
+  bbox: a
+}) => {
+  r.forEach((j) => {
+    Je(j) || j.reverse();
+  });
+  const h = typeof n == "function" ? n : void 0, { contour: d, triangles: u } = yt(r, {
+    resolution: i,
+    bbox: a,
+    projection: h
+  });
+  let f = {}, l;
+  s && (f = gt(
+    d,
+    e != null ? e : t,
+    t != null ? t : e,
+    n
+  ), l = f.topVerts);
+  let p = [];
+  (o || c) && (p = ie(u.uvs));
+  let m = {};
+  o && (m = Ce(
+    u,
+    e,
+    p,
+    !1,
+    n
+  ));
+  let b = {};
+  return c && (b = Ce(
+    u,
+    t,
+    p,
+    !0,
+    n
+  )), { contour: d, triangles: u, sideTorso: f, bottomCap: m, topCap: b, topVerts: l };
+};
+class Nt extends se {
+  constructor(e, t = {}) {
+    super(), this.type = "PolygonBufferGeometry", this.parameters = k({
+      polygonGeoJson: e,
+      startHeight: 0,
+      endHeight: 1,
+      hasTop: !0,
+      topFirst: !1,
+      hasBottom: !0,
+      hasSide: !0,
+      curvatureResolution: 1,
+      projection: "sphere",
+      userDataRsoOffset: 0
+    }, t);
+    const {
+      endHeight: i,
+      hasTop: s,
+      topFirst: o,
+      hasBottom: c,
+      hasSide: n,
+      userDataRsoOffset: a,
+      projection: h
+    } = this.parameters, { contour: d, sideTorso: u, topVerts: f, bottomCap: l, topCap: p } = Mt(k({}, this.parameters));
+    let m = [], b = [], j = [], z = 0;
+    const C = (P) => {
+      const y = Math.round(m.length / 3), w = j.length;
+      m = m.concat(P.vertices), b = b.concat(P.uvs), j = j.concat(
+        y ? P.indices.map((I) => I + y) : P.indices
+      ), this.addGroup(w, j.length - w, z++);
+    };
+    s && o && C(p), n && (C(u), this.userData.topVerts = a ? F(
+      d,
+      i + a,
+      h
+    ).vertices : f), c && C(l), s && !o && C(p), this.setIndex(j), this[je]("position", new $(m, 3)), this[je]("uv", new $(b, 2)), this.computeVertexNormals();
+  }
+}
+const xt = `
+  #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>
+}
+`, wt = `
+    #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 Ut extends Ke {
+  constructor(e = {}) {
+    const z = e, {
+      lineWidth: t = 1,
+      color: i = "#ffffff",
+      opacity: s = 1,
+      map: o = null,
+      dashOffset: c = 0,
+      dashArray: n = 0,
+      dashRatio: a = 0,
+      sizeAttenuation: h = !0,
+      offsetLoop: d = !0,
+      offset: u = new K(0, 0),
+      scaleDown: f = 0,
+      alphaMap: l = void 0,
+      alphaTest: p = 0,
+      repeat: m = new K(1, 1),
+      resolution: b = new K(1, 1)
+    } = z, j = le(z, [
+      "lineWidth",
+      "color",
+      "opacity",
+      "map",
+      "dashOffset",
+      "dashArray",
+      "dashRatio",
+      "sizeAttenuation",
+      "offsetLoop",
+      "offset",
+      "scaleDown",
+      "alphaMap",
+      "alphaTest",
+      "repeat",
+      "resolution"
+    ]);
+    super(X(k({}, j), {
+      uniforms: {
+        lineWidth: { value: t },
+        color: { value: new me(i) },
+        opacity: { value: s },
+        map: { value: o },
+        useMap: { value: o ? 1 : 0 },
+        resolution: { value: b },
+        sizeAttenuation: { value: h ? 1 : 0 },
+        offset: { value: u },
+        offsetLoop: { value: d ? 1 : 0 },
+        dashArray: { value: n },
+        dashOffset: { value: c },
+        dashRatio: { value: a },
+        useDash: { value: n > 0 ? 1 : 0 },
+        scaleDown: { value: f / 10 },
+        alphaTest: { value: p },
+        alphaMap: { value: l },
+        useAlphaMap: { value: l ? 1 : 0 },
+        repeat: { value: m }
+      },
+      vertexShader: wt,
+      fragmentShader: xt
+    })), this.type = "MeshLineMaterial";
+  }
+  // Getter and setter for color
+  get color() {
+    return this.uniforms.color.value;
+  }
+  set color(e) {
+    this.uniforms.color.value = new me(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 Z = new V(), Pe = new S(), Ae = new S(), g = new V(), M = new V(), B = new V(), J = new S(), H = new De(), x = new Qe(), Ie = new S(), N = new ke(), U = new ze(), O = new V();
+let D, L;
+function Te(r, e, t) {
+  return O.set(0, 0, -e, 1).applyMatrix4(r.projectionMatrix), O.multiplyScalar(1 / O.w), O.x = L / t.width, O.y = L / t.height, O.applyMatrix4(r.projectionMatrixInverse), O.multiplyScalar(1 / O.w), Math.abs(Math.max(O.x, O.y));
+}
+function St(r, e) {
+  const t = r.matrixWorld, i = r.geometry, s = i.attributes.instanceStart, o = i.attributes.instanceEnd, c = Math.min(i.instanceCount, s.count);
+  for (let n = 0, a = c; n < a; n++) {
+    x.start.fromBufferAttribute(s, n), x.end.fromBufferAttribute(o, n), x.applyMatrix4(t);
+    const h = new S(), d = new S();
+    D.distanceSqToSegment(x.start, x.end, d, h), d.distanceTo(h) < L * 0.5 && e.push({
+      point: d,
+      pointOnLine: h,
+      distance: D.origin.distanceTo(d),
+      object: r,
+      face: null,
+      faceIndex: n,
+      uv: null,
+      uv1: null
+    });
+  }
+}
+function jt(r, e, t) {
+  const i = e.projectionMatrix, o = r.material.resolution, c = r.matrixWorld, n = r.geometry, a = n.attributes.instanceStart, h = n.attributes.instanceEnd, d = Math.min(n.instanceCount, a.count), u = -e.near;
+  D.at(1, B), B.w = 1, B.applyMatrix4(e.matrixWorldInverse), B.applyMatrix4(i), B.multiplyScalar(1 / B.w), B.x *= o.x / 2, B.y *= o.y / 2, B.z = 0, J.copy(B), H.multiplyMatrices(e.matrixWorldInverse, c);
+  for (let f = 0, l = d; f < l; f++) {
+    if (g.fromBufferAttribute(a, f), M.fromBufferAttribute(h, f), g.w = 1, M.w = 1, g.applyMatrix4(H), M.applyMatrix4(H), g.z > u && M.z > u)
+      continue;
+    if (g.z > u) {
+      const C = g.z - M.z, P = (g.z - u) / C;
+      g.lerp(M, P);
+    } else if (M.z > u) {
+      const C = M.z - g.z, P = (M.z - u) / C;
+      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, x.start.copy(g), x.start.z = 0, x.end.copy(M), x.end.z = 0;
+    const m = x.closestPointToPointParameter(J, !0);
+    x.at(m, Ie);
+    const b = Ze.lerp(g.z, M.z, m), j = b >= -1 && b <= 1, z = J.distanceTo(Ie) < L * 0.5;
+    if (j && z) {
+      x.start.fromBufferAttribute(a, f), x.end.fromBufferAttribute(h, f), x.start.applyMatrix4(c), x.end.applyMatrix4(c);
+      const C = new S(), P = new S();
+      D.distanceSqToSegment(x.start, x.end, P, C), t.push({
+        point: P,
+        pointOnLine: C,
+        distance: D.origin.distanceTo(P),
+        object: r,
+        face: null,
+        faceIndex: f,
+        uv: null,
+        uv1: null
+      });
+    }
+  }
+}
+class Gt extends Le {
+  constructor(e = new rt(), 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, n = 0, a = t.count; c < a; c++, n += 2)
+      Pe.fromBufferAttribute(t, c), Ae.fromBufferAttribute(i, c), s[n] = n === 0 ? 0 : s[n - 1], s[n + 1] = s[n] + Pe.distanceTo(Ae);
+    const o = new Ye(
+      s,
+      2,
+      1
+    );
+    return e.setAttribute(
+      "instanceDistanceStart",
+      new ve(o, 1, 0)
+    ), e.setAttribute(
+      "instanceDistanceEnd",
+      new ve(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;
+    D = e.ray;
+    const c = this.matrixWorld, n = this.geometry, a = this.material;
+    L = a.linewidth + o, n.boundingSphere === null && n.computeBoundingSphere(), U.copy(n.boundingSphere).applyMatrix4(c);
+    let h;
+    if (i)
+      h = L * 0.5;
+    else {
+      const u = Math.max(
+        s.near,
+        U.distanceToPoint(D.origin)
+      );
+      h = Te(
+        s,
+        u,
+        a.resolution
+      );
+    }
+    if (U.radius += h, D.intersectsSphere(U) === !1)
+      return;
+    n.boundingBox === null && n.computeBoundingBox(), N.copy(n.boundingBox).applyMatrix4(c);
+    let d;
+    if (i)
+      d = L * 0.5;
+    else {
+      const u = Math.max(
+        s.near,
+        N.distanceToPoint(D.origin)
+      );
+      d = Te(
+        s,
+        u,
+        a.resolution
+      );
+    }
+    N.expandByScalar(d), D.intersectsBox(N) !== !1 && (i ? St(this, t) : jt(this, s, t));
+  }
+  onBeforeRender(e) {
+    const t = this.material.uniforms;
+    t && t.resolution && (e.getViewport(Z), this.material.uniforms.resolution.value.set(Z.z, Z.w));
+  }
+}
+const v = class v extends ee {
+  constructor(e) {
+    super(), this.objectType = "Node", this.onNodePointerIndex = [], this.options = k({
+      type: "2d"
+    }, e);
+  }
+  create() {
+    var s;
+    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), (s = this.pencil.cssRendererController) == null || s.collisionManager.add(this);
+  }
+  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 n = 0, a = 0;
+    o > i ? t.left > 0 && (n = -t.left) : t.left < 0 ? n = -t.left : t.right > i && (n = i - t.right, t.left + n < 0 && (n = -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)), (n !== 0 || a !== 0) && (e.style.transform = `translate(${n}px, ${a}px)`);
+  }
+  ensureVisible() {
+    const e = this.options.children;
+    e && (e.style.transform && (e.style.transform = ""), !v.observerMap.has(e) && (v.sharedObserver || (v.sharedObserver = new IntersectionObserver((t) => {
+      t.forEach((i) => {
+        const s = i.target, o = v.observerMap.get(s);
+        o && i.isIntersecting && (o.moveElementToViewport(), v.observerMap.delete(s), v.sharedObserver && (v.sharedObserver.unobserve(s), v.observerMap.size === 0 && (v.sharedObserver.disconnect(), v.sharedObserver = void 0)));
+      });
+    })), v.observerMap.set(e, this), v.sharedObserver.observe(e)));
+  }
+  onPointerEvent(e, t) {
+    const i = this.lead.handlePickNode([this], e, t);
+    this.onNodePointerIndex.push(i);
+  }
+  dispose() {
+    var t;
+    (t = this.pencil.cssRendererController) == null || t.collisionManager.remove(this);
+    const e = this.options.children;
+    e && v.sharedObserver && (v.observerMap.delete(e), v.sharedObserver.unobserve(e), v.observerMap.size === 0 && (v.sharedObserver.disconnect(), v.sharedObserver = void 0)), this.onNodePointerIndex.forEach((i) => {
+      this.lead.removePickNode(i);
+    }), super.dispose();
+  }
+};
+v.observerMap = /* @__PURE__ */ new Map();
+let Be = v;
+export {
+  xe as B,
+  _t as I,
+  Gt as L,
+  Ut as M,
+  Be as N,
+  Nt as P,
+  lt as R,
+  ee as a,
+  Mt as g
+};