poly-extrude 0.6.0 → 0.8.0

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.6.0
+ * poly-extrude v0.8.0
   */
 var earcut$2 = {exports: {}};
 
@@ -944,7 +944,9 @@ function generateSides$1(result, options) {
       index = result.index,
       polygon = result.polygon,
       uvs = result.uvs;
-  var z = options.depth;
+  var depth = options.depth;
+  var pIndex = points.length - 1;
+  var iIndex = index.length - 1;
 
   for (var i = 0, len = polygon.length; i < len; i++) {
     var ring = polygon[i];
@@ -962,15 +964,35 @@ function generateSides$1(result, options) {
       var idx = points.length / 3;
       var x1 = v1[0],
           y1 = v1[1],
+          z1 = v1[2] || 0,
           x2 = v2[0],
-          y2 = v2[1];
-      points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 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);
 
-      index.push(a, c, b, c, d, b); // index.push(c, d, b);
+      index[++iIndex] = a;
+      index[++iIndex] = c;
+      index[++iIndex] = b;
+      index[++iIndex] = c;
+      index[++iIndex] = d;
+      index[++iIndex] = b; // index.push(c, d, b);
 
       generateSideWallUV(uvs, points, a, b, c, d);
       j++;
@@ -1000,7 +1022,7 @@ function flatVertices(polygon, options) {
       uvs = [];
   var pOffset = count * 3,
       uOffset = count * 2;
-  var z = options.depth;
+  var depth = options.depth;
   var idx0 = 0,
       idx1 = 0,
       idx2 = 0;
@@ -1018,17 +1040,18 @@ function flatVertices(polygon, options) {
     while (j < len1) {
       var c = ring[j];
       var x = c[0],
-          y = c[1];
+          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] = z; // bottom vertices
+      points[idx1 + 2] = depth + z; // bottom vertices
 
       points[pOffset + idx1] = x;
       points[pOffset + idx1 + 1] = y;
-      points[pOffset + idx1 + 2] = 0;
+      points[pOffset + idx1 + 2] = z;
       uvs[idx2] = x;
       uvs[idx2 + 1] = y;
       uvs[uOffset + idx2] = x;
@@ -1633,8 +1656,980 @@ function cylinder(point, options) {
   };
 }
 
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+// code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Quaternion.js
+// import { clamp } from './MathUtils.js';
+var Quaternion = /*#__PURE__*/function (_Symbol$iterator) {
+  function Quaternion(x, y, z, w) {
+    if (x === void 0) {
+      x = 0;
+    }
+
+    if (y === void 0) {
+      y = 0;
+    }
+
+    if (z === void 0) {
+      z = 0;
+    }
+
+    if (w === void 0) {
+      w = 1;
+    }
+
+    this.isQuaternion = true;
+    this._x = x;
+    this._y = y;
+    this._z = z;
+    this._w = w;
+  }
+
+  Quaternion.slerpFlat = function slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
+    // fuzz-free, array-based Quaternion SLERP operation
+    var x0 = src0[srcOffset0 + 0],
+        y0 = src0[srcOffset0 + 1],
+        z0 = src0[srcOffset0 + 2],
+        w0 = src0[srcOffset0 + 3];
+    var x1 = src1[srcOffset1 + 0],
+        y1 = src1[srcOffset1 + 1],
+        z1 = src1[srcOffset1 + 2],
+        w1 = src1[srcOffset1 + 3];
+
+    if (t === 0) {
+      dst[dstOffset + 0] = x0;
+      dst[dstOffset + 1] = y0;
+      dst[dstOffset + 2] = z0;
+      dst[dstOffset + 3] = w0;
+      return;
+    }
+
+    if (t === 1) {
+      dst[dstOffset + 0] = x1;
+      dst[dstOffset + 1] = y1;
+      dst[dstOffset + 2] = z1;
+      dst[dstOffset + 3] = w1;
+      return;
+    }
+
+    if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
+      var s = 1 - t;
+      var cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
+          dir = cos >= 0 ? 1 : -1,
+          sqrSin = 1 - cos * cos; // Skip the Slerp for tiny steps to avoid numeric problems:
+
+      if (sqrSin > Number.EPSILON) {
+        var sin = Math.sqrt(sqrSin),
+            len = Math.atan2(sin, cos * dir);
+        s = Math.sin(s * len) / sin;
+        t = Math.sin(t * len) / sin;
+      }
+
+      var tDir = t * dir;
+      x0 = x0 * s + x1 * tDir;
+      y0 = y0 * s + y1 * tDir;
+      z0 = z0 * s + z1 * tDir;
+      w0 = w0 * s + w1 * tDir; // Normalize in case we just did a lerp:
+
+      if (s === 1 - t) {
+        var f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
+        x0 *= f;
+        y0 *= f;
+        z0 *= f;
+        w0 *= f;
+      }
+    }
+
+    dst[dstOffset] = x0;
+    dst[dstOffset + 1] = y0;
+    dst[dstOffset + 2] = z0;
+    dst[dstOffset + 3] = w0;
+  };
+
+  Quaternion.multiplyQuaternionsFlat = function multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
+    var x0 = src0[srcOffset0];
+    var y0 = src0[srcOffset0 + 1];
+    var z0 = src0[srcOffset0 + 2];
+    var w0 = src0[srcOffset0 + 3];
+    var x1 = src1[srcOffset1];
+    var y1 = src1[srcOffset1 + 1];
+    var z1 = src1[srcOffset1 + 2];
+    var w1 = src1[srcOffset1 + 3];
+    dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
+    dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
+    dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
+    dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
+    return dst;
+  };
+
+  var _proto = Quaternion.prototype;
+
+  _proto.set = function set(x, y, z, w) {
+    this._x = x;
+    this._y = y;
+    this._z = z;
+    this._w = w;
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.clone = function clone() {
+    return new this.constructor(this._x, this._y, this._z, this._w);
+  };
+
+  _proto.copy = function copy(quaternion) {
+    this._x = quaternion.x;
+    this._y = quaternion.y;
+    this._z = quaternion.z;
+    this._w = quaternion.w;
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.setFromEuler = function setFromEuler(euler, update) {
+    if (update === void 0) {
+      update = true;
+    }
+
+    var x = euler._x,
+        y = euler._y,
+        z = euler._z,
+        order = euler._order; // http://www.mathworks.com/matlabcentral/fileexchange/
+    // 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+    // content/SpinCalc.m
+
+    var cos = Math.cos;
+    var sin = Math.sin;
+    var c1 = cos(x / 2);
+    var c2 = cos(y / 2);
+    var c3 = cos(z / 2);
+    var s1 = sin(x / 2);
+    var s2 = sin(y / 2);
+    var s3 = sin(z / 2);
+
+    switch (order) {
+      case 'XYZ':
+        this._x = s1 * c2 * c3 + c1 * s2 * s3;
+        this._y = c1 * s2 * c3 - s1 * c2 * s3;
+        this._z = c1 * c2 * s3 + s1 * s2 * c3;
+        this._w = c1 * c2 * c3 - s1 * s2 * s3;
+        break;
+
+      case 'YXZ':
+        this._x = s1 * c2 * c3 + c1 * s2 * s3;
+        this._y = c1 * s2 * c3 - s1 * c2 * s3;
+        this._z = c1 * c2 * s3 - s1 * s2 * c3;
+        this._w = c1 * c2 * c3 + s1 * s2 * s3;
+        break;
+
+      case 'ZXY':
+        this._x = s1 * c2 * c3 - c1 * s2 * s3;
+        this._y = c1 * s2 * c3 + s1 * c2 * s3;
+        this._z = c1 * c2 * s3 + s1 * s2 * c3;
+        this._w = c1 * c2 * c3 - s1 * s2 * s3;
+        break;
+
+      case 'ZYX':
+        this._x = s1 * c2 * c3 - c1 * s2 * s3;
+        this._y = c1 * s2 * c3 + s1 * c2 * s3;
+        this._z = c1 * c2 * s3 - s1 * s2 * c3;
+        this._w = c1 * c2 * c3 + s1 * s2 * s3;
+        break;
+
+      case 'YZX':
+        this._x = s1 * c2 * c3 + c1 * s2 * s3;
+        this._y = c1 * s2 * c3 + s1 * c2 * s3;
+        this._z = c1 * c2 * s3 - s1 * s2 * c3;
+        this._w = c1 * c2 * c3 - s1 * s2 * s3;
+        break;
+
+      case 'XZY':
+        this._x = s1 * c2 * c3 - c1 * s2 * s3;
+        this._y = c1 * s2 * c3 - s1 * c2 * s3;
+        this._z = c1 * c2 * s3 + s1 * s2 * c3;
+        this._w = c1 * c2 * c3 + s1 * s2 * s3;
+        break;
+
+      default:
+        console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
+    }
+
+    if (update === true) this._onChangeCallback();
+    return this;
+  };
+
+  _proto.setFromAxisAngle = function setFromAxisAngle(axis, angle) {
+    // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+    // assumes axis is normalized
+    var halfAngle = angle / 2,
+        s = Math.sin(halfAngle);
+    this._x = axis.x * s;
+    this._y = axis.y * s;
+    this._z = axis.z * s;
+    this._w = Math.cos(halfAngle);
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.setFromRotationMatrix = function setFromRotationMatrix(m) {
+    // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+    // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+    var te = m.elements,
+        m11 = te[0],
+        m12 = te[4],
+        m13 = te[8],
+        m21 = te[1],
+        m22 = te[5],
+        m23 = te[9],
+        m31 = te[2],
+        m32 = te[6],
+        m33 = te[10],
+        trace = m11 + m22 + m33;
+
+    if (trace > 0) {
+      var s = 0.5 / Math.sqrt(trace + 1.0);
+      this._w = 0.25 / s;
+      this._x = (m32 - m23) * s;
+      this._y = (m13 - m31) * s;
+      this._z = (m21 - m12) * s;
+    } else if (m11 > m22 && m11 > m33) {
+      var _s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+
+      this._w = (m32 - m23) / _s;
+      this._x = 0.25 * _s;
+      this._y = (m12 + m21) / _s;
+      this._z = (m13 + m31) / _s;
+    } else if (m22 > m33) {
+      var _s2 = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+
+      this._w = (m13 - m31) / _s2;
+      this._x = (m12 + m21) / _s2;
+      this._y = 0.25 * _s2;
+      this._z = (m23 + m32) / _s2;
+    } else {
+      var _s3 = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+
+      this._w = (m21 - m12) / _s3;
+      this._x = (m13 + m31) / _s3;
+      this._y = (m23 + m32) / _s3;
+      this._z = 0.25 * _s3;
+    }
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.setFromUnitVectors = function setFromUnitVectors(vFrom, vTo) {
+    // assumes direction vectors vFrom and vTo are normalized
+    var r = vFrom.dot(vTo) + 1;
+
+    if (r < Number.EPSILON) {
+      // vFrom and vTo point in opposite directions
+      r = 0;
+
+      if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+        this._x = -vFrom.y;
+        this._y = vFrom.x;
+        this._z = 0;
+        this._w = r;
+      } else {
+        this._x = 0;
+        this._y = -vFrom.z;
+        this._z = vFrom.y;
+        this._w = r;
+      }
+    } else {
+      // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
+      this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+      this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+      this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+      this._w = r;
+    }
+
+    return this.normalize();
+  } // angleTo(q) {
+  //     return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1)));
+  // }
+  ;
+
+  _proto.rotateTowards = function rotateTowards(q, step) {
+    var angle = this.angleTo(q);
+    if (angle === 0) return this;
+    var t = Math.min(1, step / angle);
+    this.slerp(q, t);
+    return this;
+  };
+
+  _proto.identity = function identity() {
+    return this.set(0, 0, 0, 1);
+  };
+
+  _proto.invert = function invert() {
+    // quaternion is assumed to have unit length
+    return this.conjugate();
+  };
+
+  _proto.conjugate = function conjugate() {
+    this._x *= -1;
+    this._y *= -1;
+    this._z *= -1;
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.dot = function dot(v) {
+    return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+  };
+
+  _proto.lengthSq = function lengthSq() {
+    return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
+  };
+
+  _proto.length = function length() {
+    return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
+  };
+
+  _proto.normalize = function normalize() {
+    var l = this.length();
+
+    if (l === 0) {
+      this._x = 0;
+      this._y = 0;
+      this._z = 0;
+      this._w = 1;
+    } else {
+      l = 1 / l;
+      this._x = this._x * l;
+      this._y = this._y * l;
+      this._z = this._z * l;
+      this._w = this._w * l;
+    }
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.multiply = function multiply(q) {
+    return this.multiplyQuaternions(this, q);
+  };
+
+  _proto.premultiply = function premultiply(q) {
+    return this.multiplyQuaternions(q, this);
+  };
+
+  _proto.multiplyQuaternions = function multiplyQuaternions(a, b) {
+    // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+    var qax = a._x,
+        qay = a._y,
+        qaz = a._z,
+        qaw = a._w;
+    var qbx = b._x,
+        qby = b._y,
+        qbz = b._z,
+        qbw = b._w;
+    this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+    this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+    this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+    this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.slerp = function slerp(qb, t) {
+    if (t === 0) return this;
+    if (t === 1) return this.copy(qb);
+    var x = this._x,
+        y = this._y,
+        z = this._z,
+        w = this._w; // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+
+    var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
+
+    if (cosHalfTheta < 0) {
+      this._w = -qb._w;
+      this._x = -qb._x;
+      this._y = -qb._y;
+      this._z = -qb._z;
+      cosHalfTheta = -cosHalfTheta;
+    } else {
+      this.copy(qb);
+    }
+
+    if (cosHalfTheta >= 1.0) {
+      this._w = w;
+      this._x = x;
+      this._y = y;
+      this._z = z;
+      return this;
+    }
+
+    var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
+
+    if (sqrSinHalfTheta <= Number.EPSILON) {
+      var s = 1 - t;
+      this._w = s * w + t * this._w;
+      this._x = s * x + t * this._x;
+      this._y = s * y + t * this._y;
+      this._z = s * z + t * this._z;
+      this.normalize(); // normalize calls _onChangeCallback()
+
+      return this;
+    }
+
+    var sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+    var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+    var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
+        ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+    this._w = w * ratioA + this._w * ratioB;
+    this._x = x * ratioA + this._x * ratioB;
+    this._y = y * ratioA + this._y * ratioB;
+    this._z = z * ratioA + this._z * ratioB;
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.slerpQuaternions = function slerpQuaternions(qa, qb, t) {
+    return this.copy(qa).slerp(qb, t);
+  };
+
+  _proto.random = function random() {
+    // sets this quaternion to a uniform random unit quaternnion
+    // Ken Shoemake
+    // Uniform random rotations
+    // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
+    var theta1 = 2 * Math.PI * Math.random();
+    var theta2 = 2 * Math.PI * Math.random();
+    var x0 = Math.random();
+    var r1 = Math.sqrt(1 - x0);
+    var r2 = Math.sqrt(x0);
+    return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
+  };
+
+  _proto.equals = function equals(quaternion) {
+    return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
+  };
+
+  _proto.fromArray = function fromArray(array, offset) {
+    if (offset === void 0) {
+      offset = 0;
+    }
+
+    this._x = array[offset];
+    this._y = array[offset + 1];
+    this._z = array[offset + 2];
+    this._w = array[offset + 3];
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.toArray = function toArray(array, offset) {
+    if (array === void 0) {
+      array = [];
+    }
+
+    if (offset === void 0) {
+      offset = 0;
+    }
+
+    array[offset] = this._x;
+    array[offset + 1] = this._y;
+    array[offset + 2] = this._z;
+    array[offset + 3] = this._w;
+    return array;
+  };
+
+  _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index) {
+    this._x = attribute.getX(index);
+    this._y = attribute.getY(index);
+    this._z = attribute.getZ(index);
+    this._w = attribute.getW(index);
+
+    this._onChangeCallback();
+
+    return this;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.toArray();
+  };
+
+  _proto._onChange = function _onChange(callback) {
+    this._onChangeCallback = callback;
+    return this;
+  };
+
+  _proto._onChangeCallback = function _onChangeCallback() {};
+
+  _proto[_Symbol$iterator] = /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return this._x;
+
+          case 2:
+            _context.next = 4;
+            return this._y;
+
+          case 4:
+            _context.next = 6;
+            return this._z;
+
+          case 6:
+            _context.next = 8;
+            return this._w;
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, this);
+  });
+
+  _createClass(Quaternion, [{
+    key: "x",
+    get: function get() {
+      return this._x;
+    },
+    set: function set(value) {
+      this._x = value;
+
+      this._onChangeCallback();
+    }
+  }, {
+    key: "y",
+    get: function get() {
+      return this._y;
+    },
+    set: function set(value) {
+      this._y = value;
+
+      this._onChangeCallback();
+    }
+  }, {
+    key: "z",
+    get: function get() {
+      return this._z;
+    },
+    set: function set(value) {
+      this._z = value;
+
+      this._onChangeCallback();
+    }
+  }, {
+    key: "w",
+    get: function get() {
+      return this._w;
+    },
+    set: function set(value) {
+      this._w = value;
+
+      this._onChangeCallback();
+    }
+  }]);
+
+  return Quaternion;
+}(Symbol.iterator);
+
 // import * as MathUtils from './MathUtils.js';
-// code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js
+
+var _quaternion = new Quaternion();
+
 var Vector3 = /*#__PURE__*/function () {
   function Vector3(x, y, z) {
     if (x === void 0) {
@@ -1782,10 +2777,11 @@ var Vector3 = /*#__PURE__*/function () {
   } // applyEuler(euler) {
   //     return this.applyQuaternion(_quaternion.setFromEuler(euler));
   // }
-  // applyAxisAngle(axis, angle) {
-  //     return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
-  // }
-  // applyMatrix3(m) {
+  ;
+
+  _proto.applyAxisAngle = function applyAxisAngle(axis, angle) {
+    return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
+  } // applyMatrix3(m) {
   //     const x = this.x, y = this.y, z = this.z;
   //     const e = m.elements;
   //     this.x = e[0] * x + e[3] * y + e[6] * z;
@@ -1808,21 +2804,27 @@ var Vector3 = /*#__PURE__*/function () {
     this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
     this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
     return this;
-  } // applyQuaternion(q) {
-  //     const x = this.x, y = this.y, z = this.z;
-  //     const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
-  //     // calculate quat * vector
-  //     const ix = qw * x + qy * z - qz * y;
-  //     const iy = qw * y + qz * x - qx * z;
-  //     const iz = qw * z + qx * y - qy * x;
-  //     const iw = - qx * x - qy * y - qz * z;
-  //     // calculate result * inverse quat
-  //     this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
-  //     this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
-  //     this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
-  //     return this;
-  // }
-  // project(camera) {
+  };
+
+  _proto.applyQuaternion = function applyQuaternion(q) {
+    var x = this.x,
+        y = this.y,
+        z = this.z;
+    var qx = q.x,
+        qy = q.y,
+        qz = q.z,
+        qw = q.w; // calculate quat * vector
+
+    var ix = qw * x + qy * z - qz * y;
+    var iy = qw * y + qz * x - qx * z;
+    var iz = qw * z + qx * y - qy * x;
+    var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat
+
+    this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+    this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+    this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+    return this;
+  } // project(camera) {
   //     return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
   // }
   // unproject(camera) {
@@ -2753,21 +3755,6 @@ var Matrix4 = /*#__PURE__*/function () {
   return Matrix4;
 }(); // const _v1 = new Vector3();
 
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-
-  _setPrototypeOf(subClass, superClass);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
-}
-
 // code copy from https://github.com/mrdoob/three.js/blob/dev/src/extras/core/Curve.js
 // import * as MathUtils from '../../math/MathUtils.js';
 // import { Vector2 } from '../../math/Vector2.js';
@@ -3410,7 +4397,7 @@ var PathPointList = /*#__PURE__*/function () {
   return PathPointList;
 }();
 
-var UP = new Vector3(0, 0, 1);
+var UP$1 = new Vector3(0, 0, 1);
 function expandPaths(lines, options) {
   options = Object.assign({}, {
     lineWidth: 1,
@@ -3425,7 +4412,7 @@ function expandPaths(lines, options) {
       return new Vector3(x, y, z || 0);
     });
     var pathPointList = new PathPointList();
-    pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+    pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
     var result = generatePathVertexData(pathPointList, options);
     result.line = line;
     result.position = new Float32Array(result.points);
@@ -3602,4 +4589,142 @@ function generatePathVertexData(pathPointList, options) {
   };
 }
 
-export { cylinder, expandLine, expandPaths, extrudePolygons, extrudePolylines, extrudeSlopes, leftOnLine };
+var UP = new Vector3(0, 0, 1);
+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 = line.map(function (p) {
+      var x = p[0],
+          y = p[1],
+          z = p[2];
+      return new Vector3(x, y, z || 0);
+    });
+    var pathPointList = new PathPointList();
+    pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+    var result = generateTubeVertexData(pathPointList, options);
+    result.line = line;
+    result.position = new Float32Array(result.points);
+    result.indices = new Uint32Array(result.index);
+    result.uv = new Float32Array(result.uvs);
+    result.normal = new Float32Array(result.normal);
+    return result;
+  });
+  var result = merge(results);
+  result.lines = lines;
+  return result;
+} // Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+
+function 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 uvs = []; // const uv2 = [];
+
+  var index = [];
+  var verticesCount = 0;
+  var normalDir = new Vector3();
+  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;
+      uvs[++uIndex] = uvDist;
+      uvs[++uIndex] = i / radialSegments; // uvs.push(uvDist, r / radialSegments);
+      // if (generateUv2) {
+      //     uv2.push(uvDist2, r / radialSegments);
+      // }
+
+      verticesCount++;
+    }
+
+    if (!first) {
+      var begin1 = verticesCount - (radialSegments + 1) * 2;
+      var begin2 = verticesCount - (radialSegments + 1);
+
+      for (var _i = 0; _i < radialSegments; _i++) {
+        index[++iIndex] = begin2 + _i;
+        index[++iIndex] = begin1 + _i;
+        index[++iIndex] = begin1 + _i + 1;
+        index[++iIndex] = begin2 + _i;
+        index[++iIndex] = begin1 + _i + 1;
+        index[++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);
+      }
+    }
+  }
+
+  return {
+    points: points,
+    normal: normal,
+    uvs: uvs,
+    // uv2,
+    index: index,
+    count: count
+  };
+}
+
+export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolylines, extrudeSlopes, leftOnLine };