@luma.gl/gltf 9.0.9 → 9.0.10

package/dist/dist.dev.js

@@ -237,7 +237,10 @@ var __exports__ = (() => {
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
@@ -258,11 +261,10 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION = true ? "4.1.4" : "latest";
+  var VERSION = true ? "4.2.0-beta.2" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
-  var _globalThis$loaders;
-  var parseImageNode = (_globalThis$loaders = globalThis.loaders) === null || _globalThis$loaders === void 0 ? void 0 : _globalThis$loaders.parseImageNode;
+  var parseImageNode = globalThis.loaders?.parseImageNode;
   var IMAGE_SUPPORTED = typeof Image !== "undefined";
   var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
   var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
@@ -413,8 +415,7 @@ var __exports__ = (() => {
     const imagebitmapOptions = options && options.imagebitmap;
     return await safeCreateImageBitmap(blob, imagebitmapOptions);
   }
-  async function safeCreateImageBitmap(blob) {
-    let imagebitmapOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
     if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
       imagebitmapOptions = null;
     }
@@ -450,10 +451,7 @@ var __exports__ = (() => {
     switch (brandMajor) {
       case "avif":
       case "avis":
-        return {
-          extension: "avif",
-          mimeType: "image/avif"
-        };
+        return { extension: "avif", mimeType: "image/avif" };
       default:
         return null;
     }
@@ -464,8 +462,7 @@ var __exports__ = (() => {
   function stringToBytes(string) {
     return [...string].map((character) => character.charCodeAt(0));
   }
-  function checkString(buffer, header) {
-    let offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+  function checkString(buffer, header, offset = 0) {
     const headerBytes = stringToBytes(header);
     for (let i = 0; i < headerBytes.length; ++i) {
       if (headerBytes[i] !== buffer[i + offset]) {
@@ -490,6 +487,7 @@ var __exports__ = (() => {
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -536,10 +534,7 @@ var __exports__ = (() => {
     if (!isJpeg) {
       return null;
     }
-    const {
-      tableMarkers,
-      sofMarkers
-    } = getJpegMarkers();
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
     let i = 2;
     while (i + 9 < dataView.byteLength) {
       const marker = dataView.getUint16(i, BIG_ENDIAN);
@@ -547,7 +542,9 @@ var __exports__ = (() => {
         return {
           mimeType: "image/jpeg",
           height: dataView.getUint16(i + 5, BIG_ENDIAN),
+          // Number of lines
           width: dataView.getUint16(i + 7, BIG_ENDIAN)
+          // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
@@ -563,11 +560,23 @@ var __exports__ = (() => {
     for (let i = 65504; i < 65520; ++i) {
       tableMarkers.add(i);
     }
-    const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]);
-    return {
-      tableMarkers,
-      sofMarkers
-    };
+    const sofMarkers = /* @__PURE__ */ new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
   }
   function toDataView(data) {
     if (data instanceof DataView) {
@@ -584,11 +593,8 @@ var __exports__ = (() => {
 
   // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-node-image.js
   async function parseToNodeImage(arrayBuffer, options) {
-    var _globalThis$loaders2;
-    const {
-      mimeType
-    } = getBinaryImageMetadata(arrayBuffer) || {};
-    const parseImageNode2 = (_globalThis$loaders2 = globalThis.loaders) === null || _globalThis$loaders2 === void 0 ? void 0 : _globalThis$loaders2.parseImageNode;
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
+    const parseImageNode2 = globalThis.loaders?.parseImageNode;
     assert(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
   }
@@ -598,9 +604,7 @@ var __exports__ = (() => {
     options = options || {};
     const imageOptions = options.image || {};
     const imageType = imageOptions.type || "auto";
-    const {
-      url
-    } = context || {};
+    const { url } = context || {};
     const loadType = getLoadableImageType(imageType);
     let image;
     switch (loadType) {
@@ -634,14 +638,27 @@ var __exports__ = (() => {
 
   // ../../node_modules/@loaders.gl/images/dist/image-loader.js
   var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
-  var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"];
+  var MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "image/avif",
+    "image/bmp",
+    "image/vnd.microsoft.icon",
+    "image/svg+xml"
+  ];
   var DEFAULT_IMAGE_LOADER_OPTIONS = {
     image: {
       type: "auto",
       decode: true
+      // if format is HTML
     }
+    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
+    dataType: null,
+    batchType: null,
     id: "image",
     module: "images",
     name: "Images",
@@ -649,16 +666,14 @@ var __exports__ = (() => {
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
+    // TODO: byteOffset, byteLength;
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/texture-api/generate-url.js
   function generateUrl(getUrl, options, urlOptions) {
-    let url = typeof getUrl === "function" ? getUrl({
-      ...options,
-      ...urlOptions
-    }) : getUrl;
+    let url = typeof getUrl === "function" ? getUrl({ ...options, ...urlOptions }) : getUrl;
     const baseUrl = options.baseUrl;
     if (baseUrl) {
       url = baseUrl[baseUrl.length - 1] === "/" ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
@@ -668,8 +683,7 @@ var __exports__ = (() => {
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/texture-api/async-deep-map.js
   var isObject = (value) => value && typeof value === "object";
-  async function asyncDeepMap(tree, func) {
-    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  async function asyncDeepMap(tree, func, options = {}) {
     return await mapSubtree(tree, func, options);
   }
   async function mapSubtree(object, func, options) {
@@ -695,8 +709,7 @@ var __exports__ = (() => {
     await Promise.all(promises);
     return values;
   }
-  async function mapArray(urlArray, func) {
-    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  async function mapArray(urlArray, func, options = {}) {
     const promises = urlArray.map((url) => mapSubtree(url, func, options));
     return await Promise.all(promises);
   }
@@ -712,40 +725,26 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/texture-api/load-image.js
-  async function loadImageTexture(getUrl) {
-    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  async function loadImageTexture(getUrl, options = {}) {
     const imageUrls = await getImageUrls(getUrl, options);
     return await deepLoad(imageUrls, ImageLoader.parse, options);
   }
-  async function getImageUrls(getUrl, options) {
-    let urlOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  async function getImageUrls(getUrl, options, urlOptions = {}) {
     const mipLevels = options && options.image && options.image.mipLevels || 0;
     return mipLevels !== 0 ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) : generateUrl(getUrl, options, urlOptions);
   }
   async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
     const urls = [];
     if (mipLevels === "auto") {
-      const url = generateUrl(getUrl, options, {
-        ...urlOptions,
-        lod: 0
-      });
+      const url = generateUrl(getUrl, options, { ...urlOptions, lod: 0 });
       const image = await shallowLoad(url, ImageLoader.parse, options);
-      const {
-        width,
-        height
-      } = getImageSize(image);
-      mipLevels = getMipLevels({
-        width,
-        height
-      });
+      const { width, height } = getImageSize(image);
+      mipLevels = getMipLevels({ width, height });
       urls.push(url);
     }
     assert(mipLevels > 0);
     for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
-      const url = generateUrl(getUrl, options, {
-        ...urlOptions,
-        lod: mipLevel
-      });
+      const url = generateUrl(getUrl, options, { ...urlOptions, lod: mipLevel });
       urls.push(url);
     }
     return urls;
@@ -834,11 +833,17 @@ var __exports__ = (() => {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+  globalThis.mathgl = globalThis.mathgl || {
+    config: {
+      ...DEFAULT_CONFIG
+    }
+  };
   var config = globalThis.mathgl.config;
-  function formatValue(value, { precision = config.precision } = {}) {
+  function formatValue(value, {
+    precision = config.precision
+  } = {}) {
     value = round(value);
-    return `${parseFloat(value.toPrecision(precision))}`;
+    return "".concat(parseFloat(value.toPrecision(precision)));
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -882,12 +887,28 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  var MathArray = class extends Array {
-    // Common methods
-    /**
-     * Clone the current object
-     * @returns a new copy of this object
-     */
+  function _extendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+      var instance = Reflect.construct(cls, Array.from(arguments));
+      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+      return instance;
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+      constructor: {
+        value: cls,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(ExtendableBuiltin, cls);
+    } else {
+      ExtendableBuiltin.__proto__ = cls;
+    }
+    return ExtendableBuiltin;
+  }
+  var MathArray = class extends _extendableBuiltin(Array) {
     clone() {
       return new this.constructor().copy(this);
     }
@@ -907,10 +928,7 @@ var __exports__ = (() => {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
-        // @ts-ignore
-        this.fromObject(arrayOrObject)
-      );
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -921,20 +939,18 @@ var __exports__ = (() => {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
-    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
-    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
+      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -958,8 +974,6 @@ var __exports__ = (() => {
       }
       return true;
     }
-    // Modifiers
-    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -977,14 +991,12 @@ var __exports__ = (() => {
       }
       return this.check();
     }
-    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
-    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -1025,25 +1037,18 @@ var __exports__ = (() => {
       }
       return this.check();
     }
-    /**
-     * Multiplies all elements by `scale`
-     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
-     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
-    // Debug checks
-    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
       }
       return this;
     }
-    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -1051,48 +1056,39 @@ var __exports__ = (() => {
       }
       return valid;
     }
-    // three.js compatibility
-    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
-    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
-    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
-    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
-    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
-    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
-    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
-    /** @deprecated */
     get elements() {
       return this;
     }
@@ -1112,13 +1108,13 @@ var __exports__ = (() => {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error(`Invalid number ${JSON.stringify(value)}`);
+      throw new Error("Invalid number ".concat(JSON.stringify(value)));
     }
     return value;
   }
   function checkVector(v, length4, callerName = "") {
     if (config.debug && !validateVector(v, length4)) {
-      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
     }
     return v;
   }
@@ -1126,13 +1122,12 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert2(condition, message) {
     if (!condition) {
-      throw new Error(`math.gl assertion ${message}`);
+      throw new Error("math.gl assertion ".concat(message));
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
-    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -1145,24 +1140,12 @@ var __exports__ = (() => {
     set y(value) {
       this[1] = checkNumber(value);
     }
-    /**
-     * Returns the length of the vector from the origin to the point described by this vector
-     *
-     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
-     * Instead we provide `len` and `magnitude`
-     */
     len() {
       return Math.sqrt(this.lengthSquared());
     }
-    /**
-     * Returns the length of the vector from the origin to the point described by this vector
-     */
     magnitude() {
       return this.len();
     }
-    /**
-     * Returns the squared length of the vector from the origin to the point described by this vector
-     */
     lengthSquared() {
       let length4 = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -1170,9 +1153,6 @@ var __exports__ = (() => {
       }
       return length4;
     }
-    /**
-     * Returns the squared length of the vector from the origin to the point described by this vector
-     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -1194,7 +1174,6 @@ var __exports__ = (() => {
       }
       return checkNumber(product);
     }
-    // MODIFIERS
     normalize() {
       const length4 = this.magnitude();
       if (length4 !== 0) {
@@ -1220,7 +1199,6 @@ var __exports__ = (() => {
       }
       return this.check();
     }
-    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -1519,8 +1497,6 @@ var __exports__ = (() => {
       object.w = this[3];
       return object;
     }
-    // Getters/setters
-    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
     get ELEMENTS() {
       return 4;
     }
@@ -1552,7 +1528,6 @@ var __exports__ = (() => {
       transformQuat(this, this, quaternion2);
       return this.check();
     }
-    // three.js compatibility
     applyMatrix4(m) {
       m.transform(this, this);
       return this;
@@ -1561,29 +1536,19 @@ var __exports__ = (() => {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
-    // fromObject(object) {
-    //   const array = object.elements;
-    //   return this.fromRowMajor(array);
-    // }
-    // toObject(object) {
-    //   const array = object.elements;
-    //   this.toRowMajor(array);
-    //   return object;
-    // }
-    // TODO better override formatString?
     toString() {
       let string = "[";
       if (config.printRowMajor) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += ` ${this[col * this.RANK + row]}`;
+            string += " ".concat(this[col * this.RANK + row]);
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += ` ${this[i]}`;
+          string += " ".concat(this[i]);
         }
       }
       string += "]";
@@ -1592,11 +1557,9 @@ var __exports__ = (() => {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
-    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
-    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -2454,7 +2417,6 @@ var __exports__ = (() => {
       this[15] = array[15];
       return this.check();
     }
-    // eslint-disable-next-line max-params
     set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -2474,8 +2436,6 @@ var __exports__ = (() => {
       this[15] = m33;
       return this.check();
     }
-    // accepts row major order, stores as column major
-    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
       this[0] = m00;
       this[1] = m10;
@@ -2514,41 +2474,25 @@ var __exports__ = (() => {
       result[15] = this[15];
       return result;
     }
-    // Constructors
-    /** Set to identity matrix */
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
-    /**
-     *
-     * @param object
-     * @returns self
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
-    /**
-     * Calculates a 4x4 matrix from the given quaternion
-     * @param quaternion Quaternion to create matrix from
-     * @returns self
-     */
     fromQuaternion(quaternion2) {
       fromQuat(this, quaternion2);
       return this.check();
     }
-    /**
-     * Generates a frustum matrix with the given bounds
-     * @param view.left - Left bound of the frustum
-     * @param view.right - Right bound of the frustum
-     * @param view.bottom - Bottom bound of the frustum
-     * @param view.top - Top bound of the frustum
-     * @param view.near - Near bound of the frustum
-     * @param view.far - Far bound of the frustum. Can be set to Infinity.
-     * @returns self
-     */
     frustum(view) {
-      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -2556,47 +2500,35 @@ var __exports__ = (() => {
       }
       return this.check();
     }
-    /**
-     * Generates a look-at matrix with the given eye position, focal point,
-     * and up axis
-     * @param view.eye - (vector) Position of the viewer
-     * @param view.center - (vector) Point the viewer is looking at
-     * @param view.up - (vector) Up axis
-     * @returns self
-     */
     lookAt(view) {
-      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
+      const {
+        eye,
+        center = [0, 0, 0],
+        up = [0, 1, 0]
+      } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
-    /**
-     * Generates a orthogonal projection matrix with the given bounds
-     * from "traditional" view space parameters
-     * @param view.left - Left bound of the frustum
-     * @param view.right number  Right bound of the frustum
-     * @param view.bottom - Bottom bound of the frustum
-     * @param view.top number  Top bound of the frustum
-     * @param view.near - Near bound of the frustum
-     * @param view.far number  Far bound of the frustum
-     * @returns self
-     */
     ortho(view) {
-      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
-    /**
-     * Generates an orthogonal projection matrix with the same parameters
-     * as a perspective matrix (plus focalDistance)
-     * @param view.fovy Vertical field of view in radians
-     * @param view.aspect Aspect ratio. Typically viewport width / viewport height
-     * @param view.focalDistance Distance in the view frustum used for extent calculations
-     * @param view.near Near bound of the frustum
-     * @param view.far Far bound of the frustum
-     * @returns self
-     */
     orthographic(view) {
-      const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+      const {
+        fovy = DEFAULT_FOVY,
+        aspect = DEFAULT_ASPECT,
+        focalDistance = 1,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
       checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
@@ -2610,53 +2542,32 @@ var __exports__ = (() => {
         far
       });
     }
-    /**
-     * Generates a perspective projection matrix with the given bounds
-     * @param view.fovy Vertical field of view in radians
-     * @param view.aspect Aspect ratio. typically viewport width/height
-     * @param view.near Near bound of the frustum
-     * @param view.far Far bound of the frustum
-     * @returns self
-     */
     perspective(view) {
-      const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
+      const {
+        fovy = 45 * Math.PI / 180,
+        aspect = 1,
+        near = 0.1,
+        far = 500
+      } = view;
       checkRadians(fovy);
       perspective(this, fovy, aspect, near, far);
       return this.check();
     }
-    // Accessors
     determinant() {
       return determinant(this);
     }
-    /**
-     * Extracts the non-uniform scale assuming the matrix is an affine transformation.
-     * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
-     * @param result
-     * @returns self
-     */
     getScale(result = [-0, -0, -0]) {
       result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
       result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
       result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
       return result;
     }
-    /**
-     * Gets the translation portion, assuming the matrix is a affine transformation matrix.
-     * @param result
-     * @returns self
-     */
     getTranslation(result = [-0, -0, -0]) {
       result[0] = this[12];
       result[1] = this[13];
       result[2] = this[14];
       return result;
     }
-    /**
-     * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
-     * @param result
-     * @param scaleResult
-     * @returns self
-     */
     getRotation(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -2682,12 +2593,6 @@ var __exports__ = (() => {
       result[15] = 1;
       return result;
     }
-    /**
-     *
-     * @param result
-     * @param scaleResult
-     * @returns self
-     */
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
@@ -2706,7 +2611,6 @@ var __exports__ = (() => {
       result[8] = this[10] * inverseScale2;
       return result;
     }
-    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -2715,7 +2619,6 @@ var __exports__ = (() => {
       invert(this, this);
       return this.check();
     }
-    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -2724,68 +2627,33 @@ var __exports__ = (() => {
       multiply(this, this, a);
       return this.check();
     }
-    // Rotates a matrix by the given angle around the X axis
     rotateX(radians) {
       rotateX(this, this, radians);
       return this.check();
     }
-    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians) {
       rotateY(this, this, radians);
       return this.check();
     }
-    /**
-     * Rotates a matrix by the given angle around the Z axis.
-     * @param radians
-     * @returns self
-     */
     rotateZ(radians) {
       rotateZ(this, this, radians);
       return this.check();
     }
-    /**
-     *
-     * @param param0
-     * @returns self
-     */
     rotateXYZ(angleXYZ) {
       return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
-    /**
-     *
-     * @param radians
-     * @param axis
-     * @returns self
-     */
     rotateAxis(radians, axis) {
       rotate(this, this, radians, axis);
       return this.check();
     }
-    /**
-     *
-     * @param factor
-     * @returns self
-     */
     scale(factor) {
       scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
-    /**
-     *
-     * @param vec
-     * @returns self
-     */
     translate(vector) {
       translate(this, this, vector);
       return this.check();
     }
-    // Transforms
-    /**
-     * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
-     * @param vector
-     * @param result
-     * @returns self
-     */
     transform(vector, result) {
       if (vector.length === 4) {
         result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -2794,14 +2662,10 @@ var __exports__ = (() => {
       }
       return this.transformAsPoint(vector, result);
     }
-    /**
-     * Transforms any 2 or 3 element array as point (w implicitly 1)
-     * @param vector
-     * @param result
-     * @returns self
-     */
     transformAsPoint(vector, result) {
-      const { length: length4 } = vector;
+      const {
+        length: length4
+      } = vector;
       let out;
       switch (length4) {
         case 2:
@@ -2816,12 +2680,6 @@ var __exports__ = (() => {
       checkVector(out, vector.length);
       return out;
     }
-    /**
-     * Transforms any 2 or 3 element array as vector (w implicitly 0)
-     * @param vector
-     * @param result
-     * @returns self
-     */
     transformAsVector(vector, result) {
       let out;
       switch (vector.length) {
@@ -2837,19 +2695,15 @@ var __exports__ = (() => {
       checkVector(out, vector.length);
       return out;
     }
-    /** @deprecated */
     transformPoint(vector, result) {
       return this.transformAsPoint(vector, result);
     }
-    /** @deprecated */
     transformVector(vector, result) {
       return this.transformAsPoint(vector, result);
     }
-    /** @deprecated */
     transformDirection(vector, result) {
       return this.transformAsVector(vector, result);
     }
-    // three.js math API compatibility
     makeRotationX(radians) {
       return this.identity().rotateX(radians);
     }
@@ -3176,13 +3030,6 @@ var __exports__ = (() => {
       this[3] = object.w;
       return this.check();
     }
-    /**
-     * Creates a quaternion from the given 3x3 rotation matrix.
-     * NOTE: The resultant quaternion is not normalized, so you should
-     * be sure to renormalize the quaternion yourself where necessary.
-     * @param m
-     * @returns
-     */
     fromMatrix3(m) {
       fromMat3(this, m);
       return this.check();
@@ -3191,21 +3038,13 @@ var __exports__ = (() => {
       setAxisAngle(this, axis, rad);
       return this.check();
     }
-    /** Set a quat to the identity quaternion */
     identity() {
       identity2(this);
       return this.check();
     }
-    // Set the components of a quat to the given values
-    // set(i, j, k, l) {
-    //   quat_set(this, i, j, k, l);
-    //   return this.check();
-    // }
-    // Sets a quat from the given angle and rotation axis, then returns it.
     setAxisAngle(axis, rad) {
       return this.fromAxisRotation(axis, rad);
     }
-    // Getters/setters
     get ELEMENTS() {
       return 4;
     }
@@ -3233,72 +3072,35 @@ var __exports__ = (() => {
     set w(value) {
       this[3] = checkNumber(value);
     }
-    // Calculates the length of a quat
     len() {
       return length3(this);
     }
-    // Calculates the squared length of a quat
     lengthSquared() {
       return squaredLength2(this);
     }
-    // Calculates the dot product of two quat's
-    // @return {Number}
     dot(a) {
       return dot3(this, a);
     }
-    // Gets the rotation axis and angle for a given quaternion.
-    // If a quaternion is created with setAxisAngle, this method will
-    // return the same values as providied in the original parameter
-    // list OR functionally equivalent values.
-    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
-    // is the same as the quaternion formed by [0, 0, 1] and 270.
-    // This method favors the latter.
-    // @return {{[x,y,z], Number}}
-    // getAxisAngle() {
-    //   const axis = [];
-    // //   const angle = quat_getAxisAngle(axis, this);
-    //   return {axis, angle};
-    // }
-    // MODIFIERS
-    // Sets a quaternion to represent the shortest rotation from one vector
-    // to another. Both vectors are assumed to be unit length.
     rotationTo(vectorA, vectorB) {
       rotationTo(this, vectorA, vectorB);
       return this.check();
     }
-    // Sets the specified quaternion with values corresponding to the given axes.
-    // Each axis is a vec3 and is expected to be unit length and perpendicular
-    // to all other specified axes.
-    // setAxes() {
-    //   Number
-    // }
-    // Performs a spherical linear interpolation with two control points
-    // sqlerp() {
-    //   Number;
-    // }
-    // Adds two quat's
     add(a) {
       add2(this, this, a);
       return this.check();
     }
-    // Calculates the W component of a quat from the X, Y, and Z components.
-    // Any existing W component will be ignored.
     calculateW() {
       calculateW(this, this);
       return this.check();
     }
-    // Calculates the conjugate of a quat If the quaternion is normalized,
-    // this function is faster than quat_invert and produces the same result.
     conjugate() {
       conjugate(this, this);
       return this.check();
     }
-    // Calculates the inverse of a quat
     invert() {
       invert2(this, this);
       return this.check();
     }
-    // Performs a linear interpolation between two quat's
     lerp(a, b, t) {
       if (t === void 0) {
         return this.lerp(this, a, b);
@@ -3306,7 +3108,6 @@ var __exports__ = (() => {
       lerp2(this, a, b, t);
       return this.check();
     }
-    // Multiplies two quat's
     multiplyRight(a) {
       multiply2(this, this, a);
       return this.check();
@@ -3315,7 +3116,6 @@ var __exports__ = (() => {
       multiply2(this, a, this);
       return this.check();
     }
-    // Normalize a quat
     normalize() {
       const length4 = this.len();
       const l = length4 > 0 ? 1 / length4 : 0;
@@ -3328,27 +3128,22 @@ var __exports__ = (() => {
       }
       return this.check();
     }
-    // Rotates a quaternion by the given angle about the X axis
     rotateX(rad) {
       rotateX2(this, this, rad);
       return this.check();
     }
-    // Rotates a quaternion by the given angle about the Y axis
     rotateY(rad) {
       rotateY2(this, this, rad);
       return this.check();
     }
-    // Rotates a quaternion by the given angle about the Z axis
     rotateZ(rad) {
       rotateZ2(this, this, rad);
       return this.check();
     }
-    // Scales a quat by a scalar number
     scale(b) {
       scale3(this, this, b);
       return this.check();
     }
-    // Performs a spherical linear interpolation between two quat
     slerp(arg0, arg1, arg2) {
       let start;
       let target;
@@ -3378,7 +3173,6 @@ var __exports__ = (() => {
       transformQuat2(result, vector, this);
       return checkVector(result, 4);
     }
-    // THREE.js Math API compatibility
     lengthSq() {
       return this.lengthSquared();
     }