@matboks/utilities 0.0.1

package/dist/geometry/polyline.js

@@ -0,0 +1,100 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Polyline_instances, _Polyline_edges, _Polyline_computeEdges, _Polyline_hull, _Polyline_center, _Polyline_aabb, _Polyline_modifyVertices;
+import { AABB } from "./aabb.js";
+import { Segment } from "./segment.js";
+import { computeConvexHull } from "./shared.js";
+export class Polyline {
+    edges() { return __classPrivateFieldSet(this, _Polyline_edges, __classPrivateFieldGet(this, _Polyline_edges, "f") ?? __classPrivateFieldGet(this, _Polyline_instances, "m", _Polyline_computeEdges).call(this), "f"); }
+    ;
+    hull() { return __classPrivateFieldSet(this, _Polyline_hull, __classPrivateFieldGet(this, _Polyline_hull, "f") ?? computeConvexHull(this.vertices), "f"); }
+    center() { return __classPrivateFieldSet(this, _Polyline_center, __classPrivateFieldGet(this, _Polyline_center, "f") ?? this.hull().centroid(), "f"); }
+    aabb() { return __classPrivateFieldSet(this, _Polyline_aabb, __classPrivateFieldGet(this, _Polyline_aabb, "f") ?? AABB.fromVertices(this.vertices), "f"); }
+    numVertices() { return this.vertices.length; }
+    constructor(vertices) {
+        _Polyline_instances.add(this);
+        _Polyline_edges.set(this, void 0);
+        _Polyline_hull.set(this, void 0);
+        _Polyline_center.set(this, void 0);
+        _Polyline_aabb.set(this, void 0);
+        this.vertices = vertices;
+    }
+    clone() {
+        const clonedVertices = this.vertices.map(vertex => vertex.clone());
+        return new Polyline(clonedVertices);
+    }
+    translate(translation) {
+        return __classPrivateFieldGet(this, _Polyline_instances, "m", _Polyline_modifyVertices).call(this, vertex => vertex.plus(translation));
+    }
+    rotate(rotation, center) {
+        center ?? (center = this.center());
+        return __classPrivateFieldGet(this, _Polyline_instances, "m", _Polyline_modifyVertices).call(this, vertex => vertex.rotate(rotation, center));
+    }
+    scale(scale, center) {
+        center ?? (center = this.center());
+        return __classPrivateFieldGet(this, _Polyline_instances, "m", _Polyline_modifyVertices).call(this, vertex => vertex.minus(center).times(scale).plus(center));
+    }
+    nearestPointOn(point) {
+        const nearestSegment = this.nearestSegmentToPoint(point);
+        return nearestSegment.getNearestPoint(point);
+    }
+    nearestSegmentToPoint(point) {
+        const edges = this.edges();
+        let nearestSegment = edges[0];
+        let nearestDistance = nearestSegment.distanceToPoint(point);
+        for (let i = 1, n = edges.length; i < n; i++) {
+            const segment = edges[i];
+            const currentDistance = segment.distanceToPoint(point);
+            if (currentDistance < nearestDistance) {
+                nearestDistance = currentDistance;
+                nearestSegment = segment;
+            }
+        }
+        return nearestSegment;
+    }
+    distanceToPoint(point) {
+        return point.distance(this.nearestPointOn(point));
+    }
+    render(ctx, beginPath = true) {
+        const { vertices } = this;
+        if (beginPath)
+            ctx.beginPath();
+        ctx.moveTo(vertices[0].x, vertices[0].y);
+        for (let i = 1, n = vertices.length; i < n; i++) {
+            const { x, y } = vertices[i];
+            ctx.lineTo(x, y);
+        }
+    }
+    resetMemoized() {
+        __classPrivateFieldSet(this, _Polyline_aabb, undefined, "f");
+        __classPrivateFieldSet(this, _Polyline_edges, undefined, "f");
+        __classPrivateFieldSet(this, _Polyline_center, undefined, "f");
+        __classPrivateFieldSet(this, _Polyline_hull, undefined, "f");
+    }
+}
+_Polyline_edges = new WeakMap(), _Polyline_hull = new WeakMap(), _Polyline_center = new WeakMap(), _Polyline_aabb = new WeakMap(), _Polyline_instances = new WeakSet(), _Polyline_computeEdges = function _Polyline_computeEdges() {
+    const { vertices } = this;
+    const edges = [];
+    for (let i = 0, n = vertices.length - 1; i < n; i++) {
+        edges.push(new Segment(vertices[i], vertices[i + 1]));
+    }
+    return edges;
+}, _Polyline_modifyVertices = function _Polyline_modifyVertices(modification) {
+    if (typeof modification === "function") {
+        this.vertices.forEach(modification);
+    }
+    else {
+        this.vertices = modification;
+    }
+    this.resetMemoized();
+    return this;
+};

