@luma.gl/engine 9.0.6 → 9.0.8

package/dist/dist.dev.js

@@ -273,6 +273,8 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name, type) {
+      this.name = void 0;
+      this.type = void 0;
       this.sampleSize = 1;
       this.time = 0;
       this.count = 0;
@@ -307,31 +309,26 @@ var __exports__ = (() => {
       this.sampleSize = samples;
       return this;
     }
-    /** Call to increment count (+1) */
     incrementCount() {
       this.addCount(1);
       return this;
     }
-    /** Call to decrement count (-1) */
     decrementCount() {
       this.subtractCount(1);
       return this;
     }
-    /** Increase count */
     addCount(value) {
       this._count += value;
       this._samples++;
       this._checkSampling();
       return this;
     }
-    /** Decrease count */
     subtractCount(value) {
       this._count -= value;
       this._samples++;
       this._checkSampling();
       return this;
     }
-    /** Add an arbitrary timing and bump the count */
     addTime(time) {
       this._time += time;
       this.lastTiming = time;
@@ -339,13 +336,11 @@ var __exports__ = (() => {
       this._checkSampling();
       return this;
     }
-    /** Start a timer */
     timeStart() {
       this._startTime = getHiResTimestamp();
       this._timerPending = true;
       return this;
     }
-    /** End a timer. Adds to time and bumps the timing count. */
     timeEnd() {
       if (!this._timerPending) {
         return this;
@@ -358,22 +353,18 @@ var __exports__ = (() => {
     getSampleAverageCount() {
       return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
     }
-    /** Calculate average time / count for the previous window */
     getSampleAverageTime() {
       return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
     }
-    /** Calculate counts per second for the previous window */
     getSampleHz() {
       return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
     }
     getAverageCount() {
       return this.samples > 0 ? this.count / this.samples : 0;
     }
-    /** Calculate average time / count */
     getAverageTime() {
       return this.samples > 0 ? this.time / this.samples : 0;
     }
-    /** Calculate counts per second */
     getHz() {
       return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
     }
@@ -394,20 +385,23 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
+      this.id = void 0;
       this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    /** Acquire a stat. Create if it doesn't exist. */
-    get(name, type = "count") {
-      return this._getOrCreate({ name, type });
+    get(name) {
+      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
+      return this._getOrCreate({
+        name,
+        type
+      });
     }
     get size() {
       return Object.keys(this.stats).length;
     }
-    /** Reset all stats */
     reset() {
       for (const stat of Object.values(this.stats)) {
         stat.reset();
@@ -431,11 +425,15 @@ var __exports__ = (() => {
       });
       return table;
     }
-    _initializeStats(stats = []) {
+    _initializeStats() {
+      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
       stats.forEach((stat) => this._getOrCreate(stat));
     }
     _getOrCreate(stat) {
-      const { name, type } = stat;
+      const {
+        name,
+        type
+      } = stat;
       let result = this.stats[name];
       if (!result) {
         if (stat instanceof Stat) {
@@ -4723,11 +4721,17 @@ void main() {
     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);
@@ -4771,12 +4775,28 @@ void main() {
   }
 
   // ../../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);
     }
@@ -4796,10 +4816,7 @@ void main() {
       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) {
@@ -4810,20 +4827,18 @@ void main() {
     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) {
@@ -4847,8 +4862,6 @@ void main() {
       }
       return true;
     }
-    // Modifiers
-    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4866,14 +4879,12 @@ void main() {
       }
       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]);
@@ -4914,25 +4925,18 @@ void main() {
       }
       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) {
@@ -4940,48 +4944,39 @@ void main() {
       }
       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;
     }
@@ -5001,13 +4996,13 @@ void main() {
   }
   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, length, callerName = "") {
     if (config.debug && !validateVector(v, length)) {
-      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;
   }
@@ -5015,13 +5010,12 @@ void main() {
   // ../../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];
     }
@@ -5034,24 +5028,12 @@ void main() {
     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 length = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -5059,9 +5041,6 @@ void main() {
       }
       return length;
     }
-    /**
-     * Returns the squared length of the vector from the origin to the point described by this vector
-     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -5083,7 +5062,6 @@ void main() {
       }
       return checkNumber(product);
     }
-    // MODIFIERS
     normalize() {
       const length = this.magnitude();
       if (length !== 0) {
@@ -5109,7 +5087,6 @@ void main() {
       }
       return this.check();
     }
-    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -5382,12 +5359,6 @@ void main() {
       }
       return ZERO;
     }
-    /**
-     * @class
-     * @param x
-     * @param y
-     * @param z
-     */
     constructor(x = 0, y = 0, z = 0) {
       super(-0, -0, -0);
       if (arguments.length === 1 && isArray(x)) {
@@ -5432,7 +5403,6 @@ void main() {
       object.z = this[2];
       return object;
     }
-    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -5442,38 +5412,41 @@ void main() {
     set z(value) {
       this[2] = checkNumber(value);
     }
-    // ACCESSORS
     angle(vector) {
       return angle(this, vector);
     }
-    // MODIFIERS
     cross(vector) {
       cross(this, this, vector);
       return this.check();
     }
-    rotateX({ radians, origin = ORIGIN }) {
+    rotateX({
+      radians,
+      origin = ORIGIN
+    }) {
       rotateX(this, this, origin, radians);
       return this.check();
     }
-    rotateY({ radians, origin = ORIGIN }) {
+    rotateY({
+      radians,
+      origin = ORIGIN
+    }) {
       rotateY(this, this, origin, radians);
       return this.check();
     }
-    rotateZ({ radians, origin = ORIGIN }) {
+    rotateZ({
+      radians,
+      origin = ORIGIN
+    }) {
       rotateZ(this, this, origin, radians);
       return this.check();
     }
-    // Transforms
-    // transforms as point (4th component is implicitly 1)
     transform(matrix4) {
       return this.transformAsPoint(matrix4);
     }
-    // transforms as point (4th component is implicitly 1)
     transformAsPoint(matrix4) {
       transformMat42(this, this, matrix4);
       return this.check();
     }
-    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
     transformAsVector(matrix4) {
       vec3_transformMat4AsVector(this, this, matrix4);
       return this.check();
@@ -5494,29 +5467,19 @@ void main() {
 
   // ../../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 += "]";
@@ -5525,11 +5488,9 @@ void main() {
     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;
@@ -6295,7 +6256,6 @@ void main() {
       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;
@@ -6315,8 +6275,6 @@ void main() {
       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;
@@ -6355,41 +6313,25 @@ void main() {
       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(quaternion) {
       fromQuat(this, quaternion);
       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 {
@@ -6397,47 +6339,35 @@ void main() {
       }
       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);
@@ -6451,53 +6381,32 @@ void main() {
         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];
@@ -6523,12 +6432,6 @@ void main() {
       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];
@@ -6547,7 +6450,6 @@ void main() {
       result[8] = this[10] * inverseScale2;
       return result;
     }
-    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -6556,7 +6458,6 @@ void main() {
       invert(this, this);
       return this.check();
     }
-    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -6565,68 +6466,33 @@ void main() {
       multiply(this, this, a);
       return this.check();
     }
-    // Rotates a matrix by the given angle around the X axis
     rotateX(radians) {
       rotateX2(this, this, radians);
       return this.check();
     }
-    // Rotates a matrix by the given angle around the Y axis.
     rotateY(radians) {
       rotateY2(this, this, radians);
       return this.check();
     }
-    /**
-     * Rotates a matrix by the given angle around the Z axis.
-     * @param radians
-     * @returns self
-     */
     rotateZ(radians) {
       rotateZ2(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);
@@ -6635,14 +6501,10 @@ void main() {
       }
       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 } = vector;
+      const {
+        length
+      } = vector;
       let out;
       switch (length) {
         case 2:
@@ -6657,12 +6519,6 @@ void main() {
       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) {
@@ -6678,19 +6534,15 @@ void main() {
       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);
     }
@@ -7235,9 +7087,7 @@ void main() {
         this.setIndexBuffer(props.indexBuffer);
       }
       if (props.attributes) {
-        this.setAttributes(props.attributes, {
-          disableWarnings: props.disableWarnings
-        });
+        this.setAttributes(props.attributes);
       }
       if (props.constantAttributes) {
         this.setConstantAttributes(props.constantAttributes);
@@ -7249,7 +7099,6 @@ void main() {
         this.setUniforms(props.uniforms);
       }
       if (props.moduleSettings) {
-        import_core11.log.warn("Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()")();
         this.updateModuleSettings(props.moduleSettings);
       }
       if (props.transformFeedback) {
@@ -7457,7 +7306,7 @@ void main() {
             set = true;
           }
         }
-        if (!set && !(options?.disableWarnings || this.props.disableWarnings)) {
+        if (!set && !(options?.disableWarnings ?? this.props.disableWarnings)) {
           import_core11.log.warn(
             `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
           )();
@@ -7478,7 +7327,7 @@ void main() {
         const attributeInfo = this._attributeInfos[attributeName];
         if (attributeInfo) {
           this.vertexArray.setConstantWebGL(attributeInfo.location, value);
-        } else if (!(options?.disableWarnings || this.props.disableWarnings)) {
+        } else if (!(options?.disableWarnings ?? this.props.disableWarnings)) {
           import_core11.log.warn(
             `Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`
           )();