curvy 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/shared/{interval-05CR6eBf.mjs.map → interval-X1EYuf-T.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"interval-05CR6eBf.mjs","names":["isInterval","equals","aligned","make","makeOpenStart","makeOpenEnd","makeOpen","fromSize","fromMinMax","size","contains","containsInterval","union","filter","clamp","toStartOpen","toStartClosed","toEndOpen","toEndClosed","toClosed","toOpen","isClosed","isOpen","isOpenStart","isOpenEnd","isOpenAtStart","isOpenAtEnd","isClosedAtStart","isClosedAtEnd","unit","unitOpen","biunit","lerp","toLerpFn","normalize","toNormalizeFn","remap","toRemapFn","scaleShift","internal.isInterval","internal.equals","internal.aligned","internal.make","internal.makeOpenStart","internal.makeOpenEnd","internal.makeOpen","internal.fromSize","internal.fromMinMax","internal.size","internal.contains","internal.containsInterval","internal.union","internal.filter","internal.clamp","internal.toStartOpen","internal.toStartClosed","internal.toEndOpen","internal.toEndClosed","internal.toClosed","internal.toOpen","internal.isClosed","internal.isOpen","internal.isOpenStart","internal.isOpenEnd","internal.isOpenAtStart","internal.isOpenAtEnd","internal.isClosedAtStart","internal.isClosedAtEnd","internal.unit","internal.unitOpen","internal.biunit","internal.lerp","internal.toLerpFn","internal.normalize","internal.toNormalizeFn","internal.remap","internal.toRemapFn","internal.scaleShift"],"sources":["../../src/interval/interval.internal.ts","../../src/interval/interval.ts"],"sourcesContent":["import type { Bounds, Closed, Interval, Open, OpenEnd, OpenStart } from './interval'\nimport { dual, Pipeable } from '../utils'\nimport { epsEquals } from '../number'\n\nconst TypeId: unique symbol = Symbol.for('curvy/interval')\ntype TypeId = typeof TypeId\n\nabstract class IntervalImpl extends Pipeable {\n  readonly [TypeId]: TypeId = TypeId\n\n  abstract readonly kind: 'closed' | 'open-start' | 'open-end' | 'open'\n\n  readonly start: number\n  readonly end: number\n\n  constructor(start: number, end: number) {\n    super()\n\n    if (end < start) {\n      throw new Error('Interval end must be greater than or equal to start')\n    }\n\n    this.start = start\n    this.end = end\n  }\n\n  get [Symbol.toStringTag]() {\n    const open = this.kind === 'open-start' || this.kind === 'open' ? '(' : '['\n    const close = this.kind === 'open-end' || this.kind === 'open' ? ')' : ']'\n    return `Interval ${open}${this.start}, ${this.end}${close}`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nclass ClosedImpl extends IntervalImpl implements Closed {\n  readonly kind = 'closed' as const\n}\n\nclass OpenStartImpl extends IntervalImpl implements OpenStart {\n  readonly kind = 'open-start' as const\n}\n\nclass OpenEndImpl extends IntervalImpl implements OpenEnd {\n  readonly kind = 'open-end' as const\n}\n\nclass OpenImpl extends IntervalImpl implements Open {\n  readonly kind = 'open' as const\n}\n\nexport const isInterval = (v: unknown): v is Interval =>\n  typeof v === 'object' && v !== null && TypeId in v\n\nexport const equals = dual<\n  (b: Interval) => (a: Interval) => boolean,\n  (a: Interval, b: Interval) => boolean\n>(\n  2,\n  (a: Interval, b: Interval) =>\n    a.kind === b.kind && epsEquals(a.start, b.start) && epsEquals(a.end, b.end),\n)\n\nexport const aligned = dual<\n  (b: Bounds) => (a: Bounds) => boolean,\n  (a: Bounds, b: Bounds) => boolean\n>(2, (a: Bounds, b: Bounds) => epsEquals(a.start, b.start) && epsEquals(a.end, b.end))\n\nexport const make = (start: number, end?: number): Closed => new ClosedImpl(start, end ?? start)\n\nexport const makeOpenStart = (start: number, end?: number): OpenStart =>\n  new OpenStartImpl(start, end ?? start)\n\nexport const makeOpenEnd = (start: number, end?: number): OpenEnd =>\n  new OpenEndImpl(start, end ?? start)\n\nexport const makeOpen = (start: number, end?: number): Open => new OpenImpl(start, end ?? start)\n\nexport const fromSize = (a: number, b?: number): Closed => {\n  if (b === undefined) {\n    return new ClosedImpl(0, a)\n  }\n  return new ClosedImpl(a, a + b)\n}\n\nexport const fromMinMax = (...values: ReadonlyArray<number>): Closed =>\n  new ClosedImpl(Math.min(...values), Math.max(...values))\n\nexport const size = (i: Bounds): number => Math.abs(i.end - i.start)\n\nexport const contains = dual<\n  (value: number) => (interval: Interval) => boolean,\n  (interval: Interval, value: number) => boolean\n>(2, (interval: Interval, value: number): boolean => {\n  switch (interval.kind) {\n    case 'closed':\n      return value >= interval.start && value <= interval.end\n    case 'open-start':\n      return value > interval.start && value <= interval.end\n    case 'open-end':\n      return value >= interval.start && value < interval.end\n    case 'open':\n      return value > interval.start && value < interval.end\n  }\n})\n\nconst includesStart = (i: Interval): boolean => i.kind === 'closed' || i.kind === 'open-end'\nconst includesEnd = (i: Interval): boolean => i.kind === 'closed' || i.kind === 'open-start'\n\n// Whether `outer` is a superset of `inner`. For each endpoint pair (start/start\n// and end/end), the inner endpoint must be inside outer; when the endpoints\n// are numerically equal, the outer must include that boundary or the inner\n// must exclude it. Both shapes (closed-on-closed, open-on-open with matched\n// endpoints, etc.) are handled by this kind-aware comparison.\nexport const containsInterval = dual<\n  (inner: Interval) => (outer: Interval) => boolean,\n  (outer: Interval, inner: Interval) => boolean\n>(2, (outer: Interval, inner: Interval): boolean => {\n  const outerStart = includesStart(outer)\n  const innerStart = includesStart(inner)\n  const outerEnd = includesEnd(outer)\n  const innerEnd = includesEnd(inner)\n\n  const startOk =\n    inner.start > outer.start || (inner.start === outer.start && (outerStart || !innerStart))\n  const endOk = inner.end < outer.end || (inner.end === outer.end && (outerEnd || !innerEnd))\n\n  return startOk && endOk\n})\n\n// Smallest interval enclosing both inputs. Each endpoint of the result is the\n// extremum of (a.start, b.start) / (a.end, b.end), and its inclusivity follows\n// whichever input contributed it. When endpoints tie, the result is closed at\n// that point if EITHER input includes it.\nexport const union = dual<\n  (b: Interval) => (a: Interval) => Interval,\n  (a: Interval, b: Interval) => Interval\n>(2, (a: Interval, b: Interval): Interval => {\n  let startVal: number\n  let startInc: boolean\n  if (a.start < b.start) {\n    startVal = a.start\n    startInc = includesStart(a)\n  } else if (a.start > b.start) {\n    startVal = b.start\n    startInc = includesStart(b)\n  } else {\n    startVal = a.start\n    startInc = includesStart(a) || includesStart(b)\n  }\n\n  let endVal: number\n  let endInc: boolean\n  if (a.end > b.end) {\n    endVal = a.end\n    endInc = includesEnd(a)\n  } else if (a.end < b.end) {\n    endVal = b.end\n    endInc = includesEnd(b)\n  } else {\n    endVal = a.end\n    endInc = includesEnd(a) || includesEnd(b)\n  }\n\n  if (startInc && endInc) {\n    return make(startVal, endVal)\n  }\n  if (!startInc && endInc) {\n    return makeOpenStart(startVal, endVal)\n  }\n  if (startInc && !endInc) {\n    return makeOpenEnd(startVal, endVal)\n  }\n  return makeOpen(startVal, endVal)\n})\n\nexport const filter = dual<\n  <V extends ReadonlyArray<number>>(value: V) => (interval: Interval) => V,\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V) => V\n>(\n  2,\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V): V =>\n    value.filter((v) => contains(interval, v)) as unknown as V,\n)\n\nexport const clamp = dual<\n  <V extends number | ReadonlyArray<number>>(value: V) => (interval: Bounds) => V,\n  <V extends number | ReadonlyArray<number>>(interval: Bounds, value: V) => V\n>(2, <V extends number | ReadonlyArray<number>>(interval: Bounds, value: V): V => {\n  if (Array.isArray(value)) {\n    return value.map((v) => clamp(interval, v)) as unknown as V\n  }\n  const v = value as number\n  if (v < interval.start) {\n    return interval.start as V\n  }\n  if (v > interval.end) {\n    return interval.end as V\n  }\n  return v as V\n})\n\nexport const toStartOpen = ((i: Interval): OpenStart | Open => {\n  switch (i.kind) {\n    case 'closed':\n      return new OpenStartImpl(i.start, i.end)\n    case 'open-end':\n      return new OpenImpl(i.start, i.end)\n    case 'open-start':\n    case 'open':\n      return i\n  }\n}) as {\n  (i: Closed | OpenStart): OpenStart\n  (i: OpenEnd | Open): Open\n}\n\nexport const toStartClosed = ((i: Interval): Closed | OpenEnd => {\n  switch (i.kind) {\n    case 'open-start':\n      return new ClosedImpl(i.start, i.end)\n    case 'open':\n      return new OpenEndImpl(i.start, i.end)\n    case 'closed':\n    case 'open-end':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenEnd\n}\n\nexport const toEndOpen = ((i: Interval): OpenEnd | Open => {\n  switch (i.kind) {\n    case 'closed':\n      return new OpenEndImpl(i.start, i.end)\n    case 'open-start':\n      return new OpenImpl(i.start, i.end)\n    case 'open-end':\n    case 'open':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): OpenEnd\n  (i: OpenStart | Open): Open\n}\n\nexport const toEndClosed = ((i: Interval): Closed | OpenStart => {\n  switch (i.kind) {\n    case 'open-end':\n      return new ClosedImpl(i.start, i.end)\n    case 'open':\n      return new OpenStartImpl(i.start, i.end)\n    case 'closed':\n    case 'open-start':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenStart\n}\n\nexport const toClosed = (i: Interval): Closed => {\n  if (i.kind === 'closed') {\n    return i\n  }\n  return new ClosedImpl(i.start, i.end)\n}\n\nexport const toOpen = (i: Interval): Open => {\n  if (i.kind === 'open') {\n    return i\n  }\n  return new OpenImpl(i.start, i.end)\n}\n\nexport const isClosed = (i: Interval): i is Closed => i.kind === 'closed'\nexport const isOpen = (i: Interval): i is Open => i.kind === 'open'\nexport const isOpenStart = (i: Interval): i is OpenStart => i.kind === 'open-start'\nexport const isOpenEnd = (i: Interval): i is OpenEnd => i.kind === 'open-end'\n\nexport const isOpenAtStart = (i: Interval): i is OpenStart | Open =>\n  i.kind === 'open-start' || i.kind === 'open'\nexport const isOpenAtEnd = (i: Interval): i is OpenEnd | Open =>\n  i.kind === 'open-end' || i.kind === 'open'\nexport const isClosedAtStart = (i: Interval): i is Closed | OpenEnd =>\n  i.kind === 'closed' || i.kind === 'open-end'\nexport const isClosedAtEnd = (i: Interval): i is Closed | OpenStart =>\n  i.kind === 'closed' || i.kind === 'open-start'\n\nexport const unit: Closed = make(0, 1)\n\nexport const unitOpen: Open = new OpenImpl(0, 1)\n\nexport const biunit: Closed = make(-1, 1)\n\nexport const lerp = (interval: Bounds, t: number): number =>\n  (1 - t) * interval.start + t * interval.end\n\nexport const toLerpFn =\n  (interval: Bounds) =>\n  (t: number): number =>\n    lerp(interval, t)\n\nexport const normalize = (interval: Bounds, x: number): number =>\n  (x - interval.start) / size(interval)\n\nexport const toNormalizeFn =\n  (interval: Bounds) =>\n  (x: number): number =>\n    normalize(interval, x)\n\nexport const remap = (source: Bounds, target: Bounds, x: number): number =>\n  target.start + ((x - source.start) * size(target)) / size(source)\n\nexport const toRemapFn =\n  (source: Bounds, target: Bounds) =>\n  (x: number): number =>\n    remap(source, target, x)\n\nexport const scaleShift = (source: Bounds, target: Bounds) => {\n  const scale = size(target) / size(source)\n\n  return {\n    scale,\n    shift: target.start - source.start * scale,\n  }\n}\n","import * as internal from './interval.internal'\nimport type { Pipeable } from '../utils'\n\n/**\n * The structural minimum: any value with numeric `start` and `end` fields.\n *\n * Operations that don't read endpoint inclusivity (e.g. `lerp`, `normalize`,\n * `remap`, `size`) accept `Bounds` so the signature itself documents what\n * the operation depends on.\n *\n * @since 2.0.0\n */\nexport interface Bounds {\n  readonly start: number\n  readonly end: number\n}\n\n/**\n * A mathematical interval. Discriminated union of four variants by endpoint\n * inclusivity: `Closed`, `OpenStart`, `OpenEnd`, `Open`. Operations that\n * depend on inclusivity (e.g. `contains`, `filter`, `equals`) dispatch on\n * the `kind` field; operations that don't accept the broader `Bounds` type.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport type Interval = Closed | OpenStart | OpenEnd | Open\n\n/**\n * `[start, end]` — both endpoints included.\n *\n * @since 2.0.0\n */\nexport interface Closed extends Pipeable, Bounds {\n  readonly kind: 'closed'\n}\n\n/**\n * `(start, end]` — start excluded, end included.\n *\n * @since 2.0.0\n */\nexport interface OpenStart extends Pipeable, Bounds {\n  readonly kind: 'open-start'\n}\n\n/**\n * `[start, end)` — start included, end excluded.\n *\n * @since 2.0.0\n */\nexport interface OpenEnd extends Pipeable, Bounds {\n  readonly kind: 'open-end'\n}\n\n/**\n * `(start, end)` — both endpoints excluded.\n *\n * @since 2.0.0\n */\nexport interface Open extends Pipeable, Bounds {\n  readonly kind: 'open'\n}\n\n/**\n * Checks if a value is an `Interval`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is an `Interval`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isInterval: (v: unknown) => v is Interval = internal.isInterval\n\nexport const equals: {\n  /**\n   * Checks if two `Interval` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * Both endpoints AND the kind must match — a `Closed` and an `OpenStart` with\n   * the same numeric endpoints are not equal. Use `aligned` for the looser\n   * \"same numeric range\" check.\n   *\n   * @param a - The first interval.\n   * @param b - The second interval.\n   * @returns `true` when both intervals share a kind and both endpoints are within tolerance.\n   * @since 1.1.0\n   */\n  (a: Interval, b: Interval): boolean\n  /**\n   * Checks if two `Interval` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second interval.\n   * @returns A function that takes the first interval and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Interval): (a: Interval) => boolean\n} = internal.equals\n\nexport const aligned: {\n  /**\n   * Checks if two values share the same numeric range, ignoring endpoint\n   * inclusivity. Accepts any `Bounds`-shaped value.\n   *\n   * @param a - The first bounds.\n   * @param b - The second bounds.\n   * @returns `true` when both endpoints are within the default tolerance ({@link EPSILON}).\n   * @since 2.0.0\n   */\n  (a: Bounds, b: Bounds): boolean\n  /**\n   * @param b - The second bounds.\n   * @returns A function that takes the first bounds and returns the comparison result.\n   * @since 2.0.0\n   */\n  (b: Bounds): (a: Bounds) => boolean\n} = internal.aligned\n\nexport const make: {\n  /**\n   * Creates a new closed `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `Closed` interval `[point, point]`.\n   * @since 1.0.0\n   */\n  (point: number): Closed\n  /**\n   * Creates a new closed `Interval` instance.\n   *\n   * @param start - The start of the interval.\n   * @param end - The end of the interval.\n   * @returns A new `Closed` interval `[start, end]`.\n   * @since 1.0.0\n   */\n  (start: number, end: number): Closed\n} = internal.make\n\nexport const makeOpenStart: {\n  /**\n   * Creates a new left-open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `OpenStart` interval `(point, point]` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): OpenStart\n  /**\n   * Creates a new left-open `Interval` instance.\n   *\n   * @param start - The start of the interval (excluded).\n   * @param end - The end of the interval (included).\n   * @returns A new `OpenStart` interval `(start, end]`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): OpenStart\n} = internal.makeOpenStart\n\nexport const makeOpenEnd: {\n  /**\n   * Creates a new right-open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `OpenEnd` interval `[point, point)` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): OpenEnd\n  /**\n   * Creates a new right-open `Interval` instance.\n   *\n   * @param start - The start of the interval (included).\n   * @param end - The end of the interval (excluded).\n   * @returns A new `OpenEnd` interval `[start, end)`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): OpenEnd\n} = internal.makeOpenEnd\n\nexport const makeOpen: {\n  /**\n   * Creates a new fully open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `Open` interval `(point, point)` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): Open\n  /**\n   * Creates a new fully open `Interval` instance.\n   *\n   * @param start - The start of the interval (excluded).\n   * @param end - The end of the interval (excluded).\n   * @returns A new `Open` interval `(start, end)`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): Open\n} = internal.makeOpen\n\nexport const fromSize: {\n  /**\n   * Creates a new closed `Interval` instance from a size.\n   *\n   * @param size - The size of the interval.\n   * @returns A new `Closed` interval `[0, size]`.\n   * @since 1.0.0\n   */\n  (size: number): Closed\n  /**\n   * Creates a new closed `Interval` instance from a size.\n   *\n   * @param start - The start of the interval.\n   * @param size - The size of the interval.\n   * @returns A new `Closed` interval `[start, start + size]`.\n   * @since 1.0.0\n   */\n  (start: number, size: number): Closed\n} = internal.fromSize\n\n/**\n * Creates a new closed `Interval` from a minimum and maximum value, in any order.\n *\n * @param values - The values to take the min and max of.\n * @returns A new `Closed` interval `[min(values), max(values)]`.\n * @since 1.0.0\n */\nexport const fromMinMax: (...values: ReadonlyArray<number>) => Closed = internal.fromMinMax\n\n/**\n * Calculates the size of an interval.\n *\n * Kind-agnostic — `size` of `[0, 1]` and `(0, 1)` are both `1`.\n *\n * @param i - The bounds to calculate the size of.\n * @returns The size of the bounds.\n * @since 1.0.0\n */\nexport const size: (i: Bounds) => number = internal.size\n\nexport const contains: {\n  /**\n   * Checks if a value is contained within an interval. Endpoint inclusivity\n   * follows the interval's `kind`.\n   *\n   * @param interval - The interval to check.\n   * @param value - The value to check.\n   * @returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (interval: Interval, value: number): boolean\n  /**\n   * Checks if a value is contained within an interval. Endpoint inclusivity\n   * follows the interval's `kind`.\n   *\n   * @param value - The value to check.\n   * @returns A function that takes an interval and returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (value: number): (interval: Interval) => boolean\n} = internal.contains\n\nexport const containsInterval: {\n  /**\n   * Checks if `inner` is a subset of `outer` — every point of `inner` is also\n   * in `outer`. Respects endpoint inclusivity on both sides: a closed inner\n   * endpoint must be inside (or on a closed boundary of) the outer, while an\n   * open inner endpoint can sit exactly on an open outer boundary.\n   *\n   * @param outer - The enclosing interval.\n   * @param inner - The candidate inner interval.\n   * @returns `true` when `inner` is a subset of `outer`.\n   * @since 2.1.0\n   */\n  (outer: Interval, inner: Interval): boolean\n  /**\n   * @param inner - The candidate inner interval.\n   * @returns A function that takes the outer interval and returns the containment result.\n   * @since 2.1.0\n   */\n  (inner: Interval): (outer: Interval) => boolean\n} = internal.containsInterval\n\nexport const union: {\n  /**\n   * Returns the smallest interval enclosing both inputs. Each endpoint's\n   * inclusivity follows the input that contributed it; when both endpoints\n   * tie, the result is closed at that point if either input includes it.\n   *\n   * @param a - The first interval.\n   * @param b - The second interval.\n   * @returns A new interval enclosing both inputs.\n   * @since 2.1.0\n   */\n  (a: Interval, b: Interval): Interval\n  /**\n   * @param b - The second interval.\n   * @returns A function that takes the first interval and returns the union.\n   * @since 2.1.0\n   */\n  (b: Interval): (a: Interval) => Interval\n} = internal.union\n\nexport const filter: {\n  /**\n   * Filters an array of values to those contained within an interval.\n   * Endpoint inclusivity follows the interval's `kind`.\n   *\n   * @param interval - The interval to filter the values to.\n   * @param value - The values to filter.\n   * @returns The filtered values.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V): V\n  /**\n   * Filters an array of values to those contained within an interval.\n   *\n   * @param value - The values to filter.\n   * @returns A function that takes an interval and returns the filtered values.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(value: V): (interval: Interval) => V\n} = internal.filter\n\nexport const clamp: {\n  /**\n   * Clamps a value to be within bounds. Kind-agnostic — clamps to the numeric\n   * range regardless of endpoint inclusivity.\n   *\n   * @param interval - The bounds to clamp the value to.\n   * @param value - The value to clamp.\n   * @returns The clamped value.\n   * @since 1.0.0\n   */\n  (interval: Bounds, value: number): number\n  /**\n   * Clamps a value to be within bounds. Kind-agnostic.\n   *\n   * @param value - The value to clamp.\n   * @returns A function that takes bounds and returns the clamped value.\n   * @since 1.0.0\n   */\n  (value: number): (interval: Bounds) => number\n  /**\n   * Clamps an array of values to be within bounds. Kind-agnostic.\n   *\n   * @param interval - The bounds to clamp the values to.\n   * @param value - The values to clamp.\n   * @returns The clamped values.\n   * @since 1.0.0\n   */\n  (interval: Bounds, value: ReadonlyArray<number>): ReadonlyArray<number>\n  /**\n   * Clamps an array of values to be within bounds. Kind-agnostic.\n   *\n   * @param value - The values to clamp.\n   * @returns A function that takes bounds and returns the clamped values.\n   * @since 1.0.0\n   */\n  (value: ReadonlyArray<number>): (interval: Bounds) => ReadonlyArray<number>\n} = internal.clamp\n\n/**\n * Returns an interval with the start endpoint open. Preserves the end endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toStartOpen: {\n  (i: Closed | OpenStart): OpenStart\n  (i: OpenEnd | Open): Open\n} = internal.toStartOpen\n\n/**\n * Returns an interval with the start endpoint closed. Preserves the end endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toStartClosed: {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenEnd\n} = internal.toStartClosed\n\n/**\n * Returns an interval with the end endpoint open. Preserves the start endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toEndOpen: {\n  (i: Closed | OpenEnd): OpenEnd\n  (i: OpenStart | Open): Open\n} = internal.toEndOpen\n\n/**\n * Returns an interval with the end endpoint closed. Preserves the start endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toEndClosed: {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenStart\n} = internal.toEndClosed\n\n/**\n * Returns a closed interval over the same numeric range.\n *\n * @since 2.0.0\n */\nexport const toClosed: (i: Interval) => Closed = internal.toClosed\n\n/**\n * Returns a fully open interval over the same numeric range.\n *\n * @since 2.0.0\n */\nexport const toOpen: (i: Interval) => Open = internal.toOpen\n\n/**\n * Type-narrowing predicate: refines `Interval` to `Closed`.\n *\n * @since 2.0.0\n */\nexport const isClosed: (i: Interval) => i is Closed = internal.isClosed\n\n/**\n * Type-narrowing predicate: refines `Interval` to `Open`.\n *\n * @since 2.0.0\n */\nexport const isOpen: (i: Interval) => i is Open = internal.isOpen\n\n/**\n * Type-narrowing predicate: refines `Interval` to `OpenStart`.\n *\n * @since 2.0.0\n */\nexport const isOpenStart: (i: Interval) => i is OpenStart = internal.isOpenStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to `OpenEnd`.\n *\n * @since 2.0.0\n */\nexport const isOpenEnd: (i: Interval) => i is OpenEnd = internal.isOpenEnd\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with an open start endpoint.\n *\n * @since 2.0.0\n */\nexport const isOpenAtStart: (i: Interval) => i is OpenStart | Open = internal.isOpenAtStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with an open end endpoint.\n *\n * @since 2.0.0\n */\nexport const isOpenAtEnd: (i: Interval) => i is OpenEnd | Open = internal.isOpenAtEnd\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with a closed start endpoint.\n *\n * @since 2.0.0\n */\nexport const isClosedAtStart: (i: Interval) => i is Closed | OpenEnd = internal.isClosedAtStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with a closed end endpoint.\n *\n * @since 2.0.0\n */\nexport const isClosedAtEnd: (i: Interval) => i is Closed | OpenStart = internal.isClosedAtEnd\n\n/**\n * The unit interval, `[0, 1]`.\n *\n * @since 1.0.0\n */\nexport const unit: Closed = internal.unit\n\n/**\n * The open unit interval, `(0, 1)`. The symmetric open analog of {@link unit};\n * convenient for \"strict interior\" use cases such as filtering roots that\n * must lie strictly inside the unit parameter range.\n *\n * @since 2.1.0\n */\nexport const unitOpen: Open = internal.unitOpen\n\n/**\n * The biunit interval, `[-1, 1]`.\n *\n * @since 1.0.0\n */\nexport const biunit: Closed = internal.biunit\n\n/**\n * Linearly interpolates a value within bounds.\n *\n * @param interval - The bounds to interpolate within.\n * @param t - The interpolation factor, typically between 0 and 1.\n * @returns The interpolated value.\n * @since 1.0.0\n */\nexport const lerp: (interval: Bounds, t: number) => number = internal.lerp\n\n/**\n * Creates a linear interpolation function for given bounds.\n *\n * @param interval - The bounds to create the interpolation function for.\n * @returns A function that takes a factor `t` and returns the interpolated value.\n * @since 1.0.0\n */\nexport const toLerpFn: (interval: Bounds) => (t: number) => number = internal.toLerpFn\n\n/**\n * Normalizes a value within bounds.\n *\n * @param interval - The bounds to normalize within.\n * @param x - The value to normalize.\n * @returns The normalized value.\n * @since 1.0.0\n */\nexport const normalize: (interval: Bounds, x: number) => number = internal.normalize\n\n/**\n * Creates a normalization function for given bounds.\n *\n * @param interval - The bounds to create the normalization function for.\n * @returns A function that takes a value `x` and returns the normalized value.\n * @since 1.0.0\n */\nexport const toNormalizeFn: (interval: Bounds) => (x: number) => number = internal.toNormalizeFn\n\n/**\n * Remaps a value from one bounds to another.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @param x - The value to remap.\n * @returns The remapped value.\n * @since 1.0.0\n */\nexport const remap: (source: Bounds, target: Bounds, x: number) => number = internal.remap\n\n/**\n * Creates a remapping function for given bounds.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @returns A function that takes a value `x` and returns the remapped value.\n * @since 1.0.0\n */\nexport const toRemapFn: (source: Bounds, target: Bounds) => (x: number) => number =\n  internal.toRemapFn\n\n/**\n * Calculates the scale and shift needed to map a source bounds to a target bounds.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @returns An object containing the scale and shift values.\n * @since 1.0.0\n */\nexport const scaleShift: (source: Bounds, target: Bounds) => ScaleShift = internal.scaleShift\n\n/**\n * The scale and shift needed to map a source bounds to a target bounds.\n *\n * @since 1.0.0\n */\nexport interface ScaleShift {\n  readonly scale: number\n  readonly shift: number\n}\n"],"mappings":"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"}
+{"version":3,"file":"interval-X1EYuf-T.mjs","names":["isInterval","equals","aligned","make","makeOpenStart","makeOpenEnd","makeOpen","fromSize","fromMinMax","size","contains","containsInterval","union","filter","clamp","toStartOpen","toStartClosed","toEndOpen","toEndClosed","toClosed","toOpen","isClosed","isOpen","isOpenStart","isOpenEnd","isOpenAtStart","isOpenAtEnd","isClosedAtStart","isClosedAtEnd","unit","unitOpen","biunit","lerp","toLerpFn","normalize","toNormalizeFn","remap","toRemapFn","scaleShift","internal.isInterval","internal.equals","internal.aligned","internal.make","internal.makeOpenStart","internal.makeOpenEnd","internal.makeOpen","internal.fromSize","internal.fromMinMax","internal.size","internal.contains","internal.containsInterval","internal.union","internal.filter","internal.clamp","internal.toStartOpen","internal.toStartClosed","internal.toEndOpen","internal.toEndClosed","internal.toClosed","internal.toOpen","internal.isClosed","internal.isOpen","internal.isOpenStart","internal.isOpenEnd","internal.isOpenAtStart","internal.isOpenAtEnd","internal.isClosedAtStart","internal.isClosedAtEnd","internal.unit","internal.unitOpen","internal.biunit","internal.lerp","internal.toLerpFn","internal.normalize","internal.toNormalizeFn","internal.remap","internal.toRemapFn","internal.scaleShift"],"sources":["../../src/interval/interval.internal.ts","../../src/interval/interval.ts"],"sourcesContent":["import type { Bounds, Closed, Interval, Open, OpenEnd, OpenStart } from './interval'\nimport { dual, Pipeable } from '../utils'\nimport { epsEquals } from '../number'\n\nconst TypeId: unique symbol = Symbol.for('curvy/interval')\ntype TypeId = typeof TypeId\n\nabstract class IntervalImpl extends Pipeable {\n  readonly [TypeId]: TypeId = TypeId\n\n  abstract readonly kind: 'closed' | 'open-start' | 'open-end' | 'open'\n\n  readonly start: number\n  readonly end: number\n\n  constructor(start: number, end: number) {\n    super()\n\n    if (end < start) {\n      throw new Error('Interval end must be greater than or equal to start')\n    }\n\n    this.start = start\n    this.end = end\n  }\n\n  get [Symbol.toStringTag]() {\n    const open = this.kind === 'open-start' || this.kind === 'open' ? '(' : '['\n    const close = this.kind === 'open-end' || this.kind === 'open' ? ')' : ']'\n    return `Interval ${open}${this.start}, ${this.end}${close}`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nclass ClosedImpl extends IntervalImpl implements Closed {\n  readonly kind = 'closed' as const\n}\n\nclass OpenStartImpl extends IntervalImpl implements OpenStart {\n  readonly kind = 'open-start' as const\n}\n\nclass OpenEndImpl extends IntervalImpl implements OpenEnd {\n  readonly kind = 'open-end' as const\n}\n\nclass OpenImpl extends IntervalImpl implements Open {\n  readonly kind = 'open' as const\n}\n\nexport const isInterval = (v: unknown): v is Interval =>\n  typeof v === 'object' && v !== null && TypeId in v\n\nexport const equals = dual<\n  (b: Interval) => (a: Interval) => boolean,\n  (a: Interval, b: Interval) => boolean\n>(\n  2,\n  (a: Interval, b: Interval) =>\n    a.kind === b.kind && epsEquals(a.start, b.start) && epsEquals(a.end, b.end),\n)\n\nexport const aligned = dual<\n  (b: Bounds) => (a: Bounds) => boolean,\n  (a: Bounds, b: Bounds) => boolean\n>(2, (a: Bounds, b: Bounds) => epsEquals(a.start, b.start) && epsEquals(a.end, b.end))\n\nexport const make = (start: number, end?: number): Closed => new ClosedImpl(start, end ?? start)\n\nexport const makeOpenStart = (start: number, end?: number): OpenStart =>\n  new OpenStartImpl(start, end ?? start)\n\nexport const makeOpenEnd = (start: number, end?: number): OpenEnd =>\n  new OpenEndImpl(start, end ?? start)\n\nexport const makeOpen = (start: number, end?: number): Open => new OpenImpl(start, end ?? start)\n\nexport const fromSize = (a: number, b?: number): Closed => {\n  if (b === undefined) {\n    return new ClosedImpl(0, a)\n  }\n  return new ClosedImpl(a, a + b)\n}\n\nexport const fromMinMax = (...values: ReadonlyArray<number>): Closed =>\n  new ClosedImpl(Math.min(...values), Math.max(...values))\n\nexport const size = (i: Bounds): number => Math.abs(i.end - i.start)\n\nexport const contains = dual<\n  (value: number) => (interval: Interval) => boolean,\n  (interval: Interval, value: number) => boolean\n>(2, (interval: Interval, value: number): boolean => {\n  switch (interval.kind) {\n    case 'closed':\n      return value >= interval.start && value <= interval.end\n    case 'open-start':\n      return value > interval.start && value <= interval.end\n    case 'open-end':\n      return value >= interval.start && value < interval.end\n    case 'open':\n      return value > interval.start && value < interval.end\n  }\n})\n\nconst includesStart = (i: Interval): boolean => i.kind === 'closed' || i.kind === 'open-end'\nconst includesEnd = (i: Interval): boolean => i.kind === 'closed' || i.kind === 'open-start'\n\n// Whether `outer` is a superset of `inner`. For each endpoint pair (start/start\n// and end/end), the inner endpoint must be inside outer; when the endpoints\n// are numerically equal, the outer must include that boundary or the inner\n// must exclude it. Both shapes (closed-on-closed, open-on-open with matched\n// endpoints, etc.) are handled by this kind-aware comparison.\nexport const containsInterval = dual<\n  (inner: Interval) => (outer: Interval) => boolean,\n  (outer: Interval, inner: Interval) => boolean\n>(2, (outer: Interval, inner: Interval): boolean => {\n  const outerStart = includesStart(outer)\n  const innerStart = includesStart(inner)\n  const outerEnd = includesEnd(outer)\n  const innerEnd = includesEnd(inner)\n\n  const startOk =\n    inner.start > outer.start || (inner.start === outer.start && (outerStart || !innerStart))\n  const endOk = inner.end < outer.end || (inner.end === outer.end && (outerEnd || !innerEnd))\n\n  return startOk && endOk\n})\n\n// Smallest interval enclosing both inputs. Each endpoint of the result is the\n// extremum of (a.start, b.start) / (a.end, b.end), and its inclusivity follows\n// whichever input contributed it. When endpoints tie, the result is closed at\n// that point if EITHER input includes it.\nexport const union = dual<\n  (b: Interval) => (a: Interval) => Interval,\n  (a: Interval, b: Interval) => Interval\n>(2, (a: Interval, b: Interval): Interval => {\n  let startVal: number\n  let startInc: boolean\n  if (a.start < b.start) {\n    startVal = a.start\n    startInc = includesStart(a)\n  } else if (a.start > b.start) {\n    startVal = b.start\n    startInc = includesStart(b)\n  } else {\n    startVal = a.start\n    startInc = includesStart(a) || includesStart(b)\n  }\n\n  let endVal: number\n  let endInc: boolean\n  if (a.end > b.end) {\n    endVal = a.end\n    endInc = includesEnd(a)\n  } else if (a.end < b.end) {\n    endVal = b.end\n    endInc = includesEnd(b)\n  } else {\n    endVal = a.end\n    endInc = includesEnd(a) || includesEnd(b)\n  }\n\n  if (startInc && endInc) {\n    return make(startVal, endVal)\n  }\n  if (!startInc && endInc) {\n    return makeOpenStart(startVal, endVal)\n  }\n  if (startInc && !endInc) {\n    return makeOpenEnd(startVal, endVal)\n  }\n  return makeOpen(startVal, endVal)\n})\n\nexport const filter = dual<\n  <V extends ReadonlyArray<number>>(value: V) => (interval: Interval) => V,\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V) => V\n>(\n  2,\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V): V =>\n    value.filter((v) => contains(interval, v)) as unknown as V,\n)\n\nexport const clamp = dual<\n  <V extends number | ReadonlyArray<number>>(value: V) => (interval: Bounds) => V,\n  <V extends number | ReadonlyArray<number>>(interval: Bounds, value: V) => V\n>(2, <V extends number | ReadonlyArray<number>>(interval: Bounds, value: V): V => {\n  if (Array.isArray(value)) {\n    return value.map((v) => clamp(interval, v)) as unknown as V\n  }\n  const v = value as number\n  if (v < interval.start) {\n    return interval.start as V\n  }\n  if (v > interval.end) {\n    return interval.end as V\n  }\n  return v as V\n})\n\nexport const toStartOpen = ((i: Interval): OpenStart | Open => {\n  switch (i.kind) {\n    case 'closed':\n      return new OpenStartImpl(i.start, i.end)\n    case 'open-end':\n      return new OpenImpl(i.start, i.end)\n    case 'open-start':\n    case 'open':\n      return i\n  }\n}) as {\n  (i: Closed | OpenStart): OpenStart\n  (i: OpenEnd | Open): Open\n}\n\nexport const toStartClosed = ((i: Interval): Closed | OpenEnd => {\n  switch (i.kind) {\n    case 'open-start':\n      return new ClosedImpl(i.start, i.end)\n    case 'open':\n      return new OpenEndImpl(i.start, i.end)\n    case 'closed':\n    case 'open-end':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenEnd\n}\n\nexport const toEndOpen = ((i: Interval): OpenEnd | Open => {\n  switch (i.kind) {\n    case 'closed':\n      return new OpenEndImpl(i.start, i.end)\n    case 'open-start':\n      return new OpenImpl(i.start, i.end)\n    case 'open-end':\n    case 'open':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): OpenEnd\n  (i: OpenStart | Open): Open\n}\n\nexport const toEndClosed = ((i: Interval): Closed | OpenStart => {\n  switch (i.kind) {\n    case 'open-end':\n      return new ClosedImpl(i.start, i.end)\n    case 'open':\n      return new OpenStartImpl(i.start, i.end)\n    case 'closed':\n    case 'open-start':\n      return i\n  }\n}) as {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenStart\n}\n\nexport const toClosed = (i: Interval): Closed => {\n  if (i.kind === 'closed') {\n    return i\n  }\n  return new ClosedImpl(i.start, i.end)\n}\n\nexport const toOpen = (i: Interval): Open => {\n  if (i.kind === 'open') {\n    return i\n  }\n  return new OpenImpl(i.start, i.end)\n}\n\nexport const isClosed = (i: Interval): i is Closed => i.kind === 'closed'\nexport const isOpen = (i: Interval): i is Open => i.kind === 'open'\nexport const isOpenStart = (i: Interval): i is OpenStart => i.kind === 'open-start'\nexport const isOpenEnd = (i: Interval): i is OpenEnd => i.kind === 'open-end'\n\nexport const isOpenAtStart = (i: Interval): i is OpenStart | Open =>\n  i.kind === 'open-start' || i.kind === 'open'\nexport const isOpenAtEnd = (i: Interval): i is OpenEnd | Open =>\n  i.kind === 'open-end' || i.kind === 'open'\nexport const isClosedAtStart = (i: Interval): i is Closed | OpenEnd =>\n  i.kind === 'closed' || i.kind === 'open-end'\nexport const isClosedAtEnd = (i: Interval): i is Closed | OpenStart =>\n  i.kind === 'closed' || i.kind === 'open-start'\n\nexport const unit: Closed = make(0, 1)\n\nexport const unitOpen: Open = new OpenImpl(0, 1)\n\nexport const biunit: Closed = make(-1, 1)\n\nexport const lerp = (interval: Bounds, t: number): number =>\n  (1 - t) * interval.start + t * interval.end\n\nexport const toLerpFn =\n  (interval: Bounds) =>\n  (t: number): number =>\n    lerp(interval, t)\n\nexport const normalize = (interval: Bounds, x: number): number =>\n  (x - interval.start) / size(interval)\n\nexport const toNormalizeFn =\n  (interval: Bounds) =>\n  (x: number): number =>\n    normalize(interval, x)\n\nexport const remap = (source: Bounds, target: Bounds, x: number): number =>\n  target.start + ((x - source.start) * size(target)) / size(source)\n\nexport const toRemapFn =\n  (source: Bounds, target: Bounds) =>\n  (x: number): number =>\n    remap(source, target, x)\n\nexport const scaleShift = (source: Bounds, target: Bounds) => {\n  const scale = size(target) / size(source)\n\n  return {\n    scale,\n    shift: target.start - source.start * scale,\n  }\n}\n","import * as internal from './interval.internal'\nimport type { Pipeable } from '../utils'\n\n/**\n * The structural minimum: any value with numeric `start` and `end` fields.\n *\n * Operations that don't read endpoint inclusivity (e.g. `lerp`, `normalize`,\n * `remap`, `size`) accept `Bounds` so the signature itself documents what\n * the operation depends on.\n *\n * @since 2.0.0\n */\nexport interface Bounds {\n  readonly start: number\n  readonly end: number\n}\n\n/**\n * A mathematical interval. Discriminated union of four variants by endpoint\n * inclusivity: `Closed`, `OpenStart`, `OpenEnd`, `Open`. Operations that\n * depend on inclusivity (e.g. `contains`, `filter`, `equals`) dispatch on\n * the `kind` field; operations that don't accept the broader `Bounds` type.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport type Interval = Closed | OpenStart | OpenEnd | Open\n\n/**\n * `[start, end]` — both endpoints included.\n *\n * @since 2.0.0\n */\nexport interface Closed extends Pipeable, Bounds {\n  readonly kind: 'closed'\n}\n\n/**\n * `(start, end]` — start excluded, end included.\n *\n * @since 2.0.0\n */\nexport interface OpenStart extends Pipeable, Bounds {\n  readonly kind: 'open-start'\n}\n\n/**\n * `[start, end)` — start included, end excluded.\n *\n * @since 2.0.0\n */\nexport interface OpenEnd extends Pipeable, Bounds {\n  readonly kind: 'open-end'\n}\n\n/**\n * `(start, end)` — both endpoints excluded.\n *\n * @since 2.0.0\n */\nexport interface Open extends Pipeable, Bounds {\n  readonly kind: 'open'\n}\n\n/**\n * Checks if a value is an `Interval`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is an `Interval`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isInterval: (v: unknown) => v is Interval = internal.isInterval\n\nexport const equals: {\n  /**\n   * Checks if two `Interval` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * Both endpoints AND the kind must match — a `Closed` and an `OpenStart` with\n   * the same numeric endpoints are not equal. Use `aligned` for the looser\n   * \"same numeric range\" check.\n   *\n   * @param a - The first interval.\n   * @param b - The second interval.\n   * @returns `true` when both intervals share a kind and both endpoints are within tolerance.\n   * @since 1.1.0\n   */\n  (a: Interval, b: Interval): boolean\n  /**\n   * Checks if two `Interval` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second interval.\n   * @returns A function that takes the first interval and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Interval): (a: Interval) => boolean\n} = internal.equals\n\nexport const aligned: {\n  /**\n   * Checks if two values share the same numeric range, ignoring endpoint\n   * inclusivity. Accepts any `Bounds`-shaped value.\n   *\n   * @param a - The first bounds.\n   * @param b - The second bounds.\n   * @returns `true` when both endpoints are within the default tolerance ({@link EPSILON}).\n   * @since 2.0.0\n   */\n  (a: Bounds, b: Bounds): boolean\n  /**\n   * @param b - The second bounds.\n   * @returns A function that takes the first bounds and returns the comparison result.\n   * @since 2.0.0\n   */\n  (b: Bounds): (a: Bounds) => boolean\n} = internal.aligned\n\nexport const make: {\n  /**\n   * Creates a new closed `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `Closed` interval `[point, point]`.\n   * @since 1.0.0\n   */\n  (point: number): Closed\n  /**\n   * Creates a new closed `Interval` instance.\n   *\n   * @param start - The start of the interval.\n   * @param end - The end of the interval.\n   * @returns A new `Closed` interval `[start, end]`.\n   * @since 1.0.0\n   */\n  (start: number, end: number): Closed\n} = internal.make\n\nexport const makeOpenStart: {\n  /**\n   * Creates a new left-open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `OpenStart` interval `(point, point]` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): OpenStart\n  /**\n   * Creates a new left-open `Interval` instance.\n   *\n   * @param start - The start of the interval (excluded).\n   * @param end - The end of the interval (included).\n   * @returns A new `OpenStart` interval `(start, end]`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): OpenStart\n} = internal.makeOpenStart\n\nexport const makeOpenEnd: {\n  /**\n   * Creates a new right-open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `OpenEnd` interval `[point, point)` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): OpenEnd\n  /**\n   * Creates a new right-open `Interval` instance.\n   *\n   * @param start - The start of the interval (included).\n   * @param end - The end of the interval (excluded).\n   * @returns A new `OpenEnd` interval `[start, end)`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): OpenEnd\n} = internal.makeOpenEnd\n\nexport const makeOpen: {\n  /**\n   * Creates a new fully open `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `Open` interval `(point, point)` (degenerate, empty).\n   * @since 2.0.0\n   */\n  (point: number): Open\n  /**\n   * Creates a new fully open `Interval` instance.\n   *\n   * @param start - The start of the interval (excluded).\n   * @param end - The end of the interval (excluded).\n   * @returns A new `Open` interval `(start, end)`.\n   * @since 2.0.0\n   */\n  (start: number, end: number): Open\n} = internal.makeOpen\n\nexport const fromSize: {\n  /**\n   * Creates a new closed `Interval` instance from a size.\n   *\n   * @param size - The size of the interval.\n   * @returns A new `Closed` interval `[0, size]`.\n   * @since 1.0.0\n   */\n  (size: number): Closed\n  /**\n   * Creates a new closed `Interval` instance from a size.\n   *\n   * @param start - The start of the interval.\n   * @param size - The size of the interval.\n   * @returns A new `Closed` interval `[start, start + size]`.\n   * @since 1.0.0\n   */\n  (start: number, size: number): Closed\n} = internal.fromSize\n\n/**\n * Creates a new closed `Interval` from a minimum and maximum value, in any order.\n *\n * @param values - The values to take the min and max of.\n * @returns A new `Closed` interval `[min(values), max(values)]`.\n * @since 1.0.0\n */\nexport const fromMinMax: (...values: ReadonlyArray<number>) => Closed = internal.fromMinMax\n\n/**\n * Calculates the size of an interval.\n *\n * Kind-agnostic — `size` of `[0, 1]` and `(0, 1)` are both `1`.\n *\n * @param i - The bounds to calculate the size of.\n * @returns The size of the bounds.\n * @since 1.0.0\n */\nexport const size: (i: Bounds) => number = internal.size\n\nexport const contains: {\n  /**\n   * Checks if a value is contained within an interval. Endpoint inclusivity\n   * follows the interval's `kind`.\n   *\n   * @param interval - The interval to check.\n   * @param value - The value to check.\n   * @returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (interval: Interval, value: number): boolean\n  /**\n   * Checks if a value is contained within an interval. Endpoint inclusivity\n   * follows the interval's `kind`.\n   *\n   * @param value - The value to check.\n   * @returns A function that takes an interval and returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (value: number): (interval: Interval) => boolean\n} = internal.contains\n\nexport const containsInterval: {\n  /**\n   * Checks if `inner` is a subset of `outer` — every point of `inner` is also\n   * in `outer`. Respects endpoint inclusivity on both sides: a closed inner\n   * endpoint must be inside (or on a closed boundary of) the outer, while an\n   * open inner endpoint can sit exactly on an open outer boundary.\n   *\n   * @param outer - The enclosing interval.\n   * @param inner - The candidate inner interval.\n   * @returns `true` when `inner` is a subset of `outer`.\n   * @since 2.0.0\n   */\n  (outer: Interval, inner: Interval): boolean\n  /**\n   * @param inner - The candidate inner interval.\n   * @returns A function that takes the outer interval and returns the containment result.\n   * @since 2.0.0\n   */\n  (inner: Interval): (outer: Interval) => boolean\n} = internal.containsInterval\n\nexport const union: {\n  /**\n   * Returns the smallest interval enclosing both inputs. Each endpoint's\n   * inclusivity follows the input that contributed it; when both endpoints\n   * tie, the result is closed at that point if either input includes it.\n   *\n   * @param a - The first interval.\n   * @param b - The second interval.\n   * @returns A new interval enclosing both inputs.\n   * @since 2.0.0\n   */\n  (a: Interval, b: Interval): Interval\n  /**\n   * @param b - The second interval.\n   * @returns A function that takes the first interval and returns the union.\n   * @since 2.0.0\n   */\n  (b: Interval): (a: Interval) => Interval\n} = internal.union\n\nexport const filter: {\n  /**\n   * Filters an array of values to those contained within an interval.\n   * Endpoint inclusivity follows the interval's `kind`.\n   *\n   * @param interval - The interval to filter the values to.\n   * @param value - The values to filter.\n   * @returns The filtered values.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(interval: Interval, value: V): V\n  /**\n   * Filters an array of values to those contained within an interval.\n   *\n   * @param value - The values to filter.\n   * @returns A function that takes an interval and returns the filtered values.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(value: V): (interval: Interval) => V\n} = internal.filter\n\nexport const clamp: {\n  /**\n   * Clamps a value to be within bounds. Kind-agnostic — clamps to the numeric\n   * range regardless of endpoint inclusivity.\n   *\n   * @param interval - The bounds to clamp the value to.\n   * @param value - The value to clamp.\n   * @returns The clamped value.\n   * @since 1.0.0\n   */\n  (interval: Bounds, value: number): number\n  /**\n   * Clamps a value to be within bounds. Kind-agnostic.\n   *\n   * @param value - The value to clamp.\n   * @returns A function that takes bounds and returns the clamped value.\n   * @since 1.0.0\n   */\n  (value: number): (interval: Bounds) => number\n  /**\n   * Clamps an array of values to be within bounds. Kind-agnostic.\n   *\n   * @param interval - The bounds to clamp the values to.\n   * @param value - The values to clamp.\n   * @returns The clamped values.\n   * @since 1.0.0\n   */\n  (interval: Bounds, value: ReadonlyArray<number>): ReadonlyArray<number>\n  /**\n   * Clamps an array of values to be within bounds. Kind-agnostic.\n   *\n   * @param value - The values to clamp.\n   * @returns A function that takes bounds and returns the clamped values.\n   * @since 1.0.0\n   */\n  (value: ReadonlyArray<number>): (interval: Bounds) => ReadonlyArray<number>\n} = internal.clamp\n\n/**\n * Returns an interval with the start endpoint open. Preserves the end endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toStartOpen: {\n  (i: Closed | OpenStart): OpenStart\n  (i: OpenEnd | Open): Open\n} = internal.toStartOpen\n\n/**\n * Returns an interval with the start endpoint closed. Preserves the end endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toStartClosed: {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenEnd\n} = internal.toStartClosed\n\n/**\n * Returns an interval with the end endpoint open. Preserves the start endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toEndOpen: {\n  (i: Closed | OpenEnd): OpenEnd\n  (i: OpenStart | Open): Open\n} = internal.toEndOpen\n\n/**\n * Returns an interval with the end endpoint closed. Preserves the start endpoint's inclusivity.\n *\n * @since 2.0.0\n */\nexport const toEndClosed: {\n  (i: Closed | OpenEnd): Closed\n  (i: OpenStart | Open): OpenStart\n} = internal.toEndClosed\n\n/**\n * Returns a closed interval over the same numeric range.\n *\n * @since 2.0.0\n */\nexport const toClosed: (i: Interval) => Closed = internal.toClosed\n\n/**\n * Returns a fully open interval over the same numeric range.\n *\n * @since 2.0.0\n */\nexport const toOpen: (i: Interval) => Open = internal.toOpen\n\n/**\n * Type-narrowing predicate: refines `Interval` to `Closed`.\n *\n * @since 2.0.0\n */\nexport const isClosed: (i: Interval) => i is Closed = internal.isClosed\n\n/**\n * Type-narrowing predicate: refines `Interval` to `Open`.\n *\n * @since 2.0.0\n */\nexport const isOpen: (i: Interval) => i is Open = internal.isOpen\n\n/**\n * Type-narrowing predicate: refines `Interval` to `OpenStart`.\n *\n * @since 2.0.0\n */\nexport const isOpenStart: (i: Interval) => i is OpenStart = internal.isOpenStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to `OpenEnd`.\n *\n * @since 2.0.0\n */\nexport const isOpenEnd: (i: Interval) => i is OpenEnd = internal.isOpenEnd\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with an open start endpoint.\n *\n * @since 2.0.0\n */\nexport const isOpenAtStart: (i: Interval) => i is OpenStart | Open = internal.isOpenAtStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with an open end endpoint.\n *\n * @since 2.0.0\n */\nexport const isOpenAtEnd: (i: Interval) => i is OpenEnd | Open = internal.isOpenAtEnd\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with a closed start endpoint.\n *\n * @since 2.0.0\n */\nexport const isClosedAtStart: (i: Interval) => i is Closed | OpenEnd = internal.isClosedAtStart\n\n/**\n * Type-narrowing predicate: refines `Interval` to those with a closed end endpoint.\n *\n * @since 2.0.0\n */\nexport const isClosedAtEnd: (i: Interval) => i is Closed | OpenStart = internal.isClosedAtEnd\n\n/**\n * The unit interval, `[0, 1]`.\n *\n * @since 1.0.0\n */\nexport const unit: Closed = internal.unit\n\n/**\n * The open unit interval, `(0, 1)`. The symmetric open analog of {@link unit};\n * convenient for \"strict interior\" use cases such as filtering roots that\n * must lie strictly inside the unit parameter range.\n *\n * @since 2.0.0\n */\nexport const unitOpen: Open = internal.unitOpen\n\n/**\n * The biunit interval, `[-1, 1]`.\n *\n * @since 1.0.0\n */\nexport const biunit: Closed = internal.biunit\n\n/**\n * Linearly interpolates a value within bounds.\n *\n * @param interval - The bounds to interpolate within.\n * @param t - The interpolation factor, typically between 0 and 1.\n * @returns The interpolated value.\n * @since 1.0.0\n */\nexport const lerp: (interval: Bounds, t: number) => number = internal.lerp\n\n/**\n * Creates a linear interpolation function for given bounds.\n *\n * @param interval - The bounds to create the interpolation function for.\n * @returns A function that takes a factor `t` and returns the interpolated value.\n * @since 1.0.0\n */\nexport const toLerpFn: (interval: Bounds) => (t: number) => number = internal.toLerpFn\n\n/**\n * Normalizes a value within bounds.\n *\n * @param interval - The bounds to normalize within.\n * @param x - The value to normalize.\n * @returns The normalized value.\n * @since 1.0.0\n */\nexport const normalize: (interval: Bounds, x: number) => number = internal.normalize\n\n/**\n * Creates a normalization function for given bounds.\n *\n * @param interval - The bounds to create the normalization function for.\n * @returns A function that takes a value `x` and returns the normalized value.\n * @since 1.0.0\n */\nexport const toNormalizeFn: (interval: Bounds) => (x: number) => number = internal.toNormalizeFn\n\n/**\n * Remaps a value from one bounds to another.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @param x - The value to remap.\n * @returns The remapped value.\n * @since 1.0.0\n */\nexport const remap: (source: Bounds, target: Bounds, x: number) => number = internal.remap\n\n/**\n * Creates a remapping function for given bounds.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @returns A function that takes a value `x` and returns the remapped value.\n * @since 1.0.0\n */\nexport const toRemapFn: (source: Bounds, target: Bounds) => (x: number) => number =\n  internal.toRemapFn\n\n/**\n * Calculates the scale and shift needed to map a source bounds to a target bounds.\n *\n * @param source - The source bounds.\n * @param target - The target bounds.\n * @returns An object containing the scale and shift values.\n * @since 1.0.0\n */\nexport const scaleShift: (source: Bounds, target: Bounds) => ScaleShift = internal.scaleShift\n\n/**\n * The scale and shift needed to map a source bounds to a target bounds.\n *\n * @since 1.0.0\n */\nexport interface ScaleShift {\n  readonly scale: number\n  readonly shift: number\n}\n"],"mappings":"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"}

