poly-extrude 0.13.0 → 0.14.0

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.13.0
+ * poly-extrude v0.14.0
   */
 var earcut$2 = {exports: {}};
 
@@ -1746,1157 +1746,896 @@ var Vector3 = /*#__PURE__*/function () {
   return Vector3;
 }();
 
-/**
- * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
- * @param {*} ring
- * @returns
+/**
+ * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
+ * @param {*} ring
+ * @returns
  */
-
 function isClockwise(ring) {
-  var sum = 0;
-  var i = 1;
-  var prev;
-  var cur;
-  var len = ring.length;
-
-  while (i < len) {
-    prev = cur || ring[0];
-    cur = ring[i];
-    sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
-    i++;
-  }
-
-  return sum > 0;
+    let sum = 0;
+    let i = 1;
+    let prev;
+    let cur;
+    const len = ring.length;
+    while (i < len) {
+        prev = cur || ring[0];
+        cur = ring[i];
+        sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
+        i++;
+    }
+    return sum > 0;
 }
-
 function v3Sub(out, v1, v2) {
-  out[0] = v1[0] - v2[0];
-  out[1] = v1[1] - v2[1];
-  out[2] = v1[2] - v2[2];
-  return out;
+    out[0] = v1[0] - v2[0];
+    out[1] = v1[1] - v2[1];
+    out[2] = v1[2] - v2[2];
+    return out;
 }
-
 function v3Normalize(out, v) {
-  var x = v[0];
-  var y = v[1];
-  var z = v[2];
-  var d = Math.sqrt(x * x + y * y + z * z) || 1;
-  out[0] = x / d;
-  out[1] = y / d;
-  out[2] = z / d;
-  return out;
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    const d = Math.sqrt(x * x + y * y + z * z) || 1;
+    out[0] = x / d;
+    out[1] = y / d;
+    out[2] = z / d;
+    return out;
 }