package/dist/geometry/ray.d.ts

@@ -0,0 +1,6 @@
+import { Vec2 } from "./vec2.js";
+export declare class Ray {
+    point: Vec2;
+    direction: Vec2;
+    constructor(point: Vec2, direction: Vec2);
+}

package/dist/geometry/ray.js

@@ -0,0 +1,6 @@
+export class Ray {
+    constructor(point, direction) {
+        this.point = point;
+        this.direction = direction;
+    }
+}

package/dist/geometry/ray3.d.ts

@@ -0,0 +1,7 @@
+import { Vec3 } from "./vec3.js";
+export declare class Ray3 {
+    point: Vec3;
+    direction: Vec3;
+    constructor(point: Vec3, direction: Vec3);
+    interpolate(time: number): Vec3;
+}

package/dist/geometry/ray3.js

@@ -0,0 +1,10 @@
+import { Vec3 } from "./vec3.js";
+export class Ray3 {
+    constructor(point, direction) {
+        this.point = point;
+        this.direction = direction;
+    }
+    interpolate(time) {
+        return Vec3.add(this.point, Vec3.multiply(this.direction, time));
+    }
+}

package/dist/geometry/segment.d.ts

@@ -0,0 +1,16 @@
+import { AABB } from "./aabb.js";
+import { Vec2 } from "./vec2.js";
+export declare class Segment {
+    #private;
+    readonly start: Vec2;
+    readonly end: Vec2;
+    readonly vector: Vec2;
+    aabb(): AABB;
+    constructor(start: Vec2, end: Vec2);
+    length(): number;
+    interpolate(position: number): Vec2;
+    scalarProjectOnto(position: Vec2): number;
+    getNearestPoint(position: Vec2): Vec2;
+    distanceToPoint(point: Vec2): number;
+    intersects(other: Segment): boolean;
+}

package/dist/geometry/segment.js

@@ -0,0 +1,50 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Segment_aabb;
+import { EPS } from "../constants.js";
+import { clamp } from "../math/clamp.js";
+import { AABB } from "./aabb.js";
+import { Vec2 } from "./vec2.js";
+const { abs } = Math;
+export class Segment {
+    aabb() { return __classPrivateFieldSet(this, _Segment_aabb, __classPrivateFieldGet(this, _Segment_aabb, "f") ?? AABB.fromVertices([this.start, this.end]), "f"); }
+    constructor(start, end) {
+        _Segment_aabb.set(this, void 0);
+        this.start = start;
+        this.end = end;
+        this.vector = Vec2.subtract(this.end, this.start);
+    }
+    length() { return this.vector.length(); }
+    interpolate(position) {
+        return Vec2.interpolate(this.start, this.end, clamp(position));
+    }
+    scalarProjectOnto(position) {
+        return Vec2.subtract(position, this.start).scalarProjectOnto(this.vector);
+    }
+    getNearestPoint(position) {
+        return this.interpolate(this.scalarProjectOnto(position));
+    }
+    distanceToPoint(point) {
+        const nearestPoint = this.getNearestPoint(point);
+        return point.distance(nearestPoint);
+    }
+    intersects(other) {
+        const cross = this.vector.cross(other.vector);
+        if (abs(cross) < EPS)
+            return false;
+        const startDifference = Vec2.subtract(other.start, this.start);
+        const time1 = startDifference.cross(other.vector) / cross;
+        const time2 = startDifference.cross(this.vector) / cross;
+        return time1 > 0 && time1 < 1 && time2 > 0 && time2 < 1;
+    }
+}
+_Segment_aabb = new WeakMap();

