@luma.gl/shadertools 9.0.6 → 9.0.8

package/dist/dist.dev.js

@@ -7845,11 +7845,17 @@ vec3 geometry_getNormal() {
     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);
@@ -7893,12 +7899,28 @@ vec3 geometry_getNormal() {
   }
 
   // ../../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);
     }
@@ -7918,10 +7940,7 @@ vec3 geometry_getNormal() {
       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) {
@@ -7932,20 +7951,18 @@ vec3 geometry_getNormal() {
     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) {
@@ -7969,8 +7986,6 @@ vec3 geometry_getNormal() {
       }
       return true;
     }
-    // Modifiers
-    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -7988,14 +8003,12 @@ vec3 geometry_getNormal() {
       }
       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]);
@@ -8036,25 +8049,18 @@ vec3 geometry_getNormal() {
       }
       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) {
@@ -8062,48 +8068,39 @@ vec3 geometry_getNormal() {
       }
       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;
     }
@@ -8123,13 +8120,13 @@ vec3 geometry_getNormal() {
   }
   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;
   }
@@ -8254,29 +8251,19 @@ vec3 geometry_getNormal() {
 
   // ../../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 += "]";
@@ -8285,11 +8272,9 @@ vec3 geometry_getNormal() {
     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;
@@ -9055,7 +9040,6 @@ vec3 geometry_getNormal() {
       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;
@@ -9075,8 +9059,6 @@ vec3 geometry_getNormal() {
       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;
@@ -9115,41 +9097,25 @@ vec3 geometry_getNormal() {
       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 {
@@ -9157,47 +9123,35 @@ vec3 geometry_getNormal() {
       }
       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);
@@ -9211,53 +9165,32 @@ vec3 geometry_getNormal() {
         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];
@@ -9283,12 +9216,6 @@ vec3 geometry_getNormal() {
       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];
@@ -9307,7 +9234,6 @@ vec3 geometry_getNormal() {
       result[8] = this[10] * inverseScale2;
       return result;
     }
-    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -9316,7 +9242,6 @@ vec3 geometry_getNormal() {
       invert(this, this);
       return this.check();
     }
-    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -9325,68 +9250,33 @@ vec3 geometry_getNormal() {
       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);
@@ -9395,14 +9285,10 @@ vec3 geometry_getNormal() {
       }
       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:
@@ -9417,12 +9303,6 @@ vec3 geometry_getNormal() {
       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) {
@@ -9438,19 +9318,15 @@ vec3 geometry_getNormal() {
       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);
     }