js-draw 0.25.1 → 1.0.1

package/dist/cjs/math/Mat33.js

@@ -1,340 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Vec2_1 = require("./Vec2");
-var Vec3_1 = require("./Vec3");
-/**
- * Represents a three dimensional linear transformation or
- * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
- * **and** translates while a linear transformation just scales/rotates/shears).
- */
-var Mat33 = /** @class */ (function () {
-    /**
-     * Creates a matrix from inputs in the form,
-     * ```
-     * ⎡ a1 a2 a3 ⎤
-     * ⎢ b1 b2 b3 ⎥
-     * ⎣ c1 c2 c3 ⎦
-     * ```
-     */
-    function Mat33(a1, a2, a3, b1, b2, b3, c1, c2, c3) {
-        this.a1 = a1;
-        this.a2 = a2;
-        this.a3 = a3;
-        this.b1 = b1;
-        this.b2 = b2;
-        this.b3 = b3;
-        this.c1 = c1;
-        this.c2 = c2;
-        this.c3 = c3;
-        this.cachedInverse = undefined;
-        this.rows = [
-            Vec3_1.default.of(a1, a2, a3),
-            Vec3_1.default.of(b1, b2, b3),
-            Vec3_1.default.of(c1, c2, c3),
-        ];
-    }
-    /**
-     * Creates a matrix from the given rows:
-     * ```
-     *  ⎡ r1.x r1.y r1.z ⎤
-     *  ⎢ r2.x r2.y r2.z ⎥
-     *  ⎣ r3.x r3.y r3.z ⎦
-     * ```
-     */
-    Mat33.ofRows = function (r1, r2, r3) {
-        return new Mat33(r1.x, r1.y, r1.z, r2.x, r2.y, r2.z, r3.x, r3.y, r3.z);
-    };
-    /**
-     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
-     * returns Mat33.identity.
-     *
-     * This may cache the computed inverse and return the cached version instead of recomputing
-     * it.
-     */
-    Mat33.prototype.inverse = function () {
-        var _a;
-        return (_a = this.computeInverse()) !== null && _a !== void 0 ? _a : Mat33.identity;
-    };
-    Mat33.prototype.invertable = function () {
-        return this.computeInverse() !== null;
-    };
-    Mat33.prototype.computeInverse = function () {
-        if (this.cachedInverse !== undefined) {
-            return this.cachedInverse;
-        }
-        var toIdentity = [
-            this.rows[0],
-            this.rows[1],
-            this.rows[2],
-        ];
-        var toResult = [
-            Vec3_1.default.unitX,
-            Vec3_1.default.unitY,
-            Vec3_1.default.unitZ,
-        ];
-        // Convert toIdentity to the identity matrix and
-        // toResult to the inverse through elementary row operations
-        for (var cursor = 0; cursor < 3; cursor++) {
-            // Select the [cursor]th diagonal entry
-            var pivot = toIdentity[cursor].at(cursor);
-            // Don't divide by zero (treat very small numbers as zero).
-            var minDivideBy = 1e-10;
-            if (Math.abs(pivot) < minDivideBy) {
-                var swapIndex = -1;
-                // For all other rows,
-                for (var i = 1; i <= 2; i++) {
-                    var otherRowIdx = (cursor + i) % 3;
-                    if (Math.abs(toIdentity[otherRowIdx].at(cursor)) >= minDivideBy) {
-                        swapIndex = otherRowIdx;
-                        break;
-                    }
-                }
-                // Can't swap with another row?
-                if (swapIndex === -1) {
-                    this.cachedInverse = null;
-                    return null;
-                }
-                var tmpIdentityRow = toIdentity[cursor];
-                var tmpResultRow = toResult[cursor];
-                // Swap!
-                toIdentity[cursor] = toIdentity[swapIndex];
-                toResult[cursor] = toResult[swapIndex];
-                toIdentity[swapIndex] = tmpIdentityRow;
-                toResult[swapIndex] = tmpResultRow;
-                pivot = toIdentity[cursor].at(cursor);
-            }
-            // Make toIdentity[k = cursor] = 1
-            var scale = 1.0 / pivot;
-            toIdentity[cursor] = toIdentity[cursor].times(scale);
-            toResult[cursor] = toResult[cursor].times(scale);
-            var cursorToIdentityRow = toIdentity[cursor];
-            var cursorToResultRow = toResult[cursor];
-            // Make toIdentity[k ≠ cursor] = 0
-            for (var i = 1; i <= 2; i++) {
-                var otherRowIdx = (cursor + i) % 3;
-                scale = -toIdentity[otherRowIdx].at(cursor);
-                toIdentity[otherRowIdx] = toIdentity[otherRowIdx].plus(cursorToIdentityRow.times(scale));
-                toResult[otherRowIdx] = toResult[otherRowIdx].plus(cursorToResultRow.times(scale));
-            }
-        }
-        var inverse = Mat33.ofRows(toResult[0], toResult[1], toResult[2]);
-        this.cachedInverse = inverse;
-        return inverse;
-    };
-    Mat33.prototype.transposed = function () {
-        return new Mat33(this.a1, this.b1, this.c1, this.a2, this.b2, this.c2, this.a3, this.b3, this.c3);
-    };
-    Mat33.prototype.rightMul = function (other) {
-        var _this = this;
-        other = other.transposed();
-        var at = function (row, col) {
-            return _this.rows[row].dot(other.rows[col]);
-        };
-        return new Mat33(at(0, 0), at(0, 1), at(0, 2), at(1, 0), at(1, 1), at(1, 2), at(2, 0), at(2, 1), at(2, 2));
-    };
-    /**
-     * Applies this as an **affine** transformation to the given vector.
-     * Returns a transformed version of `other`.
-     *
-     * Unlike {@link transformVec3}, this **does** translate the given vector.
-     */
-    Mat33.prototype.transformVec2 = function (other) {
-        // When transforming a Vec2, we want to use the z transformation
-        // components of this for translation:
-        //  ⎡ . . tX ⎤
-        //  ⎢ . . tY ⎥
-        //  ⎣ 0 0 1  ⎦
-        // For this, we need other's z component to be 1 (so that tX and tY
-        // are scaled by 1):
-        var intermediate = Vec3_1.default.of(other.x, other.y, 1);
-        intermediate = this.transformVec3(intermediate);
-        // Drop the z=1 to allow magnitude to work as expected
-        return Vec2_1.Vec2.of(intermediate.x, intermediate.y);
-    };
-    /**
-     * Applies this as a linear transformation to the given vector (doesn't translate).
-     * This is the standard way of transforming vectors in ℝ³.
-     */
-    Mat33.prototype.transformVec3 = function (other) {
-        return Vec3_1.default.of(this.rows[0].dot(other), this.rows[1].dot(other), this.rows[2].dot(other));
-    };
-    /** @returns true iff this is the identity matrix. */
-    Mat33.prototype.isIdentity = function () {
-        if (this === Mat33.identity) {
-            return true;
-        }
-        return this.eq(Mat33.identity);
-    };
-    /** Returns true iff this = other ± fuzz */
-    Mat33.prototype.eq = function (other, fuzz) {
-        if (fuzz === void 0) { fuzz = 0; }
-        for (var i = 0; i < 3; i++) {
-            if (!this.rows[i].eq(other.rows[i], fuzz)) {
-                return false;
-            }
-        }
-        return true;
-    };
-    Mat33.prototype.toString = function () {
-        var result = '';
-        var maxColumnLens = [0, 0, 0];
-        // Determine the longest item in each column so we can pad the others to that
-        // length.
-        for (var _i = 0, _a = this.rows; _i < _a.length; _i++) {
-            var row = _a[_i];
-            for (var i = 0; i < 3; i++) {
-                maxColumnLens[i] = Math.max(maxColumnLens[0], "".concat(row.at(i)).length);
-            }
-        }
-        for (var i = 0; i < 3; i++) {
-            if (i === 0) {
-                result += '⎡ ';
-            }
-            else if (i === 1) {
-                result += '⎢ ';
-            }
-            else {
-                result += '⎣ ';
-            }
-            // Add each component of the ith row (after padding it)
-            for (var j = 0; j < 3; j++) {
-                var val = this.rows[i].at(j).toString();
-                var padding = '';
-                for (var i_1 = val.length; i_1 < maxColumnLens[j]; i_1++) {
-                    padding += ' ';
-                }
-                result += val + ', ' + padding;
-            }
-            if (i === 0) {
-                result += ' ⎤';
-            }
-            else if (i === 1) {
-                result += ' ⎥';
-            }
-            else {
-                result += ' ⎦';
-            }
-            result += '\n';
-        }
-        return result.trimEnd();
-    };
-    /**
-     * ```
-     * result[0] = top left element
-     * result[1] = element at row zero, column 1
-     * ...
-     * ```
-     */
-    Mat33.prototype.toArray = function () {
-        return [
-            this.a1, this.a2, this.a3,
-            this.b1, this.b2, this.b3,
-            this.c1, this.c2, this.c3,
-        ];
-    };
-    /**
-     * Returns a new `Mat33` where each entry is the output of the function
-     * `mapping`.
-     *
-     * @example
-     * ```
-     * new Mat33(
-     *  1, 2, 3,
-     *  4, 5, 6,
-     *  7, 8, 9,
-     * ).mapEntries(component => component - 1);
-     * // → ⎡ 0, 1, 2 ⎤
-     * //   ⎢ 3, 4, 5 ⎥
-     * //   ⎣ 6, 7, 8 ⎦
-     * ```
-     */
-    Mat33.prototype.mapEntries = function (mapping) {
-        return new Mat33(mapping(this.a1, [0, 0]), mapping(this.a2, [0, 1]), mapping(this.a3, [0, 2]), mapping(this.b1, [1, 0]), mapping(this.b2, [1, 1]), mapping(this.b3, [1, 2]), mapping(this.c1, [2, 0]), mapping(this.c2, [2, 1]), mapping(this.c3, [2, 2]));
-    };
-    /** Estimate the scale factor of this matrix (based on the first row). */
-    Mat33.prototype.getScaleFactor = function () {
-        return Math.hypot(this.a1, this.a2);
-    };
-    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
-    Mat33.translation = function (amount) {
-        // When transforming Vec2s by a 3x3 matrix, we give the input
-        // Vec2s z = 1. As such,
-        //   outVec2.x = inVec2.x * 1 + inVec2.y * 0 + 1 * amount.x
-        //   ...
-        return new Mat33(1, 0, amount.x, 0, 1, amount.y, 0, 0, 1);
-    };
-    Mat33.zRotation = function (radians, center) {
-        if (center === void 0) { center = Vec2_1.Vec2.zero; }
-        if (radians === 0) {
-            return Mat33.identity;
-        }
-        var cos = Math.cos(radians);
-        var sin = Math.sin(radians);
-        // Translate everything so that rotation is about the origin
-        var result = Mat33.translation(center);
-        result = result.rightMul(new Mat33(cos, -sin, 0, sin, cos, 0, 0, 0, 1));
-        return result.rightMul(Mat33.translation(center.times(-1)));
-    };
-    Mat33.scaling2D = function (amount, center) {
-        if (center === void 0) { center = Vec2_1.Vec2.zero; }
-        var result = Mat33.translation(center);
-        var xAmount, yAmount;
-        if (typeof amount === 'number') {
-            xAmount = amount;
-            yAmount = amount;
-        }
-        else {
-            xAmount = amount.x;
-            yAmount = amount.y;
-        }
-        result = result.rightMul(new Mat33(xAmount, 0, 0, 0, yAmount, 0, 0, 0, 1));
-        // Translate such that [center] goes to (0, 0)
-        return result.rightMul(Mat33.translation(center.times(-1)));
-    };
-    /** @see {@link fromCSSMatrix} */
-    Mat33.prototype.toCSSMatrix = function () {
-        return "matrix(".concat(this.a1, ",").concat(this.b1, ",").concat(this.a2, ",").concat(this.b2, ",").concat(this.a3, ",").concat(this.b3, ")");
-    };
-    /**
-     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
-     *
-     * Note that such a matrix has the form,
-     * ```
-     * ⎡ a c e ⎤
-     * ⎢ b d f ⎥
-     * ⎣ 0 0 1 ⎦
-     * ```
-     */
-    Mat33.fromCSSMatrix = function (cssString) {
-        if (cssString === '' || cssString === 'none') {
-            return Mat33.identity;
-        }
-        var numberExp = '([-]?\\d*(?:\\.\\d*)?(?:[eE][-]?\\d+)?)';
-        var numberSepExp = '[, \\t\\n]';
-        var regExpSource = "^\\s*matrix\\s*\\(".concat([
-            // According to MDN, matrix(a,b,c,d,e,f) has form:
-            // 		⎡ a c e ⎤
-            // 		⎢ b d f ⎥
-            // 		⎣ 0 0 1 ⎦
-            numberExp, numberExp, numberExp,
-            numberExp, numberExp, numberExp, // b, d, f
-        ].join("".concat(numberSepExp, "+"))).concat(numberSepExp, "*\\)\\s*$");
-        var matrixExp = new RegExp(regExpSource, 'i');
-        var match = matrixExp.exec(cssString);
-        if (!match) {
-            throw new Error("Unsupported transformation: ".concat(cssString));
-        }
-        var matrixData = match.slice(1).map(function (entry) { return parseFloat(entry); });
-        var a = matrixData[0];
-        var b = matrixData[1];
-        var c = matrixData[2];
-        var d = matrixData[3];
-        var e = matrixData[4];
-        var f = matrixData[5];
-        var transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
-        return transform;
-    };
-    Mat33.identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);
-    return Mat33;
-}());
-exports.default = Mat33;

