@math.gl/core 3.5.3 → 3.6.0-alpha.1

package/dist/es5/classes/euler.js

@@ -7,32 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
 var _mathArray = _interopRequireDefault(require("./base/math-array"));
 
 var _common = require("../lib/common");
 
 var _validators = require("../lib/validators");
 
-var _quaternion2 = _interopRequireDefault(require("./quaternion"));
+var _quaternion = _interopRequireDefault(require("./quaternion"));
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-var ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
-var ALMOST_ONE = 0.99999;
+const ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
+const ALMOST_ONE = 0.99999;
 
 function validateOrder(value) {
   return value >= 0 && value < 6;
@@ -46,595 +30,530 @@ function checkOrder(value) {
   return value;
 }
 
-var Euler = function (_MathArray) {
-  (0, _inherits2.default)(Euler, _MathArray);
+class Euler extends _mathArray.default {
+  static get ZYX() {
+    return 0;
+  }
 
-  var _super = _createSuper(Euler);
+  static get YXZ() {
+    return 1;
+  }
 
-  function Euler() {
-    var _this;
+  static get XZY() {
+    return 2;
+  }
 
-    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    var order = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Euler.DefaultOrder;
-    (0, _classCallCheck2.default)(this, Euler);
-    _this = _super.call(this, -0, -0, -0, -0);
+  static get ZXY() {
+    return 3;
+  }
 
-    if (arguments.length > 0 && Array.isArray(arguments[0])) {
-      var _this2;
+  static get YZX() {
+    return 4;
+  }
+
+  static get XYZ() {
+    return 5;
+  }
+
+  static get RollPitchYaw() {
+    return 0;
+  }
 
-      (_this2 = _this).fromVector3.apply(_this2, arguments);
+  static get DefaultOrder() {
+    return Euler.ZYX;
+  }
+
+  static get RotationOrders() {
+    return ['ZYX', 'YXZ', 'XZY', 'ZXY', 'YZX', 'XYZ'];
+  }
+
+  static rotationOrder(order) {
+    return Euler.RotationOrders[order];
+  }
+
+  get ELEMENTS() {
+    return 4;
+  }
+
+  constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
+    super(-0, -0, -0, -0);
+
+    if (arguments.length > 0 && Array.isArray(arguments[0])) {
+      this.fromVector3(...arguments);
     } else {
-      _this.set(x, y, z, order);
+      this.set(x, y, z, order);
     }
+  }
 
-    return _this;
+  fromQuaternion(quaternion) {
+    const [x, y, z, w] = quaternion;
+    const ysqr = y * y;
+    const t0 = -2.0 * (ysqr + z * z) + 1.0;
+    const t1 = +2.0 * (x * y + w * z);
+    let t2 = -2.0 * (x * z - w * y);
+    const t3 = +2.0 * (y * z + w * x);
+    const t4 = -2.0 * (x * x + ysqr) + 1.0;
+    t2 = t2 > 1.0 ? 1.0 : t2;
+    t2 = t2 < -1.0 ? -1.0 : t2;
+    const roll = Math.atan2(t3, t4);
+    const pitch = Math.asin(t2);
+    const yaw = Math.atan2(t1, t0);
+    return new Euler(roll, pitch, yaw, Euler.RollPitchYaw);
   }
 
-  (0, _createClass2.default)(Euler, [{
-    key: "ELEMENTS",
-    get: function get() {
-      return 4;
-    }
-  }, {
-    key: "fromQuaternion",
-    value: function fromQuaternion(quaternion) {
-      var _quaternion = (0, _slicedToArray2.default)(quaternion, 4),
-          x = _quaternion[0],
-          y = _quaternion[1],
-          z = _quaternion[2],
-          w = _quaternion[3];
-
-      var ysqr = y * y;
-      var t0 = -2.0 * (ysqr + z * z) + 1.0;
-      var t1 = +2.0 * (x * y + w * z);
-      var t2 = -2.0 * (x * z - w * y);
-      var t3 = +2.0 * (y * z + w * x);
-      var t4 = -2.0 * (x * x + ysqr) + 1.0;
-      t2 = t2 > 1.0 ? 1.0 : t2;
-      t2 = t2 < -1.0 ? -1.0 : t2;
-      var roll = Math.atan2(t3, t4);
-      var pitch = Math.asin(t2);
-      var yaw = Math.atan2(t1, t0);
-      return new Euler(roll, pitch, yaw, Euler.RollPitchYaw);
-    }
-  }, {
-    key: "copy",
-    value: function copy(array) {
-      this[0] = array[0];
-      this[1] = array[1];
-      this[2] = array[2];
-      this[3] = Number.isFinite(array[3]) || this.order;
-      return this.check();
-    }
-  }, {
-    key: "set",
-    value: function set() {
-      var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-      var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-      var order = arguments.length > 3 ? arguments[3] : undefined;
-      this[0] = x;
-      this[1] = y;
-      this[2] = z;
-      this[3] = Number.isFinite(order) ? order : this[3];
-      return this.check();
-    }
-  }, {
-    key: "validate",
-    value: function validate() {
-      return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
-    }
-  }, {
-    key: "toArray",
-    value: function toArray() {
-      var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      array[offset] = this[0];
-      array[offset + 1] = this[1];
-      array[offset + 2] = this[2];
-      return array;
-    }
-  }, {
-    key: "toArray4",
-    value: function toArray4() {
-      var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      array[offset] = this[0];
-      array[offset + 1] = this[1];
-      array[offset + 2] = this[2];
-      array[offset + 3] = this[3];
-      return array;
-    }
-  }, {
-    key: "toVector3",
-    value: function toVector3() {
-      var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [-0, -0, -0];
-      result[0] = this[0];
-      result[1] = this[1];
-      result[2] = this[2];
-      return result;
-    }
-  }, {
-    key: "x",
-    get: function get() {
-      return this[0];
-    },
-    set: function set(value) {
-      this[0] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "y",
-    get: function get() {
-      return this[1];
-    },
-    set: function set(value) {
-      this[1] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "z",
-    get: function get() {
-      return this[2];
-    },
-    set: function set(value) {
-      this[2] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "alpha",
-    get: function get() {
-      return this[0];
-    },
-    set: function set(value) {
-      this[0] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "beta",
-    get: function get() {
-      return this[1];
-    },
-    set: function set(value) {
-      this[1] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "gamma",
-    get: function get() {
-      return this[2];
-    },
-    set: function set(value) {
-      this[2] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "phi",
-    get: function get() {
-      return this[0];
-    },
-    set: function set(value) {
-      this[0] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "theta",
-    get: function get() {
-      return this[1];
-    },
-    set: function set(value) {
-      this[1] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "psi",
-    get: function get() {
-      return this[2];
-    },
-    set: function set(value) {
-      this[2] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "roll",
-    get: function get() {
-      return this[0];
-    },
-    set: function set(value) {
-      this[0] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "pitch",
-    get: function get() {
-      return this[1];
-    },
-    set: function set(value) {
-      this[1] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "yaw",
-    get: function get() {
-      return this[2];
-    },
-    set: function set(value) {
-      this[2] = (0, _validators.checkNumber)(value);
-    }
-  }, {
-    key: "order",
-    get: function get() {
-      return this[3];
-    },
-    set: function set(value) {
-      this[3] = checkOrder(value);
-    }
-  }, {
-    key: "fromVector3",
-    value: function fromVector3(v, order) {
-      return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
-    }
-  }, {
-    key: "fromArray",
-    value: function fromArray(array) {
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      this[0] = array[0 + offset];
-      this[1] = array[1 + offset];
-      this[2] = array[2 + offset];
-
-      if (array[3] !== undefined) {
-        this[3] = array[3];
-      }
-
-      return this.check();
-    }
-  }, {
-    key: "fromRollPitchYaw",
-    value: function fromRollPitchYaw(roll, pitch, yaw) {
-      return this.set(roll, pitch, yaw, Euler.ZYX);
-    }
-  }, {
-    key: "fromRotationMatrix",
-    value: function fromRotationMatrix(m) {
-      var order = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Euler.DefaultOrder;
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = Number.isFinite(array[3]) || this.order;
+    return this.check();
+  }
 
-      this._fromRotationMatrix(m, order);
+  set(x = 0, y = 0, z = 0, order) {
+    this[0] = x;
+    this[1] = y;
+    this[2] = z;
+    this[3] = Number.isFinite(order) ? order : this[3];
+    return this.check();
+  }
 
-      return this.check();
-    }
-  }, {
-    key: "getRotationMatrix",
-    value: function getRotationMatrix(m) {
-      return this._getRotationMatrix(m);
+  validate() {
+    return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
+  }
+
+  toArray(array = [], offset = 0) {
+    array[offset] = this[0];
+    array[offset + 1] = this[1];
+    array[offset + 2] = this[2];
+    return array;
+  }
+
+  toArray4(array = [], offset = 0) {
+    array[offset] = this[0];
+    array[offset + 1] = this[1];
+    array[offset + 2] = this[2];
+    array[offset + 3] = this[3];
+    return array;
+  }
+
+  toVector3(result = [-0, -0, -0]) {
+    result[0] = this[0];
+    result[1] = this[1];
+    result[2] = this[2];
+    return result;
+  }
+
+  get x() {
+    return this[0];
+  }
+
+  set x(value) {
+    this[0] = (0, _validators.checkNumber)(value);
+  }
+
+  get y() {
+    return this[1];
+  }
+
+  set y(value) {
+    this[1] = (0, _validators.checkNumber)(value);
+  }
+
+  get z() {
+    return this[2];
+  }
+
+  set z(value) {
+    this[2] = (0, _validators.checkNumber)(value);
+  }
+
+  get alpha() {
+    return this[0];
+  }
+
+  set alpha(value) {
+    this[0] = (0, _validators.checkNumber)(value);
+  }
+
+  get beta() {
+    return this[1];
+  }
+
+  set beta(value) {
+    this[1] = (0, _validators.checkNumber)(value);
+  }
+
+  get gamma() {
+    return this[2];
+  }
+
+  set gamma(value) {
+    this[2] = (0, _validators.checkNumber)(value);
+  }
+
+  get phi() {
+    return this[0];
+  }
+
+  set phi(value) {
+    this[0] = (0, _validators.checkNumber)(value);
+  }
+
+  get theta() {
+    return this[1];
+  }
+
+  set theta(value) {
+    this[1] = (0, _validators.checkNumber)(value);
+  }
+
+  get psi() {
+    return this[2];
+  }
+
+  set psi(value) {
+    this[2] = (0, _validators.checkNumber)(value);
+  }
+
+  get roll() {
+    return this[0];
+  }
+
+  set roll(value) {
+    this[0] = (0, _validators.checkNumber)(value);
+  }
+
+  get pitch() {
+    return this[1];
+  }
+
+  set pitch(value) {
+    this[1] = (0, _validators.checkNumber)(value);
+  }
+
+  get yaw() {
+    return this[2];
+  }
+
+  set yaw(value) {
+    this[2] = (0, _validators.checkNumber)(value);
+  }
+
+  get order() {
+    return this[3];
+  }
+
+  set order(value) {
+    this[3] = checkOrder(value);
+  }
+
+  fromVector3(v, order) {
+    return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
+  }
+
+  fromArray(array, offset = 0) {
+    this[0] = array[0 + offset];
+    this[1] = array[1 + offset];
+    this[2] = array[2 + offset];
+
+    if (array[3] !== undefined) {
+      this[3] = array[3];
     }
-  }, {
-    key: "getQuaternion",
-    value: function getQuaternion() {
-      var q = new _quaternion2.default();
 
-      switch (this[4]) {
-        case Euler.XYZ:
-          return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
+    return this.check();
+  }
+
+  fromRollPitchYaw(roll, pitch, yaw) {
+    return this.set(roll, pitch, yaw, Euler.ZYX);
+  }
+
+  fromRotationMatrix(m, order = Euler.DefaultOrder) {
+    this._fromRotationMatrix(m, order);
+
+    return this.check();
+  }
+
+  getRotationMatrix(m) {
+    return this._getRotationMatrix(m);
+  }
 
-        case Euler.YXZ:
-          return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
+  getQuaternion() {
+    const q = new _quaternion.default();
 
-        case Euler.ZXY:
-          return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
+    switch (this[3]) {
+      case Euler.XYZ:
+        return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
 
-        case Euler.ZYX:
-          return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
+      case Euler.YXZ:
+        return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
 
-        case Euler.YZX:
-          return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
+      case Euler.ZXY:
+        return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
 
-        case Euler.XZY:
-          return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
+      case Euler.ZYX:
+        return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
 
-        default:
-          throw new Error(ERR_UNKNOWN_ORDER);
-      }
+      case Euler.YZX:
+        return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
+
+      case Euler.XZY:
+        return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
+
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
     }
-  }, {
-    key: "_fromRotationMatrix",
-    value: function _fromRotationMatrix(m) {
-      var order = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Euler.DefaultOrder;
-      var te = m.elements;
-      var m11 = te[0],
+  }
+
+  _fromRotationMatrix(m, order = Euler.DefaultOrder) {
+    const te = m.elements;
+    const m11 = te[0],
           m12 = te[4],
           m13 = te[8];
-      var m21 = te[1],
+    const m21 = te[1],
           m22 = te[5],
           m23 = te[9];
-      var m31 = te[2],
+    const m31 = te[2],
           m32 = te[6],
           m33 = te[10];
-      order = order || this[3];
+    order = order || this[3];
 
-      switch (order) {
-        case Euler.XYZ:
-          this[1] = Math.asin((0, _common.clamp)(m13, -1, 1));
+    switch (order) {
+      case Euler.XYZ:
+        this[1] = Math.asin((0, _common.clamp)(m13, -1, 1));
 
-          if (Math.abs(m13) < ALMOST_ONE) {
-            this[0] = Math.atan2(-m23, m33);
-            this[2] = Math.atan2(-m12, m11);
-          } else {
-            this[0] = Math.atan2(m32, m22);
-            this[2] = 0;
-          }
+        if (Math.abs(m13) < ALMOST_ONE) {
+          this[0] = Math.atan2(-m23, m33);
+          this[2] = Math.atan2(-m12, m11);
+        } else {
+          this[0] = Math.atan2(m32, m22);
+          this[2] = 0;
+        }
 
-          break;
+        break;
 
-        case Euler.YXZ:
-          this[0] = Math.asin(-(0, _common.clamp)(m23, -1, 1));
+      case Euler.YXZ:
+        this[0] = Math.asin(-(0, _common.clamp)(m23, -1, 1));
 
-          if (Math.abs(m23) < ALMOST_ONE) {
-            this[1] = Math.atan2(m13, m33);
-            this[2] = Math.atan2(m21, m22);
-          } else {
-            this[1] = Math.atan2(-m31, m11);
-            this[2] = 0;
-          }
+        if (Math.abs(m23) < ALMOST_ONE) {
+          this[1] = Math.atan2(m13, m33);
+          this[2] = Math.atan2(m21, m22);
+        } else {
+          this[1] = Math.atan2(-m31, m11);
+          this[2] = 0;
+        }
 
-          break;
+        break;
 
-        case Euler.ZXY:
-          this[0] = Math.asin((0, _common.clamp)(m32, -1, 1));
+      case Euler.ZXY:
+        this[0] = Math.asin((0, _common.clamp)(m32, -1, 1));
 
-          if (Math.abs(m32) < ALMOST_ONE) {
-            this[1] = Math.atan2(-m31, m33);
-            this[2] = Math.atan2(-m12, m22);
-          } else {
-            this[1] = 0;
-            this[2] = Math.atan2(m21, m11);
-          }
+        if (Math.abs(m32) < ALMOST_ONE) {
+          this[1] = Math.atan2(-m31, m33);
+          this[2] = Math.atan2(-m12, m22);
+        } else {
+          this[1] = 0;
+          this[2] = Math.atan2(m21, m11);
+        }
 
-          break;
+        break;
 
-        case Euler.ZYX:
-          this[1] = Math.asin(-(0, _common.clamp)(m31, -1, 1));
+      case Euler.ZYX:
+        this[1] = Math.asin(-(0, _common.clamp)(m31, -1, 1));
 
-          if (Math.abs(m31) < ALMOST_ONE) {
-            this[0] = Math.atan2(m32, m33);
-            this[2] = Math.atan2(m21, m11);
-          } else {
-            this[0] = 0;
-            this[2] = Math.atan2(-m12, m22);
-          }
+        if (Math.abs(m31) < ALMOST_ONE) {
+          this[0] = Math.atan2(m32, m33);
+          this[2] = Math.atan2(m21, m11);
+        } else {
+          this[0] = 0;
+          this[2] = Math.atan2(-m12, m22);
+        }
 
-          break;
+        break;
 
-        case Euler.YZX:
-          this[2] = Math.asin((0, _common.clamp)(m21, -1, 1));
+      case Euler.YZX:
+        this[2] = Math.asin((0, _common.clamp)(m21, -1, 1));
 
-          if (Math.abs(m21) < ALMOST_ONE) {
-            this[0] = Math.atan2(-m23, m22);
-            this[1] = Math.atan2(-m31, m11);
-          } else {
-            this[0] = 0;
-            this[1] = Math.atan2(m13, m33);
-          }
+        if (Math.abs(m21) < ALMOST_ONE) {
+          this[0] = Math.atan2(-m23, m22);
+          this[1] = Math.atan2(-m31, m11);
+        } else {
+          this[0] = 0;
+          this[1] = Math.atan2(m13, m33);
+        }
 
-          break;
-
-        case Euler.XZY:
-          this[2] = Math.asin(-(0, _common.clamp)(m12, -1, 1));
+        break;
 
-          if (Math.abs(m12) < ALMOST_ONE) {
-            this[0] = Math.atan2(m32, m22);
-            this[1] = Math.atan2(m13, m11);
-          } else {
-            this[0] = Math.atan2(-m23, m33);
-            this[1] = 0;
-          }
+      case Euler.XZY:
+        this[2] = Math.asin(-(0, _common.clamp)(m12, -1, 1));
 
-          break;
+        if (Math.abs(m12) < ALMOST_ONE) {
+          this[0] = Math.atan2(m32, m22);
+          this[1] = Math.atan2(m13, m11);
+        } else {
+          this[0] = Math.atan2(-m23, m33);
+          this[1] = 0;
+        }
 
-        default:
-          throw new Error(ERR_UNKNOWN_ORDER);
-      }
+        break;
 
-      this[3] = order;
-      return this;
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
     }
-  }, {
-    key: "_getRotationMatrix",
-    value: function _getRotationMatrix(result) {
-      var te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
-      var x = this.x,
+
+    this[3] = order;
+    return this;
+  }
+
+  _getRotationMatrix(result) {
+    const te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+    const x = this.x,
           y = this.y,
           z = this.z;
-      var a = Math.cos(x);
-      var c = Math.cos(y);
-      var e = Math.cos(z);
-      var b = Math.sin(x);
-      var d = Math.sin(y);
-      var f = Math.sin(z);
-
-      switch (this[3]) {
-        case Euler.XYZ:
-          {
-            var ae = a * e,
+    const a = Math.cos(x);
+    const c = Math.cos(y);
+    const e = Math.cos(z);
+    const b = Math.sin(x);
+    const d = Math.sin(y);
+    const f = Math.sin(z);
+
+    switch (this[3]) {
+      case Euler.XYZ:
+        {
+          const ae = a * e,
                 af = a * f,
                 be = b * e,
                 bf = b * f;
-            te[0] = c * e;
-            te[4] = -c * f;
-            te[8] = d;
-            te[1] = af + be * d;
-            te[5] = ae - bf * d;
-            te[9] = -b * c;
-            te[2] = bf - ae * d;
-            te[6] = be + af * d;
-            te[10] = a * c;
-            break;
-          }
-
-        case Euler.YXZ:
-          {
-            var ce = c * e,
+          te[0] = c * e;
+          te[4] = -c * f;
+          te[8] = d;
+          te[1] = af + be * d;
+          te[5] = ae - bf * d;
+          te[9] = -b * c;
+          te[2] = bf - ae * d;
+          te[6] = be + af * d;
+          te[10] = a * c;
+          break;
+        }
+
+      case Euler.YXZ:
+        {
+          const ce = c * e,
+                cf = c * f,
+                de = d * e,
+                df = d * f;
+          te[0] = ce + df * b;
+          te[4] = de * b - cf;
+          te[8] = a * d;
+          te[1] = a * f;
+          te[5] = a * e;
+          te[9] = -b;
+          te[2] = cf * b - de;
+          te[6] = df + ce * b;
+          te[10] = a * c;
+          break;
+        }
+
+      case Euler.ZXY:
+        {
+          const ce = c * e,
                 cf = c * f,
                 de = d * e,
                 df = d * f;
-            te[0] = ce + df * b;
-            te[4] = de * b - cf;
-            te[8] = a * d;
-            te[1] = a * f;
-            te[5] = a * e;
-            te[9] = -b;
-            te[2] = cf * b - de;
-            te[6] = df + ce * b;
-            te[10] = a * c;
-            break;
-          }
-
-        case Euler.ZXY:
-          {
-            var _ce = c * e,
-                _cf = c * f,
-                _de = d * e,
-                _df = d * f;
-
-            te[0] = _ce - _df * b;
-            te[4] = -a * f;
-            te[8] = _de + _cf * b;
-            te[1] = _cf + _de * b;
-            te[5] = a * e;
-            te[9] = _df - _ce * b;
-            te[2] = -a * d;
-            te[6] = b;
-            te[10] = a * c;
-            break;
-          }
-
-        case Euler.ZYX:
-          {
-            var _ae = a * e,
-                _af = a * f,
-                _be = b * e,
-                _bf = b * f;
-
-            te[0] = c * e;
-            te[4] = _be * d - _af;
-            te[8] = _ae * d + _bf;
-            te[1] = c * f;
-            te[5] = _bf * d + _ae;
-            te[9] = _af * d - _be;
-            te[2] = -d;
-            te[6] = b * c;
-            te[10] = a * c;
-            break;
-          }
-
-        case Euler.YZX:
-          {
-            var ac = a * c,
+          te[0] = ce - df * b;
+          te[4] = -a * f;
+          te[8] = de + cf * b;
+          te[1] = cf + de * b;
+          te[5] = a * e;
+          te[9] = df - ce * b;
+          te[2] = -a * d;
+          te[6] = b;
+          te[10] = a * c;
+          break;
+        }
+
+      case Euler.ZYX:
+        {
+          const ae = a * e,
+                af = a * f,
+                be = b * e,
+                bf = b * f;
+          te[0] = c * e;
+          te[4] = be * d - af;
+          te[8] = ae * d + bf;
+          te[1] = c * f;
+          te[5] = bf * d + ae;
+          te[9] = af * d - be;
+          te[2] = -d;
+          te[6] = b * c;
+          te[10] = a * c;
+          break;
+        }
+
+      case Euler.YZX:
+        {
+          const ac = a * c,
                 ad = a * d,
                 bc = b * c,
                 bd = b * d;
-            te[0] = c * e;
-            te[4] = bd - ac * f;
-            te[8] = bc * f + ad;
-            te[1] = f;
-            te[5] = a * e;
-            te[9] = -b * e;
-            te[2] = -d * e;
-            te[6] = ad * f + bc;
-            te[10] = ac - bd * f;
-            break;
-          }
-
-        case Euler.XZY:
-          {
-            var _ac = a * c,
-                _ad = a * d,
-                _bc = b * c,
-                _bd = b * d;
-
-            te[0] = c * e;
-            te[4] = -f;
-            te[8] = d * e;
-            te[1] = _ac * f + _bd;
-            te[5] = a * e;
-            te[9] = _ad * f - _bc;
-            te[2] = _bc * f - _ad;
-            te[6] = b * e;
-            te[10] = _bd * f + _ac;
-            break;
-          }
-
-        default:
-          throw new Error(ERR_UNKNOWN_ORDER);
-      }
-
-      te[3] = 0;
-      te[7] = 0;
-      te[11] = 0;
-      te[12] = 0;
-      te[13] = 0;
-      te[14] = 0;
-      te[15] = 1;
-      return te;
-    }
-  }, {
-    key: "toQuaternion",
-    value: function toQuaternion() {
-      var cy = Math.cos(this.yaw * 0.5);
-      var sy = Math.sin(this.yaw * 0.5);
-      var cr = Math.cos(this.roll * 0.5);
-      var sr = Math.sin(this.roll * 0.5);
-      var cp = Math.cos(this.pitch * 0.5);
-      var sp = Math.sin(this.pitch * 0.5);
-      var w = cy * cr * cp + sy * sr * sp;
-      var x = cy * sr * cp - sy * cr * sp;
-      var y = cy * cr * sp + sy * sr * cp;
-      var z = sy * cr * cp - cy * sr * sp;
-      return new _quaternion2.default(x, y, z, w);
-    }
-  }], [{
-    key: "ZYX",
-    get: function get() {
-      return 0;
-    }
-  }, {
-    key: "YXZ",
-    get: function get() {
-      return 1;
-    }
-  }, {
-    key: "XZY",
-    get: function get() {
-      return 2;
-    }
-  }, {
-    key: "ZXY",
-    get: function get() {
-      return 3;
-    }
-  }, {
-    key: "YZX",
-    get: function get() {
-      return 4;
-    }
-  }, {
-    key: "XYZ",
-    get: function get() {
-      return 5;
-    }
-  }, {
-    key: "RollPitchYaw",
-    get: function get() {
-      return 0;
-    }
-  }, {
-    key: "DefaultOrder",
-    get: function get() {
-      return Euler.ZYX;
-    }
-  }, {
-    key: "RotationOrders",
-    get: function get() {
-      return ['ZYX', 'YXZ', 'XZY', 'ZXY', 'YZX', 'XYZ'];
-    }
-  }, {
-    key: "rotationOrder",
-    value: function rotationOrder(order) {
-      return Euler.RotationOrders[order];
+          te[0] = c * e;
+          te[4] = bd - ac * f;
+          te[8] = bc * f + ad;
+          te[1] = f;
+          te[5] = a * e;
+          te[9] = -b * e;
+          te[2] = -d * e;
+          te[6] = ad * f + bc;
+          te[10] = ac - bd * f;
+          break;
+        }
+
+      case Euler.XZY:
+        {
+          const ac = a * c,
+                ad = a * d,
+                bc = b * c,
+                bd = b * d;
+          te[0] = c * e;
+          te[4] = -f;
+          te[8] = d * e;
+          te[1] = ac * f + bd;
+          te[5] = a * e;
+          te[9] = ad * f - bc;
+          te[2] = bc * f - ad;
+          te[6] = b * e;
+          te[10] = bd * f + ac;
+          break;
+        }
+
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
     }
-  }]);
-  return Euler;
-}(_mathArray.default);
+
+    te[3] = 0;
+    te[7] = 0;
+    te[11] = 0;
+    te[12] = 0;
+    te[13] = 0;
+    te[14] = 0;
+    te[15] = 1;
+    return te;
+  }
+
+  toQuaternion() {
+    const cy = Math.cos(this.yaw * 0.5);
+    const sy = Math.sin(this.yaw * 0.5);
+    const cr = Math.cos(this.roll * 0.5);
+    const sr = Math.sin(this.roll * 0.5);
+    const cp = Math.cos(this.pitch * 0.5);
+    const sp = Math.sin(this.pitch * 0.5);
+    const w = cy * cr * cp + sy * sr * sp;
+    const x = cy * sr * cp - sy * cr * sp;
+    const y = cy * cr * sp + sy * sr * cp;
+    const z = sy * cr * cp - cy * sr * sp;
+    return new _quaternion.default(x, y, z, w);
+  }
+
+}
 
 exports.default = Euler;
 //# sourceMappingURL=euler.js.map