poly-extrude 0.6.0 → 0.7.0

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.6.0
+ * poly-extrude v0.7.0
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -1639,8 +1639,980 @@
       };
     }
 
+    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) {
@@ -1788,10 +2760,11 @@
       } // 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;
@@ -1814,21 +2787,27 @@
         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) {
@@ -2759,21 +3738,6 @@
       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';
@@ -3416,7 +4380,7 @@
       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,
@@ -3431,7 +4395,7 @@
           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);
@@ -3608,9 +4572,148 @@
       };
     }
 
+    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
+      };
+    }
+
     exports.cylinder = cylinder;
     exports.expandLine = expandLine;
     exports.expandPaths = expandPaths;
+    exports.expandTubes = expandTubes;
     exports.extrudePolygons = extrudePolygons;
     exports.extrudePolylines = extrudePolylines;
     exports.extrudeSlopes = extrudeSlopes;