package/dist/cjs/math/Vec2.d.ts

@@ -1,33 +0,0 @@
-import Vec3 from './Vec3';
-export declare namespace Vec2 {
-    /**
-     * Creates a `Vec2` from an x and y coordinate.
-     *
-     * For example,
-     * ```ts
-     * const v = Vec2.of(3, 4); // x=3, y=4.
-     * ```
-     */
-    const of: (x: number, y: number) => Vec2;
-    /**
-     * Creates a `Vec2` from an object containing x and y coordinates.
-     *
-     * For example,
-     * ```ts
-     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
-     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
-     * ```
-     */
-    const ofXY: ({ x, y }: {
-        x: number;
-        y: number;
-    }) => Vec2;
-    /** A vector of length 1 in the X direction (→). */
-    const unitX: Vec3;
-    /** A vector of length 1 in the Y direction (↑). */
-    const unitY: Vec3;
-    /** The zero vector: A vector with x=0, y=0. */
-    const zero: Vec3;
-}
-export type Point2 = Vec3;
-export type Vec2 = Vec3;

package/dist/cjs/math/Vec2.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vec2 = void 0;
-var Vec3_1 = require("./Vec3");
-var Vec2;
-(function (Vec2) {
-    /**
-     * Creates a `Vec2` from an x and y coordinate.
-     *
-     * For example,
-     * ```ts
-     * const v = Vec2.of(3, 4); // x=3, y=4.
-     * ```
-     */
-    Vec2.of = function (x, y) {
-        return Vec3_1.default.of(x, y, 0);
-    };
-    /**
-     * Creates a `Vec2` from an object containing x and y coordinates.
-     *
-     * For example,
-     * ```ts
-     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
-     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
-     * ```
-     */
-    Vec2.ofXY = function (_a) {
-        var x = _a.x, y = _a.y;
-        return Vec3_1.default.of(x, y, 0);
-    };
-    /** A vector of length 1 in the X direction (→). */
-    Vec2.unitX = Vec2.of(1, 0);
-    /** A vector of length 1 in the Y direction (↑). */
-    Vec2.unitY = Vec2.of(0, 1);
-    /** The zero vector: A vector with x=0, y=0. */
-    Vec2.zero = Vec2.of(0, 0);
-})(Vec2 || (exports.Vec2 = Vec2 = {}));