-
 function v3Cross(out, v1, v2) {
-  var ax = v1[0],
-      ay = v1[1],
-      az = v1[2],
-      bx = v2[0],
-      by = v2[1],
-      bz = v2[2];
-  out[0] = ay * bz - az * by;
-  out[1] = az * bx - ax * bz;
-  out[2] = ax * by - ay * bx;
-  return out;
+    const ax = v1[0], ay = v1[1], az = v1[2], bx = v2[0], by = v2[1], bz = v2[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
 }
-
 function generateNormal(indices, position) {
-  function v3Set(p, a, b, c) {
-    p[0] = a;
-    p[1] = b;
-    p[2] = c;
-  }
-
-  var p1 = [];
-  var p2 = [];
-  var p3 = [];
-  var v21 = [];
-  var v32 = [];
-  var n = [];
-  var len = indices.length;
-  var normals = new Float32Array(position.length);
-  var f = 0;
-
-  while (f < len) {
-    // const i1 = indices[f++] * 3;
-    // const i2 = indices[f++] * 3;
-    // const i3 = indices[f++] * 3;
-    // const i1 = indices[f];
-    // const i2 = indices[f + 1];
-    // const i3 = indices[f + 2];
-    var a = indices[f],
-        b = indices[f + 1],
-        c = indices[f + 2];
-    var i1 = a * 3,
-        i2 = b * 3,
-        i3 = c * 3;
-    v3Set(p1, position[i1], position[i1 + 1], position[i1 + 2]);
-    v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
-    v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
-    v3Sub(v32, p3, p2);
-    v3Sub(v21, p1, p2);
-    v3Cross(n, v32, v21); // Already be weighted by the triangle area
-
-    for (var _i = 0; _i < 3; _i++) {
-      normals[i1 + _i] += n[_i];
-      normals[i2 + _i] += n[_i];
-      normals[i3 + _i] += n[_i];
+    function v3Set(p, a, b, c) {
+        p[0] = a;
+        p[1] = b;
+        p[2] = c;
     }
-
-    f += 3;
-  }
-
-  var i = 0;
-  var l = normals.length;
-
-  while (i < l) {
-    v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
-    v3Normalize(n, n);
-    normals[i] = n[0] || 0;
-    normals[i + 1] = n[1] || 0;
-    normals[i + 2] = n[2] || 0;
-    i += 3;
-  }
-
-  return normals;
+    const p1 = [];
+    const p2 = [];
+    const p3 = [];
+    const v21 = [];
+    const v32 = [];
+    const n = [];
+    const len = indices.length;
+    const normals = new Float32Array(position.length);
+    let f = 0;
+    while (f < len) {
+        // const i1 = indices[f++] * 3;
+        // const i2 = indices[f++] * 3;
+        // const i3 = indices[f++] * 3;
+        // const i1 = indices[f];
+        // const i2 = indices[f + 1];
+        // const i3 = indices[f + 2];
+        const a = indices[f], b = indices[f + 1], c = indices[f + 2];
+        const i1 = a * 3, i2 = b * 3, i3 = c * 3;
+        v3Set(p1, position[i1], position[i1 + 1], position[i1 + 2]);
+        v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
+        v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
+        v3Sub(v32, p3, p2);
+        v3Sub(v21, p1, p2);
+        v3Cross(n, v32, v21);
+        // Already be weighted by the triangle area
+        for (let i = 0; i < 3; i++) {
+            normals[i1 + i] += n[i];
+            normals[i2 + i] += n[i];
+            normals[i3 + i] += n[i];
+        }
+        f += 3;
+    }
+    let i = 0;
+    const l = normals.length;
+    while (i < l) {
+        v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
+        v3Normalize(n, n);
+        normals[i] = n[0] || 0;
+        normals[i + 1] = n[1] || 0;
+        normals[i + 2] = n[2] || 0;
+        i += 3;
+    }
+    return normals;
 }
 function merge(results) {
-  if (results.length === 1) {
-    var _result = {
-      position: results[0].position,
-      normal: results[0].normal,
-      uv: results[0].uv,
-      indices: results[0].indices,
-      results: results
+    if (results.length === 1) {
+        const result = {
+            position: results[0].position,
+            normal: results[0].normal,
+            uv: results[0].uv,
+            indices: results[0].indices,
+            results
+        };
+        return result;
+    }
+    let plen = 0, ilen = 0;
+    for (let i = 0, len = results.length; i < len; i++) {
+        const { position, indices } = results[i];
+        plen += position.length;
+        ilen += indices.length;
+    }
+    const result = {
+        position: new Float32Array(plen),
+        normal: new Float32Array(plen),
+        uv: new Float32Array(plen / 3 * 2),
+        indices: new Uint32Array(ilen),
+        results
     };
-    return _result;
-  }
-
-  var plen = 0,
-      ilen = 0;
-
-  for (var i = 0, len = results.length; i < len; i++) {
-    var _results$i = results[i],
-        position = _results$i.position,
-        indices = _results$i.indices;
-    plen += position.length;
-    ilen += indices.length;
-  }
-
-  var result = {
-    position: new Float32Array(plen),
-    normal: new Float32Array(plen),
-    uv: new Float32Array(plen / 3 * 2),
-    indices: new Uint32Array(ilen),
-    results: results
-  };
-  var pOffset = 0,
-      pCount = 0,
-      iIdx = 0,
-      uvOffset = 0;
-
-  for (var _i2 = 0, _len = results.length; _i2 < _len; _i2++) {
-    var _results$_i = results[_i2],
-        _position = _results$_i.position,
-        _indices = _results$_i.indices,
-        normal = _results$_i.normal,
-        uv = _results$_i.uv;
-    result.position.set(_position, pOffset);
-    result.normal.set(normal, pOffset);
-    result.uv.set(uv, uvOffset);
-    var j = 0;
-    var len1 = _indices.length;
-
-    while (j < len1) {
-      var pIndex = _indices[j] + pCount;
-      result.indices[iIdx] = pIndex;
-      iIdx++;
-      j++;
+    let pOffset = 0, pCount = 0, iIdx = 0, uvOffset = 0;
+    for (let i = 0, len = results.length; i < len; i++) {
+        const { position, indices, normal, uv } = results[i];
+        result.position.set(position, pOffset);
+        result.normal.set(normal, pOffset);
+        result.uv.set(uv, uvOffset);
+        let j = 0;
+        const len1 = indices.length;
+        while (j < len1) {
+            const pIndex = indices[j] + pCount;
+            result.indices[iIdx] = pIndex;
+            iIdx++;
+            j++;
+        }
+        uvOffset += uv.length;
+        pOffset += position.length;
+        pCount += position.length / 3;
     }
-
-    uvOffset += uv.length;
-    pOffset += _position.length;
-    pCount += _position.length / 3;
-  }
-
-  return result;
+    return result;
 }
 function radToDeg(rad) {
-  return rad * 180 / Math.PI;
+    return rad * 180 / Math.PI;
 }
 function degToRad(angle) {
-  return angle / 180 * Math.PI;
-} // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
-
+    return angle / 180 * Math.PI;
+}
+// https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
 function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
-  var idx1 = indexA * 3,
-      idx2 = indexB * 3,
-      idx3 = indexC * 3,
-      idx4 = indexD * 3;
-  var a_x = vertices[idx1];
-  var a_y = vertices[idx1 + 1];
-  var a_z = vertices[idx1 + 2];
-  var b_x = vertices[idx2];
-  var b_y = vertices[idx2 + 1];
-  var b_z = vertices[idx2 + 2];
-  var c_x = vertices[idx3];
-  var c_y = vertices[idx3 + 1];
-  var c_z = vertices[idx3 + 2];
-  var d_x = vertices[idx4];
-  var d_y = vertices[idx4 + 1];
-  var d_z = vertices[idx4 + 2];
-  var uIndex = uvs.length - 1;
-
-  if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
-    uvs[++uIndex] = a_x;
-    uvs[++uIndex] = 1 - a_z;
-    uvs[++uIndex] = b_x;
-    uvs[++uIndex] = 1 - b_z;
-    uvs[++uIndex] = c_x;
-    uvs[++uIndex] = 1 - c_z;
-    uvs[++uIndex] = d_x;
-    uvs[++uIndex] = 1 - d_z; // uvs.push(a_x, 1 - a_z);
-    // uvs.push(b_x, 1 - b_z);
-    // uvs.push(c_x, 1 - c_z);
-    // uvs.push(d_x, 1 - d_z);
-  } else {
-    uvs[++uIndex] = a_y;
-    uvs[++uIndex] = 1 - a_z;
-    uvs[++uIndex] = b_y;
-    uvs[++uIndex] = 1 - b_z;
-    uvs[++uIndex] = c_y;
-    uvs[++uIndex] = 1 - c_z;
-    uvs[++uIndex] = d_y;
-    uvs[++uIndex] = 1 - d_z; // uvs.push(a_y, 1 - a_z);
-    // uvs.push(b_y, 1 - b_z);
-    // uvs.push(c_y, 1 - c_z);
-    // uvs.push(d_y, 1 - d_z);
-  }
+    const idx1 = indexA * 3, idx2 = indexB * 3, idx3 = indexC * 3, idx4 = indexD * 3;
+    const a_x = vertices[idx1];
+    const a_y = vertices[idx1 + 1];
+    const a_z = vertices[idx1 + 2];
+    const b_x = vertices[idx2];
+    const b_y = vertices[idx2 + 1];
+    const b_z = vertices[idx2 + 2];
+    const c_x = vertices[idx3];
+    const c_y = vertices[idx3 + 1];
+    const c_z = vertices[idx3 + 2];
+    const d_x = vertices[idx4];
+    const d_y = vertices[idx4 + 1];
+    const d_z = vertices[idx4 + 2];
+    let uIndex = uvs.length - 1;
+    if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
+        uvs[++uIndex] = a_x;
+        uvs[++uIndex] = 1 - a_z;
+        uvs[++uIndex] = b_x;
+        uvs[++uIndex] = 1 - b_z;
+        uvs[++uIndex] = c_x;
+        uvs[++uIndex] = 1 - c_z;
+        uvs[++uIndex] = d_x;
+        uvs[++uIndex] = 1 - d_z;
+        // uvs.push(a_x, 1 - a_z);
+        // uvs.push(b_x, 1 - b_z);
+        // uvs.push(c_x, 1 - c_z);
+        // uvs.push(d_x, 1 - d_z);
+    }
+    else {
+        uvs[++uIndex] = a_y;
+        uvs[++uIndex] = 1 - a_z;
+        uvs[++uIndex] = b_y;
+        uvs[++uIndex] = 1 - b_z;
+        uvs[++uIndex] = c_y;
+        uvs[++uIndex] = 1 - c_z;
+        uvs[++uIndex] = d_y;
+        uvs[++uIndex] = 1 - d_z;
+        // uvs.push(a_y, 1 - a_z);
+        // uvs.push(b_y, 1 - b_z);
+        // uvs.push(c_y, 1 - c_z);
+        // uvs.push(d_y, 1 - d_z);
+    }
 }
 function line2Vectors(line) {
-  var points = [];
-
-  for (var i = 0, len = line.length; i < len; i++) {
-    var p = line[i];
-    var x = p[0],
-        y = p[1],
-        z = p[2];
-    var v = new Vector3(x, y, z || 0);
-    points[i] = v;
-  }
-
-  return points;
+    const points = [];
+    for (let i = 0, len = line.length; i < len; i++) {
+        const p = line[i];
+        const [x, y, z] = p;
+        const v = new Vector3(x, y, z || 0);
+        points[i] = v;
+    }
+    return points;
 }
 function calLineDistance(line) {
-  var distance = 0;
-
-  for (var i = 0, len = line.length; i < len; i++) {
-    var p1 = line[i],
-        p2 = line[i + 1];
-
-    if (i === 0) {
-      p1.distance = 0;
-    }
-
-    if (p1 && p2) {
-      var x1 = p1[0],
-          y1 = p1[1],
-          z1 = p1[2];
-      var x2 = p2[0],
-          y2 = p2[1],
-          z2 = p2[2];
-      var dx = x1 - x2,
-          dy = y1 - y2,
-          dz = (z1 || 0) - (z2 || 0);
-      var dis = Math.sqrt(dx * dx + dy * dy + dz * dz);
-      distance += dis;
-      p2.distance = distance;
+    let distance = 0;
+    for (let i = 0, len = line.length; i < len; i++) {
+        const p1 = line[i], p2 = line[i + 1];
+        if (i === 0) {
+            p1.distance = 0;
+        }
+        if (p1 && p2) {
+            const [x1, y1, z1] = p1;
+            const [x2, y2, z2] = p2;
+            const dx = x1 - x2, dy = y1 - y2, dz = (z1 || 0) - (z2 || 0);
+            const dis = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            distance += dis;
+            p2.distance = distance;
+        }
     }
-  }
-
-  return distance;
+    return distance;
 }
 
 function extrudePolygons(polygons, options) {
-  options = Object.assign({}, {
-    depth: 2
-  }, options);
-  var results = polygons.map(function (polygon) {
-    for (var i = 0, len = polygon.length; i < len; i++) {
-      var ring = polygon[i];
-      validateRing(ring);
-
-      if (i === 0) {
-        if (!isClockwise(ring)) {
-          polygon[i] = ring.reverse();
+    options = Object.assign({}, { depth: 2 }, options);
+    const results = polygons.map(polygon => {
+        for (let i = 0, len = polygon.length; i < len; i++) {
+            const ring = polygon[i];
+            validateRing(ring);
+            if (i === 0) {
+                if (!isClockwise(ring)) {
+                    polygon[i] = ring.reverse();
+                }
+            }
+            else if (isClockwise(ring)) {
+                polygon[i] = ring.reverse();
+            }
+            if (isClosedRing(ring)) {
+                ring.splice(ring.length - 1, 1);
+            }
         }
-      } else if (isClockwise(ring)) {
-        polygon[i] = ring.reverse();
-      }
-
-      if (isClosedRing(ring)) {
-        ring.splice(ring.length - 1, 1);
-      }
-    }
-
-    var result = flatVertices(polygon, options);
-    result.polygon = polygon;
-    var triangles = earcut$1(result.flatVertices, result.holes, 2);
-    generateTopAndBottom$1(result, triangles);
-    generateSides$1(result, options);
-    result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.indices);
-    result.uv = new Float32Array(result.uv);
-    result.normal = generateNormal(result.indices, result.position);
+        const result = flatVertices(polygon, options);
+        result.polygon = polygon;
+        const triangles = earcut$1(result.flatVertices, result.holes, 2);
+        generateTopAndBottom$1(result, triangles);
+        generateSides$1(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+    });
+    const result = merge(results);
+    result.polygons = polygons;
     return result;
-  });
-  var result = merge(results);
-  result.polygons = polygons;
-  return result;
 }
-
 function generateTopAndBottom$1(result, triangles) {
-  var indices = [];
-  var count = result.count;
-
-  for (var i = 0, len = triangles.length; i < len; i += 3) {
-    // top
-    var a = triangles[i],
-        b = triangles[i + 1],
-        c = triangles[i + 2];
-    indices[i] = a;
-    indices[i + 1] = b;
-    indices[i + 2] = c; // bottom
-
-    var idx = len + i;
-    var a1 = count + a,
-        b1 = count + b,
-        c1 = count + c;
-    indices[idx] = a1;
-    indices[idx + 1] = b1;
-    indices[idx + 2] = c1;
-  }
-
-  result.indices = indices;
+    const indices = [];
+    const { count } = result;
+    for (let i = 0, len = triangles.length; i < len; i += 3) {
+        // top
+        const a = triangles[i], b = triangles[i + 1], c = triangles[i + 2];
+        indices[i] = a;
+        indices[i + 1] = b;
+        indices[i + 2] = c;
+        // bottom
+        const idx = len + i;
+        const a1 = count + a, b1 = count + b, c1 = count + c;
+        indices[idx] = a1;
+        indices[idx + 1] = b1;
+        indices[idx + 2] = c1;
+    }
+    result.indices = indices;
 }
-
 function generateSides$1(result, options) {
-  var points = result.points,
-      indices = result.indices,
-      polygon = result.polygon,
-      uv = result.uv;
-  var depth = options.depth;
-  var pIndex = points.length - 1;
-  var iIndex = indices.length - 1;
-
-  for (var i = 0, len = polygon.length; i < len; i++) {
-    var ring = polygon[i];
-    var j = 0;
-    var len1 = ring.length;
-
-    while (j < len1) {
-      var v1 = ring[j];
-      var v2 = ring[j + 1];
-
-      if (j === len1 - 1) {
-        v2 = ring[0];
-      }
-
-      var idx = points.length / 3;
-      var x1 = v1[0],
-          y1 = v1[1],
-          z1 = v1[2] || 0,
-          x2 = v2[0],
-          y2 = v2[1],
-          z2 = v2[2] || 0;
-      points[++pIndex] = x1;
-      points[++pIndex] = y1;
-      points[++pIndex] = z1 + depth;
-      points[++pIndex] = x2;
-      points[++pIndex] = y2;
-      points[++pIndex] = z2 + depth;
-      points[++pIndex] = x1;
-      points[++pIndex] = y1;
-      points[++pIndex] = z1;
-      points[++pIndex] = x2;
-      points[++pIndex] = y2;
-      points[++pIndex] = z2; // points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
-
-      var a = idx + 2,
-          b = idx + 3,
-          c = idx,
-          d = idx + 1; // points.push(p3, p4, p1, p2);
-      // index.push(a, c, b, c, d, b);
-
-      indices[++iIndex] = a;
-      indices[++iIndex] = c;
-      indices[++iIndex] = b;
-      indices[++iIndex] = c;
-      indices[++iIndex] = d;
-      indices[++iIndex] = b; // index.push(c, d, b);
-
-      generateSideWallUV(uv, points, a, b, c, d);
-      j++;
+    const { points, indices, polygon, uv } = result;
+    const depth = options.depth;
+    let pIndex = points.length - 1;
+    let iIndex = indices.length - 1;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
+            const v1 = ring[j];
+            let v2 = ring[j + 1];
+            if (j === len1 - 1) {
+                v2 = ring[0];
+            }
+            const idx = points.length / 3;
+            const x1 = v1[0], y1 = v1[1], z1 = v1[2] || 0, x2 = v2[0], y2 = v2[1], z2 = v2[2] || 0;
+            points[++pIndex] = x1;
+            points[++pIndex] = y1;
+            points[++pIndex] = z1 + depth;
+            points[++pIndex] = x2;
+            points[++pIndex] = y2;
+            points[++pIndex] = z2 + depth;
+            points[++pIndex] = x1;
+            points[++pIndex] = y1;
+            points[++pIndex] = z1;
+            points[++pIndex] = x2;
+            points[++pIndex] = y2;
+            points[++pIndex] = z2;
+            // points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
+            const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
+            // points.push(p3, p4, p1, p2);
+            // index.push(a, c, b, c, d, b);
+            indices[++iIndex] = a;
+            indices[++iIndex] = c;
+            indices[++iIndex] = b;
+            indices[++iIndex] = c;
+            indices[++iIndex] = d;
+            indices[++iIndex] = b;
+            // index.push(c, d, b);
+            generateSideWallUV(uv, points, a, b, c, d);
+            j++;
+        }
     }
-  }
 }
-
 function calPolygonPointsCount(polygon) {
-  var count = 0;
-  var i = 0;
-  var len = polygon.length;
-
-  while (i < len) {
-    count += polygon[i].length;
-    i++;
-  }
-
-  return count;
+    let count = 0;
+    let i = 0;
+    const len = polygon.length;
+    while (i < len) {
+        count += (polygon[i].length);
+        i++;
+    }
+    return count;
 }
-
 function flatVertices(polygon, options) {
-  var count = calPolygonPointsCount(polygon);
-  var len = polygon.length;
-  var holes = [],
-      flatVertices = new Float32Array(count * 2),
-      points = [],
-      uv = [];
-  var pOffset = count * 3,
-      uOffset = count * 2;
-  var depth = options.depth;
-  var idx0 = 0,
-      idx1 = 0,
-      idx2 = 0;
-
-  for (var i = 0; i < len; i++) {
-    var ring = polygon[i];
-
-    if (i > 0) {
-      holes.push(idx0 / 2);
-    }
-
-    var j = 0;
-    var len1 = ring.length;
-
-    while (j < len1) {
-      var c = ring[j];
-      var x = c[0],
-          y = c[1],
-          z = c[2] || 0;
-      flatVertices[idx0++] = x;
-      flatVertices[idx0++] = y; // top vertices
-
-      points[idx1] = x;
-      points[idx1 + 1] = y;
-      points[idx1 + 2] = depth + z; // bottom vertices
-
-      points[pOffset + idx1] = x;
-      points[pOffset + idx1 + 1] = y;
-      points[pOffset + idx1 + 2] = z;
-      uv[idx2] = x;
-      uv[idx2 + 1] = y;
-      uv[uOffset + idx2] = x;
-      uv[uOffset + idx2 + 1] = y;
-      idx1 += 3;
-      idx2 += 2;
-      j++;
+    const count = calPolygonPointsCount(polygon);
+    const len = polygon.length;
+    const holes = [], flatVertices = new Float32Array(count * 2), points = [], uv = [];
+    const pOffset = count * 3, uOffset = count * 2;
+    const depth = options.depth;
+    let idx0 = 0, idx1 = 0, idx2 = 0;
+    for (let i = 0; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(idx0 / 2);
+        }
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
+            const c = ring[j];
+            const x = c[0], y = c[1], z = c[2] || 0;
+            flatVertices[idx0++] = x;
+            flatVertices[idx0++] = y;
+            // top vertices
+            points[idx1] = x;
+            points[idx1 + 1] = y;
+            points[idx1 + 2] = depth + z;
+            // bottom vertices
+            points[pOffset + idx1] = x;
+            points[pOffset + idx1 + 1] = y;
+            points[pOffset + idx1 + 2] = z;
+            uv[idx2] = x;
+            uv[idx2 + 1] = y;
+            uv[uOffset + idx2] = x;
+            uv[uOffset + idx2 + 1] = y;
+            idx1 += 3;
+            idx2 += 2;
+            j++;
+        }
     }
-  }
-
-  return {
-    flatVertices: flatVertices,
-    holes: holes,
-    points: points,
-    count: count,
-    uv: uv
-  };
+    return {
+        flatVertices,
+        holes,
+        points,
+        count,
+        uv
+    };
 }
