curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/interval-Dy-RMEE3.d.mts

@@ -0,0 +1,533 @@
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+
+//#region src/interval/interval.d.ts
+declare namespace interval_d_exports {
+  export { Bounds, Closed, Interval, Open, OpenEnd, OpenStart, ScaleShift, aligned, biunit, clamp, contains, containsInterval, equals, filter, fromMinMax, fromSize, isClosed, isClosedAtEnd, isClosedAtStart, isInterval, isOpen, isOpenAtEnd, isOpenAtStart, isOpenEnd, isOpenStart, lerp, make, makeOpen, makeOpenEnd, makeOpenStart, normalize, remap, scaleShift, size, toClosed, toEndClosed, toEndOpen, toLerpFn, toNormalizeFn, toOpen, toRemapFn, toStartClosed, toStartOpen, union, unit, unitOpen };
+}
+/**
+ * The structural minimum: any value with numeric `start` and `end` fields.
+ *
+ * Operations that don't read endpoint inclusivity (e.g. `lerp`, `normalize`,
+ * `remap`, `size`) accept `Bounds` so the signature itself documents what
+ * the operation depends on.
+ *
+ * @since 2.0.0
+ */
+interface Bounds {
+  readonly start: number;
+  readonly end: number;
+}
+/**
+ * A mathematical interval. Discriminated union of four variants by endpoint
+ * inclusivity: `Closed`, `OpenStart`, `OpenEnd`, `Open`. Operations that
+ * depend on inclusivity (e.g. `contains`, `filter`, `equals`) dispatch on
+ * the `kind` field; operations that don't accept the broader `Bounds` type.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
+type Interval = Closed | OpenStart | OpenEnd | Open;
+/**
+ * `[start, end]` — both endpoints included.
+ *
+ * @since 2.0.0
+ */
+interface Closed extends Pipeable, Bounds {
+  readonly kind: 'closed';
+}
+/**
+ * `(start, end]` — start excluded, end included.
+ *
+ * @since 2.0.0
+ */
+interface OpenStart extends Pipeable, Bounds {
+  readonly kind: 'open-start';
+}
+/**
+ * `[start, end)` — start included, end excluded.
+ *
+ * @since 2.0.0
+ */
+interface OpenEnd extends Pipeable, Bounds {
+  readonly kind: 'open-end';
+}
+/**
+ * `(start, end)` — both endpoints excluded.
+ *
+ * @since 2.0.0
+ */
+interface Open extends Pipeable, Bounds {
+  readonly kind: 'open';
+}
+/**
+ * Checks if a value is an `Interval`.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is an `Interval`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isInterval: (v: unknown) => v is Interval;
+declare const equals: {
+  /**
+   * Checks if two `Interval` instances are approximately equal within the
+   * default absolute tolerance ({@link EPSILON}).
+   *
+   * Both endpoints AND the kind must match — a `Closed` and an `OpenStart` with
+   * the same numeric endpoints are not equal. Use `aligned` for the looser
+   * "same numeric range" check.
+   *
+   * @param a - The first interval.
+   * @param b - The second interval.
+   * @returns `true` when both intervals share a kind and both endpoints are within tolerance.
+   * @since 1.1.0
+   */
+  (a: Interval, b: Interval): boolean;
+  /**
+   * Checks if two `Interval` instances are approximately equal within the
+   * default absolute tolerance ({@link EPSILON}).
+   *
+   * @param b - The second interval.
+   * @returns A function that takes the first interval and returns the comparison result.
+   * @since 1.1.0
+   */
+  (b: Interval): (a: Interval) => boolean;
+};
+declare const aligned: {
+  /**
+   * Checks if two values share the same numeric range, ignoring endpoint
+   * inclusivity. Accepts any `Bounds`-shaped value.
+   *
+   * @param a - The first bounds.
+   * @param b - The second bounds.
+   * @returns `true` when both endpoints are within the default tolerance ({@link EPSILON}).
+   * @since 2.0.0
+   */
+  (a: Bounds, b: Bounds): boolean;
+  /**
+   * @param b - The second bounds.
+   * @returns A function that takes the first bounds and returns the comparison result.
+   * @since 2.0.0
+   */
+  (b: Bounds): (a: Bounds) => boolean;
+};
+declare const make: {
+  /**
+   * Creates a new closed `Interval` instance.
+   *
+   * @param point - The point of the interval.
+   * @returns A new `Closed` interval `[point, point]`.
+   * @since 1.0.0
+   */
+  (point: number): Closed;
+  /**
+   * Creates a new closed `Interval` instance.
+   *
+   * @param start - The start of the interval.
+   * @param end - The end of the interval.
+   * @returns A new `Closed` interval `[start, end]`.
+   * @since 1.0.0
+   */
+  (start: number, end: number): Closed;
+};
+declare const makeOpenStart: {
+  /**
+   * Creates a new left-open `Interval` instance.
+   *
+   * @param point - The point of the interval.
+   * @returns A new `OpenStart` interval `(point, point]` (degenerate, empty).
+   * @since 2.0.0
+   */
+  (point: number): OpenStart;
+  /**
+   * Creates a new left-open `Interval` instance.
+   *
+   * @param start - The start of the interval (excluded).
+   * @param end - The end of the interval (included).
+   * @returns A new `OpenStart` interval `(start, end]`.
+   * @since 2.0.0
+   */
+  (start: number, end: number): OpenStart;
+};
+declare const makeOpenEnd: {
+  /**
+   * Creates a new right-open `Interval` instance.
+   *
+   * @param point - The point of the interval.
+   * @returns A new `OpenEnd` interval `[point, point)` (degenerate, empty).
+   * @since 2.0.0
+   */
+  (point: number): OpenEnd;
+  /**
+   * Creates a new right-open `Interval` instance.
+   *
+   * @param start - The start of the interval (included).
+   * @param end - The end of the interval (excluded).
+   * @returns A new `OpenEnd` interval `[start, end)`.
+   * @since 2.0.0
+   */
+  (start: number, end: number): OpenEnd;
+};
+declare const makeOpen: {
+  /**
+   * Creates a new fully open `Interval` instance.
+   *
+   * @param point - The point of the interval.
+   * @returns A new `Open` interval `(point, point)` (degenerate, empty).
+   * @since 2.0.0
+   */
+  (point: number): Open;
+  /**
+   * Creates a new fully open `Interval` instance.
+   *
+   * @param start - The start of the interval (excluded).
+   * @param end - The end of the interval (excluded).
+   * @returns A new `Open` interval `(start, end)`.
+   * @since 2.0.0
+   */
+  (start: number, end: number): Open;
+};
+declare const fromSize: {
+  /**
+   * Creates a new closed `Interval` instance from a size.
+   *
+   * @param size - The size of the interval.
+   * @returns A new `Closed` interval `[0, size]`.
+   * @since 1.0.0
+   */
+  (size: number): Closed;
+  /**
+   * Creates a new closed `Interval` instance from a size.
+   *
+   * @param start - The start of the interval.
+   * @param size - The size of the interval.
+   * @returns A new `Closed` interval `[start, start + size]`.
+   * @since 1.0.0
+   */
+  (start: number, size: number): Closed;
+};
+/**
+ * Creates a new closed `Interval` from a minimum and maximum value, in any order.
+ *
+ * @param values - The values to take the min and max of.
+ * @returns A new `Closed` interval `[min(values), max(values)]`.
+ * @since 1.0.0
+ */
+declare const fromMinMax: (...values: ReadonlyArray<number>) => Closed;
+/**
+ * Calculates the size of an interval.
+ *
+ * Kind-agnostic — `size` of `[0, 1]` and `(0, 1)` are both `1`.
+ *
+ * @param i - The bounds to calculate the size of.
+ * @returns The size of the bounds.
+ * @since 1.0.0
+ */
+declare const size: (i: Bounds) => number;
+declare const contains: {
+  /**
+   * Checks if a value is contained within an interval. Endpoint inclusivity
+   * follows the interval's `kind`.
+   *
+   * @param interval - The interval to check.
+   * @param value - The value to check.
+   * @returns `true` if the value is contained within the interval, `false` otherwise.
+   * @since 1.0.0
+   */
+  (interval: Interval, value: number): boolean;
+  /**
+   * Checks if a value is contained within an interval. Endpoint inclusivity
+   * follows the interval's `kind`.
+   *
+   * @param value - The value to check.
+   * @returns A function that takes an interval and returns `true` if the value is contained within the interval, `false` otherwise.
+   * @since 1.0.0
+   */
+  (value: number): (interval: Interval) => boolean;
+};
+declare const containsInterval: {
+  /**
+   * Checks if `inner` is a subset of `outer` — every point of `inner` is also
+   * in `outer`. Respects endpoint inclusivity on both sides: a closed inner
+   * endpoint must be inside (or on a closed boundary of) the outer, while an
+   * open inner endpoint can sit exactly on an open outer boundary.
+   *
+   * @param outer - The enclosing interval.
+   * @param inner - The candidate inner interval.
+   * @returns `true` when `inner` is a subset of `outer`.
+   * @since 2.1.0
+   */
+  (outer: Interval, inner: Interval): boolean;
+  /**
+   * @param inner - The candidate inner interval.
+   * @returns A function that takes the outer interval and returns the containment result.
+   * @since 2.1.0
+   */
+  (inner: Interval): (outer: Interval) => boolean;
+};
+declare const union: {
+  /**
+   * Returns the smallest interval enclosing both inputs. Each endpoint's
+   * inclusivity follows the input that contributed it; when both endpoints
+   * tie, the result is closed at that point if either input includes it.
+   *
+   * @param a - The first interval.
+   * @param b - The second interval.
+   * @returns A new interval enclosing both inputs.
+   * @since 2.1.0
+   */
+  (a: Interval, b: Interval): Interval;
+  /**
+   * @param b - The second interval.
+   * @returns A function that takes the first interval and returns the union.
+   * @since 2.1.0
+   */
+  (b: Interval): (a: Interval) => Interval;
+};
+declare const filter: {
+  /**
+   * Filters an array of values to those contained within an interval.
+   * Endpoint inclusivity follows the interval's `kind`.
+   *
+   * @param interval - The interval to filter the values to.
+   * @param value - The values to filter.
+   * @returns The filtered values.
+   * @since 1.0.0
+   */
+  <V extends ReadonlyArray<number>>(interval: Interval, value: V): V;
+  /**
+   * Filters an array of values to those contained within an interval.
+   *
+   * @param value - The values to filter.
+   * @returns A function that takes an interval and returns the filtered values.
+   * @since 1.0.0
+   */
+  <V extends ReadonlyArray<number>>(value: V): (interval: Interval) => V;
+};
+declare const clamp: {
+  /**
+   * Clamps a value to be within bounds. Kind-agnostic — clamps to the numeric
+   * range regardless of endpoint inclusivity.
+   *
+   * @param interval - The bounds to clamp the value to.
+   * @param value - The value to clamp.
+   * @returns The clamped value.
+   * @since 1.0.0
+   */
+  (interval: Bounds, value: number): number;
+  /**
+   * Clamps a value to be within bounds. Kind-agnostic.
+   *
+   * @param value - The value to clamp.
+   * @returns A function that takes bounds and returns the clamped value.
+   * @since 1.0.0
+   */
+  (value: number): (interval: Bounds) => number;
+  /**
+   * Clamps an array of values to be within bounds. Kind-agnostic.
+   *
+   * @param interval - The bounds to clamp the values to.
+   * @param value - The values to clamp.
+   * @returns The clamped values.
+   * @since 1.0.0
+   */
+  (interval: Bounds, value: ReadonlyArray<number>): ReadonlyArray<number>;
+  /**
+   * Clamps an array of values to be within bounds. Kind-agnostic.
+   *
+   * @param value - The values to clamp.
+   * @returns A function that takes bounds and returns the clamped values.
+   * @since 1.0.0
+   */
+  (value: ReadonlyArray<number>): (interval: Bounds) => ReadonlyArray<number>;
+};
+/**
+ * Returns an interval with the start endpoint open. Preserves the end endpoint's inclusivity.
+ *
+ * @since 2.0.0
+ */
+declare const toStartOpen: {
+  (i: Closed | OpenStart): OpenStart;
+  (i: OpenEnd | Open): Open;
+};
+/**
+ * Returns an interval with the start endpoint closed. Preserves the end endpoint's inclusivity.
+ *
+ * @since 2.0.0
+ */
+declare const toStartClosed: {
+  (i: Closed | OpenEnd): Closed;
+  (i: OpenStart | Open): OpenEnd;
+};
+/**
+ * Returns an interval with the end endpoint open. Preserves the start endpoint's inclusivity.
+ *
+ * @since 2.0.0
+ */
+declare const toEndOpen: {
+  (i: Closed | OpenEnd): OpenEnd;
+  (i: OpenStart | Open): Open;
+};
+/**
+ * Returns an interval with the end endpoint closed. Preserves the start endpoint's inclusivity.
+ *
+ * @since 2.0.0
+ */
+declare const toEndClosed: {
+  (i: Closed | OpenEnd): Closed;
+  (i: OpenStart | Open): OpenStart;
+};
+/**
+ * Returns a closed interval over the same numeric range.
+ *
+ * @since 2.0.0
+ */
+declare const toClosed: (i: Interval) => Closed;
+/**
+ * Returns a fully open interval over the same numeric range.
+ *
+ * @since 2.0.0
+ */
+declare const toOpen: (i: Interval) => Open;
+/**
+ * Type-narrowing predicate: refines `Interval` to `Closed`.
+ *
+ * @since 2.0.0
+ */
+declare const isClosed: (i: Interval) => i is Closed;
+/**
+ * Type-narrowing predicate: refines `Interval` to `Open`.
+ *
+ * @since 2.0.0
+ */
+declare const isOpen: (i: Interval) => i is Open;
+/**
+ * Type-narrowing predicate: refines `Interval` to `OpenStart`.
+ *
+ * @since 2.0.0
+ */
+declare const isOpenStart: (i: Interval) => i is OpenStart;
+/**
+ * Type-narrowing predicate: refines `Interval` to `OpenEnd`.
+ *
+ * @since 2.0.0
+ */
+declare const isOpenEnd: (i: Interval) => i is OpenEnd;
+/**
+ * Type-narrowing predicate: refines `Interval` to those with an open start endpoint.
+ *
+ * @since 2.0.0
+ */
+declare const isOpenAtStart: (i: Interval) => i is OpenStart | Open;
+/**
+ * Type-narrowing predicate: refines `Interval` to those with an open end endpoint.
+ *
+ * @since 2.0.0
+ */
+declare const isOpenAtEnd: (i: Interval) => i is OpenEnd | Open;
+/**
+ * Type-narrowing predicate: refines `Interval` to those with a closed start endpoint.
+ *
+ * @since 2.0.0
+ */
+declare const isClosedAtStart: (i: Interval) => i is Closed | OpenEnd;
+/**
+ * Type-narrowing predicate: refines `Interval` to those with a closed end endpoint.
+ *
+ * @since 2.0.0
+ */
+declare const isClosedAtEnd: (i: Interval) => i is Closed | OpenStart;
+/**
+ * The unit interval, `[0, 1]`.
+ *
+ * @since 1.0.0
+ */
+declare const unit: Closed;
+/**
+ * The open unit interval, `(0, 1)`. The symmetric open analog of {@link unit};
+ * convenient for "strict interior" use cases such as filtering roots that
+ * must lie strictly inside the unit parameter range.
+ *
+ * @since 2.1.0
+ */
+declare const unitOpen: Open;
+/**
+ * The biunit interval, `[-1, 1]`.
+ *
+ * @since 1.0.0
+ */
+declare const biunit: Closed;
+/**
+ * Linearly interpolates a value within bounds.
+ *
+ * @param interval - The bounds to interpolate within.
+ * @param t - The interpolation factor, typically between 0 and 1.
+ * @returns The interpolated value.
+ * @since 1.0.0
+ */
+declare const lerp: (interval: Bounds, t: number) => number;
+/**
+ * Creates a linear interpolation function for given bounds.
+ *
+ * @param interval - The bounds to create the interpolation function for.
+ * @returns A function that takes a factor `t` and returns the interpolated value.
+ * @since 1.0.0
+ */
+declare const toLerpFn: (interval: Bounds) => (t: number) => number;
+/**
+ * Normalizes a value within bounds.
+ *
+ * @param interval - The bounds to normalize within.
+ * @param x - The value to normalize.
+ * @returns The normalized value.
+ * @since 1.0.0
+ */
+declare const normalize: (interval: Bounds, x: number) => number;
+/**
+ * Creates a normalization function for given bounds.
+ *
+ * @param interval - The bounds to create the normalization function for.
+ * @returns A function that takes a value `x` and returns the normalized value.
+ * @since 1.0.0
+ */
+declare const toNormalizeFn: (interval: Bounds) => (x: number) => number;
+/**
+ * Remaps a value from one bounds to another.
+ *
+ * @param source - The source bounds.
+ * @param target - The target bounds.
+ * @param x - The value to remap.
+ * @returns The remapped value.
+ * @since 1.0.0
+ */
+declare const remap: (source: Bounds, target: Bounds, x: number) => number;
+/**
+ * Creates a remapping function for given bounds.
+ *
+ * @param source - The source bounds.
+ * @param target - The target bounds.
+ * @returns A function that takes a value `x` and returns the remapped value.
+ * @since 1.0.0
+ */
+declare const toRemapFn: (source: Bounds, target: Bounds) => (x: number) => number;
+/**
+ * Calculates the scale and shift needed to map a source bounds to a target bounds.
+ *
+ * @param source - The source bounds.
+ * @param target - The target bounds.
+ * @returns An object containing the scale and shift values.
+ * @since 1.0.0
+ */
+declare const scaleShift: (source: Bounds, target: Bounds) => ScaleShift;
+/**
+ * The scale and shift needed to map a source bounds to a target bounds.
+ *
+ * @since 1.0.0
+ */
+interface ScaleShift {
+  readonly scale: number;
+  readonly shift: number;
+}
+//#endregion
+export { interval_d_exports as i, Closed as n, Interval as r, Bounds as t };
+//# sourceMappingURL=interval-Dy-RMEE3.d.mts.map

