js-draw 0.23.0 → 0.24.0

package/dist/mjs/localizations/es.mjs

@@ -0,0 +1,29 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import  { defaultEditorLocalization }  from '../localization.mjs';
+// A partial Spanish localization.
+var localization = __assign(__assign({}, defaultEditorLocalization), { 
+    // Strings for the main editor interface
+    // (see src/localization.ts)
+    loading: function (percentage) { return "Cargando: ".concat(percentage, "%..."); }, imageEditor: 'Editor de dibujos', undoAnnouncement: function (commandDescription) { return "".concat(commandDescription, " fue deshecho"); }, redoAnnouncement: function (commandDescription) { return "".concat(commandDescription, " fue rehecho"); }, undo: 'Deshace', redo: 'Rehace', 
+    // Strings for the toolbar
+    // (see src/toolbar/localization.ts)
+    pen: 'Lapiz', eraser: 'Borrador', select: 'Selecciona', thicknessLabel: 'Tamaño: ', colorLabel: 'Color: ', doneLoading: 'El cargado terminó', fontLabel: 'Fuente: ', anyDevicePanning: 'Mover la pantalla con todo dispotivo', touchPanning: 'Mover la pantalla con un dedo', touchPanTool: 'Instrumento de mover la pantalla con un dedo', outlinedRectanglePen: 'Rectángulo con nada más que un borde', filledRectanglePen: 'Rectángulo sin borde', linePen: 'Línea', arrowPen: 'Flecha', freehandPen: 'Dibuja sin restricción de forma', selectPenType: 'Forma de dibuja:', handTool: 'Mover', zoom: 'Zoom', resetView: 'Reiniciar vista', resizeImageToSelection: 'Redimensionar la imagen a lo que está seleccionado', deleteSelection: 'Borra la selección', duplicateSelection: 'Duplica la selección', pickColorFromScreen: 'Selecciona un color de la pantalla', clickToPickColorAnnouncement: 'Haga un clic en la pantalla para seleccionar un color', dropdownShown: function (toolName) {
+        return "Men\u00FA por ".concat(toolName, " es visible");
+    }, dropdownHidden: function (toolName) {
+        return "Men\u00FA por ".concat(toolName, " fue ocultado");
+    }, colorChangedAnnouncement: function (color) {
+        return "Color fue cambiado a ".concat(color);
+    }, keyboardPanZoom: 'Mover la pantalla con el teclado', penTool: function (penId) {
+        return "Lapiz ".concat(penId);
+    }, selectionTool: 'Selecciona', eraserTool: 'Borrador', textTool: 'Texto', enterTextToInsert: 'Entra texto', textSize: 'Tamaño', rerenderAsText: 'Redibuja la pantalla al texto', lockRotation: 'Bloquea rotación', image: 'Imagen', imageSize: function (size, units) { return "Tama\u00F1o del imagen: ".concat(size, " ").concat(units); }, imageLoadError: function (message) { return "Error cargando imagen: ".concat(message); }, toggleOverflow: 'Más', documentProperties: 'Fondo', imageWidthOption: 'Ancho: ', imageHeightOption: 'Alto: ', backgroundColor: 'Color de fondo: ' });
+export default localization;

package/dist/mjs/localizations/getLocalizationTable.d.ts

@@ -0,0 +1,17 @@
+import { EditorLocalization } from '../localization';
+export declare const allLocales: Record<string, EditorLocalization>;
+/**
+ * Return the localization table in `localizationTables` that best matches
+ * the list of `userLocales`. If there is no matching language, returns
+ * `defaultLocalizationTable`.
+ */
+export declare const matchingLocalizationTable: <T>(userLocales: readonly string[], localizationTables: Record<string, T>, defaultLocalizationTable: T) => T;
+/**
+ * Returns a localization table for the `Editor` that matches
+ * the user's current locale.
+ *
+ * Returns the default localization table if no appropriate localization
+ * exists.
+ */
+declare const getLocalizationTable: (userLocales?: readonly string[]) => EditorLocalization;
+export default getLocalizationTable;

package/dist/mjs/localizations/getLocalizationTable.mjs