-
 function validateRing(ring) {
-  if (!isClosedRing(ring)) {
-    ring.push(ring[0]);
-  }
+    if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+    }
 }
-
 function isClosedRing(ring) {
-  var len = ring.length;
-  var _ring$ = ring[0],
-      x1 = _ring$[0],
-      y1 = _ring$[1],
-      _ring = ring[len - 1],
-      x2 = _ring[0],
-      y2 = _ring[1];
-  return x1 === x2 && y1 === y2;
+    const len = ring.length;
+    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
+    return (x1 === x2 && y1 === y2);
 }
 
 function checkOptions(options) {
-  options.lineWidth = Math.max(0, options.lineWidth);
-  options.depth = Math.max(0, options.depth);
-  options.sideDepth = Math.max(0, options.sideDepth);
+    options.lineWidth = Math.max(0, options.lineWidth);
+    options.depth = Math.max(0, options.depth);
+    options.sideDepth = Math.max(0, options.sideDepth);
 }
-
 function extrudePolylines(lines, options) {
-  options = Object.assign({}, {
-    depth: 2,
-    lineWidth: 1,
-    bottomStickGround: false,
-    pathUV: false
-  }, options);
-  checkOptions(options);
-  var results = lines.map(function (line) {
-    var result = expandLine(line, options);
-    result.line = line;
-    generateTopAndBottom(result, options);
-    generateSides(result, options);
-    result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.indices);
-    result.uv = new Float32Array(result.uv);
-    result.normal = generateNormal(result.indices, result.position);
+    options = Object.assign({}, { depth: 2, lineWidth: 1, bottomStickGround: false, pathUV: false }, options);
+    checkOptions(options);
+    const results = lines.map(line => {
+        const result = expandLine(line, options);
+        result.line = line;
+        generateTopAndBottom(result, options);
+        generateSides(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+    });
+    const result = merge(results);
+    result.lines = lines;
     return result;
-  });
-  var result = merge(results);
-  result.lines = lines;
-  return result;
 }
 function extrudeSlopes(lines, options) {
-  options = Object.assign({}, {
-    depth: 2,
-    lineWidth: 1,
-    side: 'left',
-    sideDepth: 0,
-    bottomStickGround: false,
-    pathUV: false,
-    isSlope: true
-  }, options);
-  checkOptions(options);
-  var _options = options,
-      depth = _options.depth,
-      side = _options.side,
-      sideDepth = _options.sideDepth;
-  var results = lines.map(function (line) {
-    var tempResult = expandLine(line, options);
-    tempResult.line = line;
-    var leftPoints = tempResult.leftPoints,
-        rightPoints = tempResult.rightPoints;
-    var result = {
-      line: line
-    };
-    var depths;
-
-    for (var i = 0, len = line.length; i < len; i++) {
-      line[i][2] = line[i][2] || 0;
-    }
-
-    if (side === 'left') {
-      result.leftPoints = leftPoints;
-      result.rightPoints = line;
-      depths = [sideDepth, depth];
-    } else {
-      result.leftPoints = line;
-      result.rightPoints = rightPoints;
-      depths = [depth, sideDepth];
-    }
-
-    result.depths = depths;
-    generateTopAndBottom(result, options);
-    generateSides(result, options);
-    result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.indices);
-    result.uv = new Float32Array(result.uv);
-    result.normal = generateNormal(result.indices, result.position);
+    options = Object.assign({}, { depth: 2, lineWidth: 1, side: 'left', sideDepth: 0, bottomStickGround: false, pathUV: false, isSlope: true }, options);
+    checkOptions(options);
+    const { depth, side, sideDepth } = options;
+    const results = lines.map(line => {
+        const tempResult = expandLine(line, options);
+        tempResult.line = line;
+        const { leftPoints, rightPoints } = tempResult;
+        const result = { line };
+        let depths;
+        for (let i = 0, len = line.length; i < len; i++) {
+            line[i][2] = line[i][2] || 0;
+        }
+        if (side === 'left') {
+            result.leftPoints = leftPoints;
+            result.rightPoints = line;
+            depths = [sideDepth, depth];
+        }
+        else {
+            result.leftPoints = line;
+            result.rightPoints = rightPoints;
+            depths = [depth, sideDepth];
+        }
+        result.depths = depths;
+        generateTopAndBottom(result, options);
+        generateSides(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+    });
+    const result = merge(results);
+    result.lines = lines;
     return result;
-  });
-  var result = merge(results);
-  result.lines = lines;
-  return result;
 }