package/dist/geometry/shared.d.ts

@@ -0,0 +1,5 @@
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Vec2 } from "./vec2.js";
+export declare function computeConvexHull(vertices: Vec2[]): Polygon;
+export declare function computeLineIntersection(line1: Line, line2: Line): [number, number] | null;

package/dist/geometry/shared.js

@@ -0,0 +1,60 @@
+import { EPS } from "../constants.js";
+import { Polygon } from "./polygon.js";
+import { Vec2 } from "./vec2.js";
+export function computeConvexHull(vertices) {
+    let pivot = vertices[0];
+    const numVertices = vertices.length;
+    for (let i = 1; i < numVertices; i++) {
+        const vertex = vertices[i];
+        if (vertex.y < pivot.y || (Math.abs(vertex.y - pivot.y) < EPS && vertex.x > pivot.x)) {
+            pivot = vertex;
+        }
+    }
+    const indices = vertices.map((_, i) => i);
+    const angles = vertices.map((vertex) => Vec2.subtract(vertex, pivot).angle());
+    const distances = vertices.map((vertex) => vertex.distanceSquared(pivot));
+    indices.sort((i, j) => {
+        const angleI = angles[i];
+        const angleJ = angles[j];
+        if (Math.abs(angleI - angleJ) < EPS)
+            return distances[i] - distances[j];
+        return angleI - angleJ;
+    });
+    for (let i = 1; i < numVertices - 1; i++) {
+        if (angles[indices[i]] === angles[indices[i + 1]])
+            indices[i] = -1;
+    }
+    const hull = [];
+    for (let i = 0; i < numVertices; i++) {
+        const index = indices[i];
+        if (index === -1)
+            continue;
+        const vertex = vertices[index];
+        if (hull.length < 3) {
+            hull.push(vertex);
+        }
+        else {
+            while (true) {
+                const n = hull.length;
+                if (n < 3)
+                    break;
+                const secondLast = hull[n - 2];
+                const last = hull[n - 1];
+                if (Vec2.subtract(last, secondLast).cross(Vec2.subtract(vertex, secondLast)) > 0)
+                    break;
+                hull.pop();
+            }
+            hull.push(vertex);
+        }
+    }
+    return new Polygon(hull);
+}
+export function computeLineIntersection(line1, line2) {
+    const denominator = line1.direction.cross(line2.direction);
+    if (Math.abs(denominator) < EPS)
+        return null;
+    const positionDiff = Vec2.subtract(line2.point, line1.point);
+    let line1Time = positionDiff.cross(line2.direction) / denominator;
+    let line2Time = positionDiff.cross(line1.direction) / denominator;
+    return [line1Time, line2Time];
+}

package/dist/geometry/transformations.d.ts

@@ -0,0 +1,7 @@
+import { Vec2 } from "./vec2.js";
+import { Vec3 } from "./vec3.js";
+export declare function create2DBasis(normal: Vec3, rotation?: number): readonly [Vec3, Vec3];
+export declare function create3DTo2DMapper(origin: Vec3, normal: Vec3): {
+    to2D: (v: Vec3) => Vec2;
+    to3D: (v: Vec2) => Vec3;
+};

package/dist/geometry/transformations.js