@@ -0,0 +1,61 @@
+import  { defaultEditorLocalization }  from '../localization.mjs';
+import  de  from './de.mjs';
+import  en  from './en.mjs';
+import  es  from './es.mjs';
+export var allLocales = {
+    de: de,
+    en: en,
+    es: es,
+};
+// [locale]: A string in the format languageCode_Region or just languageCode. For example, en_US.
+var languageFromLocale = function (locale) {
+    var matches = /^(\w+)[_-](\w+)$/.exec(locale);
+    if (!matches) {
+        // If not in languageCode_region format, the locale should be the
+        // languageCode. Return that.
+        return locale;
+    }
+    return matches[1];
+};
+/**
+ * Return the localization table in `localizationTables` that best matches
+ * the list of `userLocales`. If there is no matching language, returns
+ * `defaultLocalizationTable`.
+ */
+export var matchingLocalizationTable = function (userLocales, localizationTables, defaultLocalizationTable) {
+    var prevLanguage;
+    for (var _i = 0, userLocales_1 = userLocales; _i < userLocales_1.length; _i++) {
+        var locale = userLocales_1[_i];
+        var language = languageFromLocale(locale);
+        // If the specific localization of the language is not available, but
+        // a localization for the language is,
+        if (prevLanguage && language !== prevLanguage) {
+            if (prevLanguage in localizationTables) {
+                return localizationTables[prevLanguage];
+            }
+        }
+        // If the full locale (e.g. en_US) is available,
+        if (locale in localizationTables) {
+            return localizationTables[locale];
+        }
+        prevLanguage = language;
+    }
+    if (prevLanguage && prevLanguage in localizationTables) {
+        return localizationTables[prevLanguage];
+    }
+    else {
+        return defaultLocalizationTable;
+    }
+};
+/**
+ * Returns a localization table for the `Editor` that matches
+ * the user's current locale.
+ *
+ * Returns the default localization table if no appropriate localization
+ * exists.
+ */
+var getLocalizationTable = function (userLocales) {
+    userLocales !== null && userLocales !== void 0 ? userLocales : (userLocales = navigator.languages);
+    return matchingLocalizationTable(userLocales, allLocales, defaultEditorLocalization);
+};
+export default getLocalizationTable;

package/dist/mjs/localizations/getLocalizationTable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/math/Mat33.d.ts

@@ -0,0 +1,123 @@
+import { Point2, Vec2 } from './Vec2';
+import Vec3 from './Vec3';
+export type Mat33Array = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * 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).
+ */
+export default class Mat33 {
+    readonly a1: number;
+    readonly a2: number;
+    readonly a3: number;
+    readonly b1: number;
+    readonly b2: number;
+    readonly b3: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+    private readonly rows;
+    /**
+     * Creates a matrix from inputs in the form,
+     * ```
+     * ⎡ a1 a2 a3 ⎤
+     * ⎢ b1 b2 b3 ⎥
+     * ⎣ c1 c2 c3 ⎦
+     * ```
+     */
+    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
+    /**
+     * 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 ⎦
+     * ```
+     */
+    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
+    static identity: Mat33;
+    /**
+     * 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.
+     */
+    inverse(): Mat33;
+    invertable(): boolean;
+    private cachedInverse;
+    private computeInverse;
+    transposed(): Mat33;
+    rightMul(other: Mat33): Mat33;
+    /**
+     * 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.
+     */
+    transformVec2(other: Vec2): Vec2;
+    /**
+     * Applies this as a linear transformation to the given vector (doesn't translate).
+     * This is the standard way of transforming vectors in ℝ³.
+     */
+    transformVec3(other: Vec3): Vec3;
+    /** @returns true iff this is the identity matrix. */
+    isIdentity(): boolean;
+    /** Returns true iff this = other ± fuzz */
+    eq(other: Mat33, fuzz?: number): boolean;
+    toString(): string;
+    /**
+     * ```
+     * result[0] = top left element
+     * result[1] = element at row zero, column 1
+     * ...
+     * ```
+     */
+    toArray(): Mat33Array;
+    /**
+     * 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 ⎦
+     * ```
+     */
+    mapEntries(mapping: (component: number, rowcol: [number, number]) => number): Mat33;
+    /** Estimate the scale factor of this matrix (based on the first row). */
+    getScaleFactor(): number;
+    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
+    static translation(amount: Vec2): Mat33;
+    static zRotation(radians: number, center?: Point2): Mat33;
+    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
+    /** @see {@link fromCSSMatrix} */
+    toCSSMatrix(): string;
+    /**
+     * 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 ⎦
+     * ```
+     */
+    static fromCSSMatrix(cssString: string): Mat33;
+}

package/dist/mjs/math/Mat33.mjs

@@ -0,0 +1,338 @@
+import  { Vec2 }  from './Vec2.mjs';
+import  Vec3  from './Vec3.mjs';
+/**
+ * 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.of(a1, a2, a3),
+            Vec3.of(b1, b2, b3),
+            Vec3.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.unitX,
+            Vec3.unitY,
+            Vec3.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.of(other.x, other.y, 1);
+        intermediate = this.transformVec3(intermediate);
+        // Drop the z=1 to allow magnitude to work as expected
+        return 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.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.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.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;
+}());
+export default Mat33;

package/dist/mjs/math/Mat33.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/math/Vec2.mjs

@@ -0,0 +1,34 @@
+import  Vec3  from './Vec3.mjs';
+export 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.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.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 || (Vec2 = {}));

package/dist/mjs/math/Vec2.test.d.ts

@@ -0,0 +1 @@
+export {};