-
 function generateTopAndBottom(result, options) {
-  var bottomStickGround = options.bottomStickGround;
-  var z = options.depth;
-  var depths = result.depths;
-  var lz = z,
-      rz = z;
-
-  if (depths) {
-    lz = depths[0];
-    rz = depths[1];
-  }
-
-  var leftPoints = result.leftPoints,
-      rightPoints = result.rightPoints;
-  var line = result.line;
-  var pathUV = options.pathUV;
-
-  if (pathUV) {
-    calLineDistance(line);
-
-    for (var _i = 0, _len = line.length; _i < _len; _i++) {
-      leftPoints[_i].distance = rightPoints[_i].distance = line[_i].distance;
+    const bottomStickGround = options.bottomStickGround;
+    const z = options.depth;
+    const depths = result.depths;
+    let lz = z, rz = z;
+    if (depths) {
+        lz = depths[0];
+        rz = depths[1];
     }
-  }
-
-  var i = 0,
-      len = leftPoints.length;
-  var points = [],
-      indices = [],
-      uv = [];
-
-  while (i < len) {
-    // top left
-    var idx0 = i * 3;
-    var _leftPoints$i = leftPoints[i],
-        x1 = _leftPoints$i[0],
-        y1 = _leftPoints$i[1],
-        z1 = _leftPoints$i[2];
-    points[idx0] = x1;
-    points[idx0 + 1] = y1;
-    points[idx0 + 2] = lz + z1; // top right
-
-    var _rightPoints$i = rightPoints[i],
-        x2 = _rightPoints$i[0],
-        y2 = _rightPoints$i[1],
-        z2 = _rightPoints$i[2];
-    var idx1 = len * 3 + idx0;
-    points[idx1] = x2;
-    points[idx1 + 1] = y2;
-    points[idx1 + 2] = rz + z2; // bottom left
-
-    var idx2 = len * 2 * 3 + idx0;
-    points[idx2] = x1;
-    points[idx2 + 1] = y1;
-    points[idx2 + 2] = z1;
-
-    if (bottomStickGround) {
-      points[idx2 + 2] = 0;
-    } // bottom right
-
-
-    var idx3 = len * 2 * 3 + len * 3 + idx0;
-    points[idx3] = x2;
-    points[idx3 + 1] = y2;
-    points[idx3 + 2] = z2;
-
-    if (bottomStickGround) {
-      points[idx3 + 2] = 0;
-    } // generate path uv
-
-
+    const { leftPoints, rightPoints } = result;
+    const line = result.line;
+    const pathUV = options.pathUV;
     if (pathUV) {
-      var p = line[i];
-      var uvx = p.distance;
-      var uIndex0 = i * 2;
-      uv[uIndex0] = uvx;
-      uv[uIndex0 + 1] = 1;
-      var uIndex1 = len * 2 + uIndex0;
-      uv[uIndex1] = uvx;
-      uv[uIndex1 + 1] = 0;
-      var uIndex2 = len * 2 * 2 + uIndex0;
-      uv[uIndex2] = uvx;
-      uv[uIndex2 + 1] = 1;
-      var uIndex3 = len * 2 * 2 + len * 2 + uIndex0;
-      uv[uIndex3] = uvx;
-      uv[uIndex3 + 1] = 0;
+        calLineDistance(line);
+        for (let i = 0, len = line.length; i < len; i++) {
+            leftPoints[i].distance = rightPoints[i].distance = line[i].distance;
+        }
     }
-
-    i++;
-  }
-
-  if (!pathUV) {
-    i = 0;
-    len = points.length;
-    var uIndex = uv.length - 1;
-
+    let i = 0, len = leftPoints.length;
+    const points = [], indices = [], uv = [];
     while (i < len) {
-      var x = points[i],
-          y = points[i + 1];
-      uv[++uIndex] = x;
-      uv[++uIndex] = y; // uvs.push(x, y);
-
-      i += 3;
+        // top left
+        const idx0 = i * 3;
+        const [x1, y1, z1] = leftPoints[i];
+        points[idx0] = x1;
+        points[idx0 + 1] = y1;
+        points[idx0 + 2] = lz + z1;
+        // top right
+        const [x2, y2, z2] = rightPoints[i];
+        const idx1 = len * 3 + idx0;
+        points[idx1] = x2;
+        points[idx1 + 1] = y2;
+        points[idx1 + 2] = rz + z2;
+        // bottom left
+        const idx2 = (len * 2) * 3 + idx0;
+        points[idx2] = x1;
+        points[idx2 + 1] = y1;
+        points[idx2 + 2] = z1;
+        if (bottomStickGround) {
+            points[idx2 + 2] = 0;
+        }
+        // bottom right
+        const idx3 = (len * 2) * 3 + len * 3 + idx0;
+        points[idx3] = x2;
+        points[idx3 + 1] = y2;
+        points[idx3 + 2] = z2;
+        if (bottomStickGround) {
+            points[idx3 + 2] = 0;
+        }
+        // generate path uv
+        if (pathUV) {
+            const p = line[i];
+            const uvx = p.distance;
+            const uIndex0 = i * 2;
+            uv[uIndex0] = uvx;
+            uv[uIndex0 + 1] = 1;
+            const uIndex1 = len * 2 + uIndex0;
+            uv[uIndex1] = uvx;
+            uv[uIndex1 + 1] = 0;
+            const uIndex2 = (len * 2) * 2 + uIndex0;
+            uv[uIndex2] = uvx;
+            uv[uIndex2 + 1] = 1;
+            const uIndex3 = (len * 2) * 2 + len * 2 + uIndex0;
+            uv[uIndex3] = uvx;
+            uv[uIndex3 + 1] = 0;
+        }
+        i++;
+    }
+    if (!pathUV) {
+        i = 0;
+        len = points.length;
+        let uIndex = uv.length - 1;
+        while (i < len) {
+            const x = points[i], y = points[i + 1];
+            uv[++uIndex] = x;
+            uv[++uIndex] = y;
+            // uvs.push(x, y);
+            i += 3;
+        }
     }
-  }
-
-  i = 0;
-  len = leftPoints.length;
-  var iIndex = indices.length - 1;
-
-  while (i < len - 1) {
-    // top
-    // left1 left2 right1,right2
-    var a1 = i,
-        b1 = i + 1,
-        c1 = a1 + len,
-        d1 = b1 + len;
-    indices[++iIndex] = a1;
-    indices[++iIndex] = c1;
-    indices[++iIndex] = b1;
-    indices[++iIndex] = c1;
-    indices[++iIndex] = d1;
-    indices[++iIndex] = b1; // index.push(a1, c1, b1);
-    // index.push(c1, d1, b1);
-    // bottom
-    // left1 left2 right1,right2
-
-    var len2 = len * 2;
-    var a2 = i + len2,
-        b2 = a2 + 1,
-        c2 = a2 + len,
-        d2 = b2 + len;
-    indices[++iIndex] = a2;
-    indices[++iIndex] = c2;
-    indices[++iIndex] = b2;
-    indices[++iIndex] = c2;
-    indices[++iIndex] = d2;
-    indices[++iIndex] = b2; // index.push(a2, c2, b2);
-    // index.push(c2, d2, b2);
-
-    i++;
-  }
-
-  result.indices = indices;
-  result.points = points;
-  result.uv = uv;
-
-  if (depths) {
-    len = leftPoints.length;
     i = 0;
-
-    while (i < len) {
-      leftPoints[i].depth = lz;
-      rightPoints[i].depth = rz;
-      i++;
+    len = leftPoints.length;
+    let iIndex = indices.length - 1;
+    while (i < len - 1) {
+        // top
+        // left1 left2 right1,right2
+        const a1 = i, b1 = i + 1, c1 = a1 + len, d1 = b1 + len;
+        indices[++iIndex] = a1;
+        indices[++iIndex] = c1;
+        indices[++iIndex] = b1;
+        indices[++iIndex] = c1;
+        indices[++iIndex] = d1;
+        indices[++iIndex] = b1;
+        // index.push(a1, c1, b1);
+        // index.push(c1, d1, b1);
+        // bottom
+        // left1 left2 right1,right2
+        const len2 = len * 2;
+        const a2 = i + len2, b2 = a2 + 1, c2 = a2 + len, d2 = b2 + len;
+        indices[++iIndex] = a2;
+        indices[++iIndex] = c2;
+        indices[++iIndex] = b2;
+        indices[++iIndex] = c2;
+        indices[++iIndex] = d2;
+        indices[++iIndex] = b2;
+        // index.push(a2, c2, b2);
+        // index.push(c2, d2, b2);
+        i++;
+    }
+    result.indices = indices;
+    result.points = points;
+    result.uv = uv;
+    if (depths) {
+        len = leftPoints.length;
+        i = 0;
+        while (i < len) {
+            leftPoints[i].depth = lz;
+            rightPoints[i].depth = rz;
+            i++;
+        }
     }
-  }
 }
-
 function generateSides(result, options) {
-  var points = result.points,
-      indices = result.indices,
-      leftPoints = result.leftPoints,
-      rightPoints = result.rightPoints,
-      uv = result.uv;
-  var z = options.depth;
-  var bottomStickGround = options.bottomStickGround;
-  var rings = [leftPoints, rightPoints];
-  var depthsEnable = result.depths;
-  var pathUV = options.pathUV;
-  var lineWidth = options.lineWidth;
-  var pIndex = points.length - 1;
-  var iIndex = indices.length - 1;
-  var uIndex = uv.length - 1;
-
-  function addOneSideIndex(v1, v2) {
-    var idx = points.length / 3; // let pIndex = points.length - 1;
-
-    var v1Depth = depthsEnable ? v1.depth : z;
-    var v2Depth = depthsEnable ? v2.depth : z; // top
-
-    points[++pIndex] = v1[0];
-    points[++pIndex] = v1[1];
-    points[++pIndex] = v1Depth + v1[2];
-    points[++pIndex] = v2[0];
-    points[++pIndex] = v2[1];
-    points[++pIndex] = v2Depth + v2[2]; // points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2]);
-    // bottom
-
-    points[++pIndex] = v1[0];
-    points[++pIndex] = v1[1];
-    points[++pIndex] = bottomStickGround ? 0 : v1[2];
-    points[++pIndex] = v2[0];
-    points[++pIndex] = v2[1];
-    points[++pIndex] = bottomStickGround ? 0 : v2[2]; // points.push(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
-
-    var a = idx + 2,
-        b = idx + 3,
-        c = idx,
-        d = idx + 1;
-    indices[++iIndex] = a;
-    indices[++iIndex] = c;
-    indices[++iIndex] = b;
-    indices[++iIndex] = c;
-    indices[++iIndex] = d;
-    indices[++iIndex] = b; // index.push(a, c, b, c, d, b);
-
-    if (!pathUV) {
-      generateSideWallUV(uv, points, a, b, c, d);
-    } else {
-      uv[++uIndex] = v1.distance;
-      uv[++uIndex] = v1Depth / lineWidth;
-      uv[++uIndex] = v2.distance;
-      uv[++uIndex] = v2Depth / lineWidth;
-      uv[++uIndex] = v1.distance;
-      uv[++uIndex] = 0;
-      uv[++uIndex] = v2.distance;
-      uv[++uIndex] = 0;
+    const { points, indices, leftPoints, rightPoints, uv } = result;
+    const z = options.depth;
+    const bottomStickGround = options.bottomStickGround;
+    const rings = [leftPoints, rightPoints];
+    const depthsEnable = result.depths;
+    const pathUV = options.pathUV;
+    const lineWidth = options.lineWidth;
+    let pIndex = points.length - 1;
+    let iIndex = indices.length - 1;
+    let uIndex = uv.length - 1;
+    function addOneSideIndex(v1, v2) {
+        const idx = points.length / 3;
+        // let pIndex = points.length - 1;
+        const v1Depth = (depthsEnable ? v1.depth : z);
+        const v2Depth = (depthsEnable ? v2.depth : z);
+        // top
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = v1Depth + v1[2];
+        points[++pIndex] = v2[0];
+        points[++pIndex] = v2[1];
+        points[++pIndex] = v2Depth + v2[2];
+        // points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2]);
+        // bottom
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = bottomStickGround ? 0 : v1[2];
+        points[++pIndex] = v2[0];
+        points[++pIndex] = v2[1];
+        points[++pIndex] = bottomStickGround ? 0 : v2[2];
+        // points.push(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
+        const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
+        indices[++iIndex] = a;
+        indices[++iIndex] = c;
+        indices[++iIndex] = b;
+        indices[++iIndex] = c;
+        indices[++iIndex] = d;
+        indices[++iIndex] = b;
+        // index.push(a, c, b, c, d, b);
+        if (!pathUV) {
+            generateSideWallUV(uv, points, a, b, c, d);
+        }
+        else {
+            uv[++uIndex] = v1.distance;
+            uv[++uIndex] = v1Depth / lineWidth;
+            uv[++uIndex] = v2.distance;
+            uv[++uIndex] = v2Depth / lineWidth;
+            uv[++uIndex] = v1.distance;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = v2.distance;
+            uv[++uIndex] = 0;
+        }
     }
-  }
-
-  for (var i = 0, _len2 = rings.length; i < _len2; i++) {
-    var ring = rings[i];
-
-    if (i > 0) {
-      ring = ring.map(function (p) {
-        return p;
-      });
-      ring = ring.reverse();
+    for (let i = 0, len = rings.length; i < len; i++) {
+        let ring = rings[i];
+        if (i > 0) {
+            ring = ring.map(p => {
+                return p;
+            });
+            ring = ring.reverse();
+        }
+        let j = 0;
+        const len1 = ring.length - 1;
+        while (j < len1) {
+            const v1 = ring[j];
+            const v2 = ring[j + 1];
+            addOneSideIndex(v1, v2);
+            j++;
+        }
     }
-
-    var j = 0;
-    var len1 = ring.length - 1;
-
-    while (j < len1) {
-      var v1 = ring[j];
-      var v2 = ring[j + 1];
-      addOneSideIndex(v1, v2);
-      j++;
+    const len = leftPoints.length;
+    const vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
+    for (let i = 0; i < vs.length; i += 2) {
+        const v1 = vs[i], v2 = vs[i + 1];
+        addOneSideIndex(v1, v2);
     }
-  }
-
-  var len = leftPoints.length;
-  var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
-
-  for (var _i2 = 0; _i2 < vs.length; _i2 += 2) {
-    var _v = vs[_i2],
-        _v2 = vs[_i2 + 1];
-    addOneSideIndex(_v, _v2);
-  }
 }
-
-var TEMPV1 = {
-  x: 0,
-  y: 0
-},
-    TEMPV2 = {
-  x: 0,
-  y: 0
-};
+const TEMPV1 = { x: 0, y: 0 }, TEMPV2 = { x: 0, y: 0 };
 function expandLine(line, options) {
-  // let preAngle = 0;
-  var radius = options.lineWidth / 2;
-
-  if (options.isSlope) {
-    radius *= 2;
-  }
-
-  var points = [],
-      leftPoints = [],
-      rightPoints = [];
-  var len = line.length;
-  var i = 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;
-
-    if (i === 0 || i === len - 1) {
-      rAngle = angle;
-      rAngle -= 90;
-    } else {
-      // 至少3个顶点才会触发
-      var p0 = line[i - 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;
-    }
-
-    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 _translateLine = translateLine(p1, p2, radius),
-        line1 = _translateLine[0],
-        line2 = _translateLine[1];
-
-    var op1 = lineIntersection(line1[0], line1[1], p3, p4);
-    var op2 = lineIntersection(line2[0], line2[1], p3, p4); // 平行，回头路
-
-    if (!op1 || !op2) {
-      var len1 = points.length;
-      var point1 = points[len1 - 2];
-      var point2 = points[len1 - 1];
-
-      if (!point1 || !point2) {
-        continue;
-      }
-
-      op1 = [point1[0], point1[1]];
-      op2 = [point2[0], point2[1]];
+    // let preAngle = 0;
+    let radius = options.lineWidth / 2;
+    if (options.isSlope) {
+        radius *= 2;
     }
-
-    op1[2] = currentp[2] || 0;
-    op2[2] = currentp[2] || 0; // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
-
-    points.push(op1, op2);
-
-    if (leftOnLine(op1, p1, p2)) {
-      leftPoints.push(op1);
-      rightPoints.push(op2);
-    } else {
-      leftPoints.push(op2);
-      rightPoints.push(op1);
+    const points = [], leftPoints = [], rightPoints = [];
+    const len = line.length;
+    let i = 0;
+    while (i < len) {
+        let p1 = line[i], p2 = line[i + 1];
+        const currentp = line[i];
+        // last vertex
+        if (i === len - 1) {
+            p1 = line[len - 2];
+            p2 = line[len - 1];
+        }
+        const dy = p2[1] - p1[1], dx = p2[0] - p1[0];
+        let rAngle = 0;
+        const rad = Math.atan(dy / dx);
+        const angle = radToDeg(rad);
+        // preAngle = angle;
+        if (i === 0 || i === len - 1) {
+            rAngle = angle;
+            rAngle -= 90;
+        }
+        else {
+            // 至少3个顶点才会触发
+            const p0 = line[i - 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];
+            const vAngle = getAngle(TEMPV1, TEMPV2);
+            rAngle = angle - vAngle / 2;
+        }
+        const rRad = degToRad(rAngle);
+        const p3 = currentp;
+        const x = Math.cos(rRad) + p3[0], y = Math.sin(rRad) + p3[1];
+        const p4 = [x, y];
+        const [line1, line2] = translateLine(p1, p2, radius);
+        let op1 = lineIntersection(line1[0], line1[1], p3, p4);
+        let op2 = lineIntersection(line2[0], line2[1], p3, p4);
+        // 平行，回头路
+        if (!op1 || !op2) {
+            const len1 = points.length;
+            const point1 = points[len1 - 2];
+            const point2 = points[len1 - 1];
+            if (!point1 || !point2) {
+                continue;
+            }
+            op1 = [point1[0], point1[1]];
+            op2 = [point2[0], point2[1]];
+        }
+        op1[2] = currentp[2] || 0;
+        op2[2] = currentp[2] || 0;
+        // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
+        points.push(op1, op2);
+        if (leftOnLine(op1, p1, p2)) {
+            leftPoints.push(op1);
+            rightPoints.push(op2);
+        }
+        else {
+            leftPoints.push(op2);
+            rightPoints.push(op1);
+        }
+        i++;
     }
-
-    i++;
-  }
-
-  return {
-    offsetPoints: points,
-    leftPoints: leftPoints,
-    rightPoints: rightPoints,
-    line: line
-  };
-} // eslint-disable-next-line no-unused-vars
-
-var getAngle = function getAngle(_ref, _ref2) {
-  var x1 = _ref.x,
-      y1 = _ref.y;
-  var x2 = _ref2.x,
-      y2 = _ref2.y;
-  var dot = x1 * x2 + y1 * y2;
-  var det = x1 * y2 - y1 * x2;
-  var angle = Math.atan2(det, dot) / Math.PI * 180;
-  return (angle + 360) % 360;
+    return { offsetPoints: points, leftPoints, rightPoints, line };
+}
+const getAngle = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
+    const dot = x1 * x2 + y1 * y2;
+    const det = x1 * y2 - y1 * x2;
+    const angle = Math.atan2(det, dot) / Math.PI * 180;
+    return (angle + 360) % 360;
 };
-
 function leftOnLine(p, p1, p2) {
-  var x1 = p1[0],
-      y1 = p1[1];
-  var x2 = p2[0],
-      y2 = p2[1];
-  var x = p[0],
-      y = p[1];
-  return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
+    const [x1, y1] = p1;
+    const [x2, y2] = p2;
+    const [x, y] = p;
+    return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
 }
-/**
- * 平移线
- * @param {*} p1
- * @param {*} p2
- * @param {*} distance
- * @returns
+/**
+ * 平移线
+ * @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]];
+    const dy = p2[1] - p1[1], dx = p2[0] - p1[0];
+    const rad = Math.atan2(dy, dx);
+    const rad1 = rad + Math.PI / 2;
+    let offsetX = Math.cos(rad1) * distance, offsetY = Math.sin(rad1) * distance;
+    const tp1 = [p1[0] + offsetX, p1[1] + offsetY];
+    const tp2 = [p2[0] + offsetX, p2[1] + offsetY];
+    const rad2 = rad - Math.PI / 2;
+    offsetX = Math.cos(rad2) * distance;
+    offsetY = Math.sin(rad2) * distance;
+    const tp3 = [p1[0] + offsetX, p1[1] + offsetY];
+    const tp4 = [p2[0] + offsetX, p2[1] + offsetY];
+    return [[tp1, tp2], [tp3, tp4]];
 }
-/**
- * 直线交点
- * @param {*} p1
- * @param {*} p2
- * @param {*} p3
- * @param {*} p4
- * @returns
+/**
+ * 直线交点
+ * @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];
+    const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1];
+    const dx2 = p4[0] - p3[0], dy2 = p4[1] - p3[1];
+    if (dx1 === 0 && dx2 === 0) {
+        return null;
+    }
+    if (dy1 === 0 && dy2 === 0) {
+        return null;
+    }
+    const k1 = dy1 / dx1;
+    const k2 = dy2 / dx2;
+    const b1 = p1[1] - k1 * p1[0];
+    const b2 = p3[1] - k2 * p3[0];
+    let 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) {
-    options = {};
-  }
-
-  options = Object.assign({}, {
-    radius: 1,
-    height: 2,
-    radialSegments: 6
-  }, options);
-  var radialSegments = Math.round(Math.max(4, options.radialSegments));
-  var _options = options,
-      radius = _options.radius,
-      height = _options.height;
-  var aRad = 360 / radialSegments / 360 * Math.PI * 2;
-  var circlePointsLen = radialSegments + 1;
-  var points = new Float32Array(circlePointsLen * 3 * 2);
-  var centerx = point[0],
-      centery = point[1];
-  var idx = 0,
-      uIdx = 0;
-  var offset = circlePointsLen * 3,
-      uOffset = circlePointsLen * 2;
-  var indices = [],
-      uv = [];
-  var iIndex = indices.length - 1;
-
-  for (var i = -1; i < radialSegments; i++) {
-    var rad = aRad * i;
-    var x = Math.cos(rad) * radius + centerx,
-        y = Math.sin(rad) * radius + centery; // bottom vertices
-
-    points[idx] = x;
-    points[idx + 1] = y;
-    points[idx + 2] = 0; // top vertices
-
-    points[idx + offset] = x;
-    points[idx + 1 + offset] = y;
-    points[idx + 2 + offset] = height;
-    var u = 0,
-        v = 0;
-    u = 0.5 + x / radius / 2;
-    v = 0.5 + y / radius / 2;
-    uv[uIdx] = u;
-    uv[uIdx + 1] = v;
-    uv[uIdx + uOffset] = u;
-    uv[uIdx + 1 + uOffset] = v;
-    idx += 3;
-    uIdx += 2;
-
-    if (i > 1) {
-      // bottom indices
-      // indices.push(0, i - 1, i);
-      indices[++iIndex] = 0;
-      indices[++iIndex] = i - 1;
-      indices[++iIndex] = i;
+    options = Object.assign({}, { radius: 1, height: 2, radialSegments: 6 }, options);
+    const radialSegments = Math.round(Math.max(4, options.radialSegments));
+    let { radius, height } = options;
+    radius = radius;
+    height = height;
+    const aRad = 360 / radialSegments / 360 * Math.PI * 2;
+    const circlePointsLen = (radialSegments + 1);
+    const points = new Float32Array(circlePointsLen * 3 * 2);
+    const [centerx, centery] = point;
+    let idx = 0, uIdx = 0;
+    const offset = circlePointsLen * 3, uOffset = circlePointsLen * 2;
+    const indices = [], uv = [];
+    let iIndex = indices.length - 1;
+    for (let i = -1; i < radialSegments; i++) {
+        const rad = aRad * i;
+        const x = Math.cos(rad) * radius + centerx, y = Math.sin(rad) * radius + centery;
+        // bottom vertices
+        points[idx] = x;
+        points[idx + 1] = y;
+        points[idx + 2] = 0;
+        // top vertices
+        points[idx + offset] = x;
+        points[idx + 1 + offset] = y;
+        points[idx + 2 + offset] = height;
+        let u = 0, v = 0;
+        u = 0.5 + x / radius / 2;
+        v = 0.5 + y / radius / 2;
+        uv[uIdx] = u;
+        uv[uIdx + 1] = v;
+        uv[uIdx + uOffset] = u;
+        uv[uIdx + 1 + uOffset] = v;
+        idx += 3;
+        uIdx += 2;
+        if (i > 1) {
+            // bottom indices
+            // indices.push(0, i - 1, i);
+            indices[++iIndex] = 0;
+            indices[++iIndex] = i - 1;
+            indices[++iIndex] = i;
+        }
     }
-  }
-
-  idx -= 3;
-  points[idx] = points[0];
-  points[idx + 1] = points[1];
-  points[idx + 2] = points[2];
-  var pointsLen = points.length;
-  points[pointsLen - 3] = points[0];
-  points[pointsLen - 2] = points[1];
-  points[pointsLen - 1] = height;
-  var indicesLen = indices.length; // top indices
-
-  iIndex = indices.length - 1;
-
-  for (var _i = 0; _i < indicesLen; _i++) {
-    var index = indices[_i];
-    indices[++iIndex] = index + circlePointsLen; // indices.push(index + circlePointsLen);
-  }
-
-  var sidePoints = new Float32Array((circlePointsLen * 3 * 2 - 6) * 2);
-  var pIndex = -1;
-  idx = circlePointsLen * 2;
-  uIdx = 0;
-  iIndex = indices.length - 1;
-  var uvIndex = uv.length - 1;
-
-  for (var _i2 = 0, len = points.length / 2; _i2 < len - 3; _i2 += 3) {
-    var x1 = points[_i2],
-        y1 = points[_i2 + 1],
-        x2 = points[_i2 + 3],
-        y2 = points[_i2 + 4];
-    sidePoints[++pIndex] = x1;
-    sidePoints[++pIndex] = y1;
-    sidePoints[++pIndex] = height;
-    sidePoints[++pIndex] = x2;
-    sidePoints[++pIndex] = y2;
-    sidePoints[++pIndex] = height;
-    sidePoints[++pIndex] = x1;
-    sidePoints[++pIndex] = y1;
-    sidePoints[++pIndex] = 0;
-    sidePoints[++pIndex] = x2;
-    sidePoints[++pIndex] = y2;
-    sidePoints[++pIndex] = 0;
-    var a = idx + 2,
-        b = idx + 3,
-        c = idx,
-        d = idx + 1; // indices.push(a, c, b, c, d, b);
-
-    indices[++iIndex] = c;
-    indices[++iIndex] = a;
-    indices[++iIndex] = d;
-    indices[++iIndex] = a;
-    indices[++iIndex] = b;
-    indices[++iIndex] = d; // indices.push(c, a, d, a, b, d);
-
-    idx += 4;
-    var u1 = uIdx / circlePointsLen,
-        u2 = (uIdx + 1) / circlePointsLen;
-    uv[++uvIndex] = u1;
-    uv[++uvIndex] = height / radius / 2;
-    uv[++uvIndex] = u2;
-    uv[++uvIndex] = height / radius / 2;
-    uv[++uvIndex] = u1;
-    uv[++uvIndex] = 0;
-    uv[++uvIndex] = u2;
-    uv[++uvIndex] = 0; // uvs.push(u1, height / radius / 2, u2, height / radius / 2, u1, 0, u2, 0);
-
-    uIdx++;
-  }
-
-  var position = new Float32Array(points.length + sidePoints.length);
-  position.set(points, 0);
-  position.set(sidePoints, points.length);
-  var normal = generateNormal(indices, position);
-  return {
-    points: points,
-    indices: new Uint32Array(indices),
-    position: position,
-    normal: normal,
-    uv: new Float32Array(uv)
-  };
+    idx -= 3;
+    points[idx] = points[0];
+    points[idx + 1] = points[1];
+    points[idx + 2] = points[2];
+    const pointsLen = points.length;
+    points[pointsLen - 3] = points[0];
+    points[pointsLen - 2] = points[1];
+    points[pointsLen - 1] = height;
+    const indicesLen = indices.length;
+    // top indices
+    iIndex = indices.length - 1;
+    for (let i = 0; i < indicesLen; i++) {
+        const index = indices[i];
+        indices[++iIndex] = index + circlePointsLen;
+        // indices.push(index + circlePointsLen);
+    }
+    const sidePoints = new Float32Array((circlePointsLen * 3 * 2 - 6) * 2);
+    let pIndex = -1;
+    idx = circlePointsLen * 2;
+    uIdx = 0;
+    iIndex = indices.length - 1;
+    let uvIndex = uv.length - 1;
+    for (let i = 0, len = points.length / 2; i < len - 3; i += 3) {
+        const x1 = points[i], y1 = points[i + 1], x2 = points[i + 3], y2 = points[i + 4];
+        sidePoints[++pIndex] = x1;
+        sidePoints[++pIndex] = y1;
+        sidePoints[++pIndex] = height;
+        sidePoints[++pIndex] = x2;
+        sidePoints[++pIndex] = y2;
+        sidePoints[++pIndex] = height;
+        sidePoints[++pIndex] = x1;
+        sidePoints[++pIndex] = y1;
+        sidePoints[++pIndex] = 0;
+        sidePoints[++pIndex] = x2;
+        sidePoints[++pIndex] = y2;
+        sidePoints[++pIndex] = 0;
+        const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
+        // indices.push(a, c, b, c, d, b);
+        indices[++iIndex] = c;
+        indices[++iIndex] = a;
+        indices[++iIndex] = d;
+        indices[++iIndex] = a;
+        indices[++iIndex] = b;
+        indices[++iIndex] = d;
+        // indices.push(c, a, d, a, b, d);
+        idx += 4;
+        const u1 = uIdx / circlePointsLen, u2 = (uIdx + 1) / circlePointsLen;
+        uv[++uvIndex] = u1;
+        uv[++uvIndex] = height / radius / 2;
+        uv[++uvIndex] = u2;
+        uv[++uvIndex] = height / radius / 2;
+        uv[++uvIndex] = u1;
+        uv[++uvIndex] = 0;
+        uv[++uvIndex] = u2;
+        uv[++uvIndex] = 0;
+        // uvs.push(u1, height / radius / 2, u2, height / radius / 2, u1, 0, u2, 0);
+        uIdx++;
+    }
+    const position = new Float32Array(points.length + sidePoints.length);
+    position.set(points, 0);
+    position.set(sidePoints, points.length);
+    const normal = generateNormal(indices, position);
+    return { points, indices: new Uint32Array(indices), position, normal, uv: new Float32Array(uv) };
 }
 
 /* eslint-disable no-tabs */
@@ -4191,539 +3930,505 @@ var PathPointList = /*#__PURE__*/function () {
   return PathPointList;
 }();
 
-var UP$1 = new Vector3(0, 0, 1);
-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();
+const UP$1 = new Vector3(0, 0, 1);
+const right = new Vector3();
+const left = new Vector3();
+// for sharp corners
+const leftOffset = new Vector3();
+const rightOffset = new Vector3();
+const tempPoint1 = new Vector3();
+const tempPoint2 = new Vector3();
 function expandPaths(lines, options) {
-  options = Object.assign({}, {
-    lineWidth: 1,
-    cornerRadius: 0,
-    cornerSplit: 10
-  }, options);
-  var results = lines.map(function (line) {
-    var points = line2Vectors(line);
-    var pathPointList = new PathPointList();
-    pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
-    var result = generatePathVertexData(pathPointList, options);
-    result.line = line;
-    result.position = new Float32Array(result.position);
-    result.indices = new Uint32Array(result.indices);
-    result.uv = new Float32Array(result.uv);
-    result.normal = new Float32Array(result.normal);
+    options = Object.assign({}, { lineWidth: 1, cornerRadius: 0, cornerSplit: 10 }, options);
+    const results = lines.map(line => {
+        const points = line2Vectors(line);
+        const pathPointList = new PathPointList();
+        //@ts-ignore
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
+        const params = generatePathVertexData(pathPointList, options);
+        const result = {
+            position: new Float32Array(params.position),
+            indices: new Uint32Array(params.indices),
+            uv: new Float32Array(params.uv),
+            normal: new Float32Array(params.normal),
+            line,
+            count: params.count
+        };
+        return result;
+    });
+    const result = merge(results);
+    result.lines = lines;
     return result;
-  });
-  var result = merge(results);
-  result.lines = lines;
-  return result;
-} // Vertex Data Generate Functions
+}
+// 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 pIndex = position.length - 1;
-  var nIndex = normal.length - 1;
-  var uIndex = uv.length - 1;
-  var iIndex = indices.length - 1;
-
-  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);
+    const width = options.lineWidth || 0.1;
+    const progress = 1;
+    const halfWidth = width / 2;
+    const sideWidth = (width);
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+    let count = 0;
+    // modify data
+    const position = [];
+    const normal = [];
+    const uv = [];
+    const indices = [];
+    let verticesCount = 0;
+    if (totalDistance === 0) {
+        return {
+            position: position,
+            normal,
+            uv: uv,
+            indices: indices,
+            count
+        };
     }
-
-    {
-      left.copy(_right).multiplyScalar(-halfWidth * pathPoint.widthScale);
+    const sharpUvOffset = halfWidth / sideWidth;
+    // const sharpUvOffset2 = halfWidth / totalDistance;
+    let pIndex = position.length - 1;
+    let nIndex = normal.length - 1;
+    let uIndex = uv.length - 1;
+    let iIndex = indices.length - 1;
+    function addVertices(pathPoint) {
+        const first = position.length === 0;
+        const sharpCorner = pathPoint.sharp && !first;
+        const uvDist = pathPoint.dist / sideWidth;
+        // const uvDist2 = pathPoint.dist / totalDistance;
+        const dir = pathPoint.dir;
+        const up = pathPoint.up;
+        const _right = pathPoint.right;
+        //@ts-ignore
+        {
+            right.copy(_right).multiplyScalar(halfWidth * pathPoint.widthScale);
+        }
+        //@ts-ignore
+        {
+            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);
+            const leftDist = leftOffset.length();
+            const rightDist = rightOffset.length();
+            const sideOffset = leftDist - rightDist;
+            let 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
+            let _cos = tempPoint2.copy(longEdge).sub(tempPoint1).normalize().dot(dir);
+            // eslint-disable-next-line prefer-const
+            let _len = tempPoint2.copy(longEdge).sub(tempPoint1).length();
+            // eslint-disable-next-line prefer-const
+            let _dist = _cos * _len * 2;
+            tempPoint2.copy(dir).setLength(_dist).add(tempPoint1);
+            if (sideOffset > 0) {
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                // 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[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 1;
+                // 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[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                // 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[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+                // 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;
+            }
+            for (let i = 0; i < 6; i++) {
+                normal[++nIndex] = up.x;
+                normal[++nIndex] = up.y;
+                normal[++nIndex] = up.z;
+            }
+            // 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[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 1;
+            // 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[++pIndex] = left.x;
+            position[++pIndex] = left.y;
+            position[++pIndex] = left.z;
+            position[++pIndex] = right.x;
+            position[++pIndex] = right.y;
+            position[++pIndex] = right.z;
+            // position.push(
+            //     left.x, left.y, left.z,
+            //     right.x, right.y, right.z
+            // );
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            // normal.push(
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z
+            // );
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            // uv.push(
+            //     uvDist, 0,
+            //     uvDist, 1
+            // );
+            // if (generateUv2) {
+            //     uv2.push(
+            //         uvDist2, 0,
+            //         uvDist2, 1
+            //     );
+            // }
+            verticesCount += 2;
+            if (!first) {
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+                // indices.push(
+                //     verticesCount - 2, verticesCount - 4, verticesCount - 3,
+                //     verticesCount - 2, verticesCount - 3, verticesCount - 1
+                // );
+                count += 6;
+            }
+        }
     }
-
-    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[++pIndex] = tempPoint1.x;
-        position[++pIndex] = tempPoint1.y;
-        position[++pIndex] = tempPoint1.z;
-        position[++pIndex] = right.x;
-        position[++pIndex] = right.y;
-        position[++pIndex] = right.z;
-        position[++pIndex] = left.x;
-        position[++pIndex] = left.y;
-        position[++pIndex] = left.z;
-        position[++pIndex] = right.x;
-        position[++pIndex] = right.y;
-        position[++pIndex] = right.z;
-        position[++pIndex] = tempPoint2.x;
-        position[++pIndex] = tempPoint2.y;
-        position[++pIndex] = tempPoint2.z;
-        position[++pIndex] = right.x;
-        position[++pIndex] = right.y;
-        position[++pIndex] = right.z; // 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[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 8;
-        indices[++iIndex] = verticesCount - 7;
-        indices[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 7;
-        indices[++iIndex] = verticesCount - 5;
-        indices[++iIndex] = verticesCount - 4;
-        indices[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 5;
-        indices[++iIndex] = verticesCount - 2;
-        indices[++iIndex] = verticesCount - 4;
-        indices[++iIndex] = verticesCount - 1; // 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[++pIndex] = left.x;
-        position[++pIndex] = left.y;
-        position[++pIndex] = left.z;
-        position[++pIndex] = tempPoint1.x;
-        position[++pIndex] = tempPoint1.y;
-        position[++pIndex] = tempPoint1.z;
-        position[++pIndex] = left.x;
-        position[++pIndex] = left.y;
-        position[++pIndex] = left.z;
-        position[++pIndex] = right.x;
-        position[++pIndex] = right.y;
-        position[++pIndex] = right.z;
-        position[++pIndex] = left.x;
-        position[++pIndex] = left.y;
-        position[++pIndex] = left.z;
-        position[++pIndex] = tempPoint2.x;
-        position[++pIndex] = tempPoint2.y;
-        position[++pIndex] = tempPoint2.z; // 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[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 8;
-        indices[++iIndex] = verticesCount - 7;
-        indices[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 7;
-        indices[++iIndex] = verticesCount - 5;
-        indices[++iIndex] = verticesCount - 6;
-        indices[++iIndex] = verticesCount - 5;
-        indices[++iIndex] = verticesCount - 3;
-        indices[++iIndex] = verticesCount - 2;
-        indices[++iIndex] = verticesCount - 3;
-        indices[++iIndex] = verticesCount - 1; // 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;
-      }
-
-      for (var i = 0; i < 6; i++) {
-        normal[++nIndex] = up.x;
-        normal[++nIndex] = up.y;
-        normal[++nIndex] = up.z;
-      } // 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[++uIndex] = uvDist - sharpUvOffset;
-      uv[++uIndex] = 0;
-      uv[++uIndex] = uvDist - sharpUvOffset;
-      uv[++uIndex] = 1;
-      uv[++uIndex] = uvDist;
-      uv[++uIndex] = 0;
-      uv[++uIndex] = uvDist;
-      uv[++uIndex] = 1;
-      uv[++uIndex] = uvDist + sharpUvOffset;
-      uv[++uIndex] = 0;
-      uv[++uIndex] = uvDist + sharpUvOffset;
-      uv[++uIndex] = 1; // 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[++pIndex] = left.x;
-      position[++pIndex] = left.y;
-      position[++pIndex] = left.z;
-      position[++pIndex] = right.x;
-      position[++pIndex] = right.y;
-      position[++pIndex] = right.z; // position.push(
-      //     left.x, left.y, left.z,
-      //     right.x, right.y, right.z
-      // );
-
-      normal[++nIndex] = up.x;
-      normal[++nIndex] = up.y;
-      normal[++nIndex] = up.z;
-      normal[++nIndex] = up.x;
-      normal[++nIndex] = up.y;
-      normal[++nIndex] = up.z; // normal.push(
-      //     up.x, up.y, up.z,
-      //     up.x, up.y, up.z
-      // );
-
-      uv[++uIndex] = uvDist;
-      uv[++uIndex] = 0;
-      uv[++uIndex] = uvDist;
-      uv[++uIndex] = 1; // uv.push(
-      //     uvDist, 0,
-      //     uvDist, 1
-      // );
-      // if (generateUv2) {
-      //     uv2.push(
-      //         uvDist2, 0,
-      //         uvDist2, 1
-      //     );
-      // }
-
-      verticesCount += 2;
-
-      if (!first) {
-        indices[++iIndex] = verticesCount - 2;
-        indices[++iIndex] = verticesCount - 4;
-        indices[++iIndex] = verticesCount - 3;
-        indices[++iIndex] = verticesCount - 2;
-        indices[++iIndex] = verticesCount - 3;
-        indices[++iIndex] = verticesCount - 1; // indices.push(
-        //     verticesCount - 2, verticesCount - 4, verticesCount - 3,
-        //     verticesCount - 2, verticesCount - 3, verticesCount - 1
-        // );
-
-        count += 6;
-      }
+    let lastPoint;
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                lastPoint = new PathPoint();
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+                addVertices(lastPoint);
+                break;
+            }
+            else {
+                addVertices(pathPoint);
+            }
+        }
     }
-  }
-
-  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];
     }