package/dist/shared/interval2d-BMk5UYXD.d.mts

@@ -0,0 +1,29 @@
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+import { t as Interval } from "./interval-Bhzeqp8M.mjs";
+
+//#region src/interval/interval2d.internal.d.ts
+declare const Interval2dTypeId: unique symbol;
+type Interval2dTypeId = typeof Interval2dTypeId;
+//#endregion
+//#region src/interval/interval2d.d.ts
+/**
+ * An axis-aligned 2D interval — the Cartesian product of two 1D intervals.
+ * Used as a bounding box for curves and paths, and as a region for
+ * containment tests.
+ *
+ * The two type parameters carry the per-axis interval subtype so that a value
+ * built from closed intervals stays `Interval2d<Closed, Closed>` and a value
+ * with mixed openness preserves that information at the type level.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.0.0
+ */
+interface Interval2d<X extends Interval = Interval, Y extends Interval = Interval> extends Pipeable {
+  readonly [Interval2dTypeId]: Interval2dTypeId;
+  readonly x: X;
+  readonly y: Y;
+}
+//#endregion
+export { Interval2d as t };
+//# sourceMappingURL=interval2d-BMk5UYXD.d.mts.map

package/dist/shared/{interval2d-8IBZnUOq.mjs → interval2d-ca0J1NMr.mjs}

