gl-draw 0.13.2 → 0.13.4

package/dist/index.module2.js

@@ -1,152 +1,400 @@
-var ce = Object.defineProperty, fe = Object.defineProperties;
-var he = Object.getOwnPropertyDescriptors;
+var ft = Object.defineProperty, pt = Object.defineProperties;
+var dt = Object.getOwnPropertyDescriptors;
 var K = Object.getOwnPropertySymbols;
-var pe = Object.prototype.hasOwnProperty, me = Object.prototype.propertyIsEnumerable;
-var X = Math.pow, Q = (n, t, e) => t in n ? ce(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, U = (n, t) => {
+var mt = Object.prototype.hasOwnProperty, vt = Object.prototype.propertyIsEnumerable;
+var Y = Math.pow, X = (o, t, e) => t in o ? ft(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, E = (o, t) => {
   for (var e in t || (t = {}))
-    pe.call(t, e) && Q(n, e, t[e]);
+    mt.call(t, e) && X(o, e, t[e]);
   if (K)
     for (var e of K(t))
-      me.call(t, e) && Q(n, e, t[e]);
-  return n;
-}, Y = (n, t) => fe(n, he(t));
-import * as _ from "three";
-import { Vector4 as O, Vector3 as D, Matrix4 as de, Line3 as ve, Box3 as ge, Sphere as ye, Mesh as xe, InstancedInterleavedBuffer as Me, InterleavedBufferAttribute as H, MathUtils as be } from "three";
-import { LineSegmentsGeometry as we } from "three/examples/jsm/lines/LineSegmentsGeometry";
-import { merge as q, mean as Pe, extent as J } from "d3-array";
-import Ae, { flatten as ue } from "earcut";
-import Ce from "@turf/boolean-clockwise";
-import { p as _e } from "./polar2Cartesian.module.js";
-import Se from "delaunator";
-import ze from "@turf/boolean-point-in-polygon";
-import { geoBounds as le, geoContains as We, geoDistance as Ie, geoInterpolate as Be } from "d3-geo";
-import { geoVoronoi as Ve } from "d3-geo-voronoi";
-import { scaleLinear as ee } from "d3-scale";
-const j = new O(), te = new D(), ie = new D(), y = new O(), x = new O(), I = new O(), $ = new D(), k = new de(), M = new ve(), ne = new D(), E = new ge(), G = new ye(), B = new O();
-let V, L;
-function re(n, t, e) {
-  return B.set(0, 0, -t, 1).applyMatrix4(n.projectionMatrix), B.multiplyScalar(1 / B.w), B.x = L / e.width, B.y = L / e.height, B.applyMatrix4(n.projectionMatrixInverse), B.multiplyScalar(1 / B.w), Math.abs(Math.max(B.x, B.y));
+      vt.call(t, e) && X(o, e, t[e]);
+  return o;
+}, H = (o, t) => pt(o, dt(t));
+import * as h from "three";
+import { Vector4 as V, Vector3 as W, Matrix4 as gt, Line3 as bt, Box3 as yt, Sphere as xt, Mesh as Mt, InstancedInterleavedBuffer as wt, InterleavedBufferAttribute as J, MathUtils as Pt } from "three";
+import { makePromiseCreator as At } from "esus-lite";
+import { CSS2DObject as Ct } from "three/examples/jsm/renderers/CSS2DRenderer";
+import { CSS3DObject as St, CSS3DSprite as jt } from "three/examples/jsm/renderers/CSS3DRenderer";
+import { p as tt, d as U, a as zt } from "./parseVector.module.js";
+import { geoBounds as ct, geoContains as It, geoDistance as Dt, geoInterpolate as _t } from "d3-geo";
+import "d3-geo-projection";
+import { LineSegmentsGeometry as Bt } from "three/examples/jsm/lines/LineSegmentsGeometry";
+import { merge as Q, mean as Lt, extent as et } from "d3-array";
+import Wt, { flatten as ht } from "earcut";
+import Tt from "@turf/boolean-clockwise";
+import Vt from "delaunator";
+import Ot from "@turf/boolean-point-in-polygon";
+import { geoVoronoi as Et } from "d3-geo-voronoi";
+import { scaleLinear as it } from "d3-scale";
+const Ut = (o, t = 1) => {
+  const e = new h.BufferGeometry();
+  e.setAttribute(
+    "position",
+    new h.Float32BufferAttribute(new Array(t * 3).fill(0), 3)
+  ), e.setAttribute(
+    "scaleAtt",
+    new h.Float32BufferAttribute(new Array(t).fill(1), 1)
+  );
+  const i = o.material, r = new h.PointsMaterial({
+    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 r.onBeforeCompile = (n) => {
+    n.vertexShader = `
+            attribute float scaleAtt;
+              ${n.vertexShader.replace(
+      "gl_PointSize = size;",
+      "gl_PointSize = size * scaleAtt;"
+    )}
+            `;
+  }, new h.Points(e, r);
+};
+class Gt {
+  constructor() {
+    this.objectType = "BaseObject", this.userData = {}, this.prefab = !1, this.isInstantiate = !1, this.pm = At(), this.materialList = {}, this.useMaterialType = "origin", this.onPointerIndex = [];
+  }
+  get parent() {
+    const t = this.object3d.parent;
+    return t ? this.drawController.objMap.get(t) || this.pencil.scene : null;
+  }
+  get children() {
+    return this.object3d.children.map((t) => this.drawController.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 add() {
+    return this.object3d.add.bind(this.object3d);
+  }
+  get remove() {
+    return this.object3d.remove.bind(this.object3d);
+  }
+  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;
+  }
+  hide() {
+    return this.object3d.visible = !1, this;
+  }
+  createMesh(...t) {
+    return this.object3d = new h.Mesh(...t), this;
+  }
+  createGroup() {
+    return this.object3d = new h.Group(), this;
+  }
+  createPoints(...t) {
+    return this.object3d = new h.Points(...t), this;
+  }
+  createCSS2DObject(t) {
+    return this.object3d = new Ct(t), this;
+  }
+  createCSS3DObject(t) {
+    return this.object3d = new St(t), this;
+  }
+  createCSS3DSprite(t) {
+    return this.object3d = new jt(t), this;
+  }
+  createSprite(t) {
+    return this.object3d = new h.Sprite(t), this;
+  }
+  attach(...t) {
+    return [...t].forEach((e) => {
+      this.object3d.attach(e.object3d);
+    }), this;
+  }
+  getSize() {
+    const t = new h.Box3().setFromObject(this.object3d);
+    return {
+      min: t.min,
+      max: t.max,
+      size: t.getSize(new h.Vector3()),
+      center: t.getCenter(new h.Vector3())
+    };
+  }
+  traverse(t) {
+    t(this), this.children.forEach((e) => {
+      e.traverse(t);
+    });
+  }
+  clone() {
+    return this.instantiate();
+  }
+  instantiate(t) {
+    const e = t && t.length > 0;
+    return this.drawController.instantiate(this, {
+      create: (i) => {
+        var r;
+        if (this.object3d) {
+          if (e) {
+            const n = t.length;
+            if (this.object3d instanceof h.Sprite)
+              i.object3d = Ut(this.object3d, n);
+            else {
+              const s = this.object3d;
+              i.object3d = new h.InstancedMesh(
+                s.geometry,
+                s.material,
+                n
+              ), i.setMaterialList("instantiate", "clone"), i.useMaterial("instantiate");
+            }
+            const a = new h.Object3D();
+            t.forEach((s, l) => {
+              const u = tt(s.position), f = tt(s.scale || [1, 1, 1]);
+              a.position.copy(u), a.scale.copy(f), a.updateMatrix(), i.setInstancedMatrix(l, a.matrix.clone());
+            });
+          } else
+            i.object3d = this.object3d.clone(!0), i.position.set(0, 0, 0), i.rotation.set(0, 0, 0), i.setMaterialList("instantiate", "clone"), i.useMaterial("instantiate");
+          i.object3d.userData.bloom && ((r = this.pencil.composerController) == null || r.toggleBloomSelection(
+            i.object3d,
+            !0
+          )), i.object3d.userData.prefab && (i.object3d.userData.prefab = !1);
+        }
+      }
+    });
+  }
+  setInstancedMatrix(t, e) {
+    if (this.object3d instanceof h.InstancedMesh || this.object3d.isInstantiate)
+      this.object3d.setMatrixAt(t, e);
+    else if (this.object3d instanceof h.Points || this.object3d.type === "Points") {
+      const r = this.object3d.geometry, n = r.attributes.position.array, a = r.attributes.scaleAtt.array, s = new h.Vector3(), l = new h.Vector3(), u = new h.Quaternion(), f = t * 3, p = t * 1;
+      e.decompose(s, u, l), n[f] = s.x, n[f + 1] = s.y, n[f + 2] = s.z, a[p] = Math.max(l.x, l.y, l.z), r.attributes.position.needsUpdate = !0, r.attributes.scaleAtt.needsUpdate = !0;
+    }
+  }
+  erase() {
+    this.drawController.erase(this);
+  }
+  cloneMaterial() {
+    const t = this.object3d;
+    if (!t || !t.material)
+      return;
+    const e = t.material;
+    if (Array.isArray(e))
+      return e.map((i) => {
+        const r = i.userData;
+        i.userData = {};
+        const n = i.clone();
+        return i.userData = r, n;
+      });
+    {
+      const i = e.userData;
+      e.userData = {};
+      const r = e.clone();
+      return e.userData = i, r;
+    }
+  }
+  setMaterialList(t, e, i = !0) {
+    const r = this.object3d;
+    if (!r || !r.material)
+      return;
+    if (this.materialList.origin || (this.materialList.origin = r.material), this.materialList[t])
+      if (i) {
+        const a = this.materialList[t];
+        U({
+          material: a
+        });
+      } else
+        return this.materialList[t];
+    const n = e === "clone" ? this.cloneMaterial() : e;
+    return this.materialList[t] = n, n;
+  }
+  useMaterial(t) {
+    const e = this.object3d;
+    !e || !e.material || this.useMaterialType === t || !this.materialList[t] || (this.useMaterialType = t, e.material = this.materialList[t]);
+  }
+  setTop(t) {
+    this.object3d && (this.object3d.renderOrder = t);
+  }
+  onPointerEvent(t, e) {
+    const i = this.drawController.handlePick([this], t, e);
+    this.onPointerIndex.push(i);
+  }
+  dispose() {
+    this.onPointerIndex.forEach((t) => {
+      this.drawController.removePick(t);
+    }), this.object3d && U(this.object3d), Object.keys(this.materialList).forEach((t) => {
+      if (t !== this.useMaterialType) {
+        if (this.isInstantiate && t === "origin")
+          return;
+        U({
+          material: this.materialList[t]
+        });
+      }
+    });
+  }
+  disposeWithOutMaterial() {
+    this.onPointerIndex.forEach((t) => {
+      this.drawController.removePick(t);
+    }), this.object3d && U(this.object3d, !1);
+  }
+}
+class pe extends Gt {
+  create() {
+    this.createGroup();
+  }
+}
+const Z = new V(), rt = new W(), st = new W(), y = new V(), x = new V(), D = new V(), $ = new W(), q = new gt(), M = new bt(), nt = new W(), G = new yt(), R = new xt(), _ = new V();
+let B, T;
+function ot(o, t, e) {
+  return _.set(0, 0, -t, 1).applyMatrix4(o.projectionMatrix), _.multiplyScalar(1 / _.w), _.x = T / e.width, _.y = T / e.height, _.applyMatrix4(o.projectionMatrixInverse), _.multiplyScalar(1 / _.w), Math.abs(Math.max(_.x, _.y));
 }
-function Te(n, t) {
-  const e = n.matrixWorld, s = n.geometry, r = s.attributes.instanceStart, o = s.attributes.instanceEnd, a = Math.min(s.instanceCount, r.count);
-  for (let i = 0, c = a; i < c; i++) {
-    M.start.fromBufferAttribute(r, i), M.end.fromBufferAttribute(o, i), M.applyMatrix4(e);
-    const u = new D(), m = new D();
-    V.distanceSqToSegment(M.start, M.end, m, u), m.distanceTo(u) < L * 0.5 && t.push({
-      point: m,
+function Rt(o, t) {
+  const e = o.matrixWorld, i = o.geometry, r = i.attributes.instanceStart, n = i.attributes.instanceEnd, a = Math.min(i.instanceCount, r.count);
+  for (let s = 0, l = a; s < l; s++) {
+    M.start.fromBufferAttribute(r, s), M.end.fromBufferAttribute(n, s), M.applyMatrix4(e);
+    const u = new W(), f = new W();
+    B.distanceSqToSegment(M.start, M.end, f, u), f.distanceTo(u) < T * 0.5 && t.push({
+      point: f,
       pointOnLine: u,
-      distance: V.origin.distanceTo(m),
-      object: n,
+      distance: B.origin.distanceTo(f),
+      object: o,
       face: null,
-      faceIndex: i,
+      faceIndex: s,
       uv: null,
       uv1: null
     });
   }
 }
-function De(n, t, e) {
-  const s = t.projectionMatrix, o = n.material.resolution, a = n.matrixWorld, i = n.geometry, c = i.attributes.instanceStart, u = i.attributes.instanceEnd, m = Math.min(i.instanceCount, c.count), f = -t.near;
-  V.at(1, I), I.w = 1, I.applyMatrix4(t.matrixWorldInverse), I.applyMatrix4(s), I.multiplyScalar(1 / I.w), I.x *= o.x / 2, I.y *= o.y / 2, I.z = 0, $.copy(I), k.multiplyMatrices(t.matrixWorldInverse, a);
-  for (let d = 0, l = m; d < l; d++) {
-    if (y.fromBufferAttribute(c, d), x.fromBufferAttribute(u, d), y.w = 1, x.w = 1, y.applyMatrix4(k), x.applyMatrix4(k), y.z > f && x.z > f)
+function Ft(o, t, e) {
+  const i = t.projectionMatrix, n = o.material.resolution, a = o.matrixWorld, s = o.geometry, l = s.attributes.instanceStart, u = s.attributes.instanceEnd, f = Math.min(s.instanceCount, l.count), p = -t.near;
+  B.at(1, D), D.w = 1, D.applyMatrix4(t.matrixWorldInverse), D.applyMatrix4(i), D.multiplyScalar(1 / D.w), D.x *= n.x / 2, D.y *= n.y / 2, D.z = 0, $.copy(D), q.multiplyMatrices(t.matrixWorldInverse, a);
+  for (let v = 0, c = f; v < c; v++) {
+    if (y.fromBufferAttribute(l, v), x.fromBufferAttribute(u, v), y.w = 1, x.w = 1, y.applyMatrix4(q), x.applyMatrix4(q), y.z > p && x.z > p)
       continue;
-    if (y.z > f) {
-      const W = y.z - x.z, w = (y.z - f) / W;
-      y.lerp(x, w);
-    } else if (x.z > f) {
-      const W = x.z - y.z, w = (x.z - f) / W;
-      x.lerp(y, w);
+    if (y.z > p) {
+      const I = y.z - x.z, P = (y.z - p) / I;
+      y.lerp(x, P);
+    } else if (x.z > p) {
+      const I = x.z - y.z, P = (x.z - p) / I;
+      x.lerp(y, P);
     }
-    y.applyMatrix4(s), x.applyMatrix4(s), y.multiplyScalar(1 / y.w), x.multiplyScalar(1 / x.w), y.x *= o.x / 2, y.y *= o.y / 2, x.x *= o.x / 2, x.y *= o.y / 2, M.start.copy(y), M.start.z = 0, M.end.copy(x), M.end.z = 0;
-    const h = M.closestPointToPointParameter($, !0);
-    M.at(h, ne);
-    const g = be.lerp(y.z, x.z, h), S = g >= -1 && g <= 1, z = $.distanceTo(ne) < L * 0.5;
-    if (S && z) {
-      M.start.fromBufferAttribute(c, d), M.end.fromBufferAttribute(u, d), M.start.applyMatrix4(a), M.end.applyMatrix4(a);
-      const W = new D(), w = new D();
-      V.distanceSqToSegment(M.start, M.end, w, W), e.push({
-        point: w,
-        pointOnLine: W,
-        distance: V.origin.distanceTo(w),
-        object: n,
+    y.applyMatrix4(i), x.applyMatrix4(i), y.multiplyScalar(1 / y.w), x.multiplyScalar(1 / x.w), y.x *= n.x / 2, y.y *= n.y / 2, x.x *= n.x / 2, x.y *= n.y / 2, M.start.copy(y), M.start.z = 0, M.end.copy(x), M.end.z = 0;
+    const d = M.closestPointToPointParameter($, !0);
+    M.at(d, nt);
+    const b = Pt.lerp(y.z, x.z, d), j = b >= -1 && b <= 1, z = $.distanceTo(nt) < T * 0.5;
+    if (j && z) {
+      M.start.fromBufferAttribute(l, v), M.end.fromBufferAttribute(u, v), M.start.applyMatrix4(a), M.end.applyMatrix4(a);
+      const I = new W(), P = new W();
+      B.distanceSqToSegment(M.start, M.end, P, I), e.push({
+        point: P,
+        pointOnLine: I,
+        distance: B.origin.distanceTo(P),
+        object: o,
         face: null,
-        faceIndex: d,
+        faceIndex: v,
         uv: null,
         uv1: null
       });
     }
   }
 }
-class tt extends xe {
-  constructor(t = new we(), e) {
+class de extends Mt {
+  constructor(t = new Bt(), 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, s = t.attributes.instanceEnd, r = new Float32Array(2 * e.count);
-    for (let a = 0, i = 0, c = e.count; a < c; a++, i += 2)
-      te.fromBufferAttribute(e, a), ie.fromBufferAttribute(s, a), r[i] = i === 0 ? 0 : r[i - 1], r[i + 1] = r[i] + te.distanceTo(ie);
-    const o = new Me(
+    const t = this.geometry, e = t.attributes.instanceStart, i = t.attributes.instanceEnd, r = new Float32Array(2 * e.count);
+    for (let a = 0, s = 0, l = e.count; a < l; a++, s += 2)
+      rt.fromBufferAttribute(e, a), st.fromBufferAttribute(i, a), r[s] = s === 0 ? 0 : r[s - 1], r[s + 1] = r[s] + rt.distanceTo(st);
+    const n = new wt(
       r,
       2,
       1
     );
     return t.setAttribute(
       "instanceDistanceStart",
-      new H(o, 1, 0)
+      new J(n, 1, 0)
     ), t.setAttribute(
       "instanceDistanceEnd",
-      new H(o, 1, 1)
+      new J(n, 1, 1)
     ), this;
   }
   raycast(t, e) {
-    const s = this.material.worldUnits, r = t.camera;
-    r === null && !s && console.error(
+    const i = this.material.worldUnits, r = t.camera;
+    r === 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 = t.params.Line2 !== void 0 && t.params.Line2.threshold || 0;
-    V = t.ray;
-    const a = this.matrixWorld, i = this.geometry, c = this.material;
-    L = c.linewidth + o, i.boundingSphere === null && i.computeBoundingSphere(), G.copy(i.boundingSphere).applyMatrix4(a);
+    const n = t.params.Line2 !== void 0 && t.params.Line2.threshold || 0;
+    B = t.ray;
+    const a = this.matrixWorld, s = this.geometry, l = this.material;
+    T = l.linewidth + n, s.boundingSphere === null && s.computeBoundingSphere(), R.copy(s.boundingSphere).applyMatrix4(a);
     let u;
-    if (s)
-      u = L * 0.5;
+    if (i)
+      u = T * 0.5;
     else {
-      const f = Math.max(
+      const p = Math.max(
         r.near,
-        G.distanceToPoint(V.origin)
+        R.distanceToPoint(B.origin)
       );
-      u = re(
+      u = ot(
         r,
-        f,
-        c.resolution
+        p,
+        l.resolution
       );
     }
-    if (G.radius += u, V.intersectsSphere(G) === !1)
+    if (R.radius += u, B.intersectsSphere(R) === !1)
       return;
-    i.boundingBox === null && i.computeBoundingBox(), E.copy(i.boundingBox).applyMatrix4(a);
-    let m;
-    if (s)
-      m = L * 0.5;
+    s.boundingBox === null && s.computeBoundingBox(), G.copy(s.boundingBox).applyMatrix4(a);
+    let f;
+    if (i)
+      f = T * 0.5;
     else {
-      const f = Math.max(
+      const p = Math.max(
         r.near,
-        E.distanceToPoint(V.origin)
+        G.distanceToPoint(B.origin)
       );
-      m = re(
+      f = ot(
         r,
-        f,
-        c.resolution
+        p,
+        l.resolution
       );
     }
-    E.expandByScalar(m), V.intersectsBox(E) !== !1 && (s ? Te(this, e) : De(this, r, e));
+    G.expandByScalar(f), B.intersectsBox(G) !== !1 && (i ? Rt(this, e) : Ft(this, r, e));
   }
   onBeforeRender(t) {
     const e = this.material.uniforms;
-    e && e.resolution && (t.getViewport(j), this.material.uniforms.resolution.value.set(j.z, j.w));
+    e && e.resolution && (t.getViewport(Z), this.material.uniforms.resolution.value.set(Z.z, Z.w));
   }
 }
-const se = ["encodings_fragment", "colorspace_fragment"], Le = (
+const at = ["encodings_fragment", "colorspace_fragment"], kt = (
   /* glsl */
   `
   #include <common>
@@ -242,7 +490,7 @@ const se = ["encodings_fragment", "colorspace_fragment"], Le = (
     #include <fog_vertex>
   }
 `
-), Oe = (
+), Zt = (
   /* glsl */
   `
   #include <packing>
@@ -294,22 +542,22 @@ const se = ["encodings_fragment", "colorspace_fragment"], Le = (
    
     #include <fog_fragment>
     #include <tonemapping_fragment>
-    #include <${+_.REVISION < 154 ? se[0] : se[1]}>
+    #include <${+h.REVISION < 154 ? at[0] : at[1]}>
   }
 `
 );
-class it extends _.ShaderMaterial {
+class me extends h.ShaderMaterial {
   constructor(t) {
     super({
-      uniforms: Y(U({}, _.UniformsLib.fog), {
+      uniforms: H(E({}, h.UniformsLib.fog), {
         lineWidth: { value: 1 },
         map: { value: null },
         useMap: { value: 0 },
         alphaMap: { value: null },
         useAlphaMap: { value: 0 },
-        color: { value: new _.Color(16777215) },
+        color: { value: new h.Color(16777215) },
         opacity: { value: 1 },
-        resolution: { value: new _.Vector2(1, 1) },
+        resolution: { value: new h.Vector2(1, 1) },
         sizeAttenuation: { value: 1 },
         dashArray: { value: 0 },
         dashOffset: { value: 0 },
@@ -318,19 +566,19 @@ class it extends _.ShaderMaterial {
         useDepth: { value: 0 },
         visibility: { value: 1 },
         alphaTest: { value: 0 },
-        repeat: { value: new _.Vector2(1, 1) },
-        offset: { value: new _.Vector2(0, 0) },
+        repeat: { value: new h.Vector2(1, 1) },
+        offset: { value: new h.Vector2(0, 0) },
         offsetLoop: { value: 1 },
         lineLightAnimation: { value: 0 },
         time: { value: 0 },
         size: { value: 300 },
         speed: { value: 0.3 },
         lightWidth: { value: 0.1 },
-        uCenter: { value: new _.Vector2(0, 0) },
-        lightColor: { value: new _.Color(16777215) }
+        uCenter: { value: new h.Vector2(0, 0) },
+        lightColor: { value: new h.Color(16777215) }
       }),
-      vertexShader: Le,
-      fragmentShader: Oe
+      vertexShader: kt,
+      fragmentShader: Zt
     }), this.type = "MeshLineMaterial", Object.defineProperties(this, {
       lineWidth: {
         enumerable: !0,
@@ -554,220 +802,220 @@ class it extends _.ShaderMaterial {
     return super.copy(t), this.lineWidth = t.lineWidth, this.map = t.map, this.useMap = t.useMap, this.alphaMap = t.alphaMap, this.useAlphaMap = t.useAlphaMap, this.color.copy(t.color), this.opacity = t.opacity, this.resolution.copy(t.resolution), this.sizeAttenuation = t.sizeAttenuation, this.dashArray = t.dashArray, this.dashOffset = t.dashOffset, this.dashRatio = t.dashRatio, this.useDash = t.useDash, this.visibility = t.visibility, this.alphaTest = t.alphaTest, this.repeat.copy(t.repeat), this;
   }
 }
-function Re(n, t) {
-  return n.map((e) => {
-    const s = [];
+function $t(o, t) {
+  return o.map((e) => {
+    const i = [];
     let r;
-    return e.forEach((o) => {
+    return e.forEach((n) => {
       if (r) {
-        const a = Ie(o, r) * 180 / Math.PI;
+        const a = Dt(n, r) * 180 / Math.PI;
         if (a > t) {
-          const i = Be(r, o), c = 1 / Math.ceil(a / t);
-          let u = c;
+          const s = _t(r, n), l = 1 / Math.ceil(a / t);
+          let u = l;
           for (; u < 1; )
-            s.push(i(u)), u += c;
+            i.push(s(u)), u += l;
         }
       }
-      s.push(r = o);
-    }), s;
+      i.push(r = n);
+    }), i;
   });
 }
-function Ue(n, { minLng: t, maxLng: e, minLat: s, maxLat: r } = {}) {
-  const o = Math.round(X(360 / n, 2) / Math.PI), a = (1 + Math.sqrt(5)) / 2, i = (l) => l / a * 360 % 360 - 180, c = (l) => Math.acos(2 * l / o - 1) / Math.PI * 180 - 90, u = (l) => o * (Math.cos((l + 90) * Math.PI / 180) + 1) / 2, m = [
+function qt(o, { minLng: t, maxLng: e, minLat: i, maxLat: r } = {}) {
+  const n = Math.round(Y(360 / o, 2) / Math.PI), a = (1 + Math.sqrt(5)) / 2, s = (c) => c / a * 360 % 360 - 180, l = (c) => Math.acos(2 * c / n - 1) / Math.PI * 180 - 90, u = (c) => n * (Math.cos((c + 90) * Math.PI / 180) + 1) / 2, f = [
     r !== void 0 ? Math.ceil(u(r)) : 0,
-    s !== void 0 ? Math.floor(u(s)) : o - 1
-  ], f = t === void 0 && e === void 0 ? () => !0 : t === void 0 ? (l) => l <= e : e === void 0 ? (l) => l >= t : e >= t ? (l) => l >= t && l <= e : (l) => l >= t || l <= e, d = [];
-  for (let l = m[0]; l <= m[1]; l++) {
-    const p = i(l);
-    f(p) && d.push([p, c(l)]);
+    i !== void 0 ? Math.floor(u(i)) : n - 1
+  ], p = t === void 0 && e === void 0 ? () => !0 : t === void 0 ? (c) => c <= e : e === void 0 ? (c) => c >= t : e >= t ? (c) => c >= t && c <= e : (c) => c >= t || c <= e, v = [];
+  for (let c = f[0]; c <= f[1]; c++) {
+    const m = s(c);
+    p(m) && v.push([m, l(c)]);
   }
-  return d;
+  return v;
 }
-function N(n, t, e = !1) {
-  return e ? We(t, n) : ze(n, t);
+function N(o, t, e = !1) {
+  return e ? It(t, o) : Ot(o, t);
 }
-function Ee(n, t) {
-  const e = { type: "Polygon", coordinates: n }, [[s, r], [o, a]] = le(e);
-  if (Math.min(Math.abs(o - s), Math.abs(a - r)) < t)
+function Nt(o, t) {
+  const e = { type: "Polygon", coordinates: o }, [[i, r], [n, a]] = ct(e);
+  if (Math.min(Math.abs(n - i), Math.abs(a - r)) < t)
     return [];
-  const i = s > o || a >= 89 || r <= -89;
-  return Ue(t, {
-    minLng: s,
-    maxLng: o,
+  const s = i > n || a >= 89 || r <= -89;
+  return qt(t, {
+    minLng: i,
+    maxLng: n,
     minLat: r,
     maxLat: a
   }).filter(
-    (c) => N(c, e, i)
+    (l) => N(l, e, s)
   );
 }
-function Ge(n, { resolution: t = 1 / 0, bbox: e, projection: s } = {}) {
-  const r = Re(n, t), o = q(r), a = Ee(n, t), i = [...o, ...a], c = { type: "Polygon", coordinates: n }, [[u, m], [f, d]] = le(c), l = u > f || // crosses antimeridian
-  d >= 89 || // crosses north pole
-  m <= -89;
-  let p = [];
-  if (l) {
-    const v = Ve(i).triangles(), b = new Map(
-      i.map(([P, A], T) => [`${P}-${A}`, T])
+function Qt(o, { resolution: t = 1 / 0, bbox: e, projection: i } = {}) {
+  const r = $t(o, t), n = Q(r), a = Nt(o, t), s = [...n, ...a], l = { type: "Polygon", coordinates: o }, [[u, f], [p, v]] = ct(l), c = u > p || // crosses antimeridian
+  v >= 89 || // crosses north pole
+  f <= -89;
+  let m = [];
+  if (c) {
+    const g = Et(s).triangles(), w = new Map(
+      s.map(([A, C], L) => [`${A}-${C}`, L])
     );
-    v.features.forEach((P) => {
-      const A = P.geometry.coordinates[0].slice(0, 3).reverse(), T = [];
-      if (A.forEach(([C, Z]) => {
-        const R = `${C}-${Z}`;
-        b.has(R) && T.push(b.get(R));
-      }), T.length === 3) {
-        if (T.some((C) => C < o.length)) {
-          const C = P.properties.circumcenter;
+    g.features.forEach((A) => {
+      const C = A.geometry.coordinates[0].slice(0, 3).reverse(), L = [];
+      if (C.forEach(([S, k]) => {
+        const O = `${S}-${k}`;
+        w.has(O) && L.push(w.get(O));
+      }), L.length === 3) {
+        if (L.some((S) => S < n.length)) {
+          const S = A.properties.circumcenter;
           if (!N(
-            C,
-            c,
-            l
+            S,
+            l,
+            c
           ))
             return;
         }
-        p.push(...T);
+        m.push(...L);
       }
     });
   } else if (a.length) {
-    const v = Se.from(i);
-    for (let b = 0, P = v.triangles.length; b < P; b += 3) {
-      const A = [2, 1, 0].map((C) => v.triangles[b + C]), T = A.map((C) => i[C]);
-      if (A.some((C) => C < o.length)) {
-        const C = [0, 1].map(
-          (Z) => Pe(T, (R) => R[Z])
+    const g = Vt.from(s);
+    for (let w = 0, A = g.triangles.length; w < A; w += 3) {
+      const C = [2, 1, 0].map((S) => g.triangles[w + S]), L = C.map((S) => s[S]);
+      if (C.some((S) => S < n.length)) {
+        const S = [0, 1].map(
+          (k) => Lt(L, (O) => O[k])
         );
         if (!N(
-          C,
-          c,
-          l
+          S,
+          l,
+          c
         ))
           continue;
       }
-      p.push(...A);
+      m.push(...C);
     }
   } else {
-    const { vertices: v, holes: b = [] } = ue(r);
-    p = Ae(v, b, 2);
-  }
-  let h = e ? [e[0], e[2]] : J(i, (v) => v[0]), g = e ? [e[1], e[3]] : J(i, (v) => v[1]);
-  if (s) {
-    const [v, b] = s([h[0], g[0]]), [P, A] = s([h[1], g[1]]);
-    h = [v, P], g = [-b, -A];
-  }
-  const S = ee(h, [0, 1]), z = ee(g, [0, 1]), W = i.map(([v, b]) => {
-    if (s) {
-      const [P, A] = s([v, b]);
-      return [S(P), z(-A)];
+    const { vertices: g, holes: w = [] } = ht(r);
+    m = Wt(g, w, 2);
+  }
+  let d = e ? [e[0], e[2]] : et(s, (g) => g[0]), b = e ? [e[1], e[3]] : et(s, (g) => g[1]);
+  if (i) {
+    const [g, w] = i([d[0], b[0]]), [A, C] = i([d[1], b[1]]);
+    d = [g, A], b = [-w, -C];
+  }
+  const j = it(d, [0, 1]), z = it(b, [0, 1]), I = s.map(([g, w]) => {
+    if (i) {
+      const [A, C] = i([g, w]);
+      return [j(A), z(-C)];
     } else
-      return [S(v), z(b)];
+      return [j(g), z(w)];
   });
-  return { contour: r, triangles: { points: i, indices: p, uvs: W } };
+  return { contour: r, triangles: { points: s, indices: m, uvs: I } };
 }
-const oe = new _.BufferGeometry().setAttribute ? "setAttribute" : "addAttribute";
-function F(n, t, e, s) {
-  const r = n.map(
-    (o) => o.map(([a, i]) => {
-      if (s) {
-        const [c, u] = s([a, i]);
-        return [c, -u, t];
+const lt = new h.BufferGeometry().setAttribute ? "setAttribute" : "addAttribute";
+function F(o, t, e, i) {
+  const r = o.map(
+    (n) => n.map(([a, s]) => {
+      if (i) {
+        const [l, u] = i([a, s]);
+        return [l, -u, t];
       }
-      return e ? _e(a, i, t) : [a, i, t];
+      return e ? zt(a, s, t) : [a, s, t];
     })
   );
-  return ue(r);
+  return ht(r);
 }
-function Fe(n, t, e, s, r) {
-  const { vertices: o, holes: a } = F(
-    n,
+function Kt(o, t, e, i, r) {
+  const { vertices: n, holes: a } = F(
+    o,
     t,
-    s,
+    i,
     r
-  ), { vertices: i } = F(
-    n,
+  ), { vertices: s } = F(
+    o,
     e,
-    s,
+    i,
     r
-  ), c = q([i, o]), u = Math.round(i.length / 3), m = new Set(a);
-  let f = 0;
-  const d = [];
-  for (let p = 0; p < u; p++) {
-    let h = p + 1;
-    if (h === u)
-      h = f;
-    else if (m.has(h)) {
-      const g = h;
-      h = f, f = g;
+  ), l = Q([s, n]), u = Math.round(s.length / 3), f = new Set(a);
+  let p = 0;
+  const v = [];
+  for (let m = 0; m < u; m++) {
+    let d = m + 1;
+    if (d === u)
+      d = p;
+    else if (f.has(d)) {
+      const b = d;
+      d = p, p = b;
     }
-    d.push(p, p + u, h + u), d.push(h + u, h, p);
+    v.push(m, m + u, d + u), v.push(d + u, d, m);
   }
-  const l = [];
-  for (let p = 1; p >= 0; p--)
-    for (let h = 0; h < u; h += 1) l.push(h / (u - 1), p);
-  return { indices: d, vertices: c, uvs: l, topVerts: i };
+  const c = [];
+  for (let m = 1; m >= 0; m--)
+    for (let d = 0; d < u; d += 1) c.push(d / (u - 1), m);
+  return { indices: v, vertices: l, uvs: c, topVerts: s };
 }
-function ae(n, t, e, s, r, o) {
+function ut(o, t, e, i, r, n) {
   return {
-    indices: s ? n.indices : n.indices.slice().reverse(),
+    indices: i ? o.indices : o.indices.slice().reverse(),
     vertices: F(
-      [n.points],
+      [o.points],
       t,
       r,
-      o
+      n
     ).vertices,
     uvs: e
   };
 }
-const Ze = ({
-  polygonGeoJson: n,
+const Xt = ({
+  polygonGeoJson: o,
   startHeight: t,
   endHeight: e,
-  curvatureResolution: s = 1,
+  curvatureResolution: i = 1,
   cartesian: r = !0,
-  hasSide: o = !0,
+  hasSide: n = !0,
   hasBottom: a = !1,
-  hasTop: i = !1,
-  projection: c,
+  hasTop: s = !1,
+  projection: l,
   bbox: u
 }) => {
-  n.forEach((S) => {
-    Ce(S) || S.reverse();
+  o.forEach((j) => {
+    Tt(j) || j.reverse();
   });
-  const { contour: m, triangles: f } = Ge(n, {
-    resolution: s,
+  const { contour: f, triangles: p } = Qt(o, {
+    resolution: i,
     bbox: u,
-    projection: c
+    projection: l
   });
-  let d = {}, l;
-  o && (d = Fe(
-    m,
+  let v = {}, c;
+  n && (v = Kt(
+    f,
     t != null ? t : e,
     e != null ? e : t,
     r,
-    c
-  ), l = d.topVerts);
-  let p = [];
-  (a || i) && (p = q(f.uvs));
-  let h = {};
-  a && (h = ae(
-    f,
-    t,
+    l
+  ), c = v.topVerts);
+  let m = [];
+  (a || s) && (m = Q(p.uvs));
+  let d = {};
+  a && (d = ut(
     p,
+    t,
+    m,
     !1,
     r,
-    c
+    l
   ));
-  let g = {};
-  return i && (g = ae(
-    f,
-    e,
+  let b = {};
+  return s && (b = ut(
     p,
+    e,
+    m,
     !0,
     r,
-    c
-  )), { contour: m, triangles: f, sideTorso: d, bottomCap: h, topCap: g, topVerts: l };
+    l
+  )), { contour: f, triangles: p, sideTorso: v, bottomCap: d, topCap: b, topVerts: c };
 };
-class nt extends _.BufferGeometry {
+class ve extends h.BufferGeometry {
   constructor(t, e = {}) {
-    super(), this.type = "PolygonBufferGeometry", this.parameters = U({
+    super(), this.type = "PolygonBufferGeometry", this.parameters = E({
       polygonGeoJson: t,
       startHeight: 0,
       endHeight: 1,
@@ -780,36 +1028,38 @@ class nt extends _.BufferGeometry {
       userDataRsoOffset: 0
     }, e);
     const {
-      endHeight: s,
+      endHeight: i,
       hasTop: r,
-      topFirst: o,
+      topFirst: n,
       hasBottom: a,
-      hasSide: i,
-      cartesian: c,
+      hasSide: s,
+      cartesian: l,
       userDataRsoOffset: u,
-      projection: m
-    } = this.parameters, { contour: f, sideTorso: d, topVerts: l, bottomCap: p, topCap: h } = Ze(U({}, this.parameters));
-    let g = [], S = [], z = [], W = 0;
-    const w = (v) => {
-      const b = Math.round(g.length / 3), P = z.length;
-      g = g.concat(v.vertices), S = S.concat(v.uvs), z = z.concat(
-        b ? v.indices.map((A) => A + b) : v.indices
-      ), this.addGroup(P, z.length - P, W++);
+      projection: f
+    } = this.parameters, { contour: p, sideTorso: v, topVerts: c, bottomCap: m, topCap: d } = Xt(E({}, this.parameters));
+    let b = [], j = [], z = [], I = 0;
+    const P = (g) => {
+      const w = Math.round(b.length / 3), A = z.length;
+      b = b.concat(g.vertices), j = j.concat(g.uvs), z = z.concat(
+        w ? g.indices.map((C) => C + w) : g.indices
+      ), this.addGroup(A, z.length - A, I++);
     };
-    r && o && w(h), i && (w(d), this.userData.topVerts = u ? F(
-      f,
-      s + u,
-      c,
-      m
-    ).vertices : l), a && w(p), r && !o && w(h), this.setIndex(z), this[oe](
+    r && n && P(d), s && (P(v), this.userData.topVerts = u ? F(
+      p,
+      i + u,
+      l,
+      f
+    ).vertices : c), a && P(m), r && !n && P(d), this.setIndex(z), this[lt](
       "position",
-      new _.Float32BufferAttribute(g, 3)
-    ), this[oe]("uv", new _.Float32BufferAttribute(S, 2)), this.computeVertexNormals();
+      new h.Float32BufferAttribute(b, 3)
+    ), this[lt]("uv", new h.Float32BufferAttribute(j, 2)), this.computeVertexNormals();
   }
 }
 export {
-  tt as L,
-  it as M,
-  nt as P,
-  Ze as g
+  Gt as B,
+  pe as G,
+  de as L,
+  me as M,
+  ve as P,
+  Xt as g
 };