curvy 1.0.9 → 2.0.0-alpha.2

package/dist/{pipe.d.mts → shared/utils-MCckigYk.d.mts}

@@ -1,3 +1,4 @@
+//#region src/utils.d.ts
 /**
  * pipe() and dual() are slightly modified versions of Effect-TS's pipe() and dual() functions.
  * https://github.com/effect-ts/core/blob/main/src/function.ts
@@ -7,8 +8,8 @@
  */
 type AnyFunction = (...args: Array<any>) => any;
 declare const dual: {
-    <DataLast extends AnyFunction, DataFirst extends AnyFunction>(arity: Parameters<DataFirst>['length'], body: DataFirst): DataLast & DataFirst;
-    <DataLast extends AnyFunction, DataFirst extends AnyFunction>(isDataFirst: (args: IArguments) => boolean, body: DataFirst): DataLast & DataFirst;
+  <DataLast extends AnyFunction, DataFirst extends AnyFunction>(arity: Parameters<DataFirst>['length'], body: DataFirst): DataLast & DataFirst;
+  <DataLast extends AnyFunction, DataFirst extends AnyFunction>(isDataFirst: (args: IArguments) => boolean, body: DataFirst): DataLast & DataFirst;
 };
 declare function pipe<A>(a: A): A;
 declare function pipe<A, B = never>(a: A, ab: (a: A) => B): B;
@@ -31,28 +32,45 @@ declare function pipe<A, B = never, C = never, D = never, E = never, F = never,
 declare function pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S): S;
 declare function pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T): T;
 declare class Pipeable {
-    pipe<A>(this: A): A;
-    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
-    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
-    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
-    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
-    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
-    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+  pipe<A>(this: A): A;
+  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
 }
-
-export { Pipeable, dual, pipe };
+/**
+ * Asserts that a condition is true, throwing an error with the provided message if it is not.
+ *
+ * @param condition - The condition to assert.
+ * @param message - The error message to throw if the condition is false.
+ * @throws An error with the provided message if the condition is false.
+ * @example
+ * ```ts
+ * import { invariant } from 'curvy/utils'
+ *
+ * invariant(1 + 1 === 2, 'Math is broken!') // No error
+ * invariant(1 + 1 === 3, 'Math is broken!') // Throws: Math is broken!
+ * ```
+ * @since 1.0.0
+ */
+declare function invariant(condition: boolean, message: string): asserts condition;
+//#endregion
+export { pipe as i, dual as n, invariant as r, Pipeable as t };
+//# sourceMappingURL=utils-MCckigYk.d.mts.map

package/dist/shared/vector2-CL1HDdPr.mjs

