poly-extrude 0.2.0 → 0.4.0

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.2.0
+ * poly-extrude v0.4.0
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -1233,7 +1233,7 @@
       y: 0
     };
     function expandLine(line, options) {
-      var preAngle = 0;
+      // let preAngle = 0;
       var radius = options.lineWidth / 2;
       var points = [],
           leftPoints = [],
@@ -1241,66 +1241,76 @@
       var len = line.length;
       var i = 0;
 
-      while (i < len - 1) {
-        var _p = line[i],
-            _p2 = line[i + 1];
-        var dy = _p2[1] - _p[1],
-            dx = _p2[0] - _p[0];
-        var _rAngle = 0;
+      while (i < len) {
+        var p1 = line[i],
+            p2 = line[i + 1];
+        var currentp = line[i]; // last vertex
+
+        if (i === len - 1) {
+          p1 = line[len - 2];
+          p2 = line[len - 1];
+        }
+
+        var dy = p2[1] - p1[1],
+            dx = p2[0] - p1[0];
+        var rAngle = 0;
         var rad = Math.atan(dy / dx);
-        var angle = radToDeg(rad);
-        preAngle = angle;
+        var angle = radToDeg(rad); // preAngle = angle;
 
-        if (i === 0) {
-          _rAngle = angle;
-          _rAngle -= 90;
+        if (i === 0 || i === len - 1) {
+          rAngle = angle;
+          rAngle -= 90;
         } else {
+          // 至少3个顶点才会触发
           var p0 = line[i - 1];
-          TEMPV1.x = p0[0] - _p[0];
-          TEMPV1.y = p0[1] - _p[1];
-          TEMPV2.x = _p2[0] - _p[0];
-          TEMPV2.y = _p2[1] - _p[1];
+          TEMPV1.x = p0[0] - p1[0];
+          TEMPV1.y = p0[1] - p1[1];
+          TEMPV2.x = p2[0] - p1[0];
+          TEMPV2.y = p2[1] - p1[1];
           var vAngle = getAngle(TEMPV1, TEMPV2);
-          _rAngle = angle - vAngle / 2;
+          rAngle = angle - vAngle / 2;
         }
 
-        var _rRad = degToRad(_rAngle);
+        var rRad = degToRad(rAngle);
+        var p3 = currentp;
+        var x = Math.cos(rRad) + p3[0],
+            y = Math.sin(rRad) + p3[1];
+        var p4 = [x, y];
 
-        var _calOffsetPoint = calOffsetPoint(_rRad, radius, _p),
-            _op = _calOffsetPoint[0],
-            _op2 = _calOffsetPoint[1];
+        var _translateLine = translateLine(p1, p2, radius),
+            line1 = _translateLine[0],
+            line2 = _translateLine[1];
 
-        points.push(_op, _op2);
+        var op1 = lineIntersection(line1[0], line1[1], p3, p4);
+        var op2 = lineIntersection(line2[0], line2[1], p3, p4); // 平行，回头路
 
-        if (leftOnLine(_op, _p, _p2)) {
-          leftPoints.push(_op);
-          rightPoints.push(_op2);
-        } else {
-          leftPoints.push(_op2);
-          rightPoints.push(_op);
-        }
+        if (!op1 || !op2) {
+          var len1 = points.length;
+          var point1 = points[len1 - 2];
+          var point2 = points[len1 - 1];
 
-        i++;
-      }
+          if (!point1 || !point2) {
+            continue;
+          }
 
-      var rAngle = preAngle;
-      rAngle -= 90;
-      var rRad = degToRad(rAngle);
-      var p1 = line[len - 2];
-      var p2 = line[len - 1];
+          op1 = [point1[0], point1[1]];
+          op2 = [point2[0], point2[1]];
+        }
 
-      var _calOffsetPoint2 = calOffsetPoint(rRad, radius, p2),
-          op1 = _calOffsetPoint2[0],
-          op2 = _calOffsetPoint2[1];
+        op1[2] = currentp[2] || 0;
+        op2[2] = currentp[2] || 0; // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
 
-      points.push(op1, op2);
+        points.push(op1, op2);
 
-      if (leftOnLine(op1, p1, p2)) {
-        leftPoints.push(op1);
-        rightPoints.push(op2);
-      } else {
-        leftPoints.push(op2);
-        rightPoints.push(op1);
+        if (leftOnLine(op1, p1, p2)) {
+          leftPoints.push(op1);
+          rightPoints.push(op2);
+        } else {
+          leftPoints.push(op2);
+          rightPoints.push(op1);
+        }
+
+        i++;
       }
 
       return {
@@ -1308,21 +1318,7 @@
         leftPoints: leftPoints,
         rightPoints: rightPoints
       };
-    }
-
-    function calOffsetPoint(rad, radius, p) {
-      var x = p[0],
-          y = p[1];
-      var z = p[2] || 0;
-      var x1 = Math.cos(rad) * radius,
-          y1 = Math.sin(rad) * radius;
-      var p1 = [x + x1, y + y1, z];
-      var rad1 = rad += Math.PI;
-      var x2 = Math.cos(rad1) * radius,
-          y2 = Math.sin(rad1) * radius;
-      var p2 = [x + x2, y + y2, z];
-      return [p1, p2];
-    }
+    } // eslint-disable-next-line no-unused-vars
 
     var getAngle = function getAngle(_ref, _ref2) {
       var x1 = _ref.x,
@@ -1344,6 +1340,80 @@
           y = p[1];
       return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
     }
+    /**
+     * 平移线
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} distance
+     * @returns
+     */
+
+
+    function translateLine(p1, p2, distance) {
+      var dy = p2[1] - p1[1],
+          dx = p2[0] - p1[0];
+      var rad = Math.atan2(dy, dx);
+      var rad1 = rad + Math.PI / 2;
+      var offsetX = Math.cos(rad1) * distance,
+          offsetY = Math.sin(rad1) * distance;
+      var tp1 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp2 = [p2[0] + offsetX, p2[1] + offsetY];
+      var rad2 = rad - Math.PI / 2;
+      offsetX = Math.cos(rad2) * distance;
+      offsetY = Math.sin(rad2) * distance;
+      var tp3 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp4 = [p2[0] + offsetX, p2[1] + offsetY];
+      return [[tp1, tp2], [tp3, tp4]];
+    }
+    /**
+     * 直线交点
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} p3
+     * @param {*} p4
+     * @returns
+     */
+
+
+    function lineIntersection(p1, p2, p3, p4) {
+      var dx1 = p2[0] - p1[0],
+          dy1 = p2[1] - p1[1];
+      var dx2 = p4[0] - p3[0],
+          dy2 = p4[1] - p3[1];
+
+      if (dx1 === 0 && dx2 === 0) {
+        return null;
+      }
+
+      if (dy1 === 0 && dy2 === 0) {
+        return null;
+      }
+
+      var k1 = dy1 / dx1;
+      var k2 = dy2 / dx2;
+      var b1 = p1[1] - k1 * p1[0];
+      var b2 = p3[1] - k2 * p3[0];
+      var x, y;
+
+      if (dx1 === 0) {
+        x = p1[0];
+        y = k2 * x + b2;
+      } else if (dx2 === 0) {
+        x = p3[0];
+        y = k1 * x + b1;
+      } else if (dy1 === 0) {
+        y = p1[1];
+        x = (y - b2) / k2;
+      } else if (dy2 === 0) {
+        y = p3[1];
+        x = (y - b1) / k1;
+      } else {
+        x = (b2 - b1) / (k1 - k2);
+        y = k1 * x + b1;
+      }
+
+      return [x, y];
+    }
 
     function cylinder(point, options) {
       if (options === void 0) {
@@ -1463,8 +1533,1978 @@
       };
     }
 
+    // import * as MathUtils from './MathUtils.js';
+    // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js
+    var Vector3 = /*#__PURE__*/function () {
+      function Vector3(x, y, z) {
+        if (x === void 0) {
+          x = 0;
+        }
+
+        if (y === void 0) {
+          y = 0;
+        }
+
+        if (z === void 0) {
+          z = 0;
+        }
+
+        this.x = x;
+        this.y = y;
+        this.z = z;
+      }
+
+      var _proto = Vector3.prototype;
+
+      _proto.set = function set(x, y, z) {
+        if (z === undefined) z = this.z; // sprite.scale.set(x,y)
+
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+      } // setScalar(scalar) {
+      //     this.x = scalar;
+      //     this.y = scalar;
+      //     this.z = scalar;
+      //     return this;
+      // }
+      // setX(x) {
+      //     this.x = x;
+      //     return this;
+      // }
+      // setY(y) {
+      //     this.y = y;
+      //     return this;
+      // }
+      // setZ(z) {
+      //     this.z = z;
+      //     return this;
+      // }
+      // setComponent(index, value) {
+      //     switch (index) {
+      //         case 0: this.x = value; break;
+      //         case 1: this.y = value; break;
+      //         case 2: this.z = value; break;
+      //         default: throw new Error('index is out of range: ' + index);
+      //     }
+      //     return this;
+      // }
+      // getComponent(index) {
+      //     switch (index) {
+      //         case 0: return this.x;
+      //         case 1: return this.y;
+      //         case 2: return this.z;
+      //         default: throw new Error('index is out of range: ' + index);
+      //     }
+      // }
+      ;
+
+      _proto.clone = function clone() {
+        return new this.constructor(this.x, this.y, this.z);
+      };
+
+      _proto.copy = function copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+      };
+
+      _proto.add = function add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
+        return this;
+      };
+
+      _proto.addScalar = function addScalar(s) {
+        this.x += s;
+        this.y += s;
+        this.z += s;
+        return this;
+      };
+
+      _proto.addVectors = function addVectors(a, b) {
+        this.x = a.x + b.x;
+        this.y = a.y + b.y;
+        this.z = a.z + b.z;
+        return this;
+      };
+
+      _proto.addScaledVector = function addScaledVector(v, s) {
+        this.x += v.x * s;
+        this.y += v.y * s;
+        this.z += v.z * s;
+        return this;
+      };
+
+      _proto.sub = function sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
+        return this;
+      };
+
+      _proto.subScalar = function subScalar(s) {
+        this.x -= s;
+        this.y -= s;
+        this.z -= s;
+        return this;
+      };
+
+      _proto.subVectors = function subVectors(a, b) {
+        this.x = a.x - b.x;
+        this.y = a.y - b.y;
+        this.z = a.z - b.z;
+        return this;
+      };
+
+      _proto.multiply = function multiply(v) {
+        this.x *= v.x;
+        this.y *= v.y;
+        this.z *= v.z;
+        return this;
+      };
+
+      _proto.multiplyScalar = function multiplyScalar(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+      };
+
+      _proto.multiplyVectors = function multiplyVectors(a, b) {
+        this.x = a.x * b.x;
+        this.y = a.y * b.y;
+        this.z = a.z * b.z;
+        return this;
+      } // applyEuler(euler) {
+      //     return this.applyQuaternion(_quaternion.setFromEuler(euler));
+      // }
+      // applyAxisAngle(axis, angle) {
+      //     return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
+      // }
+      // applyMatrix3(m) {
+      //     const x = this.x, y = this.y, z = this.z;
+      //     const e = m.elements;
+      //     this.x = e[0] * x + e[3] * y + e[6] * z;
+      //     this.y = e[1] * x + e[4] * y + e[7] * z;
+      //     this.z = e[2] * x + e[5] * y + e[8] * z;
+      //     return this;
+      // }
+      // applyNormalMatrix(m) {
+      //     return this.applyMatrix3(m).normalize();
+      // }
+      ;
+
+      _proto.applyMatrix4 = function applyMatrix4(m) {
+        var x = this.x,
+            y = this.y,
+            z = this.z;
+        var e = m.elements;
+        var w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+        this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
+        this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
+        this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
+        return this;
+      } // applyQuaternion(q) {
+      //     const x = this.x, y = this.y, z = this.z;
+      //     const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+      //     // calculate quat * vector
+      //     const ix = qw * x + qy * z - qz * y;
+      //     const iy = qw * y + qz * x - qx * z;
+      //     const iz = qw * z + qx * y - qy * x;
+      //     const iw = - qx * x - qy * y - qz * z;
+      //     // calculate result * inverse quat
+      //     this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
+      //     this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
+      //     this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
+      //     return this;
+      // }
+      // project(camera) {
+      //     return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
+      // }
+      // unproject(camera) {
+      //     return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
+      // }
+      // transformDirection(m) {
+      //     // input: THREE.Matrix4 affine matrix
+      //     // vector interpreted as a direction
+      //     const x = this.x, y = this.y, z = this.z;
+      //     const e = m.elements;
+      //     this.x = e[0] * x + e[4] * y + e[8] * z;
+      //     this.y = e[1] * x + e[5] * y + e[9] * z;
+      //     this.z = e[2] * x + e[6] * y + e[10] * z;
+      //     return this.normalize();
+      // }
+      ;
+
+      _proto.divide = function divide(v) {
+        this.x /= v.x;
+        this.y /= v.y;
+        this.z /= v.z;
+        return this;
+      };
+
+      _proto.divideScalar = function divideScalar(scalar) {
+        return this.multiplyScalar(1 / scalar);
+      };
+
+      _proto.min = function min(v) {
+        this.x = Math.min(this.x, v.x);
+        this.y = Math.min(this.y, v.y);
+        this.z = Math.min(this.z, v.z);
+        return this;
+      };
+
+      _proto.max = function max(v) {
+        this.x = Math.max(this.x, v.x);
+        this.y = Math.max(this.y, v.y);
+        this.z = Math.max(this.z, v.z);
+        return this;
+      };
+
+      _proto.clamp = function clamp(min, max) {
+        // assumes min < max, componentwise
+        this.x = Math.max(min.x, Math.min(max.x, this.x));
+        this.y = Math.max(min.y, Math.min(max.y, this.y));
+        this.z = Math.max(min.z, Math.min(max.z, this.z));
+        return this;
+      };
+
+      _proto.clampScalar = function clampScalar(minVal, maxVal) {
+        this.x = Math.max(minVal, Math.min(maxVal, this.x));
+        this.y = Math.max(minVal, Math.min(maxVal, this.y));
+        this.z = Math.max(minVal, Math.min(maxVal, this.z));
+        return this;
+      };
+
+      _proto.clampLength = function clampLength(min, max) {
+        var length = this.length();
+        return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+      } // floor() {
+      //     this.x = Math.floor(this.x);
+      //     this.y = Math.floor(this.y);
+      //     this.z = Math.floor(this.z);
+      //     return this;
+      // }
+      // ceil() {
+      //     this.x = Math.ceil(this.x);
+      //     this.y = Math.ceil(this.y);
+      //     this.z = Math.ceil(this.z);
+      //     return this;
+      // }
+      // round() {
+      //     this.x = Math.round(this.x);
+      //     this.y = Math.round(this.y);
+      //     this.z = Math.round(this.z);
+      //     return this;
+      // }
+      // roundToZero() {
+      //     this.x = (this.x < 0) ? Math.ceil(this.x) : Math.floor(this.x);
+      //     this.y = (this.y < 0) ? Math.ceil(this.y) : Math.floor(this.y);
+      //     this.z = (this.z < 0) ? Math.ceil(this.z) : Math.floor(this.z);
+      //     return this;
+      // }
+      // negate() {
+      //     this.x = -this.x;
+      //     this.y = -this.y;
+      //     this.z = -this.z;
+      //     return this;
+      // }
+      ;
+
+      _proto.dot = function dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+      } // TODO lengthSquared?
+      ;
+
+      _proto.lengthSq = function lengthSq() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+      };
+
+      _proto.length = function length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+      } // manhattanLength() {
+      //     return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
+      // }
+      ;
+
+      _proto.normalize = function normalize() {
+        return this.divideScalar(this.length() || 1);
+      };
+
+      _proto.setLength = function setLength(length) {
+        return this.normalize().multiplyScalar(length);
+      };
+
+      _proto.lerp = function lerp(v, alpha) {
+        this.x += (v.x - this.x) * alpha;
+        this.y += (v.y - this.y) * alpha;
+        this.z += (v.z - this.z) * alpha;
+        return this;
+      };
+
+      _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
+        this.x = v1.x + (v2.x - v1.x) * alpha;
+        this.y = v1.y + (v2.y - v1.y) * alpha;
+        this.z = v1.z + (v2.z - v1.z) * alpha;
+        return this;
+      };
+
+      _proto.cross = function cross(v) {
+        return this.crossVectors(this, v);
+      };
+
+      _proto.crossVectors = function crossVectors(a, b) {
+        var ax = a.x,
+            ay = a.y,
+            az = a.z;
+        var bx = b.x,
+            by = b.y,
+            bz = b.z;
+        this.x = ay * bz - az * by;
+        this.y = az * bx - ax * bz;
+        this.z = ax * by - ay * bx;
+        return this;
+      } // projectOnVector(v) {
+      //     const denominator = v.lengthSq();
+      //     if (denominator === 0) return this.set(0, 0, 0);
+      //     const scalar = v.dot(this) / denominator;
+      //     return this.copy(v).multiplyScalar(scalar);
+      // }
+      // projectOnPlane(planeNormal) {
+      //     _vector.copy(this).projectOnVector(planeNormal);
+      //     return this.sub(_vector);
+      // }
+      // reflect(normal) {
+      //     // reflect incident vector off plane orthogonal to normal
+      //     // normal is assumed to have unit length
+      //     return this.sub(_vector.copy(normal).multiplyScalar(2 * this.dot(normal)));
+      // }
+      // angleTo(v) {
+      //     const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
+      //     if (denominator === 0) return Math.PI / 2;
+      //     const theta = this.dot(v) / denominator;
+      //     // clamp, to handle numerical problems
+      //     return Math.acos(MathUtils.clamp(theta, -1, 1));
+      // }
+      ;
+
+      _proto.distanceTo = function distanceTo(v) {
+        return Math.sqrt(this.distanceToSquared(v));
+      } // distanceToSquared(v) {
+      //     const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+      //     return dx * dx + dy * dy + dz * dz;
+      // }
+      // manhattanDistanceTo(v) {
+      //     return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
+      // }
+      // setFromSpherical(s) {
+      //     return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
+      // }
+      // setFromSphericalCoords(radius, phi, theta) {
+      //     const sinPhiRadius = Math.sin(phi) * radius;
+      //     this.x = sinPhiRadius * Math.sin(theta);
+      //     this.y = Math.cos(phi) * radius;
+      //     this.z = sinPhiRadius * Math.cos(theta);
+      //     return this;
+      // }
+      // setFromCylindrical(c) {
+      //     return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
+      // }
+      // setFromCylindricalCoords(radius, theta, y) {
+      //     this.x = radius * Math.sin(theta);
+      //     this.y = y;
+      //     this.z = radius * Math.cos(theta);
+      //     return this;
+      // }
+      // setFromMatrixPosition(m) {
+      //     const e = m.elements;
+      //     this.x = e[12];
+      //     this.y = e[13];
+      //     this.z = e[14];
+      //     return this;
+      // }
+      // setFromMatrixScale(m) {
+      //     const sx = this.setFromMatrixColumn(m, 0).length();
+      //     const sy = this.setFromMatrixColumn(m, 1).length();
+      //     const sz = this.setFromMatrixColumn(m, 2).length();
+      //     this.x = sx;
+      //     this.y = sy;
+      //     this.z = sz;
+      //     return this;
+      // }
+      // setFromMatrixColumn(m, index) {
+      //     return this.fromArray(m.elements, index * 4);
+      // }
+      // setFromMatrix3Column(m, index) {
+      //     return this.fromArray(m.elements, index * 3);
+      // }
+      // setFromEuler(e) {
+      //     this.x = e._x;
+      //     this.y = e._y;
+      //     this.z = e._z;
+      //     return this;
+      // }
+      // setFromColor(c) {
+      //     this.x = c.r;
+      //     this.y = c.g;
+      //     this.z = c.b;
+      //     return this;
+      // }
+      ;
+
+      _proto.equals = function equals(v) {
+        return v.x === this.x && v.y === this.y && v.z === this.z;
+      };
+
+      _proto.fromArray = function fromArray(array, offset) {
+        if (offset === void 0) {
+          offset = 0;
+        }
+
+        this.x = array[offset];
+        this.y = array[offset + 1];
+        this.z = array[offset + 2];
+        return this;
+      } // toArray(array = [], offset = 0) {
+      //     array[offset] = this.x;
+      //     array[offset + 1] = this.y;
+      //     array[offset + 2] = this.z;
+      //     return array;
+      // }
+      // fromBufferAttribute(attribute, index) {
+      //     this.x = attribute.getX(index);
+      //     this.y = attribute.getY(index);
+      //     this.z = attribute.getZ(index);
+      //     return this;
+      // }
+      ;
+
+      _proto.random = function random() {
+        this.x = Math.random();
+        this.y = Math.random();
+        this.z = Math.random();
+        return this;
+      } // randomDirection() {
+      //     // Derived from https://mathworld.wolfram.com/SpherePointPicking.html
+      //     const u = (Math.random() - 0.5) * 2;
+      //     const t = Math.random() * Math.PI * 2;
+      //     const f = Math.sqrt(1 - u ** 2);
+      //     this.x = f * Math.cos(t);
+      //     this.y = f * Math.sin(t);
+      //     this.z = u;
+      //     return this;
+      // }
+      ;
+
+      return Vector3;
+    }();
+
+    /* eslint-disable no-tabs */
+    /**
+     * PathPoint
+     */
+
+    var PathPoint = /*#__PURE__*/function () {
+      function PathPoint() {
+        this.pos = new Vector3();
+        this.dir = new Vector3();
+        this.right = new Vector3();
+        this.up = new Vector3(); // normal
+
+        this.dist = 0; // distance from start
+
+        this.widthScale = 1; // for corner
+
+        this.sharp = false; // marks as sharp corner
+      }
+
+      var _proto = PathPoint.prototype;
+
+      _proto.lerpPathPoints = function lerpPathPoints(p1, p2, alpha) {
+        this.pos.lerpVectors(p1.pos, p2.pos, alpha);
+        this.dir.lerpVectors(p1.dir, p2.dir, alpha);
+        this.up.lerpVectors(p1.up, p2.up, alpha);
+        this.right.lerpVectors(p1.right, p2.right, alpha);
+        this.dist = (p2.dist - p1.dist) * alpha + p1.dist;
+        this.widthScale = (p2.widthScale - p1.widthScale) * alpha + p1.widthScale;
+      };
+
+      _proto.copy = function copy(source) {
+        this.pos.copy(source.pos);
+        this.dir.copy(source.dir);
+        this.up.copy(source.up);
+        this.right.copy(source.right);
+        this.dist = source.dist;
+        this.widthScale = source.widthScale;
+      };
+
+      return PathPoint;
+    }();
+
+    // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Matrix4.js
+    // import { WebGLCoordinateSystem, WebGPUCoordinateSystem } from '../constants.js';
+    // import { Vector3 } from './Vector3.js';
+    var Matrix4 = /*#__PURE__*/function () {
+      function Matrix4(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
+        this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+
+        if (n11 !== undefined) {
+          this.set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44);
+        }
+      }
+
+      var _proto = Matrix4.prototype;
+
+      _proto.set = function set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
+        var te = this.elements;
+        te[0] = n11;
+        te[4] = n12;
+        te[8] = n13;
+        te[12] = n14;
+        te[1] = n21;
+        te[5] = n22;
+        te[9] = n23;
+        te[13] = n24;
+        te[2] = n31;
+        te[6] = n32;
+        te[10] = n33;
+        te[14] = n34;
+        te[3] = n41;
+        te[7] = n42;
+        te[11] = n43;
+        te[15] = n44;
+        return this;
+      } // identity() {
+      //     this.set(
+      //         1, 0, 0, 0,
+      //         0, 1, 0, 0,
+      //         0, 0, 1, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // clone() {
+      //     return new Matrix4().fromArray(this.elements);
+      // }
+      // copy(m) {
+      //     const te = this.elements;
+      //     const me = m.elements;
+      //     te[0] = me[0]; te[1] = me[1]; te[2] = me[2]; te[3] = me[3];
+      //     te[4] = me[4]; te[5] = me[5]; te[6] = me[6]; te[7] = me[7];
+      //     te[8] = me[8]; te[9] = me[9]; te[10] = me[10]; te[11] = me[11];
+      //     te[12] = me[12]; te[13] = me[13]; te[14] = me[14]; te[15] = me[15];
+      //     return this;
+      // }
+      // copyPosition(m) {
+      //     const te = this.elements, me = m.elements;
+      //     te[12] = me[12];
+      //     te[13] = me[13];
+      //     te[14] = me[14];
+      //     return this;
+      // }
+      // setFromMatrix3(m) {
+      //     const me = m.elements;
+      //     this.set(
+      //         me[0], me[3], me[6], 0,
+      //         me[1], me[4], me[7], 0,
+      //         me[2], me[5], me[8], 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // extractBasis(xAxis, yAxis, zAxis) {
+      //     xAxis.setFromMatrixColumn(this, 0);
+      //     yAxis.setFromMatrixColumn(this, 1);
+      //     zAxis.setFromMatrixColumn(this, 2);
+      //     return this;
+      // }
+      // makeBasis(xAxis, yAxis, zAxis) {
+      //     this.set(
+      //         xAxis.x, yAxis.x, zAxis.x, 0,
+      //         xAxis.y, yAxis.y, zAxis.y, 0,
+      //         xAxis.z, yAxis.z, zAxis.z, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // extractRotation(m) {
+      //     // this method does not support reflection matrices
+      //     const te = this.elements;
+      //     const me = m.elements;
+      //     const scaleX = 1 / _v1.setFromMatrixColumn(m, 0).length();
+      //     const scaleY = 1 / _v1.setFromMatrixColumn(m, 1).length();
+      //     const scaleZ = 1 / _v1.setFromMatrixColumn(m, 2).length();
+      //     te[0] = me[0] * scaleX;
+      //     te[1] = me[1] * scaleX;
+      //     te[2] = me[2] * scaleX;
+      //     te[3] = 0;
+      //     te[4] = me[4] * scaleY;
+      //     te[5] = me[5] * scaleY;
+      //     te[6] = me[6] * scaleY;
+      //     te[7] = 0;
+      //     te[8] = me[8] * scaleZ;
+      //     te[9] = me[9] * scaleZ;
+      //     te[10] = me[10] * scaleZ;
+      //     te[11] = 0;
+      //     te[12] = 0;
+      //     te[13] = 0;
+      //     te[14] = 0;
+      //     te[15] = 1;
+      //     return this;
+      // }
+      // makeRotationFromEuler(euler) {
+      //     const te = this.elements;
+      //     const x = euler.x, y = euler.y, z = euler.z;
+      //     const a = Math.cos(x), b = Math.sin(x);
+      //     const c = Math.cos(y), d = Math.sin(y);
+      //     const e = Math.cos(z), f = Math.sin(z);
+      //     if (euler.order === 'XYZ') {
+      //         const ae = a * e, af = a * f, be = b * e, bf = b * f;
+      //         te[0] = c * e;
+      //         te[4] = -c * f;
+      //         te[8] = d;
+      //         te[1] = af + be * d;
+      //         te[5] = ae - bf * d;
+      //         te[9] = -b * c;
+      //         te[2] = bf - ae * d;
+      //         te[6] = be + af * d;
+      //         te[10] = a * c;
+      //     } else if (euler.order === 'YXZ') {
+      //         const ce = c * e, cf = c * f, de = d * e, df = d * f;
+      //         te[0] = ce + df * b;
+      //         te[4] = de * b - cf;
+      //         te[8] = a * d;
+      //         te[1] = a * f;
+      //         te[5] = a * e;
+      //         te[9] = -b;
+      //         te[2] = cf * b - de;
+      //         te[6] = df + ce * b;
+      //         te[10] = a * c;
+      //     } else if (euler.order === 'ZXY') {
+      //         const ce = c * e, cf = c * f, de = d * e, df = d * f;
+      //         te[0] = ce - df * b;
+      //         te[4] = -a * f;
+      //         te[8] = de + cf * b;
+      //         te[1] = cf + de * b;
+      //         te[5] = a * e;
+      //         te[9] = df - ce * b;
+      //         te[2] = -a * d;
+      //         te[6] = b;
+      //         te[10] = a * c;
+      //     } else if (euler.order === 'ZYX') {
+      //         const ae = a * e, af = a * f, be = b * e, bf = b * f;
+      //         te[0] = c * e;
+      //         te[4] = be * d - af;
+      //         te[8] = ae * d + bf;
+      //         te[1] = c * f;
+      //         te[5] = bf * d + ae;
+      //         te[9] = af * d - be;
+      //         te[2] = -d;
+      //         te[6] = b * c;
+      //         te[10] = a * c;
+      //     } else if (euler.order === 'YZX') {
+      //         const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+      //         te[0] = c * e;
+      //         te[4] = bd - ac * f;
+      //         te[8] = bc * f + ad;
+      //         te[1] = f;
+      //         te[5] = a * e;
+      //         te[9] = -b * e;
+      //         te[2] = -d * e;
+      //         te[6] = ad * f + bc;
+      //         te[10] = ac - bd * f;
+      //     } else if (euler.order === 'XZY') {
+      //         const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+      //         te[0] = c * e;
+      //         te[4] = -f;
+      //         te[8] = d * e;
+      //         te[1] = ac * f + bd;
+      //         te[5] = a * e;
+      //         te[9] = ad * f - bc;
+      //         te[2] = bc * f - ad;
+      //         te[6] = b * e;
+      //         te[10] = bd * f + ac;
+      //     }
+      //     // bottom row
+      //     te[3] = 0;
+      //     te[7] = 0;
+      //     te[11] = 0;
+      //     // last column
+      //     te[12] = 0;
+      //     te[13] = 0;
+      //     te[14] = 0;
+      //     te[15] = 1;
+      //     return this;
+      // }
+      // makeRotationFromQuaternion(q) {
+      //     return this.compose(_zero, q, _one);
+      // }
+      // lookAt(eye, target, up) {
+      //     const te = this.elements;
+      //     _z.subVectors(eye, target);
+      //     if (_z.lengthSq() === 0) {
+      //         // eye and target are in the same position
+      //         _z.z = 1;
+      //     }
+      //     _z.normalize();
+      //     _x.crossVectors(up, _z);
+      //     if (_x.lengthSq() === 0) {
+      //         // up and z are parallel
+      //         if (Math.abs(up.z) === 1) {
+      //             _z.x += 0.0001;
+      //         } else {
+      //             _z.z += 0.0001;
+      //         }
+      //         _z.normalize();
+      //         _x.crossVectors(up, _z);
+      //     }
+      //     _x.normalize();
+      //     _y.crossVectors(_z, _x);
+      //     te[0] = _x.x; te[4] = _y.x; te[8] = _z.x;
+      //     te[1] = _x.y; te[5] = _y.y; te[9] = _z.y;
+      //     te[2] = _x.z; te[6] = _y.z; te[10] = _z.z;
+      //     return this;
+      // }
+      ;
+
+      _proto.multiply = function multiply(m) {
+        return this.multiplyMatrices(this, m);
+      } // premultiply(m) {
+      //     return this.multiplyMatrices(m, this);
+      // }
+      // multiplyMatrices(a, b) {
+      //     const ae = a.elements;
+      //     const be = b.elements;
+      //     const te = this.elements;
+      //     const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
+      //     const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
+      //     const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
+      //     const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
+      //     const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
+      //     const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
+      //     const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
+      //     const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
+      //     te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
+      //     te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
+      //     te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
+      //     te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
+      //     te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
+      //     te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
+      //     te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
+      //     te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
+      //     te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
+      //     te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
+      //     te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
+      //     te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
+      //     te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
+      //     te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
+      //     te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
+      //     te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
+      //     return this;
+      // }
+      // multiplyScalar(s) {
+      //     const te = this.elements;
+      //     te[0] *= s; te[4] *= s; te[8] *= s; te[12] *= s;
+      //     te[1] *= s; te[5] *= s; te[9] *= s; te[13] *= s;
+      //     te[2] *= s; te[6] *= s; te[10] *= s; te[14] *= s;
+      //     te[3] *= s; te[7] *= s; te[11] *= s; te[15] *= s;
+      //     return this;
+      // }
+      // determinant() {
+      //     const te = this.elements;
+      //     const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12];
+      //     const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13];
+      //     const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14];
+      //     const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15];
+      //     //TODO: make this more efficient
+      //     //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
+      //     return (
+      //         n41 * (
+      //             + n14 * n23 * n32
+      //             - n13 * n24 * n32
+      //             - n14 * n22 * n33
+      //             + n12 * n24 * n33
+      //             + n13 * n22 * n34
+      //             - n12 * n23 * n34
+      //         ) +
+      //         n42 * (
+      //             + n11 * n23 * n34
+      //             - n11 * n24 * n33
+      //             + n14 * n21 * n33
+      //             - n13 * n21 * n34
+      //             + n13 * n24 * n31
+      //             - n14 * n23 * n31
+      //         ) +
+      //         n43 * (
+      //             + n11 * n24 * n32
+      //             - n11 * n22 * n34
+      //             - n14 * n21 * n32
+      //             + n12 * n21 * n34
+      //             + n14 * n22 * n31
+      //             - n12 * n24 * n31
+      //         ) +
+      //         n44 * (
+      //             - n13 * n22 * n31
+      //             - n11 * n23 * n32
+      //             + n11 * n22 * n33
+      //             + n13 * n21 * n32
+      //             - n12 * n21 * n33
+      //             + n12 * n23 * n31
+      //         )
+      //     );
+      // }
+      // transpose() {
+      //     const te = this.elements;
+      //     let tmp;
+      //     tmp = te[1]; te[1] = te[4]; te[4] = tmp;
+      //     tmp = te[2]; te[2] = te[8]; te[8] = tmp;
+      //     tmp = te[6]; te[6] = te[9]; te[9] = tmp;
+      //     tmp = te[3]; te[3] = te[12]; te[12] = tmp;
+      //     tmp = te[7]; te[7] = te[13]; te[13] = tmp;
+      //     tmp = te[11]; te[11] = te[14]; te[14] = tmp;
+      //     return this;
+      // }
+      // setPosition(x, y, z) {
+      //     const te = this.elements;
+      //     if (x.isVector3) {
+      //         te[12] = x.x;
+      //         te[13] = x.y;
+      //         te[14] = x.z;
+      //     } else {
+      //         te[12] = x;
+      //         te[13] = y;
+      //         te[14] = z;
+      //     }
+      //     return this;
+      // }
+      // invert() {
+      //     // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
+      //     const te = this.elements,
+      //         n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3],
+      //         n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7],
+      //         n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11],
+      //         n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15],
+      //         t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
+      //         t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
+      //         t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
+      //         t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+      //     const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+      //     if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+      //     const detInv = 1 / det;
+      //     te[0] = t11 * detInv;
+      //     te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv;
+      //     te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv;
+      //     te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv;
+      //     te[4] = t12 * detInv;
+      //     te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv;
+      //     te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv;
+      //     te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv;
+      //     te[8] = t13 * detInv;
+      //     te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv;
+      //     te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv;
+      //     te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv;
+      //     te[12] = t14 * detInv;
+      //     te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv;
+      //     te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv;
+      //     te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv;
+      //     return this;
+      // }
+      // scale(v) {
+      //     const te = this.elements;
+      //     const x = v.x, y = v.y, z = v.z;
+      //     te[0] *= x; te[4] *= y; te[8] *= z;
+      //     te[1] *= x; te[5] *= y; te[9] *= z;
+      //     te[2] *= x; te[6] *= y; te[10] *= z;
+      //     te[3] *= x; te[7] *= y; te[11] *= z;
+      //     return this;
+      // }
+      // getMaxScaleOnAxis() {
+      //     const te = this.elements;
+      //     const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
+      //     const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
+      //     const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
+      //     return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
+      // }
+      // makeTranslation(x, y, z) {
+      //     if (x.isVector3) {
+      //         this.set(
+      //             1, 0, 0, x.x,
+      //             0, 1, 0, x.y,
+      //             0, 0, 1, x.z,
+      //             0, 0, 0, 1
+      //         );
+      //     } else {
+      //         this.set(
+      //             1, 0, 0, x,
+      //             0, 1, 0, y,
+      //             0, 0, 1, z,
+      //             0, 0, 0, 1
+      //         );
+      //     }
+      //     return this;
+      // }
+      // makeRotationX(theta) {
+      //     const c = Math.cos(theta), s = Math.sin(theta);
+      //     this.set(
+      //         1, 0, 0, 0,
+      //         0, c, -s, 0,
+      //         0, s, c, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // makeRotationY(theta) {
+      //     const c = Math.cos(theta), s = Math.sin(theta);
+      //     this.set(
+      //         c, 0, s, 0,
+      //         0, 1, 0, 0,
+      //         -s, 0, c, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // makeRotationZ(theta) {
+      //     const c = Math.cos(theta), s = Math.sin(theta);
+      //     this.set(
+      //         c, -s, 0, 0,
+      //         s, c, 0, 0,
+      //         0, 0, 1, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      ;
+
+      _proto.makeRotationAxis = function makeRotationAxis(axis, angle) {
+        // Based on http://www.gamedev.net/reference/articles/article1199.asp
+        var c = Math.cos(angle);
+        var s = Math.sin(angle);
+        var t = 1 - c;
+        var x = axis.x,
+            y = axis.y,
+            z = axis.z;
+        var tx = t * x,
+            ty = t * y;
+        this.set(tx * x + c, tx * y - s * z, tx * z + s * y, 0, tx * y + s * z, ty * y + c, ty * z - s * x, 0, tx * z - s * y, ty * z + s * x, t * z * z + c, 0, 0, 0, 0, 1);
+        return this;
+      } // makeScale(x, y, z) {
+      //     this.set(
+      //         x, 0, 0, 0,
+      //         0, y, 0, 0,
+      //         0, 0, z, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // makeShear(xy, xz, yx, yz, zx, zy) {
+      //     this.set(
+      //         1, yx, zx, 0,
+      //         xy, 1, zy, 0,
+      //         xz, yz, 1, 0,
+      //         0, 0, 0, 1
+      //     );
+      //     return this;
+      // }
+      // compose(position, quaternion, scale) {
+      //     const te = this.elements;
+      //     const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
+      //     const x2 = x + x, y2 = y + y, z2 = z + z;
+      //     const xx = x * x2, xy = x * y2, xz = x * z2;
+      //     const yy = y * y2, yz = y * z2, zz = z * z2;
+      //     const wx = w * x2, wy = w * y2, wz = w * z2;
+      //     const sx = scale.x, sy = scale.y, sz = scale.z;
+      //     te[0] = (1 - (yy + zz)) * sx;
+      //     te[1] = (xy + wz) * sx;
+      //     te[2] = (xz - wy) * sx;
+      //     te[3] = 0;
+      //     te[4] = (xy - wz) * sy;
+      //     te[5] = (1 - (xx + zz)) * sy;
+      //     te[6] = (yz + wx) * sy;
+      //     te[7] = 0;
+      //     te[8] = (xz + wy) * sz;
+      //     te[9] = (yz - wx) * sz;
+      //     te[10] = (1 - (xx + yy)) * sz;
+      //     te[11] = 0;
+      //     te[12] = position.x;
+      //     te[13] = position.y;
+      //     te[14] = position.z;
+      //     te[15] = 1;
+      //     return this;
+      // }
+      // decompose(position, quaternion, scale) {
+      //     const te = this.elements;
+      //     let sx = _v1.set(te[0], te[1], te[2]).length();
+      //     const sy = _v1.set(te[4], te[5], te[6]).length();
+      //     const sz = _v1.set(te[8], te[9], te[10]).length();
+      //     // if determine is negative, we need to invert one scale
+      //     const det = this.determinant();
+      //     if (det < 0) sx = -sx;
+      //     position.x = te[12];
+      //     position.y = te[13];
+      //     position.z = te[14];
+      //     // scale the rotation part
+      //     _m1.copy(this);
+      //     const invSX = 1 / sx;
+      //     const invSY = 1 / sy;
+      //     const invSZ = 1 / sz;
+      //     _m1.elements[0] *= invSX;
+      //     _m1.elements[1] *= invSX;
+      //     _m1.elements[2] *= invSX;
+      //     _m1.elements[4] *= invSY;
+      //     _m1.elements[5] *= invSY;
+      //     _m1.elements[6] *= invSY;
+      //     _m1.elements[8] *= invSZ;
+      //     _m1.elements[9] *= invSZ;
+      //     _m1.elements[10] *= invSZ;
+      //     quaternion.setFromRotationMatrix(_m1);
+      //     scale.x = sx;
+      //     scale.y = sy;
+      //     scale.z = sz;
+      //     return this;
+      // }
+      // makePerspective(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
+      //     const te = this.elements;
+      //     const x = 2 * near / (right - left);
+      //     const y = 2 * near / (top - bottom);
+      //     const a = (right + left) / (right - left);
+      //     const b = (top + bottom) / (top - bottom);
+      //     let c, d;
+      //     if (coordinateSystem === WebGLCoordinateSystem) {
+      //         c = - (far + near) / (far - near);
+      //         d = (- 2 * far * near) / (far - near);
+      //     } else if (coordinateSystem === WebGPUCoordinateSystem) {
+      //         c = - far / (far - near);
+      //         d = (- far * near) / (far - near);
+      //     } else {
+      //         throw new Error('THREE.Matrix4.makePerspective(): Invalid coordinate system: ' + coordinateSystem);
+      //     }
+      //     te[0] = x; te[4] = 0; te[8] = a; te[12] = 0;
+      //     te[1] = 0; te[5] = y; te[9] = b; te[13] = 0;
+      //     te[2] = 0; te[6] = 0; te[10] = c; te[14] = d;
+      //     te[3] = 0; te[7] = 0; te[11] = - 1; te[15] = 0;
+      //     return this;
+      // }
+      // makeOrthographic(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
+      //     const te = this.elements;
+      //     const w = 1.0 / (right - left);
+      //     const h = 1.0 / (top - bottom);
+      //     const p = 1.0 / (far - near);
+      //     const x = (right + left) * w;
+      //     const y = (top + bottom) * h;
+      //     let z, zInv;
+      //     if (coordinateSystem === WebGLCoordinateSystem) {
+      //         z = (far + near) * p;
+      //         zInv = - 2 * p;
+      //     } else if (coordinateSystem === WebGPUCoordinateSystem) {
+      //         z = near * p;
+      //         zInv = - 1 * p;
+      //     } else {
+      //         throw new Error('THREE.Matrix4.makeOrthographic(): Invalid coordinate system: ' + coordinateSystem);
+      //     }
+      //     te[0] = 2 * w; te[4] = 0; te[8] = 0; te[12] = - x;
+      //     te[1] = 0; te[5] = 2 * h; te[9] = 0; te[13] = - y;
+      //     te[2] = 0; te[6] = 0; te[10] = zInv; te[14] = - z;
+      //     te[3] = 0; te[7] = 0; te[11] = 0; te[15] = 1;
+      //     return this;
+      // }
+      ;
+
+      _proto.equals = function equals(matrix) {
+        var te = this.elements;
+        var me = matrix.elements;
+
+        for (var i = 0; i < 16; i++) {
+          if (te[i] !== me[i]) return false;
+        }
+
+        return true;
+      } // fromArray(array, offset = 0) {
+      //     for (let i = 0; i < 16; i++) {
+      //         this.elements[i] = array[i + offset];
+      //     }
+      //     return this;
+      // }
+      // toArray(array = [], offset = 0) {
+      //     const te = this.elements;
+      //     array[offset] = te[0];
+      //     array[offset + 1] = te[1];
+      //     array[offset + 2] = te[2];
+      //     array[offset + 3] = te[3];
+      //     array[offset + 4] = te[4];
+      //     array[offset + 5] = te[5];
+      //     array[offset + 6] = te[6];
+      //     array[offset + 7] = te[7];
+      //     array[offset + 8] = te[8];
+      //     array[offset + 9] = te[9];
+      //     array[offset + 10] = te[10];
+      //     array[offset + 11] = te[11];
+      //     array[offset + 12] = te[12];
+      //     array[offset + 13] = te[13];
+      //     array[offset + 14] = te[14];
+      //     array[offset + 15] = te[15];
+      //     return array;
+      // }
+      ;
+
+      return Matrix4;
+    }(); // const _v1 = new Vector3();
+
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+
+      _setPrototypeOf(subClass, superClass);
+    }
+
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+      };
+      return _setPrototypeOf(o, p);
+    }
+
+    // code copy from https://github.com/mrdoob/three.js/blob/dev/src/extras/core/Curve.js
+    // import * as MathUtils from '../../math/MathUtils.js';
+    // import { Vector2 } from '../../math/Vector2.js';
+    // import { Vector3 } from '../../math/Vector3.js';
+    // import { Matrix4 } from '../../math/Matrix4.js';
+
+    /**
+     * Extensible curve object.
+     *
+     * Some common of curve methods:
+     * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )
+     * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )
+     * .getPoints(), .getSpacedPoints()
+     * .getLength()
+     * .updateArcLengths()
+     *
+     * This following curves inherit from THREE.Curve:
+     *
+     * -- 2D curves --
+     * THREE.ArcCurve
+     * THREE.CubicBezierCurve
+     * THREE.EllipseCurve
+     * THREE.LineCurve
+     * THREE.QuadraticBezierCurve
+     * THREE.SplineCurve
+     *
+     * -- 3D curves --
+     * THREE.CatmullRomCurve3
+     * THREE.CubicBezierCurve3
+     * THREE.LineCurve3
+     * THREE.QuadraticBezierCurve3
+     *
+     * A series of curves can be represented as a THREE.CurvePath.
+     *
+     **/
+    var Curve = /*#__PURE__*/function () {
+      function Curve() {
+        this.type = 'Curve';
+        this.arcLengthDivisions = 200;
+      } // Virtual base class method to overwrite and implement in subclasses
+
+
+      var _proto = Curve.prototype;
+
+      _proto.getPoint = function getPoint() {
+        console.warn('THREE.Curve: .getPoint() not implemented.');
+        return null;
+      } // Get point at relative position in curve according to arc length
+      // - u [0 .. 1]
+      ;
+
+      _proto.getPointAt = function getPointAt(u, optionalTarget) {
+        var t = this.getUtoTmapping(u);
+        return this.getPoint(t, optionalTarget);
+      } // Get sequence of points using getPoint( t )
+      ;
+
+      _proto.getPoints = function getPoints(divisions) {
+        if (divisions === void 0) {
+          divisions = 5;
+        }
+
+        var points = [];
+
+        for (var d = 0; d <= divisions; d++) {
+          points.push(this.getPoint(d / divisions));
+        }
+
+        return points;
+      } // // Get sequence of points using getPointAt( u )
+      // getSpacedPoints(divisions = 5) {
+      //     const points = [];
+      //     for (let d = 0; d <= divisions; d++) {
+      //         points.push(this.getPointAt(d / divisions));
+      //     }
+      //     return points;
+      // }
+      // Get total curve arc length
+      ;
+
+      _proto.getLength = function getLength() {
+        var lengths = this.getLengths();
+        return lengths[lengths.length - 1];
+      } // Get list of cumulative segment lengths
+      ;
+
+      _proto.getLengths = function getLengths(divisions) {
+        if (divisions === void 0) {
+          divisions = this.arcLengthDivisions;
+        }
+
+        if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) {
+          return this.cacheArcLengths;
+        }
+
+        this.needsUpdate = false;
+        var cache = [];
+        var current,
+            last = this.getPoint(0);
+        var sum = 0;
+        cache.push(0);
+
+        for (var p = 1; p <= divisions; p++) {
+          current = this.getPoint(p / divisions);
+          sum += current.distanceTo(last);
+          cache.push(sum);
+          last = current;
+        }
+
+        this.cacheArcLengths = cache;
+        return cache; // { sums: cache, sum: sum }; Sum is in the last element.
+      } // updateArcLengths() {
+      //     this.needsUpdate = true;
+      //     this.getLengths();
+      // }
+      // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
+      ;
+
+      _proto.getUtoTmapping = function getUtoTmapping(u, distance) {
+        var arcLengths = this.getLengths();
+        var i = 0;
+        var il = arcLengths.length;
+        var targetArcLength; // The targeted u distance value to get
+
+        if (distance) {
+          targetArcLength = distance;
+        } else {
+          targetArcLength = u * arcLengths[il - 1];
+        } // binary search for the index with largest value smaller than target u distance
+
+
+        var low = 0,
+            high = il - 1,
+            comparison;
+
+        while (low <= high) {
+          i = Math.floor(low + (high - low) / 2); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
+
+          comparison = arcLengths[i] - targetArcLength;
+
+          if (comparison < 0) {
+            low = i + 1;
+          } else if (comparison > 0) {
+            high = i - 1;
+          } else {
+            high = i;
+            break; // DONE
+          }
+        }
+
+        i = high;
+
+        if (arcLengths[i] === targetArcLength) {
+          return i / (il - 1);
+        } // we could get finer grain at lengths, or use simple interpolation between two points
+
+
+        var lengthBefore = arcLengths[i];
+        var lengthAfter = arcLengths[i + 1];
+        var segmentLength = lengthAfter - lengthBefore; // determine where we are between the 'before' and 'after' points
+
+        var segmentFraction = (targetArcLength - lengthBefore) / segmentLength; // add that fractional amount to t
+
+        var t = (i + segmentFraction) / (il - 1);
+        return t;
+      } // Returns a unit vector tangent at t
+      // In case any sub curve does not implement its tangent derivation,
+      // 2 points a small delta apart will be used to find its gradient
+      // which seems to give a reasonable approximation
+      // getTangent(t, optionalTarget) {
+      //     const delta = 0.0001;
+      //     let t1 = t - delta;
+      //     let t2 = t + delta;
+      //     // Capping in case of danger
+      //     if (t1 < 0) t1 = 0;
+      //     if (t2 > 1) t2 = 1;
+      //     const pt1 = this.getPoint(t1);
+      //     const pt2 = this.getPoint(t2);
+      //     const tangent = optionalTarget || ((pt1.isVector2) ? new Vector2() : new Vector3());
+      //     tangent.copy(pt2).sub(pt1).normalize();
+      //     return tangent;
+      // }
+      // getTangentAt(u, optionalTarget) {
+      //     const t = this.getUtoTmapping(u);
+      //     return this.getTangent(t, optionalTarget);
+      // }
+      // computeFrenetFrames(segments, closed) {
+      //     // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
+      //     const normal = new Vector3();
+      //     const tangents = [];
+      //     const normals = [];
+      //     const binormals = [];
+      //     const vec = new Vector3();
+      //     const mat = new Matrix4();
+      //     // compute the tangent vectors for each segment on the curve
+      //     for (let i = 0; i <= segments; i++) {
+      //         const u = i / segments;
+      //         tangents[i] = this.getTangentAt(u, new Vector3());
+      //     }
+      //     // select an initial normal vector perpendicular to the first tangent vector,
+      //     // and in the direction of the minimum tangent xyz component
+      //     normals[0] = new Vector3();
+      //     binormals[0] = new Vector3();
+      //     let min = Number.MAX_VALUE;
+      //     const tx = Math.abs(tangents[0].x);
+      //     const ty = Math.abs(tangents[0].y);
+      //     const tz = Math.abs(tangents[0].z);
+      //     if (tx <= min) {
+      //         min = tx;
+      //         normal.set(1, 0, 0);
+      //     }
+      //     if (ty <= min) {
+      //         min = ty;
+      //         normal.set(0, 1, 0);
+      //     }
+      //     if (tz <= min) {
+      //         normal.set(0, 0, 1);
+      //     }
+      //     vec.crossVectors(tangents[0], normal).normalize();
+      //     normals[0].crossVectors(tangents[0], vec);
+      //     binormals[0].crossVectors(tangents[0], normals[0]);
+      //     // compute the slowly-varying normal and binormal vectors for each segment on the curve
+      //     for (let i = 1; i <= segments; i++) {
+      //         normals[i] = normals[i - 1].clone();
+      //         binormals[i] = binormals[i - 1].clone();
+      //         vec.crossVectors(tangents[i - 1], tangents[i]);
+      //         if (vec.length() > Number.EPSILON) {
+      //             vec.normalize();
+      //             const theta = Math.acos(MathUtils.clamp(tangents[i - 1].dot(tangents[i]), - 1, 1)); // clamp for floating pt errors
+      //             normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
+      //         }
+      //         binormals[i].crossVectors(tangents[i], normals[i]);
+      //     }
+      //     // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
+      //     if (closed === true) {
+      //         let theta = Math.acos(MathUtils.clamp(normals[0].dot(normals[segments]), - 1, 1));
+      //         theta /= segments;
+      //         if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
+      //             theta = - theta;
+      //         }
+      //         for (let i = 1; i <= segments; i++) {
+      //             // twist a little...
+      //             normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
+      //             binormals[i].crossVectors(tangents[i], normals[i]);
+      //         }
+      //     }
+      //     return {
+      //         tangents: tangents,
+      //         normals: normals,
+      //         binormals: binormals
+      //     };
+      // }
+      // clone() {
+      //     return new this.constructor().copy(this);
+      // }
+      // copy(source) {
+      //     this.arcLengthDivisions = source.arcLengthDivisions;
+      //     return this;
+      // }
+      // toJSON() {
+      //     const data = {
+      //         metadata: {
+      //             version: 4.6,
+      //             type: 'Curve',
+      //             generator: 'Curve.toJSON'
+      //         }
+      //     };
+      //     data.arcLengthDivisions = this.arcLengthDivisions;
+      //     data.type = this.type;
+      //     return data;
+      // }
+      // fromJSON(json) {
+      //     this.arcLengthDivisions = json.arcLengthDivisions;
+      //     return this;
+      // }
+      ;
+
+      return Curve;
+    }();
+
+    /**
+     * // code copy from https://github.com/mrdoob/three.js/blob/dev/src/extras/core/Interpolations.js
+     * Bezier Curves formulas obtained from
+     * https://en.wikipedia.org/wiki/B%C3%A9zier_curve
+     */
+
+
+    function QuadraticBezierP0(t, p) {
+      var k = 1 - t;
+      return k * k * p;
+    }
+
+    function QuadraticBezierP1(t, p) {
+      return 2 * (1 - t) * t * p;
+    }
+
+    function QuadraticBezierP2(t, p) {
+      return t * t * p;
+    }
+
+    function QuadraticBezier(t, p0, p1, p2) {
+      return QuadraticBezierP0(t, p0) + QuadraticBezierP1(t, p1) + QuadraticBezierP2(t, p2);
+    } //
+
+    var QuadraticBezierCurve3 = /*#__PURE__*/function (_Curve) {
+      _inheritsLoose(QuadraticBezierCurve3, _Curve);
+
+      function QuadraticBezierCurve3(v0, v1, v2) {
+        var _this;
+
+        if (v0 === void 0) {
+          v0 = new Vector3();
+        }
+
+        if (v1 === void 0) {
+          v1 = new Vector3();
+        }
+
+        if (v2 === void 0) {
+          v2 = new Vector3();
+        }
+
+        _this = _Curve.call(this) || this;
+        _this.isQuadraticBezierCurve3 = true;
+        _this.type = 'QuadraticBezierCurve3';
+        _this.v0 = v0;
+        _this.v1 = v1;
+        _this.v2 = v2;
+        return _this;
+      }
+
+      var _proto = QuadraticBezierCurve3.prototype;
+
+      _proto.getPoint = function getPoint(t, optionalTarget) {
+        if (optionalTarget === void 0) {
+          optionalTarget = new Vector3();
+        }
+
+        var point = optionalTarget;
+        var v0 = this.v0,
+            v1 = this.v1,
+            v2 = this.v2;
+        point.set(QuadraticBezier(t, v0.x, v1.x, v2.x), QuadraticBezier(t, v0.y, v1.y, v2.y), QuadraticBezier(t, v0.z, v1.z, v2.z));
+        return point;
+      } // copy(source) {
+      //     super.copy(source);
+      //     this.v0.copy(source.v0);
+      //     this.v1.copy(source.v1);
+      //     this.v2.copy(source.v2);
+      //     return this;
+      // }
+      // toJSON() {
+      //     const data = super.toJSON();
+      //     data.v0 = this.v0.toArray();
+      //     data.v1 = this.v1.toArray();
+      //     data.v2 = this.v2.toArray();
+      //     return data;
+      // }
+      // fromJSON(json) {
+      //     super.fromJSON(json);
+      //     this.v0.fromArray(json.v0);
+      //     this.v1.fromArray(json.v1);
+      //     this.v2.fromArray(json.v2);
+      //     return this;
+      // }
+      ;
+
+      return QuadraticBezierCurve3;
+    }(Curve);
+
+    /* eslint-disable no-tabs */
+    var helpVec3_1 = new Vector3();
+    var helpVec3_2 = new Vector3();
+    var helpVec3_3 = new Vector3();
+    var helpMat4 = new Matrix4();
+    var helpCurve = new QuadraticBezierCurve3();
+
+    function _getCornerBezierCurve(last, current, next, cornerRadius, firstCorner, out) {
+      var lastDir = helpVec3_1.subVectors(current, last);
+      var nextDir = helpVec3_2.subVectors(next, current);
+      var lastDirLength = lastDir.length();
+      var nextDirLength = nextDir.length();
+      lastDir.normalize();
+      nextDir.normalize(); // cornerRadius can not bigger then lineDistance / 2, auto fix this
+
+      var v0Dist = Math.min((firstCorner ? lastDirLength / 2 : lastDirLength) * 0.999999, cornerRadius);
+      out.v0.copy(current).sub(lastDir.multiplyScalar(v0Dist));
+      out.v1.copy(current);
+      var v2Dist = Math.min(nextDirLength / 2 * 0.999999, cornerRadius);
+      out.v2.copy(current).add(nextDir.multiplyScalar(v2Dist));
+      return out;
+    }
+    /**
+     * PathPointList
+     * input points to generate a PathPoint list
+     */
+
+
+    var PathPointList = /*#__PURE__*/function () {
+      function PathPointList() {
+        this.array = []; // path point array
+
+        this.count = 0;
+      }
+      /**
+       * Set points
+       * @param {THREE.Vector3[]} points key points array
+       * @param {number} cornerRadius? the corner radius. set 0 to disable round corner. default is 0.1
+       * @param {number} cornerSplit? the corner split. default is 10.
+       * @param {number} up? force up. default is auto up (calculate by tangent).
+       * @param {boolean} close? close path. default is false.
+       */
+
+
+      var _proto = PathPointList.prototype;
+
+      _proto.set = function set(points, cornerRadius, cornerSplit, up, close) {
+        if (cornerRadius === void 0) {
+          cornerRadius = 0.1;
+        }
+
+        if (cornerSplit === void 0) {
+          cornerSplit = 10;
+        }
+
+        if (up === void 0) {
+          up = null;
+        }
+
+        if (close === void 0) {
+          close = false;
+        }
+
+        points = points.slice(0);
+
+        if (points.length < 2) {
+          console.warn('PathPointList: points length less than 2.');
+          this.count = 0;
+          return;
+        } // Auto close
+
+
+        if (close && !points[0].equals(points[points.length - 1])) {
+          points.push(new Vector3().copy(points[0]));
+        } // Generate path point list
+
+
+        for (var i = 0, l = points.length; i < l; i++) {
+          if (i === 0) {
+            this._start(points[i], points[i + 1], up);
+          } else if (i === l - 1) {
+            if (close) {
+              // Connect end point and start point
+              this._corner(points[i], points[1], cornerRadius, cornerSplit, up); // Fix start point
+
+
+              var dist = this.array[0].dist; // should not copy dist
+
+              this.array[0].copy(this.array[this.count - 1]);
+              this.array[0].dist = dist;
+            } else {
+              this._end(points[i]);
+            }
+          } else {
+            this._corner(points[i], points[i + 1], cornerRadius, cornerSplit, up);
+          }
+        }
+      }
+      /**
+       * Get distance of this path
+       * @return {number}
+       */
+      ;
+
+      _proto.distance = function distance() {
+        if (this.count > 0) {
+          return this.array[this.count - 1].dist;
+        }
+
+        return 0;
+      };
+
+      _proto._getByIndex = function _getByIndex(index) {
+        if (!this.array[index]) {
+          this.array[index] = new PathPoint();
+        }
+
+        return this.array[index];
+      };
+
+      _proto._start = function _start(current, next, up) {
+        this.count = 0;
+
+        var point = this._getByIndex(this.count);
+
+        point.pos.copy(current);
+        point.dir.subVectors(next, current); // init start up dir
+
+        if (up) {
+          point.up.copy(up);
+        } else {
+          // select an initial normal vector perpendicular to the first tangent vector
+          var min = Number.MAX_VALUE;
+          var tx = Math.abs(point.dir.x);
+          var ty = Math.abs(point.dir.y);
+          var tz = Math.abs(point.dir.z);
+
+          if (tx < min) {
+            min = tx;
+            point.up.set(1, 0, 0);
+          }
+
+          if (ty < min) {
+            min = ty;
+            point.up.set(0, 1, 0);
+          }
+
+          if (tz < min) {
+            point.up.set(0, 0, 1);
+          }
+        }
+
+        point.right.crossVectors(point.dir, point.up).normalize();
+        point.up.crossVectors(point.right, point.dir).normalize();
+        point.dist = 0;
+        point.widthScale = 1;
+        point.sharp = false;
+        point.dir.normalize();
+        this.count++;
+      };
+
+      _proto._end = function _end(current) {
+        var lastPoint = this.array[this.count - 1];
+
+        var point = this._getByIndex(this.count);
+
+        point.pos.copy(current);
+        point.dir.subVectors(current, lastPoint.pos);
+        var dist = point.dir.length();
+        point.dir.normalize();
+        point.up.copy(lastPoint.up); // copy last up
+
+        var vec = helpVec3_1.crossVectors(lastPoint.dir, point.dir);
+
+        if (vec.length() > Number.EPSILON) {
+          vec.normalize();
+          var theta = Math.acos(Math.min(Math.max(lastPoint.dir.dot(point.dir), -1), 1)); // clamp for floating pt errors
+
+          point.up.applyMatrix4(helpMat4.makeRotationAxis(vec, theta));
+        }
+
+        point.right.crossVectors(point.dir, point.up).normalize();
+        point.dist = lastPoint.dist + dist;
+        point.widthScale = 1;
+        point.sharp = false;
+        this.count++;
+      };
+
+      _proto._corner = function _corner(current, next, cornerRadius, cornerSplit, up) {
+        if (cornerRadius > 0 && cornerSplit > 0) {
+          var lastPoint = this.array[this.count - 1];
+
+          var curve = _getCornerBezierCurve(lastPoint.pos, current, next, cornerRadius, this.count - 1 === 0, helpCurve);
+
+          var samplerPoints = curve.getPoints(cornerSplit); // TODO optimize
+
+          for (var f = 0; f < cornerSplit; f++) {
+            this._sharpCorner(samplerPoints[f], samplerPoints[f + 1], up, f === 0 ? 1 : 0);
+          }
+
+          if (!samplerPoints[cornerSplit].equals(next)) {
+            this._sharpCorner(samplerPoints[cornerSplit], next, up, 2);
+          }
+        } else {
+          this._sharpCorner(current, next, up, 0, true);
+        }
+      } // dirType: 0 - use middle dir / 1 - use last dir / 2- use next dir
+      ;
+
+      _proto._sharpCorner = function _sharpCorner(current, next, up, dirType, sharp) {
+        if (dirType === void 0) {
+          dirType = 0;
+        }
+
+        if (sharp === void 0) {
+          sharp = false;
+        }
+
+        var lastPoint = this.array[this.count - 1];
+
+        var point = this._getByIndex(this.count);
+
+        var lastDir = helpVec3_1.subVectors(current, lastPoint.pos);
+        var nextDir = helpVec3_2.subVectors(next, current);
+        var lastDirLength = lastDir.length();
+        lastDir.normalize();
+        nextDir.normalize();
+        point.pos.copy(current);
+
+        if (dirType === 1) {
+          point.dir.copy(lastDir);
+        } else if (dirType === 2) {
+          point.dir.copy(nextDir);
+        } else {
+          point.dir.addVectors(lastDir, nextDir);
+          point.dir.normalize();
+        }
+
+        if (up) {
+          if (point.dir.dot(up) === 1) {
+            point.right.crossVectors(nextDir, up).normalize();
+          } else {
+            point.right.crossVectors(point.dir, up).normalize();
+          }
+
+          point.up.crossVectors(point.right, point.dir).normalize();
+        } else {
+          point.up.copy(lastPoint.up);
+          var vec = helpVec3_3.crossVectors(lastPoint.dir, point.dir);
+
+          if (vec.length() > Number.EPSILON) {
+            vec.normalize();
+            var theta = Math.acos(Math.min(Math.max(lastPoint.dir.dot(point.dir), -1), 1)); // clamp for floating pt errors
+
+            point.up.applyMatrix4(helpMat4.makeRotationAxis(vec, theta));
+          }
+
+          point.right.crossVectors(point.dir, point.up).normalize();
+        }
+
+        point.dist = lastPoint.dist + lastDirLength;
+
+        var _cos = lastDir.dot(nextDir);
+
+        point.widthScale = Math.min(1 / Math.sqrt((1 + _cos) / 2), 1.415) || 1;
+        point.sharp = Math.abs(_cos - 1) > 0.05 && sharp;
+        this.count++;
+      };
+
+      return PathPointList;
+    }();
+
+    var UP = new Vector3(0, 0, 1);
+    function expandPaths(lines, options) {
+      options = Object.assign({}, {
+        lineWidth: 1,
+        cornerRadius: 0,
+        cornerSplit: 10
+      }, options);
+      var results = lines.map(function (line) {
+        var points = line.map(function (p) {
+          var x = p[0],
+              y = p[1],
+              z = p[2];
+          return new Vector3(x, y, z || 0);
+        });
+        var pathPointList = new PathPointList();
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+        var result = generatePathVertexData(pathPointList, options);
+        result.line = line;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.index);
+        result.uv = new Float32Array(result.uvs);
+        result.normal = new Float32Array(result.normal);
+        return result;
+      });
+      var result = merge(results);
+      result.lines = lines;
+      return result;
+    } // Vertex Data Generate Functions
+    // code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+
+    function generatePathVertexData(pathPointList, options) {
+      var width = options.lineWidth || 0.1;
+      var progress = 1;
+      var halfWidth = width / 2;
+      var sideWidth = width;
+      var totalDistance = pathPointList.distance();
+      var progressDistance = progress * totalDistance;
+
+      if (totalDistance === 0) {
+        return null;
+      }
+
+      var sharpUvOffset = halfWidth / sideWidth; // const sharpUvOffset2 = halfWidth / totalDistance;
+
+      var count = 0; // modify data
+
+      var position = [];
+      var normal = [];
+      var uv = [];
+      var indices = [];
+      var verticesCount = 0;
+      var right = new Vector3();
+      var left = new Vector3(); // for sharp corners
+
+      var leftOffset = new Vector3();
+      var rightOffset = new Vector3();
+      var tempPoint1 = new Vector3();
+      var tempPoint2 = new Vector3();
+
+      function addVertices(pathPoint) {
+        var first = position.length === 0;
+        var sharpCorner = pathPoint.sharp && !first;
+        var uvDist = pathPoint.dist / sideWidth; // const uvDist2 = pathPoint.dist / totalDistance;
+
+        var dir = pathPoint.dir;
+        var up = pathPoint.up;
+        var _right = pathPoint.right;
+
+        {
+          right.copy(_right).multiplyScalar(halfWidth * pathPoint.widthScale);
+        }
+
+        {
+          left.copy(_right).multiplyScalar(-halfWidth * pathPoint.widthScale);
+        }
+
+        right.add(pathPoint.pos);
+        left.add(pathPoint.pos);
+
+        if (sharpCorner) {
+          leftOffset.fromArray(position, position.length - 6).sub(left);
+          rightOffset.fromArray(position, position.length - 3).sub(right);
+          var leftDist = leftOffset.length();
+          var rightDist = rightOffset.length();
+          var sideOffset = leftDist - rightDist;
+          var longerOffset, longEdge;
+
+          if (sideOffset > 0) {
+            longerOffset = leftOffset;
+            longEdge = left;
+          } else {
+            longerOffset = rightOffset;
+            longEdge = right;
+          }
+
+          tempPoint1.copy(longerOffset).setLength(Math.abs(sideOffset)).add(longEdge); // eslint-disable-next-line prefer-const
+
+          var _cos = tempPoint2.copy(longEdge).sub(tempPoint1).normalize().dot(dir); // eslint-disable-next-line prefer-const
+
+
+          var _len = tempPoint2.copy(longEdge).sub(tempPoint1).length(); // eslint-disable-next-line prefer-const
+
+
+          var _dist = _cos * _len * 2;
+
+          tempPoint2.copy(dir).setLength(_dist).add(tempPoint1);
+
+          if (sideOffset > 0) {
+            position.push(tempPoint1.x, tempPoint1.y, tempPoint1.z, // 6
+            right.x, right.y, right.z, // 5
+            left.x, left.y, left.z, // 4
+            right.x, right.y, right.z, // 3
+            tempPoint2.x, tempPoint2.y, tempPoint2.z, // 2
+            right.x, right.y, right.z // 1
+            );
+            verticesCount += 6;
+            indices.push(verticesCount - 6, verticesCount - 8, verticesCount - 7, verticesCount - 6, verticesCount - 7, verticesCount - 5, verticesCount - 4, verticesCount - 6, verticesCount - 5, verticesCount - 2, verticesCount - 4, verticesCount - 1);
+            count += 12;
+          } else {
+            position.push(left.x, left.y, left.z, // 6
+            tempPoint1.x, tempPoint1.y, tempPoint1.z, // 5
+            left.x, left.y, left.z, // 4
+            right.x, right.y, right.z, // 3
+            left.x, left.y, left.z, // 2
+            tempPoint2.x, tempPoint2.y, tempPoint2.z // 1
+            );
+            verticesCount += 6;
+            indices.push(verticesCount - 6, verticesCount - 8, verticesCount - 7, verticesCount - 6, verticesCount - 7, verticesCount - 5, verticesCount - 6, verticesCount - 5, verticesCount - 3, verticesCount - 2, verticesCount - 3, verticesCount - 1);
+            count += 12;
+          }
+
+          normal.push(up.x, up.y, up.z, up.x, up.y, up.z, up.x, up.y, up.z, up.x, up.y, up.z, up.x, up.y, up.z, up.x, up.y, up.z);
+          uv.push(uvDist - sharpUvOffset, 0, uvDist - sharpUvOffset, 1, uvDist, 0, uvDist, 1, uvDist + sharpUvOffset, 0, uvDist + sharpUvOffset, 1); // if (generateUv2) {
+          //     uv2.push(
+          //         uvDist2 - sharpUvOffset2, 0,
+          //         uvDist2 - sharpUvOffset2, 1,
+          //         uvDist2, 0,
+          //         uvDist2, 1,
+          //         uvDist2 + sharpUvOffset2, 0,
+          //         uvDist2 + sharpUvOffset2, 1
+          //     );
+          // }
+        } else {
+          position.push(left.x, left.y, left.z, right.x, right.y, right.z);
+          normal.push(up.x, up.y, up.z, up.x, up.y, up.z);
+          uv.push(uvDist, 0, uvDist, 1); // if (generateUv2) {
+          //     uv2.push(
+          //         uvDist2, 0,
+          //         uvDist2, 1
+          //     );
+          // }
+
+          verticesCount += 2;
+
+          if (!first) {
+            indices.push(verticesCount - 2, verticesCount - 4, verticesCount - 3, verticesCount - 2, verticesCount - 3, verticesCount - 1);
+            count += 6;
+          }
+        }
+      }
+
+      var lastPoint;
+
+      if (progressDistance > 0) {
+        for (var i = 0; i < pathPointList.count; i++) {
+          var pathPoint = pathPointList.array[i];
+
+          if (pathPoint.dist > progressDistance) {
+            var prevPoint = pathPointList.array[i - 1];
+            lastPoint = new PathPoint(); // linear lerp for progress
+
+            var alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+            lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+            addVertices(lastPoint);
+            break;
+          } else {
+            addVertices(pathPoint);
+          }
+        }
+      } else {
+        lastPoint = pathPointList.array[0];
+      }
+
+      return {
+        points: position,
+        normal: normal,
+        uvs: uv,
+        index: indices,
+        count: count
+      };
+    }
+
     exports.cylinder = cylinder;
     exports.expandLine = expandLine;
+    exports.expandPaths = expandPaths;
     exports.extrudePolygons = extrudePolygons;
     exports.extrudePolylines = extrudePolylines;