@@ -1,7 +1,7 @@
 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";
+import { a as make$2 } from "./vector2-CCuJx1rX.mjs";
+import { f as union$2, i as equals$2, n as contains, o as fromMinMax, r as containsInterval } from "./interval-X1EYuf-T.mjs";
 //#region src/interval/interval2d.internal.ts
 const Interval2dTypeId = Symbol("curvy/interval/interval2d");
 var Interval2dImpl = class extends Pipeable {
@@ -56,7 +56,7 @@ var interval2d_exports = /* @__PURE__ */ __exportAll({
 *
 * @param v - The value to check.
 * @returns `true` if the value is an `Interval2d`, `false` otherwise.
-* @since 2.1.0
+* @since 2.0.0
 */
 const isInterval2d = isInterval2d$1;
 /**
@@ -66,7 +66,7 @@ const isInterval2d = isInterval2d$1;
 * @param x - The x-axis interval.
 * @param y - The y-axis interval.
 * @returns A new `Interval2d` instance.
-* @since 2.1.0
+* @since 2.0.0
 */
 const make = make$1;
 /**
@@ -76,7 +76,7 @@ const make = make$1;
 * @param p0 - The first corner.
 * @param p1 - The second corner.
 * @returns A new `Interval2d<Closed, Closed>` enclosing both corners.
-* @since 2.1.0
+* @since 2.0.0
 */
 const fromCorners = fromCorners$1;
 /**
@@ -86,7 +86,7 @@ const fromCorners = fromCorners$1;
 * @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
+* @since 2.0.0
 */
 const fromVectors = fromVectors$1;
 const containsVector = containsVector$1;
@@ -97,7 +97,7 @@ const containsInterval2d = containsInterval2d$1;
 *
 * @param box - The 2D interval (or bounds-shaped value) to measure.
 * @returns The size as a `Vector2`.
-* @since 2.1.0
+* @since 2.0.0
 */
 const size = size$1;
 const union = union$1;
@@ -105,4 +105,4 @@ const equals = equals$1;
 //#endregion
 export { make as n, union as r, interval2d_exports as t };
 
-//# sourceMappingURL=interval2d-8IBZnUOq.mjs.map
+//# sourceMappingURL=interval2d-ca0J1NMr.mjs.map

package/dist/shared/{interval2d-8IBZnUOq.mjs.map → interval2d-ca0J1NMr.mjs.map}

@@ -1 +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"}
+{"version":3,"file":"interval2d-ca0J1NMr.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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"}

package/dist/shared/matrix4x4-CaytTaB_.d.mts

@@ -0,0 +1,168 @@
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+
+//#region src/matrix/matrix2x2.internal.d.ts
+declare const Matrix2x2TypeId: unique symbol;
+type Matrix2x2TypeId = typeof Matrix2x2TypeId;
+//#endregion
+//#region src/matrix/matrix2x2.d.ts
+/**
+ * A 2D matrix with 2 rows and 2 columns.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
+interface Matrix2x2 extends Pipeable {
+  readonly [Matrix2x2TypeId]: Matrix2x2TypeId;
+  /**
+   * The value in the first row and first column.
+   */
+  readonly m00: number;
+  /**
+   * The value in the first row and second column.
+   */
+  readonly m01: number;
+  /**
+   * The value in the second row and first column.
+   */
+  readonly m10: number;
+  /**
+   * The value in the second row and second column.
+   */
+  readonly m11: number;
+}
+//#endregion
+//#region src/matrix/matrix3x3.internal.d.ts
+declare const Matrix3x3TypeId: unique symbol;
+type Matrix3x3TypeId = typeof Matrix3x3TypeId;
+//#endregion
+//#region src/matrix/matrix3x3.d.ts
+/**
+ * A 3x3 matrix.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
+interface Matrix3x3 extends Pipeable {
+  readonly [Matrix3x3TypeId]: Matrix3x3TypeId;
+  /**
+   * The value of the first row and first column.
+   */
+  readonly m00: number;
+  /**
+   * The value of the first row and second column.
+   */
+  readonly m01: number;
+  /**
+   * The value of the first row and third column.
+   */
+  readonly m02: number;
+  /**
+   * The value of the second row and first column.
+   */
+  readonly m10: number;
+  /**
+   * The value of the second row and second column.
+   */
+  readonly m11: number;
+  /**
+   * The value of the second row and third column.
+   */
+  readonly m12: number;
+  /**
+   * The value of the third row and first column.
+   */
+  readonly m20: number;
+  /**
+   * The value of the third row and second column.
+   */
+  readonly m21: number;
+  /**
+   * The value of the third row and third column.
+   */
+  readonly m22: number;
+}
+//#endregion
+//#region src/matrix/matrix4x4.internal.d.ts
+declare const Matrix4x4TypeId: unique symbol;
+type Matrix4x4TypeId = typeof Matrix4x4TypeId;
+//#endregion
+//#region src/matrix/matrix4x4.d.ts
+/**
+ * A 4x4 matrix.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
+interface Matrix4x4 extends Pipeable {
+  readonly [Matrix4x4TypeId]: Matrix4x4TypeId;
+  /**
+   * The value of the first row and first column.
+   */
+  readonly m00: number;
+  /**
+   * The value of the first row and second column.
+   */
+  readonly m01: number;
+  /**
+   * The value of the first row and third column.
+   */
+  readonly m02: number;
+  /**
+   * The value of the first row and fourth column.
+   */
+  readonly m03: number;
+  /**
+   * The value of the second row and first column.
+   */
+  readonly m10: number;
+  /**
+   * The value of the second row and second column.
+   */
+  readonly m11: number;
+  /**
+   * The value of the second row and third column.
+   */
+  readonly m12: number;
+  /**
+   * The value of the second row and fourth column.
+   */
+  readonly m13: number;
+  /**
+   * The value of the third row and first column.
+   */
+  readonly m20: number;
+  /**
+   * The value of the third row and second column.
+   */
+  readonly m21: number;
+  /**
+   * The value of the third row and third column.
+   */
+  readonly m22: number;
+  /**
+   * The value of the third row and fourth column.
+   */
+  readonly m23: number;
+  /**
+   * The value of the fourth row and first column.
+   */
+  readonly m30: number;
+  /**
+   * The value of the fourth row and second column.
+   */
+  readonly m31: number;
+  /**
+   * The value of the fourth row and third column.
+   */
+  readonly m32: number;
+  /**
+   * The value of the fourth row and fourth column.
+   */
+  readonly m33: number;
+}
+//#endregion
+export { Matrix3x3 as n, Matrix2x2 as r, Matrix4x4 as t };
+//# sourceMappingURL=matrix4x4-CaytTaB_.d.mts.map