package/dist/cjs/math/Vec3.d.ts

@@ -1,106 +0,0 @@
-/**
- * A vector with three components. Can also be used to represent a two-component vector.
- *
- * A `Vec3` is immutable.
- */
-export default class Vec3 {
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
-    private constructor();
-    /** Returns the x, y components of this. */
-    get xy(): {
-        x: number;
-        y: number;
-    };
-    static of(x: number, y: number, z: number): Vec3;
-    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
-    at(idx: number): number;
-    /** Alias for this.magnitude. */
-    length(): number;
-    magnitude(): number;
-    magnitudeSquared(): number;
-    /**
-     * Return this' angle in the XY plane (treats this as a Vec2).
-     *
-     * This is equivalent to `Math.atan2(vec.y, vec.x)`.
-     */
-    angle(): number;
-    /**
-     * Returns a unit vector in the same direction as this.
-     *
-     * If `this` has zero length, the resultant vector has `NaN` components.
-     */
-    normalized(): Vec3;
-    /** @returns A copy of `this` multiplied by a scalar. */
-    times(c: number): Vec3;
-    plus(v: Vec3): Vec3;
-    minus(v: Vec3): Vec3;
-    dot(other: Vec3): number;
-    cross(other: Vec3): Vec3;
-    /**
-     * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
-     * if `other is a `number`, returns the result of scalar multiplication.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
-     * ```
-     */
-    scale(other: Vec3 | number): Vec3;
-    /**
-     * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
-     * 90 degrees counter-clockwise.
-     */
-    orthog(): Vec3;
-    /** Returns this plus a vector of length `distance` in `direction`. */
-    extend(distance: number, direction: Vec3): Vec3;
-    /** Returns a vector `fractionTo` of the way to target from this. */
-    lerp(target: Vec3, fractionTo: number): Vec3;
-    /**
-     * `zip` Maps a component of this and a corresponding component of
-     * `other` to a component of the output vector.
-     *
-     * @example
-     * ```
-     * const a = Vec3.of(1, 2, 3);
-     * const b = Vec3.of(0.5, 2.1, 2.9);
-     *
-     * const zipped = a.zip(b, (aComponent, bComponent) => {
-     *   return Math.min(aComponent, bComponent);
-     * });
-     *
-     * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
-     * ```
-     */
-    zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
-    /**
-     * Returns a vector with each component acted on by `fn`.
-     *
-     * @example
-     * ```
-     * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
-     * ```
-     */
-    map(fn: (component: number, index: number) => number): Vec3;
-    asArray(): [number, number, number];
-    /**
-     * [fuzz] The maximum difference between two components for this and [other]
-     * to be considered equal.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 100);  // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 0.1);  // → false
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3);    // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3.01); // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
-     * ```
-     */
-    eq(other: Vec3, fuzz?: number): boolean;
-    toString(): string;
-    static unitX: Vec3;
-    static unitY: Vec3;
-    static unitZ: Vec3;
-    static zero: Vec3;
-}