package/dist/shared/interval2d-8IBZnUOq.mjs

@@ -0,0 +1,108 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { i as make$2 } from "./vector2-CL1HDdPr.mjs";
+import { f as union$2, i as equals$2, n as contains, o as fromMinMax, r as containsInterval } from "./interval-05CR6eBf.mjs";
+//#region src/interval/interval2d.internal.ts
+const Interval2dTypeId = Symbol("curvy/interval/interval2d");
+var Interval2dImpl = class extends Pipeable {
+	[Interval2dTypeId] = Interval2dTypeId;
+	x;
+	y;
+	constructor(x, y) {
+		super();
+		this.x = x;
+		this.y = y;
+	}
+	get [Symbol.toStringTag]() {
+		return `Interval2d(${String(this.x)} × ${String(this.y)})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+const isInterval2d$1 = (v) => typeof v === "object" && v !== null && Interval2dTypeId in v;
+const make$1 = (x, y) => new Interval2dImpl(x, y);
+const fromCorners$1 = (p0, p1) => new Interval2dImpl(fromMinMax(p0.x, p1.x), fromMinMax(p0.y, p1.y));
+const fromVectors$1 = (...points) => {
+	invariant(points.length > 0, "fromVectors requires at least one point");
+	const xs = [];
+	const ys = [];
+	for (const p of points) {
+		xs.push(p.x);
+		ys.push(p.y);
+	}
+	return new Interval2dImpl(fromMinMax(...xs), fromMinMax(...ys));
+};
+const containsVector$1 = dual(2, (box, v) => contains(box.x, v.x) && contains(box.y, v.y));
+const containsInterval2d$1 = dual(2, (outer, inner) => containsInterval(outer.x, inner.x) && containsInterval(outer.y, inner.y));
+const size$1 = (box) => make$2(Math.abs(box.x.end - box.x.start), Math.abs(box.y.end - box.y.start));
+const union$1 = dual(2, (a, b) => new Interval2dImpl(union$2(a.x, b.x), union$2(a.y, b.y)));
+const equals$1 = dual(2, (a, b) => equals$2(a.x, b.x) && equals$2(a.y, b.y));
+//#endregion
+//#region src/interval/interval2d.ts
+var interval2d_exports = /* @__PURE__ */ __exportAll({
+	containsInterval2d: () => containsInterval2d,
+	containsVector: () => containsVector,
+	equals: () => equals,
+	fromCorners: () => fromCorners,
+	fromVectors: () => fromVectors,
+	isInterval2d: () => isInterval2d,
+	make: () => make,
+	size: () => size,
+	union: () => union
+});
+/**
+* Checks if a value is an `Interval2d`.
+*
+* @param v - The value to check.
+* @returns `true` if the value is an `Interval2d`, `false` otherwise.
+* @since 2.1.0
+*/
+const isInterval2d = isInterval2d$1;
+/**
+* Creates a new `Interval2d` from two intervals — one for the x axis, one
+* for the y axis. Preserves both interval subtypes at the type level.
+*
+* @param x - The x-axis interval.
+* @param y - The y-axis interval.
+* @returns A new `Interval2d` instance.
+* @since 2.1.0
+*/
+const make = make$1;
+/**
+* Creates a closed `Interval2d` from two corner points. The corners can be in
+* any order — each axis is built from the min and max of the coordinate.
+*
+* @param p0 - The first corner.
+* @param p1 - The second corner.
+* @returns A new `Interval2d<Closed, Closed>` enclosing both corners.
+* @since 2.1.0
+*/
+const fromCorners = fromCorners$1;
+/**
+* Creates the smallest closed `Interval2d` enclosing the given points. Useful
+* for computing a bounding box from sampled points.
+*
+* @param points - One or more points to enclose.
+* @returns A new `Interval2d<Closed, Closed>` enclosing all input points.
+* @throws When called with zero points.
+* @since 2.1.0
+*/
+const fromVectors = fromVectors$1;
+const containsVector = containsVector$1;
+const containsInterval2d = containsInterval2d$1;
+/**
+* Returns the size as a vector `(width, height)`. Accepts the broader
+* {@link Bounds2d} type because size does not depend on endpoint inclusivity.
+*
+* @param box - The 2D interval (or bounds-shaped value) to measure.
+* @returns The size as a `Vector2`.
+* @since 2.1.0
+*/
+const size = size$1;
+const union = union$1;
+const equals = equals$1;
+//#endregion
+export { make as n, union as r, interval2d_exports as t };
+
+//# sourceMappingURL=interval2d-8IBZnUOq.mjs.map

package/dist/shared/interval2d-8IBZnUOq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval2d-8IBZnUOq.mjs","names":["isInterval2d","make","fromCorners","Interval.fromMinMax","fromVectors","containsVector","Interval.contains","containsInterval2d","Interval.containsInterval","size","Vector2.make","union","Interval.union","equals","Interval.equals","internal.isInterval2d","internal.make","internal.fromCorners","internal.fromVectors","internal.containsVector","internal.containsInterval2d","internal.size","internal.union","internal.equals"],"sources":["../../src/interval/interval2d.internal.ts","../../src/interval/interval2d.ts"],"sourcesContent":["import { dual, invariant, Pipeable } from '../utils'\nimport * as Vector2 from '../vector/vector2'\nimport * as Interval from './interval'\nimport type { Bounds2d, Interval2d } from './interval2d'\n\nexport const Interval2dTypeId: unique symbol = Symbol('curvy/interval/interval2d')\nexport type Interval2dTypeId = typeof Interval2dTypeId\n\nclass Interval2dImpl<X extends Interval.Interval, Y extends Interval.Interval>\n  extends Pipeable\n  implements Interval2d<X, Y>\n{\n  readonly [Interval2dTypeId]: Interval2dTypeId = Interval2dTypeId\n\n  readonly x: X\n  readonly y: Y\n\n  constructor(x: X, y: Y) {\n    super()\n    this.x = x\n    this.y = y\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Interval2d(${String(this.x)} × ${String(this.y)})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nexport const isInterval2d = (v: unknown): v is Interval2d =>\n  typeof v === 'object' && v !== null && Interval2dTypeId in v\n\nexport const make = <X extends Interval.Interval, Y extends Interval.Interval>(\n  x: X,\n  y: Y,\n): Interval2d<X, Y> => new Interval2dImpl(x, y)\n\nexport const fromCorners = (\n  p0: Vector2.Vector2,\n  p1: Vector2.Vector2,\n): Interval2d<Interval.Closed, Interval.Closed> =>\n  new Interval2dImpl(Interval.fromMinMax(p0.x, p1.x), Interval.fromMinMax(p0.y, p1.y))\n\nexport const fromVectors = (\n  ...points: ReadonlyArray<Vector2.Vector2>\n): Interval2d<Interval.Closed, Interval.Closed> => {\n  invariant(points.length > 0, 'fromVectors requires at least one point')\n  const xs: Array<number> = []\n  const ys: Array<number> = []\n  for (const p of points) {\n    xs.push(p.x)\n    ys.push(p.y)\n  }\n  return new Interval2dImpl(Interval.fromMinMax(...xs), Interval.fromMinMax(...ys))\n}\n\nexport const containsVector = dual<\n  (v: Vector2.Vector2) => (box: Interval2d) => boolean,\n  (box: Interval2d, v: Vector2.Vector2) => boolean\n>(\n  2,\n  (box: Interval2d, v: Vector2.Vector2): boolean =>\n    Interval.contains(box.x, v.x) && Interval.contains(box.y, v.y),\n)\n\nexport const containsInterval2d = dual<\n  (inner: Interval2d) => (outer: Interval2d) => boolean,\n  (outer: Interval2d, inner: Interval2d) => boolean\n>(\n  2,\n  (outer: Interval2d, inner: Interval2d): boolean =>\n    Interval.containsInterval(outer.x, inner.x) && Interval.containsInterval(outer.y, inner.y),\n)\n\n// Accepts the structural minimum because size doesn't read kind.\nexport const size = (box: Bounds2d): Vector2.Vector2 =>\n  Vector2.make(Math.abs(box.x.end - box.x.start), Math.abs(box.y.end - box.y.start))\n\n// Per-axis union — the runtime delegates to `Interval.union`, which is\n// kind-correct (the resulting endpoint openness reflects which input\n// contributed each side). The conditional return type collapses to the\n// shared kind when both inputs match on an axis and falls back to `Interval`\n// when they differ — at runtime the result genuinely could be any of the four\n// kinds depending on which endpoint wins.\nexport const union: {\n  <\n    AX extends Interval.Interval,\n    AY extends Interval.Interval,\n    BX extends Interval.Interval,\n    BY extends Interval.Interval,\n  >(\n    a: Interval2d<AX, AY>,\n    b: Interval2d<BX, BY>,\n  ): Interval2d<\n    AX extends BX ? (BX extends AX ? AX : Interval.Interval) : Interval.Interval,\n    AY extends BY ? (BY extends AY ? AY : Interval.Interval) : Interval.Interval\n  >\n  <BX extends Interval.Interval, BY extends Interval.Interval>(\n    b: Interval2d<BX, BY>,\n  ): <AX extends Interval.Interval, AY extends Interval.Interval>(\n    a: Interval2d<AX, AY>,\n  ) => Interval2d<\n    AX extends BX ? (BX extends AX ? AX : Interval.Interval) : Interval.Interval,\n    AY extends BY ? (BY extends AY ? AY : Interval.Interval) : Interval.Interval\n  >\n} = dual(\n  2,\n  (a: Interval2d, b: Interval2d) =>\n    new Interval2dImpl(Interval.union(a.x, b.x), Interval.union(a.y, b.y)),\n) as never\n\nexport const equals = dual<\n  (b: Interval2d) => (a: Interval2d) => boolean,\n  (a: Interval2d, b: Interval2d) => boolean\n>(\n  2,\n  (a: Interval2d, b: Interval2d): boolean => Interval.equals(a.x, b.x) && Interval.equals(a.y, b.y),\n)\n","import type { Pipeable } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { Bounds, Closed, Interval } from './interval'\nimport type { Interval2dTypeId } from './interval2d.internal'\nimport * as internal from './interval2d.internal'\n\n/**\n * An axis-aligned 2D interval — the Cartesian product of two 1D intervals.\n * Used as a bounding box for curves and paths, and as a region for\n * containment tests.\n *\n * The two type parameters carry the per-axis interval subtype so that a value\n * built from closed intervals stays `Interval2d<Closed, Closed>` and a value\n * with mixed openness preserves that information at the type level.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 2.1.0\n */\nexport interface Interval2d<\n  X extends Interval = Interval,\n  Y extends Interval = Interval,\n> extends Pipeable {\n  readonly [Interval2dTypeId]: Interval2dTypeId\n  readonly x: X\n  readonly y: Y\n}\n\n/**\n * The structural minimum: any value with `x` and `y` fields shaped like\n * {@link Bounds}. Operations that don't read endpoint inclusivity (e.g.\n * {@link size}) accept `Bounds2d` so the signature itself documents what the\n * operation depends on. Mirrors the {@link Bounds}/{@link Interval} split in 1D.\n *\n * @since 2.1.0\n */\nexport interface Bounds2d {\n  readonly x: Bounds\n  readonly y: Bounds\n}\n\n/**\n * Checks if a value is an `Interval2d`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is an `Interval2d`, `false` otherwise.\n * @since 2.1.0\n */\nexport const isInterval2d: (v: unknown) => v is Interval2d = internal.isInterval2d\n\n/**\n * Creates a new `Interval2d` from two intervals — one for the x axis, one\n * for the y axis. Preserves both interval subtypes at the type level.\n *\n * @param x - The x-axis interval.\n * @param y - The y-axis interval.\n * @returns A new `Interval2d` instance.\n * @since 2.1.0\n */\nexport const make: <X extends Interval, Y extends Interval>(x: X, y: Y) => Interval2d<X, Y> =\n  internal.make\n\n/**\n * Creates a closed `Interval2d` from two corner points. The corners can be in\n * any order — each axis is built from the min and max of the coordinate.\n *\n * @param p0 - The first corner.\n * @param p1 - The second corner.\n * @returns A new `Interval2d<Closed, Closed>` enclosing both corners.\n * @since 2.1.0\n */\nexport const fromCorners: (p0: Vector2, p1: Vector2) => Interval2d<Closed, Closed> =\n  internal.fromCorners\n\n/**\n * Creates the smallest closed `Interval2d` enclosing the given points. Useful\n * for computing a bounding box from sampled points.\n *\n * @param points - One or more points to enclose.\n * @returns A new `Interval2d<Closed, Closed>` enclosing all input points.\n * @throws When called with zero points.\n * @since 2.1.0\n */\nexport const fromVectors: (...points: ReadonlyArray<Vector2>) => Interval2d<Closed, Closed> =\n  internal.fromVectors\n\nexport const containsVector: {\n  /**\n   * Checks if a vector lies within the 2D interval. Per-axis endpoint\n   * inclusivity follows each axis interval's `kind`.\n   *\n   * @param box - The 2D interval to test against.\n   * @param v - The vector to test.\n   * @returns `true` when the vector lies within the box on both axes.\n   * @since 2.1.0\n   */\n  (box: Interval2d, v: Vector2): boolean\n  /**\n   * @param v - The vector to test.\n   * @returns A function that takes a 2D interval and returns the containment result.\n   * @since 2.1.0\n   */\n  (v: Vector2): (box: Interval2d) => boolean\n} = internal.containsVector\n\nexport const containsInterval2d: {\n  /**\n   * Checks if `inner` is a subset of `outer`. The check is per-axis interval\n   * containment — for each axis, every point of the inner interval must also\n   * be in the outer interval, respecting endpoint inclusivity on both sides.\n   *\n   * @param outer - The enclosing 2D interval.\n   * @param inner - The candidate inner 2D interval.\n   * @returns `true` when every point of `inner` is also in `outer`.\n   * @since 2.1.0\n   */\n  (outer: Interval2d, inner: Interval2d): boolean\n  /**\n   * @param inner - The candidate inner 2D interval.\n   * @returns A function that takes the outer 2D interval and returns the containment result.\n   * @since 2.1.0\n   */\n  (inner: Interval2d): (outer: Interval2d) => boolean\n} = internal.containsInterval2d\n\n/**\n * Returns the size as a vector `(width, height)`. Accepts the broader\n * {@link Bounds2d} type because size does not depend on endpoint inclusivity.\n *\n * @param box - The 2D interval (or bounds-shaped value) to measure.\n * @returns The size as a `Vector2`.\n * @since 2.1.0\n */\nexport const size: (box: Bounds2d) => Vector2 = internal.size\n\nexport const union: {\n  /**\n   * Returns the smallest 2D interval enclosing both inputs.\n   *\n   * The per-axis return kind is determined by which input's endpoint wins on\n   * each side, with the contributor's openness preserved (or unioned to\n   * \"closed\" when endpoints are numerically equal and either is closed at\n   * that point).\n   *\n   * When both inputs share the same kind on an axis, the result collapses\n   * back to that kind. Otherwise the axis falls back to the open\n   * {@link Interval} type since the runtime kind depends on the values.\n   *\n   * @param a - The first 2D interval.\n   * @param b - The second 2D interval.\n   * @returns A new `Interval2d` enclosing both inputs.\n   * @since 2.1.0\n   */\n  <AX extends Interval, AY extends Interval, BX extends Interval, BY extends Interval>(\n    a: Interval2d<AX, AY>,\n    b: Interval2d<BX, BY>,\n  ): Interval2d<\n    AX extends BX ? (BX extends AX ? AX : Interval) : Interval,\n    AY extends BY ? (BY extends AY ? AY : Interval) : Interval\n  >\n  /**\n   * @param b - The second 2D interval.\n   * @returns A function that takes the first 2D interval and returns the union.\n   * @since 2.1.0\n   */\n  <BX extends Interval, BY extends Interval>(\n    b: Interval2d<BX, BY>,\n  ): <AX extends Interval, AY extends Interval>(\n    a: Interval2d<AX, AY>,\n  ) => Interval2d<\n    AX extends BX ? (BX extends AX ? AX : Interval) : Interval,\n    AY extends BY ? (BY extends AY ? AY : Interval) : Interval\n  >\n} = internal.union\n\nexport const equals: {\n  /**\n   * Checks if two `Interval2d` values are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}). Both the numeric endpoints\n   * AND the per-axis kinds must match.\n   *\n   * @param a - The first 2D interval.\n   * @param b - The second 2D interval.\n   * @returns `true` when both axes are equal.\n   * @since 2.1.0\n   */\n  (a: Interval2d, b: Interval2d): boolean\n  /**\n   * @param b - The second 2D interval.\n   * @returns A function that takes the first 2D interval and returns the comparison result.\n   * @since 2.1.0\n   */\n  (b: Interval2d): (a: Interval2d) => boolean\n} = internal.equals\n"],"mappings":";;;;;AAKA,MAAa,mBAAkC,OAAO,4BAA4B;AAGlF,IAAM,iBAAN,cACU,SAEV;CACE,CAAU,oBAAsC;CAEhD;CACA;CAEA,YAAY,GAAM,GAAM;EACtB,OAAO;EACP,KAAK,IAAI;EACT,KAAK,IAAI;;CAGX,KAAK,OAAO,eAAe;EACzB,OAAO,cAAc,OAAO,KAAK,EAAE,CAAC,KAAK,OAAO,KAAK,EAAE,CAAC;;CAG1D,KAAK,OAAO,IAAI,6BAA6B,IAAI;EAC/C,OAAO,KAAK,OAAO;;;AAIvB,MAAaA,kBAAgB,MAC3B,OAAO,MAAM,YAAY,MAAM,QAAQ,oBAAoB;AAE7D,MAAaC,UACX,GACA,MACqB,IAAI,eAAe,GAAG,EAAE;AAE/C,MAAaC,iBACX,IACA,OAEA,IAAI,eAAeC,WAAoB,GAAG,GAAG,GAAG,EAAE,EAAEA,WAAoB,GAAG,GAAG,GAAG,EAAE,CAAC;AAEtF,MAAaC,iBACX,GAAG,WAC8C;CACjD,UAAU,OAAO,SAAS,GAAG,0CAA0C;CACvE,MAAM,KAAoB,EAAE;CAC5B,MAAM,KAAoB,EAAE;CAC5B,KAAK,MAAM,KAAK,QAAQ;EACtB,GAAG,KAAK,EAAE,EAAE;EACZ,GAAG,KAAK,EAAE,EAAE;;CAEd,OAAO,IAAI,eAAeD,WAAoB,GAAG,GAAG,EAAEA,WAAoB,GAAG,GAAG,CAAC;;AAGnF,MAAaE,mBAAiB,KAI5B,IACC,KAAiB,MAChBC,SAAkB,IAAI,GAAG,EAAE,EAAE,IAAIA,SAAkB,IAAI,GAAG,EAAE,EAAE,CACjE;AAED,MAAaC,uBAAqB,KAIhC,IACC,OAAmB,UAClBC,iBAA0B,MAAM,GAAG,MAAM,EAAE,IAAIA,iBAA0B,MAAM,GAAG,MAAM,EAAE,CAC7F;AAGD,MAAaC,UAAQ,QACnBC,OAAa,KAAK,IAAI,IAAI,EAAE,MAAM,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,IAAI,EAAE,MAAM,IAAI,EAAE,MAAM,CAAC;AAQpF,MAAaC,UAqBT,KACF,IACC,GAAe,MACd,IAAI,eAAeC,QAAe,EAAE,GAAG,EAAE,EAAE,EAAEA,QAAe,EAAE,GAAG,EAAE,EAAE,CAAC,CACzE;AAED,MAAaC,WAAS,KAIpB,IACC,GAAe,MAA2BC,SAAgB,EAAE,GAAG,EAAE,EAAE,IAAIA,SAAgB,EAAE,GAAG,EAAE,EAAE,CAClG;;;;;;;;;;;;;;;;;;;;;ACxED,MAAa,eAAgDC;;;;;;;;;;AAW7D,MAAa,OACXC;;;;;;;;;;AAWF,MAAa,cACXC;;;;;;;;;;AAWF,MAAa,cACXC;AAEF,MAAa,iBAiBTC;AAEJ,MAAa,qBAkBTC;;;;;;;;;AAUJ,MAAa,OAAmCC;AAEhD,MAAa,QAsCTC;AAEJ,MAAa,SAkBTC"}