package/dist/shared/{quadratic-CamozcFc.mjs → quadratic-DyeMtvET.mjs}

@@ -1,11 +1,12 @@
 import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
-import { $ as extreme$1, At as make$2, Ct as fromPoints$2, Dt as isLinearPolynomial$1, Et as isIncreasing$2, Ft as toInverseSolver$2, G as antiderivative$3, It as toSolver$2, J as asMonotonic$3, K as asDecreasing$3, Mt as range$2, Nt as solve$2, Ot as isMonotonic$2, Pt as solveInverse$2, Q as equals$3, St as fromPointSlope$1, Tt as isDecreasing$2, X as derivative$3, Y as curvature$1, Z as domain$3, _t as asIncreasing$2, at as isQuadraticPolynomial$1, bt as domain$2, ct as monotonicity$3, dt as solve$3, et as fromPoints$3, ft as solveInverse$3, gt as asDecreasing$2, ht as antiderivative$2, it as isMonotonic$3, jt as monotonicity$2, kt as length$2, lt as range$3, mt as toSolver$3, nt as isDecreasing$3, ot as length$3, pt as toInverseSolver$3, q as asIncreasing$3, rt as isIncreasing$3, st as make$3, tt as fromVector$3, ut as roots$1, vt as asMonotonic$2, wt as fromVector$2, xt as equals$2, yt as derivative$2 } from "./cubic-CpHAx8cC.mjs";
+import { $ as equals$3, At as isMonotonic$2, Ct as equals$2, Dt as isDecreasing$2, Et as fromVector$2, Ft as solve$2, G as antiderivative$3, It as solveInverse$2, J as asMonotonic$3, K as asDecreasing$3, Lt as toInverseSolver$2, Mt as make$2, Nt as monotonicity$2, Ot as isIncreasing$2, Pt as range$2, Q as domain$3, Rt as toSolver$2, St as domain$2, Tt as fromPoints$2, X as curvature$1, Y as coefficients$3, Z as derivative$3, _t as asDecreasing$2, at as isMonotonic$3, bt as coefficients$2, ct as make$3, dt as roots$1, et as extreme$1, ft as solve$3, gt as antiderivative$2, ht as toSolver$3, it as isIncreasing$3, jt as length$2, kt as isLinearPolynomial$1, lt as monotonicity$3, mt as toInverseSolver$3, nt as fromVector$3, ot as isQuadraticPolynomial$1, pt as solveInverse$3, q as asIncreasing$3, rt as isDecreasing$3, st as length$3, tt as fromPoints$3, ut as range$3, vt as asIncreasing$2, wt as fromPointSlope$1, xt as derivative$2, yt as asMonotonic$2 } from "./cubic-CMonq6bg.mjs";
 //#region src/polynomial/linear.ts
 var linear_exports = /* @__PURE__ */ __exportAll({
 	antiderivative: () => antiderivative$1,
 	asDecreasing: () => asDecreasing$1,
 	asIncreasing: () => asIncreasing$1,
 	asMonotonic: () => asMonotonic$1,
+	coefficients: () => coefficients$1,
 	derivative: () => derivative$1,
 	domain: () => domain$1,
 	equals: () => equals$1,
@@ -155,6 +156,14 @@ const asIncreasing$1 = asIncreasing$2;
 */
 const asDecreasing$1 = asDecreasing$2;
 /**
+* Returns the polynomial's coefficients as a tuple `[c0, c1]`.
+*
+* @param p - The linear polynomial.
+* @returns The coefficients in monomial order.
+* @since 2.0.0
+*/
+const coefficients$1 = coefficients$2;
+/**
 * Calculates the derivative of a linear polynomial.
 *
 * @param p - The linear polynomial to differentiate.
@@ -173,6 +182,7 @@ var quadratic_exports = /* @__PURE__ */ __exportAll({
 	asDecreasing: () => asDecreasing,
 	asIncreasing: () => asIncreasing,
 	asMonotonic: () => asMonotonic,
+	coefficients: () => coefficients,
 	curvature: () => curvature,
 	derivative: () => derivative,
 	domain: () => domain,
@@ -250,6 +260,14 @@ const solveInverse = solveInverse$3;
 */
 const toInverseSolver = toInverseSolver$3;
 /**
+* Returns the polynomial's coefficients as a tuple `[c0, c1, c2]`.
+*
+* @param p - The quadratic polynomial.
+* @returns The coefficients in monomial order.
+* @since 2.0.0
+*/
+const coefficients = coefficients$3;
+/**
 * Computes the derivative of the quadratic polynomial.
 *
 * @param p - The quadratic polynomial.
@@ -327,4 +345,4 @@ const curvature = curvature$1;
 //#endregion
 export { solveInverse$1 as _, make as a, solve as c, isIncreasing$1 as d, isMonotonic$1 as f, solve$1 as g, range$1 as h, isMonotonic as i, solveInverse as l, make$1 as m, isDecreasing as n, quadratic_exports as o, linear_exports as p, isIncreasing as r, range as s, derivative as t, isDecreasing$1 as u };
 
-//# sourceMappingURL=quadratic-CamozcFc.mjs.map
+//# sourceMappingURL=quadratic-DyeMtvET.mjs.map