@math.gl/core 4.0.0-alpha.4 → 4.0.0

package/dist/gl-matrix/quat.d.ts

@@ -353,5 +353,5 @@ export declare const sqlerp: (out: any, a: any, b: any, c: any, d: any, t: any)
  * @param {ReadonlyVec3} up    the vector representing the local "up" direction
  * @returns {quat} out
  */
-export declare const setAxes: (out: any, view: any, right: any, up: any) => vec4;
+export declare const setAxes: (out: any, view: any, right: any, up: any) => any;
 //# sourceMappingURL=quat.d.ts.map

package/dist/gl-matrix/quat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quat.d.ts","sourceRoot":"","sources":["../../src/gl-matrix/quat.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"quat.d.ts","sourceRoot":"","sources":["../../src/gl-matrix/quat.ts"],"names":[],"mappings":"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"}

package/dist/gl-matrix/vec2.d.ts

@@ -5,369 +5,359 @@
 /**
  * Creates a new, empty vec2
  *
- * @returns {vec2} a new 2D vector
+ * @returns {NumericArray} a new 2D vector
  */
-export function create(): vec2;
+export declare function create(): any[] | Float32Array;
 /**
  * Creates a new vec2 initialized with values from an existing vector
  *
- * @param {ReadonlyVec2} a vector to clone
- * @returns {vec2} a new 2D vector
+ * @param {Readonly<NumericArray>} a vector to clone
+ * @returns {NumericArray} a new 2D vector
  */
-export function clone(a: ReadonlyVec2): vec2;
+export declare function clone(a: any): any[] | Float32Array;
 /**
  * Creates a new vec2 initialized with the given values
  *
  * @param {Number} x X component
  * @param {Number} y Y component
- * @returns {vec2} a new 2D vector
+ * @returns {NumericArray} a new 2D vector
  */
-export function fromValues(x: number, y: number): vec2;
+export declare function fromValues(x: any, y: any): any[] | Float32Array;
 /**
  * Copy the values from one vec2 to another
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the source vector
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the source vector
+ * @returns {NumericArray} out
  */
-export function copy(out: vec2, a: ReadonlyVec2): vec2;
+export declare function copy(out: any, a: any): any;
 /**
  * Set the components of a vec2 to the given values
  *
- * @param {vec2} out the receiving vector
+ * @param {NumericArray} out the receiving vector
  * @param {Number} x X component
  * @param {Number} y Y component
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function set(out: vec2, x: number, y: number): vec2;
+export declare function set(out: any, x: any, y: any): any;
 /**
  * Adds two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function add(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function add(out: any, a: any, b: any): any;
 /**
  * Subtracts vector b from vector a
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function subtract(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function subtract(out: any, a: any, b: any): any;
 /**
  * Multiplies two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function multiply(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function multiply(out: any, a: any, b: any): any;
 /**
  * Divides two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function divide(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function divide(out: any, a: any, b: any): any;
 /**
  * Math.ceil the components of a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to ceil
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to ceil
+ * @returns {NumericArray} out
  */
-export function ceil(out: vec2, a: ReadonlyVec2): vec2;
+export declare function ceil(out: any, a: any): any;
 /**
  * Math.floor the components of a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to floor
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to floor
+ * @returns {NumericArray} out
  */
-export function floor(out: vec2, a: ReadonlyVec2): vec2;
+export declare function floor(out: any, a: any): any;
 /**
  * Returns the minimum of two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function min(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function min(out: any, a: any, b: any): any;
 /**
  * Returns the maximum of two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
+ * @returns {NumericArray} out
  */