@@ -0,0 +1,28 @@
+import { EPS } from "../constants.js";
+import { vec2 } from "./vec2.js";
+import { Vec3, vec3 } from "./vec3.js";
+// Creates a coordinate system with unit vectors (i, j, k), where k is specified as normal
+export function create2DBasis(normal, rotation) {
+    normal = normal.clone().normalize();
+    const i = normal.cross(Math.abs(normal.z) > (1 - EPS) ? vec3(1, 0, 0) : vec3(0, 0, 1)).normalize();
+    const j = normal.cross(i);
+    const vectors = [i, j];
+    if (rotation) {
+        for (const v of vectors)
+            v.axisAngleRotate(normal, rotation);
+    }
+    return vectors;
+}
+export function create3DTo2DMapper(origin, normal) {
+    const [i, j] = create2DBasis(normal);
+    const to2D = (v) => {
+        const vCentered = Vec3.subtract(v, origin);
+        return vec2(i.dot(vCentered), j.dot(vCentered));
+    };
+    const to3D = (v) => {
+        return Vec3.multiply(i, v.x).plus(Vec3.multiply(j, v.y)).plus(origin);
+    };
+    return {
+        to2D, to3D
+    };
+}

package/dist/geometry/vec2.d.ts

@@ -0,0 +1,71 @@
+export declare function vec2(vector: Vec2): Vec2;
+export declare function vec2(x: number, y?: number): Vec2;
+export declare class Vec2 {
+    x: number;
+    y: number;
+    length(): number;
+    lengthSquared(): number;
+    angle(): number;
+    get xx(): Vec2;
+    get xy(): Vec2;
+    get yx(): Vec2;
+    get yy(): Vec2;
+    constructor(vector: Vec2);
+    constructor(x: number, y?: number);
+    static fromPolar: (radius: number, angle: number) => Vec2;
+    static add(left: Vec2, ...right: Array<Vec2>): Vec2;
+    static subtract(left: Vec2, right: Vec2): Vec2;
+    static multiply(vector: Vec2, value: number | Vec2): Vec2;
+    static dot(a: Vec2, b: Vec2): number;
+    static cross(a: Vec2, b: Vec2): number;
+    static interpolate(start: Vec2, end: Vec2, position: number): Vec2;
+    static midpoint(start: Vec2, end: Vec2): Vec2;
+    static absolute(vector: Vec2): Vec2;
+    static distance(a: Vec2, b: Vec2): number;
+    static angle(start: Vec2, end: Vec2): number;
+    static bisector(vector1: Vec2, vector2: Vec2): Vec2;
+    static toBuffer(vertices: Array<Vec2>): number[];
+    static smoothstep(vector: Vec2, lower?: number | Vec2, upper?: number | Vec2): Vec2;
+    setX(x: number): this;
+    setY(y: number): this;
+    setCoordinates(vector: Vec2): Vec2;
+    setCoordinates(x: number, y?: number): Vec2;
+    clone(): Vec2;
+    copy(vector: Vec2): Vec2;
+    plus(vector: Vec2): Vec2;
+    minus(vector: Vec2): Vec2;
+    times(value: number | Vec2): Vec2;
+    distance(vector: Vec2): number;
+    distanceSquared(vector: Vec2): number;
+    perpendicular(): Vec2;
+    rotate(rotation: number, centerOfRotation?: Vec2): this;
+    dot(vector: Vec2): number;
+    cross(vector: Vec2): number;
+    scalarProjectOnto(target: Vec2): number;
+    projectOnto(target: Vec2): Vec2;
+    rejectOnto(target: Vec2): Vec2;
+    scalarRejectOnto(target: Vec2): number;
+    reflectByVector(vector: Vec2): Vec2;
+    reflectByPoint(point: Vec2): Vec2;
+    normalize(): Vec2;
+    absolute(): Vec2;
+    negate(): Vec2;
+    floor(): Vec2;
+    round(): Vec2;
+    fract(): Vec2;
+    signed(): Vec2;
+    toVec3(z?: number): import("./vec3.js").Vec3;
+    sum(): number;
+    product(): number;
+    smoothstep(lower?: number | Vec2, upper?: number | Vec2): Vec2;
+    min(): number;
+    max(): number;
+    mod(modulo: number | Vec2): Vec2;
+    clamp(lower?: number | Vec2, upper?: number | Vec2): Vec2;
+    pow(power: number | Vec2): Vec2;
+    reflect(vector: Vec2): Vec2;
+    splitIntoIntAndFract(): [Vec2, Vec2];
+    toString(precision?: number): string;
+    toArray(): [number, number];
+}
+export declare function ensureVec2(value: number | Vec2): Vec2;