-  } else {
-    lastPoint = pathPointList.array[0];
-  }
-
-  return {
-    position: position,
-    normal: normal,
-    uv: uv,
-    indices: indices,
-    count: count
-  };
+    return {
+        position: position,
+        normal,
+        uv: uv,
+        indices: indices,
+        count
+    };
 }
 
-var UP = new Vector3(0, 0, 1);
-var normalDir = new Vector3();
+const UP = new Vector3(0, 0, 1);
+const normalDir = new Vector3();
 function expandTubes(lines, options) {
-  options = Object.assign({}, {
-    radius: 1,
-    cornerSplit: 0,
-    radialSegments: 8,
-    startRad: -Math.PI / 4
-  }, options);
-  var results = lines.map(function (line) {
-    var points = line2Vectors(line);
-    var pathPointList = new PathPointList();
-    pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
-    var result = generateTubeVertexData(pathPointList, options);
-    result.line = line;
-    result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.indices);
-    result.uv = new Float32Array(result.uv);
-    result.normal = new Float32Array(result.normal);
+    options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, options);
+    const results = lines.map(line => {
+        const points = line2Vectors(line);
+        const pathPointList = new PathPointList();
+        //@ts-ignore
+        pathPointList.set(points, 0, options.cornerSplit, UP);
+        const result = generateTubeVertexData(pathPointList, options);
+        result.line = line;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    result.lines = lines;
     return result;
-  });
-  var result = merge(results);
-  result.lines = lines;
-  return result;
-} // Vertex Data Generate Functions
+}
+// Vertex Data Generate Functions
 // code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