package/dist/cjs/math/Vec3.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * A vector with three components. Can also be used to represent a two-component vector.
- *
- * A `Vec3` is immutable.
- */
-var Vec3 = /** @class */ (function () {
-    function Vec3(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    Object.defineProperty(Vec3.prototype, "xy", {
-        /** Returns the x, y components of this. */
-        get: function () {
-            // Useful for APIs that behave differently if .z is present.
-            return {
-                x: this.x,
-                y: this.y,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Vec3.of = function (x, y, z) {
-        return new Vec3(x, y, z);
-    };
-    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
-    Vec3.prototype.at = function (idx) {
-        if (idx === 0)
-            return this.x;
-        if (idx === 1)
-            return this.y;
-        if (idx === 2)
-            return this.z;
-        throw new Error("".concat(idx, " out of bounds!"));
-    };
-    /** Alias for this.magnitude. */
-    Vec3.prototype.length = function () {
-        return this.magnitude();
-    };
-    Vec3.prototype.magnitude = function () {
-        return Math.sqrt(this.dot(this));
-    };
-    Vec3.prototype.magnitudeSquared = function () {
-        return this.dot(this);
-    };
-    /**
-     * Return this' angle in the XY plane (treats this as a Vec2).
-     *
-     * This is equivalent to `Math.atan2(vec.y, vec.x)`.
-     */
-    Vec3.prototype.angle = function () {
-        return Math.atan2(this.y, this.x);
-    };
-    /**
-     * Returns a unit vector in the same direction as this.
-     *
-     * If `this` has zero length, the resultant vector has `NaN` components.
-     */
-    Vec3.prototype.normalized = function () {
-        var norm = this.magnitude();
-        return Vec3.of(this.x / norm, this.y / norm, this.z / norm);
-    };
-    /** @returns A copy of `this` multiplied by a scalar. */
-    Vec3.prototype.times = function (c) {
-        return Vec3.of(this.x * c, this.y * c, this.z * c);
-    };
-    Vec3.prototype.plus = function (v) {
-        return Vec3.of(this.x + v.x, this.y + v.y, this.z + v.z);
-    };
-    Vec3.prototype.minus = function (v) {
-        return Vec3.of(this.x - v.x, this.y - v.y, this.z - v.z);
-    };
-    Vec3.prototype.dot = function (other) {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    };
-    Vec3.prototype.cross = function (other) {
-        // | i  j  k |
-        // | x1 y1 z1| = (i)(y1z2 - y2z1) - (j)(x1z2 - x2z1) + (k)(x1y2 - x2y1)
-        // | x2 y2 z2|
-        return Vec3.of(this.y * other.z - other.y * this.z, other.x * this.z - this.x * other.z, this.x * other.y - other.x * this.y);
-    };
-    /**
-     * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
-     * if `other is a `number`, returns the result of scalar multiplication.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
-     * ```
-     */
-    Vec3.prototype.scale = function (other) {
-        if (typeof other === 'number') {
-            return this.times(other);
-        }
-        return Vec3.of(this.x * other.x, this.y * other.y, this.z * other.z);
-    };
-    /**
-     * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
-     * 90 degrees counter-clockwise.
-     */
-    Vec3.prototype.orthog = function () {
-        // If parallel to the z-axis
-        if (this.dot(Vec3.unitX) === 0 && this.dot(Vec3.unitY) === 0) {
-            return this.dot(Vec3.unitX) === 0 ? Vec3.unitX : this.cross(Vec3.unitX).normalized();
-        }
-        return this.cross(Vec3.unitZ.times(-1)).normalized();
-    };
-    /** Returns this plus a vector of length `distance` in `direction`. */
-    Vec3.prototype.extend = function (distance, direction) {
-        return this.plus(direction.normalized().times(distance));
-    };
-    /** Returns a vector `fractionTo` of the way to target from this. */
-    Vec3.prototype.lerp = function (target, fractionTo) {
-        return this.times(1 - fractionTo).plus(target.times(fractionTo));
-    };
-    /**
-     * `zip` Maps a component of this and a corresponding component of
-     * `other` to a component of the output vector.
-     *
-     * @example
-     * ```
-     * const a = Vec3.of(1, 2, 3);
-     * const b = Vec3.of(0.5, 2.1, 2.9);
-     *
-     * const zipped = a.zip(b, (aComponent, bComponent) => {
-     *   return Math.min(aComponent, bComponent);
-     * });
-     *
-     * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
-     * ```
-     */
-    Vec3.prototype.zip = function (other, zip) {
-        return Vec3.of(zip(other.x, this.x), zip(other.y, this.y), zip(other.z, this.z));
-    };
-    /**
-     * Returns a vector with each component acted on by `fn`.
-     *
-     * @example
-     * ```
-     * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
-     * ```
-     */
-    Vec3.prototype.map = function (fn) {
-        return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(this.z, 2));
-    };
-    Vec3.prototype.asArray = function () {
-        return [this.x, this.y, this.z];
-    };
-    /**
-     * [fuzz] The maximum difference between two components for this and [other]
-     * to be considered equal.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 100);  // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 0.1);  // → false
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3);    // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3.01); // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
-     * ```
-     */
-    Vec3.prototype.eq = function (other, fuzz) {
-        if (fuzz === void 0) { fuzz = 1e-10; }
-        for (var i = 0; i < 3; i++) {
-            if (Math.abs(other.at(i) - this.at(i)) > fuzz) {
-                return false;
-            }
-        }
-        return true;
-    };
-    Vec3.prototype.toString = function () {
-        return "Vec(".concat(this.x, ", ").concat(this.y, ", ").concat(this.z, ")");
-    };
-    Vec3.unitX = Vec3.of(1, 0, 0);
-    Vec3.unitY = Vec3.of(0, 1, 0);
-    Vec3.unitZ = Vec3.of(0, 0, 1);
-    Vec3.zero = Vec3.of(0, 0, 0);
-    return Vec3;
-}());
-exports.default = Vec3;