@@ -0,0 +1,187 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { C as subtract$1, D as withWeight$1, E as weightedEquals$1, S as softmax$1, T as unweighted$1, _ as scale$1, a as equals$1, b as setX$1, c as getX$1, d as isVector2$1, f as isWeighted$1, g as normalize$1, h as makeWeighted$1, i as dot$1, l as getY$1, m as make$1, n as components$1, o as fromPolar$1, p as magnitude$1, r as cross$1, s as getTheta$1, t as add$1, u as hadamard$1, v as setR$1, w as transpose$1, x as setY$1, y as setTheta$1 } from "./vector2.internal-DU_E808S.mjs";
+//#region src/vector/vector2.ts
+var vector2_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	components: () => components,
+	cross: () => cross,
+	dot: () => dot,
+	equals: () => equals,
+	fromPolar: () => fromPolar,
+	getR: () => getR,
+	getTheta: () => getTheta,
+	getX: () => getX,
+	getY: () => getY,
+	hadamard: () => hadamard,
+	isVector2: () => isVector2,
+	isWeighted: () => isWeighted,
+	magnitude: () => magnitude,
+	make: () => make,
+	makeWeighted: () => makeWeighted,
+	normalize: () => normalize,
+	scale: () => scale,
+	setR: () => setR,
+	setTheta: () => setTheta,
+	setX: () => setX,
+	setY: () => setY,
+	softmax: () => softmax,
+	subtract: () => subtract,
+	transpose: () => transpose,
+	unit: () => unit,
+	unweighted: () => unweighted,
+	weightedEquals: () => weightedEquals,
+	withWeight: () => withWeight,
+	zero: () => zero
+});
+/**
+* Checks if a value is a `Vector2`.
+*
+* @param v - The value to check.
+* @returns `true` if the value is a `Vector2`, `false` otherwise.
+* @since 1.0.0
+*/
+const isVector2 = isVector2$1;
+/**
+* Checks if a value is a `Vector2.Weighted`.
+*
+* @param v - The value to check.
+* @returns `true` if the value is a `Vector2.Weighted`, `false` otherwise.
+* @since 2.1.0
+*/
+const isWeighted = isWeighted$1;
+/**
+* Creates a new `Vector2.Weighted` from raw components. The weight must be
+* finite and positive.
+*
+* @param x - The x component.
+* @param y - The y component.
+* @param weight - The positive scalar weight.
+* @returns A new `Vector2.Weighted` instance.
+* @since 2.1.0
+*/
+const makeWeighted = makeWeighted$1;
+const withWeight = withWeight$1;
+/**
+* Strips the weight from a `Vector2.Weighted`, returning the underlying point.
+*
+* @param w - The weighted point.
+* @returns A new `Vector2` instance with the same x and y components.
+* @since 2.1.0
+*/
+const unweighted = unweighted$1;
+const weightedEquals = weightedEquals$1;
+const equals = equals$1;
+const make = make$1;
+/**
+* Transposes a 2-tuple of items into one or more `Vector2`s, one per channel
+* extracted by the projection function. See {@link Vector4.transpose} for the
+* full operation description; this is the 2-component analog.
+*
+* @param inputs - Exactly two items of any type.
+* @param project - A function returning a fixed-arity tuple of numbers — one per output channel.
+* @returns A tuple of `Vector2`s with the same arity as the projection's return tuple.
+* @since 2.1.0
+*/
+const transpose = transpose$1;
+/**
+* Creates a new `Vector2` instance from polar coordinates.
+*
+* @param r - The radius.
+* @param theta - The angle, in radians.
+* @returns A new `Vector2` instance.
+* @since 1.0.0
+*/
+const fromPolar = fromPolar$1;
+/**
+* Calculates the magnitude of a `Vector2`.
+*
+* @param vector - The vector to calculate the magnitude of.
+* @returns The magnitude of the vector.
+* @since 1.0.0
+*/
+const magnitude = magnitude$1;
+/**
+* Normalizes a `Vector2`.
+*
+* @param vector - The vector to normalize.
+* @returns A new `Vector2` instance with the same direction and a magnitude of 1.
+* @since 1.0.0
+*/
+const normalize = normalize$1;
+const dot = dot$1;
+const cross = cross$1;
+/**
+* Returns the components of a `Vector2` as an array.
+*
+* @param r - The radius.
+* @param theta - The angle, in radians.
+* @returns A new `Vector2` instance.
+* @since 1.0.0
+*/
+const components = components$1;
+/**
+* Applies the softmax function to a `Vector2`.
+*
+* @param v - The vector to apply the softmax function to.
+* @returns A new `Vector2` instance with the softmax applied.
+* @since 1.0.0
+*/
+const softmax = softmax$1;
+/**
+* Creates a zero vector.
+*
+* @returns A new `Vector2` instance with both components set to 0.
+* @since 1.0.0
+*/
+const zero = make(0);
+/**
+* Creates a unit vector.
+*
+* @returns A new `Vector2` instance with both components set to 1.
+* @since 1.0.0
+*/
+const unit = make(1);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+const scale = scale$1;
+/**
+* Gets the x component of a `Vector2`.
+*
+* @param v - The vector to get the x component from.
+* @returns The x component of the vector.
+* @since 1.0.0
+*/
+const getX = getX$1;
+const setX = setX$1;
+/**
+* Gets the y component of a `Vector2`.
+*
+* @param v - The vector to get the y component from.
+* @returns The y component of the vector.
+* @since 1.0.0
+*/
+const getY = getY$1;
+const setY = setY$1;
+/**
+* Gets the radius of a `Vector2`.
+*
+* @param v - The vector to get the radius from.
+* @returns The radius of the vector.
+* @since 1.0.0
+*/
+const getR = magnitude;
+const setR = setR$1;
+/**
+* Gets the angle of a `Vector2`.
+*
+* @param v - The vector to get the angle from.
+* @returns The angle of the vector in radians.
+* @since 1.0.0
+*/
+const getTheta = getTheta$1;
+const setTheta = setTheta$1;
+//#endregion
+export { makeWeighted as a, vector2_exports as c, make as i, cross as n, scale as o, magnitude as r, subtract as s, add as t };
+
+//# sourceMappingURL=vector2-CL1HDdPr.mjs.map