-
 function generateTubeVertexData(pathPointList, options) {
-  var radius = Math.max(options.radius || 1, 0.00000001);
-  var progress = options.progress !== undefined ? options.progress : 1;
-  var radialSegments = Math.max(3, options.radialSegments || 8);
-  var startRad = options.startRad || 0;
-  var circum = radius * 2 * Math.PI;
-  var totalDistance = pathPointList.distance();
-  var progressDistance = progress * totalDistance;
-
-  if (progressDistance === 0) {
-    return null;
-  }
-
-  var count = 0; // modify data
-
-  var points = [];
-  var normal = [];
-  var uv = []; // const uv2 = [];
-
-  var indices = [];
-  var verticesCount = 0;
-  var pIndex = -1;
-  var nIndex = -1;
-  var uIndex = -1;
-  var iIndex = -1;
-
-  function addVertices(pathPoint, radius, radialSegments) {
-    var first = points.length === 0;
-    var uvDist = pathPoint.dist / circum; // const uvDist2 = pathPoint.dist / totalDistance;
-
-    for (var i = 0; i <= radialSegments; i++) {
-      var r = i;
-
-      if (r === radialSegments) {
-        r = 0;
-      }
-
-      normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
-      var scale = radius * pathPoint.widthScale;
-      points[++pIndex] = pathPoint.pos.x + normalDir.x * scale;
-      points[++pIndex] = pathPoint.pos.y + normalDir.y * scale;
-      points[++pIndex] = pathPoint.pos.z + normalDir.z * scale;
-      normal[++nIndex] = normalDir.x;
-      normal[++nIndex] = normalDir.y;
-      normal[++nIndex] = normalDir.z;
-      uv[++uIndex] = uvDist;
-      uv[++uIndex] = i / radialSegments; // uvs.push(uvDist, r / radialSegments);
-      // if (generateUv2) {
-      //     uv2.push(uvDist2, r / radialSegments);
-      // }
-
-      verticesCount++;
+    const radius = Math.max(options.radius || 1, 0.00000001);
+    const progress = options.progress !== undefined ? options.progress : 1;
+    const radialSegments = Math.max(3, options.radialSegments || 8);
+    const startRad = options.startRad || 0;
+    const circum = radius * 2 * Math.PI;
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+    if (progressDistance === 0) {
+        return null;
     }
-
-    if (!first) {
-      var begin1 = verticesCount - (radialSegments + 1) * 2;
-      var begin2 = verticesCount - (radialSegments + 1);
-
-      for (var _i = 0; _i < radialSegments; _i++) {
-        indices[++iIndex] = begin2 + _i;
-        indices[++iIndex] = begin1 + _i;
-        indices[++iIndex] = begin1 + _i + 1;
-        indices[++iIndex] = begin2 + _i;
-        indices[++iIndex] = begin1 + _i + 1;
-        indices[++iIndex] = begin2 + _i + 1; // index.push(
-        //     begin2 + i,
-        //     begin1 + i,
-        //     begin1 + i + 1,
-        //     begin2 + i,
-        //     begin1 + i + 1,
-        //     begin2 + i + 1
-        // );
-
-        count += 6;
-      }
+    let count = 0;
+    // modify data
+    const points = [];
+    const normal = [];
+    const uv = [];
+    // const uv2 = [];
+    const indices = [];
+    let verticesCount = 0;
+    let pIndex = -1;
+    let nIndex = -1;
+    let uIndex = -1;
+    let iIndex = -1;
+    function addVertices(pathPoint, radius, radialSegments) {
+        const first = points.length === 0;
+        const uvDist = pathPoint.dist / circum;
+        // const uvDist2 = pathPoint.dist / totalDistance;
+        for (let i = 0; i <= radialSegments; i++) {
+            let r = i;
+            if (r === radialSegments) {
+                r = 0;
+            }
+            normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
+            const scale = radius * pathPoint.widthScale;
+            points[++pIndex] = pathPoint.pos.x + normalDir.x * scale;
+            points[++pIndex] = pathPoint.pos.y + normalDir.y * scale;
+            points[++pIndex] = pathPoint.pos.z + normalDir.z * scale;
+            normal[++nIndex] = normalDir.x;
+            normal[++nIndex] = normalDir.y;
+            normal[++nIndex] = normalDir.z;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = i / radialSegments;
+            // uvs.push(uvDist, r / radialSegments);
+            // if (generateUv2) {
+            //     uv2.push(uvDist2, r / radialSegments);
+            // }
+            verticesCount++;
+        }
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments + 1) * 2;
+            const begin2 = verticesCount - (radialSegments + 1);
+            for (let i = 0; i < radialSegments; i++) {
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i + 1;
+                // index.push(
+                //     begin2 + i,
+                //     begin1 + i,
+                //     begin1 + i + 1,
+                //     begin2 + i,
+                //     begin1 + i + 1,
+                //     begin2 + i + 1
+                // );
+                count += 6;
+            }
+        }
     }
-  }
-
-  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];
-        var lastPoint = new PathPoint(); // linear lerp for progress
-
-        var alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
-        lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
-        addVertices(lastPoint, radius, radialSegments);
-        break;
-      } else {
-        addVertices(pathPoint, radius, radialSegments);
-      }
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                const lastPoint = new PathPoint();
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+                addVertices(lastPoint, radius, radialSegments);
+                break;
+            }
+            else {
+                addVertices(pathPoint, radius, radialSegments);
+            }
+        }
     }