-export function max(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare function max(out: any, a: any, b: any): any;
 /**
  * symmetric round the components of a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to round
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to round
+ * @returns {NumericArray} out
  */
-export function round(out: vec2, a: ReadonlyVec2): vec2;
+export declare function round(out: any, a: any): any;
 /**
  * Scales a vec2 by a scalar number
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the vector to scale
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the vector to scale
  * @param {Number} b amount to scale the vector by
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function scale(out: vec2, a: ReadonlyVec2, b: number): vec2;
+export declare function scale(out: any, a: any, b: any): any;
 /**
  * Adds two vec2's after scaling the second operand by a scalar value
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @param {Number} scale the amount to scale b by before adding
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function scaleAndAdd(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, scale: number): vec2;
+export declare function scaleAndAdd(out: any, a: any, b: any, scale: any): any;
 /**
  * Calculates the euclidian distance between two vec2's
  *
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @returns {Number} distance between a and b
  */
-export function distance(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare function distance(a: any, b: any): number;
 /**
  * Calculates the squared euclidian distance between two vec2's
  *
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @returns {Number} squared distance between a and b
  */
-export function squaredDistance(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare function squaredDistance(a: any, b: any): number;
 /**
  * Calculates the length of a vec2
  *
- * @param {ReadonlyVec2} a vector to calculate length of
+ * @param {Readonly<NumericArray>} a vector to calculate length of
  * @returns {Number} length of a
  */
-export function length(a: ReadonlyVec2): number;
+export declare function length(a: any): number;
 /**
  * Calculates the squared length of a vec2
  *
- * @param {ReadonlyVec2} a vector to calculate squared length of
+ * @param {Readonly<NumericArray>} a vector to calculate squared length of
  * @returns {Number} squared length of a
  */
-export function squaredLength(a: ReadonlyVec2): number;
+export declare function squaredLength(a: any): number;
 /**
  * Negates the components of a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to negate
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to negate
+ * @returns {NumericArray} out
  */
-export function negate(out: vec2, a: ReadonlyVec2): vec2;
+export declare function negate(out: any, a: any): any;
 /**
  * Returns the inverse of the components of a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to invert
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to invert
+ * @returns {NumericArray} out
  */
-export function inverse(out: vec2, a: ReadonlyVec2): vec2;
+export declare function inverse(out: any, a: any): any;
 /**
  * Normalize a vec2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a vector to normalize
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a vector to normalize
+ * @returns {NumericArray} out
  */
-export function normalize(out: vec2, a: ReadonlyVec2): vec2;
+export declare function normalize(out: any, a: any): any;
 /**
  * Calculates the dot product of two vec2's
  *
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @returns {Number} dot product of a and b
  */
-export function dot(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare function dot(a: any, b: any): number;
 /**
  * Computes the cross product of two vec2's
  * Note that the cross product must by definition produce a 3D vector
  *
  * @param {vec3} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @returns {vec3} out
  */
-export function cross(out: vec3, a: ReadonlyVec2, b: ReadonlyVec2): vec3;
+export declare function cross(out: any, a: any, b: any): any;
 /**
  * Performs a linear interpolation between two vec2's
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the first operand
+ * @param {Readonly<NumericArray>} b the second operand
  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function lerp(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, t: number): vec2;
+export declare function lerp(out: any, a: any, b: any, t: any): any;
 /**
  * Generates a random vector with the given scale
  *
- * @param {vec2} out the receiving vector
+ * @param {NumericArray} out the receiving vector
  * @param {Number} [scale] Length of the resulting vector. If omitted, a unit vector will be returned
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function random(out: vec2, scale?: number): vec2;
+export declare function random(out: any, scale: any): any;
 /**
  * Transforms the vec2 with a mat2
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the vector to transform
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the vector to transform
  * @param {ReadonlyMat2} m matrix to transform with
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function transformMat2(out: vec2, a: ReadonlyVec2, m: ReadonlyMat2): vec2;
+export declare function transformMat2(out: any, a: any, m: any): any;
 /**
  * Transforms the vec2 with a mat2d
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the vector to transform
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the vector to transform
  * @param {ReadonlyMat2d} m matrix to transform with
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function transformMat2d(out: vec2, a: ReadonlyVec2, m: ReadonlyMat2d): vec2;
+export declare function transformMat2d(out: any, a: any, m: any): any;
 /**
  * Transforms the vec2 with a mat3
  * 3rd vector component is implicitly '1'
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the vector to transform
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the vector to transform
  * @param {ReadonlyMat3} m matrix to transform with
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function transformMat3(out: vec2, a: ReadonlyVec2, m: ReadonlyMat3): vec2;
+export declare function transformMat3(out: any, a: any, m: any): any;
 /**
  * Transforms the vec2 with a mat4
  * 3rd vector component is implicitly '0'
  * 4th vector component is implicitly '1'
  *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the vector to transform
+ * @param {NumericArray} out the receiving vector
+ * @param {Readonly<NumericArray>} a the vector to transform
  * @param {ReadonlyMat4} m matrix to transform with
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function transformMat4(out: vec2, a: ReadonlyVec2, m: ReadonlyMat4): vec2;
+export declare function transformMat4(out: any, a: any, m: any): any;
 /**
  * Rotate a 2D vector
- * @param {vec2} out The receiving vec2
- * @param {ReadonlyVec2} a The vec2 point to rotate
- * @param {ReadonlyVec2} b The origin of the rotation
+ * @param {NumericArray} out The receiving vec2
+ * @param {Readonly<NumericArray>} a The vec2 point to rotate
+ * @param {Readonly<NumericArray>} b The origin of the rotation
  * @param {Number} rad The angle of rotation in radians
- * @returns {vec2} out
+ * @returns {NumericArray} out
  */
-export function rotate(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, rad: number): vec2;
+export declare function rotate(out: any, a: any, b: any, rad: any): any;
 /**
  * Get the angle between two 2D vectors
- * @param {ReadonlyVec2} a The first operand
- * @param {ReadonlyVec2} b The second operand
+ * @param {Readonly<NumericArray>} a The first operand
+ * @param {Readonly<NumericArray>} b The second operand
  * @returns {Number} The angle in radians
  */
-export function angle(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare function angle(a: any, b: any): number;
 /**
  * Set the components of a vec2 to zero
  *
- * @param {vec2} out the receiving vector
- * @returns {vec2} out
+ * @param {NumericArray} out the receiving vector
+ * @returns {NumericArray} out
  */
-export function zero(out: vec2): vec2;
+export declare function zero(out: any): any;
 /**
  * Returns a string representation of a vector
  *
- * @param {ReadonlyVec2} a vector to represent as a string
+ * @param {Readonly<NumericArray>} a vector to represent as a string
  * @returns {String} string representation of the vector
  */
-export function str(a: ReadonlyVec2): string;
+export declare function str(a: any): string;
 /**
  * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
  *
- * @param {ReadonlyVec2} a The first vector.
- * @param {ReadonlyVec2} b The second vector.
+ * @param {Readonly<NumericArray>} a The first vector.
+ * @param {Readonly<NumericArray>} b The second vector.
  * @returns {Boolean} True if the vectors are equal, false otherwise.
  */
-export function exactEquals(a: ReadonlyVec2, b: ReadonlyVec2): boolean;
+export declare function exactEquals(a: any, b: any): boolean;
 /**
  * Returns whether or not the vectors have approximately the same elements in the same position.
  *
- * @param {ReadonlyVec2} a The first vector.
- * @param {ReadonlyVec2} b The second vector.
+ * @param {Readonly<NumericArray>} a The first vector.
+ * @param {Readonly<NumericArray>} b The second vector.
  * @returns {Boolean} True if the vectors are equal, false otherwise.
  */
-export function equals(a: ReadonlyVec2, b: ReadonlyVec2): boolean;
+export declare function equals(a: any, b: any): boolean;
 /**
- * Calculates the length of a vec2
- *
- * @param {ReadonlyVec2} a vector to calculate length of
- * @returns {Number} length of a
+ * Alias for {@link vec2.length}
+ * @function
  */
-export function len(a: ReadonlyVec2): number;
+export declare const len: typeof length;
 /**
- * Subtracts vector b from vector a
- *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * Alias for {@link vec2.subtract}
+ * @function
  */
-export function sub(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare const sub: typeof subtract;
 /**
- * Multiplies two vec2's
- *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * Alias for {@link vec2.multiply}
+ * @function
  */
-export function mul(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare const mul: typeof multiply;
 /**
- * Divides two vec2's
- *
- * @param {vec2} out the receiving vector
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {vec2} out
+ * Alias for {@link vec2.divide}
+ * @function
  */
-export function div(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2;
+export declare const div: typeof divide;
 /**
- * Calculates the euclidian distance between two vec2's
- *
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {Number} distance between a and b
+ * Alias for {@link vec2.distance}
+ * @function
  */
-export function dist(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare const dist: typeof distance;
 /**
- * Calculates the squared euclidian distance between two vec2's
- *
- * @param {ReadonlyVec2} a the first operand
- * @param {ReadonlyVec2} b the second operand
- * @returns {Number} squared distance between a and b
+ * Alias for {@link vec2.squaredDistance}
+ * @function
  */
-export function sqrDist(a: ReadonlyVec2, b: ReadonlyVec2): number;
+export declare const sqrDist: typeof squaredDistance;
 /**
- * Calculates the squared length of a vec2
+ * Alias for {@link vec2.squaredLength}
+ * @function
+ */
+export declare const sqrLen: typeof squaredLength;
+/**
+ * Perform some operation over an array of vec2s.
  *
- * @param {ReadonlyVec2} a vector to calculate squared length of
- * @returns {Number} squared length of a
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
  */
-export function sqrLen(a: ReadonlyVec2): number;
-export function forEach(a: any, stride: any, offset: any, count: any, fn: any, arg: any): any;
+export declare const forEach: (a: any, stride: any, offset: any, count: any, fn: any, arg: any) => any;
 //# sourceMappingURL=vec2.d.ts.map

package/dist/gl-matrix/vec2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vec2.d.ts","sourceRoot":"","sources":["../../src/gl-matrix/vec2.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"vec2.d.ts","sourceRoot":"","sources":["../../src/gl-matrix/vec2.ts"],"names":[],"mappings":"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"}