package/dist/shared/vector2-CL1HDdPr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector2-CL1HDdPr.mjs","names":["internal.isVector2","internal.isWeighted","internal.makeWeighted","internal.withWeight","internal.unweighted","internal.weightedEquals","internal.equals","internal.make","internal.transpose","internal.fromPolar","internal.magnitude","internal.normalize","internal.dot","internal.cross","internal.components","internal.softmax","internal.add","internal.subtract","internal.hadamard","internal.scale","internal.getX","internal.setX","internal.getY","internal.setY","internal.setR","internal.getTheta","internal.setTheta"],"sources":["../../src/vector/vector2.ts"],"sourcesContent":["import type { TwoDimensional } from '../dimensions'\nimport type { Pipeable } from '../utils'\nimport type { Vector2TypeId, WeightedVector2TypeId } from './vector2.internal'\nimport * as internal from './vector2.internal'\n\n/**\n * A 2D vector.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Vector2 extends Pipeable, TwoDimensional<number> {\n  readonly [Vector2TypeId]: Vector2TypeId\n}\n\n/**\n * A 2D point with an associated positive scalar weight.\n *\n * Used by rational primitives (e.g. `RationalBezier2d`) where each control\n * point carries an influence weight. The interface is structurally distinct\n * from `Vector2` — its brand prevents accidental use with vector arithmetic\n * (`add`, `subtract`, `scale`, etc.) where weighted operations are not\n * well-defined.\n *\n * Construct via {@link makeWeighted} (from raw components) or\n * {@link withWeight} (from an existing `Vector2`).\n *\n * @since 2.1.0\n */\nexport interface Weighted extends Pipeable {\n  readonly [WeightedVector2TypeId]: WeightedVector2TypeId\n  readonly x: number\n  readonly y: number\n  readonly weight: number\n}\n\n/**\n * Checks if a value is a `Vector2`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Vector2`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isVector2: (v: unknown) => v is Vector2 = internal.isVector2\n\n/**\n * Checks if a value is a `Vector2.Weighted`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Vector2.Weighted`, `false` otherwise.\n * @since 2.1.0\n */\nexport const isWeighted: (v: unknown) => v is Weighted = internal.isWeighted\n\n/**\n * Creates a new `Vector2.Weighted` from raw components. The weight must be\n * finite and positive.\n *\n * @param x - The x component.\n * @param y - The y component.\n * @param weight - The positive scalar weight.\n * @returns A new `Vector2.Weighted` instance.\n * @since 2.1.0\n */\nexport const makeWeighted: (x: number, y: number, weight: number) => Weighted =\n  internal.makeWeighted\n\nexport const withWeight: {\n  /**\n   * Promotes a `Vector2` to a `Vector2.Weighted` by attaching the given\n   * positive scalar weight.\n   *\n   * @param v - The point to weight.\n   * @param weight - The positive scalar weight.\n   * @returns A new `Vector2.Weighted` instance.\n   * @since 2.1.0\n   */\n  (v: Vector2, weight: number): Weighted\n  /**\n   * Promotes a `Vector2` to a `Vector2.Weighted` by attaching the given\n   * positive scalar weight.\n   *\n   * @param weight - The positive scalar weight.\n   * @returns A function that takes a `Vector2` and returns a weighted point.\n   * @since 2.1.0\n   */\n  (weight: number): (v: Vector2) => Weighted\n} = internal.withWeight\n\n/**\n * Strips the weight from a `Vector2.Weighted`, returning the underlying point.\n *\n * @param w - The weighted point.\n * @returns A new `Vector2` instance with the same x and y components.\n * @since 2.1.0\n */\nexport const unweighted: (w: Weighted) => Vector2 = internal.unweighted\n\nexport const weightedEquals: {\n  /**\n   * Checks if two `Vector2.Weighted` instances are approximately equal —\n   * point components and weight all within the default absolute tolerance.\n   *\n   * @param a - The first weighted point.\n   * @param b - The second weighted point.\n   * @returns `true` when components and weight are within tolerance.\n   * @since 2.1.0\n   */\n  (a: Weighted, b: Weighted): boolean\n  /**\n   * Checks if two `Vector2.Weighted` instances are approximately equal.\n   *\n   * @param b - The second weighted point.\n   * @returns A function that takes the first weighted point and returns the comparison result.\n   * @since 2.1.0\n   */\n  (b: Weighted): (a: Weighted) => boolean\n} = internal.weightedEquals\n\nexport const equals: {\n  /**\n   * Checks if two `Vector2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Vector2, b: Vector2): boolean\n  /**\n   * Checks if two `Vector2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Vector2): (a: Vector2) => boolean\n} = internal.equals\n\nexport const make: {\n  /**\n   * Creates a new `Vector2` instance.\n   *\n   * @param xy - The x and y components of the vector.\n   * @returns A new `Vector2` instance.\n   * @since 1.0.0\n   */\n  (xy: number): Vector2\n  /**\n   * Creates a new `Vector2` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param y - The y component of the vector.\n   * @returns A new `Vector2` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number): Vector2\n} = internal.make\n\n/**\n * Transposes a 2-tuple of items into one or more `Vector2`s, one per channel\n * extracted by the projection function. See {@link Vector4.transpose} for the\n * full operation description; this is the 2-component analog.\n *\n * @param inputs - Exactly two items of any type.\n * @param project - A function returning a fixed-arity tuple of numbers — one per output channel.\n * @returns A tuple of `Vector2`s with the same arity as the projection's return tuple.\n * @since 2.1.0\n */\nexport const transpose: <T, const Channels extends ReadonlyArray<number>>(\n  inputs: readonly [T, T],\n  project: (item: T) => Channels,\n) => { readonly [K in keyof Channels]: Vector2 } = internal.transpose\n\n/**\n * Creates a new `Vector2` instance from polar coordinates.\n *\n * @param r - The radius.\n * @param theta - The angle, in radians.\n * @returns A new `Vector2` instance.\n * @since 1.0.0\n */\nexport const fromPolar: (r: number, theta: number) => Vector2 = internal.fromPolar\n\n/**\n * Calculates the magnitude of a `Vector2`.\n *\n * @param vector - The vector to calculate the magnitude of.\n * @returns The magnitude of the vector.\n * @since 1.0.0\n */\nexport const magnitude: (vector: Vector2) => number = internal.magnitude\n\n/**\n * Normalizes a `Vector2`.\n *\n * @param vector - The vector to normalize.\n * @returns A new `Vector2` instance with the same direction and a magnitude of 1.\n * @since 1.0.0\n */\nexport const normalize: (vector: Vector2) => Vector2 = internal.normalize\n\nexport const dot: {\n  /**\n   * Calculates the dot product of two `Vector2` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns The dot product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector2, b: Vector2): number\n  /**\n   * Calculates the dot product of two `Vector2` instances.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the dot product.\n   * @since 1.0.0\n   */\n  (b: Vector2): (a: Vector2) => number\n} = internal.dot\n\nexport const cross: {\n  /**\n   * Calculates the cross product of two `Vector2` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns The cross product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector2, b: Vector2): number\n  /**\n   * Calculates the cross product of two `Vector2` instances.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the cross product.\n   * @since 1.0.0\n   */\n  (b: Vector2): (a: Vector2) => number\n} = internal.cross\n\n/**\n * Returns the components of a `Vector2` as an array.\n *\n * @param r - The radius.\n * @param theta - The angle, in radians.\n * @returns A new `Vector2` instance.\n * @since 1.0.0\n */\nexport const components: (v: Vector2) => [number, number] = internal.components\n\n/**\n * Applies the softmax function to a `Vector2`.\n *\n * @param v - The vector to apply the softmax function to.\n * @returns A new `Vector2` instance with the softmax applied.\n * @since 1.0.0\n */\nexport const softmax: (v: Vector2) => Vector2 = internal.softmax\n\n/**\n * Creates a zero vector.\n *\n * @returns A new `Vector2` instance with both components set to 0.\n * @since 1.0.0\n */\nexport const zero = make(0)\n\n/**\n * Creates a unit vector.\n *\n * @returns A new `Vector2` instance with both components set to 1.\n * @since 1.0.0\n */\nexport const unit = make(1)\n\nexport const add: {\n  /**\n   * Adds two `Vector2` instances together.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector2` instance representing the sum of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector2, b: Vector2): Vector2\n  /**\n   * Adds two `Vector2` instances together.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the sum.\n   * @since 1.0.0\n   */\n  (b: Vector2): (a: Vector2) => Vector2\n} = internal.add\n\nexport const subtract: {\n  /**\n   * Subtracts one `Vector2` instance from another.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector2` instance representing the difference of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector2, b: Vector2): Vector2\n  /**\n   * Subtracts one `Vector2` instance from another.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the difference.\n   * @since 1.0.0\n   */\n  (b: Vector2): (a: Vector2) => Vector2\n} = internal.subtract\n\nexport const hadamard: {\n  /**\n   * Performs the Hadamard product of two `Vector2` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector2` instance representing the Hadamard product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector2, b: Vector2): Vector2\n  /**\n   * Performs the Hadamard product of two `Vector2` instances.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the Hadamard product.\n   * @since 1.0.0\n   */\n  (b: Vector2): (a: Vector2) => Vector2\n} = internal.hadamard\n\nexport const scale: {\n  /**\n   * Scales a `Vector2` by a scalar value.\n   *\n   * @param s - The scalar value to scale by.\n   * @returns A function that takes a vector and returns the scaled vector.\n   * @since 1.0.0\n   */\n  (s: number): (v: Vector2) => Vector2\n  /**\n   * Scales a `Vector2` by a scalar value.\n   *\n   * @param v - The vector to scale.\n   * @param s - The scalar value to scale by.\n   * @returns A new `Vector2` instance representing the scaled vector.\n   * @since 1.0.0\n   */\n  (v: Vector2, s: number): Vector2\n} = internal.scale\n\n/**\n * Gets the x component of a `Vector2`.\n *\n * @param v - The vector to get the x component from.\n * @returns The x component of the vector.\n * @since 1.0.0\n */\nexport const getX: (v: Vector2) => number = internal.getX\n\nexport const setX: {\n  /**\n   * Sets the x component of a `Vector2`.\n   *\n   * @param v - The vector to set the x component of.\n   * @param x - The new x component.\n   * @returns A new `Vector2` instance with the updated x component.\n   * @since 1.0.0\n   */\n  (v: Vector2, x: number): Vector2\n  /**\n   * Sets the x component of a `Vector2`.\n   *\n   * @param x - The new x component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (x: number): (v: Vector2) => Vector2\n} = internal.setX\n\n/**\n * Gets the y component of a `Vector2`.\n *\n * @param v - The vector to get the y component from.\n * @returns The y component of the vector.\n * @since 1.0.0\n */\nexport const getY: (v: Vector2) => number = internal.getY\n\nexport const setY: {\n  /**\n   * Sets the y component of a `Vector2`.\n   *\n   * @param v - The vector to set the y component of.\n   * @param y - The new y component.\n   * @returns A new `Vector2` instance with the updated y component.\n   * @since 1.0.0\n   */\n  (v: Vector2, y: number): Vector2\n  /**\n   * Sets the y component of a `Vector2`.\n   *\n   * @param y - The new y component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (y: number): (v: Vector2) => Vector2\n} = internal.setY\n\n/**\n * Gets the radius of a `Vector2`.\n *\n * @param v - The vector to get the radius from.\n * @returns The radius of the vector.\n * @since 1.0.0\n */\nexport const getR: (v: Vector2) => number = magnitude\n\nexport const setR: {\n  /**\n   * Sets the radius of a `Vector2`.\n   *\n   * @param v - The vector to set the radius of.\n   * @param r - The new radius.\n   * @returns A new `Vector2` instance with the updated radius.\n   * @since 1.0.0\n   */\n  (v: Vector2, r: number): Vector2\n  /**\n   * Sets the radius of a `Vector2`.\n   *\n   * @param r - The new radius.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (r: number): (v: Vector2) => Vector2\n} = internal.setR\n\n/**\n * Gets the angle of a `Vector2`.\n *\n * @param v - The vector to get the angle from.\n * @returns The angle of the vector in radians.\n * @since 1.0.0\n */\nexport const getTheta: (v: Vector2) => number = internal.getTheta\n\nexport const setTheta: {\n  /**\n   * Sets the angle of a `Vector2`.\n   *\n   * @param v - The vector to set the angle of.\n   * @param theta - The new angle, in radians.\n   * @returns A new `Vector2` instance with the updated angle.\n   * @since 1.0.0\n   */\n  (v: Vector2, theta: number): Vector2\n  /**\n   * Sets the angle of a `Vector2`.\n   *\n   * @param theta - The new angle, in radians.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (theta: number): (v: Vector2) => Vector2\n} = internal.setTheta\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,YAA0CA;;;;;;;;AASvD,MAAa,aAA4CC;;;;;;;;;;;AAYzD,MAAa,eACXC;AAEF,MAAa,aAoBTC;;;;;;;;AASJ,MAAa,aAAuCC;AAEpD,MAAa,iBAmBTC;AAEJ,MAAa,SAoBTC;AAEJ,MAAa,OAkBTC;;;;;;;;;;;AAYJ,MAAa,YAGsCC;;;;;;;;;AAUnD,MAAa,YAAmDC;;;;;;;;AAShE,MAAa,YAAyCC;;;;;;;;AAStD,MAAa,YAA0CC;AAEvD,MAAa,MAkBTC;AAEJ,MAAa,QAkBTC;;;;;;;;;AAUJ,MAAa,aAA+CC;;;;;;;;AAS5D,MAAa,UAAmCC;;;;;;;AAQhD,MAAa,OAAO,KAAK,EAAE;;;;;;;AAQ3B,MAAa,OAAO,KAAK,EAAE;AAE3B,MAAa,MAkBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,QAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+B;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,WAAmCC;AAEhD,MAAa,WAkBTC"}