package/dist/geometry/vec2.js

@@ -0,0 +1,225 @@
+import { clamp, fract, smoothstep, mod, splitIntoIntAndFract } from "../math/index.js";
+import { vec3 } from "./vec3.js";
+const { cos, sin, abs, floor, round, hypot, atan2, min, max, pow, PI } = Math;
+export function vec2(...args) {
+    return new Vec2(args[0], args[1]);
+}
+export class Vec2 {
+    length() { return hypot(this.x, this.y); }
+    lengthSquared() { const x = this.x, y = this.y; return x * x + y * y; }
+    angle() { return atan2(this.y, this.x); }
+    get xx() { return vec2(this.x); }
+    get xy() { return vec2(this.x, this.y); }
+    get yx() { return vec2(this.y, this.x); }
+    get yy() { return vec2(this.y); }
+    constructor(...args) {
+        this.setCoordinates(args[0], args[1]);
+    }
+    static add(left, ...right) {
+        left = left.clone();
+        for (let vector of right)
+            left.plus(vector);
+        return left;
+    }
+    static subtract(left, right) {
+        return left.clone().minus(right);
+    }
+    static multiply(vector, value) {
+        return vector.clone().times(value);
+    }
+    static dot(a, b) {
+        return a.dot(b);
+    }
+    static cross(a, b) {
+        return a.cross(b);
+    }
+    static interpolate(start, end, position) {
+        return start.clone().times(1 - position).plus(Vec2.multiply(end, position));
+    }
+    static midpoint(start, end) {
+        return Vec2.interpolate(start, end, 0.5);
+    }
+    static absolute(vector) {
+        return vector.clone().absolute();
+    }
+    static distance(a, b) {
+        return Vec2.subtract(b, a).length();
+    }
+    static angle(start, end) {
+        return mod(end.angle() - start.angle() + PI, 2 * PI) - PI; // returns in range [-PI, PI]
+    }
+    static bisector(vector1, vector2) {
+        const angle = Vec2.angle(vector1, vector2);
+        return vector1.clone().rotate(angle / 2);
+    }
+    static toBuffer(vertices) {
+        const data = [];
+        for (const vertex of vertices) {
+            data.push(vertex.x, vertex.y);
+        }
+        return data;
+    }
+    static smoothstep(vector, lower = 0, upper = 1) {
+        return vector.clone().smoothstep(lower, upper);
+    }
+    setX(x) {
+        this.x = x;
+        return this;
+    }
+    setY(y) {
+        this.y = y;
+        return this;
+    }
+    setCoordinates(...args) {
+        const [a, b] = args;
+        if (typeof a === "object") {
+            this.x = a.x;
+            this.y = a.y;
+        }
+        else {
+            this.x = a;
+            this.y = b ?? a;
+        }
+        return this;
+    }
+    clone() {
+        return vec2(this.x, this.y);
+    }
+    copy(vector) {
+        return this.setCoordinates(vector);
+    }
+    plus(vector) {
+        return this.setCoordinates(this.x + vector.x, this.y + vector.y);
+    }
+    minus(vector) {
+        return this.setCoordinates(this.x - vector.x, this.y - vector.y);
+    }
+    times(value) {
+        value = ensureVec2(value);
+        return this.setCoordinates(value.x * this.x, value.y * this.y);
+    }
+    distance(vector) {
+        return hypot(vector.x - this.x, vector.y - this.y);
+    }
+    distanceSquared(vector) {
+        let dx = vector.x - this.x;
+        let dy = vector.y - this.y;
+        return dx * dx + dy * dy;
+    }
+    perpendicular() {
+        return vec2(this.y, -this.x);
+    }
+    rotate(rotation, centerOfRotation) {
+        if (centerOfRotation)
+            this.minus(centerOfRotation);
+        let x = this.x, y = this.y;
+        const c = cos(rotation);
+        const s = sin(rotation);
+        this.setCoordinates(x * c - y * s, x * s + y * c);
+        if (centerOfRotation)
+            this.plus(centerOfRotation);
+        return this;
+    }
+    dot(vector) {
+        return this.x * vector.x + this.y * vector.y;
+    }
+    cross(vector) {
+        return this.x * vector.y - vector.x * this.y;
+    }
+    scalarProjectOnto(target) {
+        return this.dot(target) / target.dot(target);
+    }
+    projectOnto(target) {
+        return target.clone().times(this.scalarProjectOnto(target));
+    }
+    rejectOnto(target) {
+        return Vec2.subtract(this, this.projectOnto(target));
+    }
+    scalarRejectOnto(target) {
+        return this.rejectOnto(target).length();
+    }
+    reflectByVector(vector) {
+        const rejection = this.rejectOnto(vector);
+        return this.clone().minus(rejection.times(2));
+    }
+    reflectByPoint(point) {
+        const translation = Vec2.subtract(point, this).times(2);
+        return this.clone().plus(translation);
+    }
+    normalize() {
+        return this.times(1 / this.length());
+    }
+    absolute() {
+        return this.setCoordinates(abs(this.x), abs(this.y));
+    }
+    negate() {
+        return this.times(-1);
+    }
+    floor() {
+        return this.setCoordinates(floor(this.x), floor(this.y));
+    }
+    round() {
+        return this.setCoordinates(round(this.x), round(this.y));
+    }
+    fract() {
+        return this.setCoordinates(fract(this.x), fract(this.y));
+    }
+    signed() {
+        return this.times(2).plus(vec2(-1));
+    }
+    toVec3(z) {
+        return vec3(this.x, this.y, z);
+    }
+    sum() {
+        return this.x + this.y;
+    }
+    product() {
+        return this.x * this.y;
+    }
+    smoothstep(lower = 0, upper = 1) {
+        lower = ensureVec2(lower);
+        upper = ensureVec2(upper);
+        return this.setCoordinates(smoothstep(this.x, lower.x, upper.x), smoothstep(this.y, lower.y, upper.y));
+    }
+    min() {
+        return min(this.x, this.y);
+    }
+    max() {
+        return max(this.x, this.y);
+    }
+    mod(modulo) {
+        modulo = ensureVec2(modulo);
+        return this.setCoordinates(mod(this.x, modulo.y), mod(this.y, modulo.x));
+    }
+    clamp(lower = 0, upper = 1) {
+        lower = ensureVec2(lower);
+        upper = ensureVec2(upper);
+        return this.setCoordinates(clamp(this.x, lower.x, upper.x), clamp(this.y, lower.y, upper.y));
+    }
+    pow(power) {
+        power = ensureVec2(power);
+        return this.setCoordinates(pow(this.x, power.x), pow(this.y, power.y));
+    }
+    reflect(vector) {
+        const normalizedVector = vector.clone().normalize();
+        const reflectedVector = Vec2.subtract(this, Vec2.multiply(normalizedVector, 2 * this.dot(normalizedVector)));
+        return this.setCoordinates(reflectedVector);
+    }
+    splitIntoIntAndFract() {
+        const [xi, xf] = splitIntoIntAndFract(this.x);
+        const [yi, yf] = splitIntoIntAndFract(this.y);
+        return [vec2(xi, yi), vec2(xf, yf)];
+    }
+    toString(precision = 3) {
+        return `(${this.x.toFixed(precision)}, ${this.y.toFixed(precision)})`;
+    }
+    toArray() {
+        return [this.x, this.y];
+    }
+}
+Vec2.fromPolar = function (radius, angle) {
+    return vec2(radius * cos(angle), radius * sin(angle));
+};
+export function ensureVec2(value) {
+    return value = typeof value === "number" ? vec2(value) : value;
+}