-  }
-
-  return {
-    points: points,
-    normal: normal,
-    uv: uv,
-    // uv2,
-    indices: indices,
-    count: count
-  };
+    return {
+        points,
+        normal,
+        uv,
+        // uv2,
+        indices,
+        count
+    };
 }
 
 function plane(width, height, devideW, devideH) {
-  devideW = Math.max(1, devideW);
-  devideH = Math.max(1, devideH);
-  var dx = width / devideW,
-      dy = height / devideH;
-  var minX = -width / 2,
-      maxY = height / 2,
-      minY = -height / 2;
-  var len = (devideW + 1) * (devideH + 1);
-  var position = new Float32Array(len * 3),
-      uv = new Float32Array(len * 2),
-      normal = new Float32Array(len * 3),
-      indices = new Uint32Array(len * 10);
-  var index = 0,
-      uIndex = 0,
-      iIndex = 0;
-
-  for (var j = 0; j <= devideH; j++) {
-    for (var i = 0; i <= devideW; i++) {
-      var x = minX + dx * i;
-      var y = maxY - dy * j;
-      position[index] = x;
-      position[index + 1] = y;
-      position[index + 2] = 0;
-      normal[index] = 0;
-      normal[index + 1] = 0;
-      normal[index + 2] = 1; // position.push(x, y, 0);
-      // normal.push(0, 0, 1);
-
-      var uvx = (x - minX) / width,
-          uvy = (y - minY) / height; // uv.push(uvx, uvy);
-
-      uv[uIndex] = uvx;
-      uv[uIndex + 1] = uvy;
-      index += 3;
-      uIndex += 2;
-
-      if (i < devideW && j < devideH) {
-        var a = j * (devideW + 1) + i,
-            b = a + 1,
-            c = (devideW + 1) * (j + 1) + i,
-            d = c + 1;
-        indices[iIndex] = a;
-        indices[iIndex + 1] = c;
-        indices[iIndex + 2] = b;
-        indices[iIndex + 3] = c;
-        indices[iIndex + 4] = d;
-        indices[iIndex + 5] = b;
-        iIndex += 6; // indexs.push(a, c, b, c, d, b);
-      }
+    devideW = Math.max(1, devideW);
+    devideH = Math.max(1, devideH);
+    const dx = width / devideW, dy = height / devideH;
+    const minX = -width / 2, maxY = height / 2, minY = -height / 2;
+    const len = (devideW + 1) * (devideH + 1);
+    const position = new Float32Array(len * 3), uv = new Float32Array(len * 2), normal = new Float32Array(len * 3), indices = new Uint32Array(len * 10);
+    let index = 0, uIndex = 0, iIndex = 0;
+    for (let j = 0; j <= devideH; j++) {
+        for (let i = 0; i <= devideW; i++) {
+            const x = minX + dx * i;
+            const y = maxY - dy * j;
+            position[index] = x;
+            position[index + 1] = y;
+            position[index + 2] = 0;
+            normal[index] = 0;
+            normal[index + 1] = 0;
+            normal[index + 2] = 1;
+            // position.push(x, y, 0);
+            // normal.push(0, 0, 1);
+            const uvx = (x - minX) / width, uvy = (y - minY) / height;
+            // uv.push(uvx, uvy);
+            uv[uIndex] = uvx;
+            uv[uIndex + 1] = uvy;
+            index += 3;
+            uIndex += 2;
+            if (i < devideW && j < devideH) {
+                const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
+                indices[iIndex] = a;
+                indices[iIndex + 1] = c;
+                indices[iIndex + 2] = b;
+                indices[iIndex + 3] = c;
+                indices[iIndex + 4] = d;
+                indices[iIndex + 5] = b;
+                iIndex += 6;
+                // indexs.push(a, c, b, c, d, b);
+            }
+        }
     }
-  }
-
-  var indexArray = new Uint32Array(iIndex);
-
-  for (var _i = 0, _len = indexArray.length; _i < _len; _i++) {
-    indexArray[_i] = indices[_i];
-  } // for (let j = 0; j < devideH; j++) {
-  //     for (let i = 0; i < devideW; i++) {
-  //         const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
-  //         indexs.push(a, c, b, c, d, b);
-  //     }
-  // }
-
-
-  return {
-    position: position,
-    uv: uv,
-    normal: normal,
-    indices: indexArray
-  };
+    const indexArray = new Uint32Array(iIndex);
+    for (let i = 0, len = indexArray.length; i < len; i++) {
+        indexArray[i] = indices[i];
+    }
+    // for (let j = 0; j < devideH; j++) {
+    //     for (let i = 0; i < devideW; i++) {
+    //         const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
+    //         indexs.push(a, c, b, c, d, b);
+    //     }
+    // }
+    return {
+        position,
+        uv,
+        normal,
+        indices: indexArray
+    };
 }
 
 export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolylines, extrudeSlopes, leftOnLine, plane };
+//# sourceMappingURL=poly-extrude.mjs.map