curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/solution-CrtLfqEq.mjs

@@ -0,0 +1,306 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { n as contains } from "./interval-05CR6eBf.mjs";
+//#region src/solution/solution.internal.ts
+const EMPTY_ITERATOR = { next: () => ({
+	done: true,
+	value: void 0
+}) };
+var NoneImpl = class extends Pipeable {
+	_tag = "none";
+	length = 0;
+	[Symbol.iterator]() {
+		return EMPTY_ITERATOR;
+	}
+};
+var OneImpl = class extends Pipeable {
+	value;
+	_tag = "one";
+	length = 1;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	[Symbol.iterator]() {
+		return [this.value][Symbol.iterator]();
+	}
+};
+var TwoImpl = class extends Pipeable {
+	values;
+	_tag = "two";
+	length = 2;
+	constructor(values) {
+		super();
+		this.values = values;
+	}
+	get value() {
+		return this.values[0];
+	}
+	[Symbol.iterator]() {
+		return this.values[Symbol.iterator]();
+	}
+};
+var ThreeImpl = class extends Pipeable {
+	values;
+	_tag = "three";
+	length = 3;
+	constructor(values) {
+		super();
+		this.values = values;
+	}
+	get value() {
+		return this.values[0];
+	}
+	[Symbol.iterator]() {
+		return this.values[Symbol.iterator]();
+	}
+};
+const NONE_INSTANCE = new NoneImpl();
+const none$1 = NONE_INSTANCE;
+const one$1 = (value) => new OneImpl(value);
+const two$1 = (a, b) => new TwoImpl([a, b]);
+const three$1 = (a, b, c) => new ThreeImpl([
+	a,
+	b,
+	c
+]);
+const fromArray$1 = (arr) => {
+	switch (arr.length) {
+		case 0: return NONE_INSTANCE;
+		case 1: return one$1(arr[0]);
+		case 2: return two$1(arr[0], arr[1]);
+		case 3: return three$1(arr[0], arr[1], arr[2]);
+		default: invariant(false, `Solution can hold at most 3 values, got ${arr.length}`);
+	}
+};
+const isNone$1 = (s) => s._tag === "none";
+const isSome$1 = (s) => s._tag !== "none";
+const valueOrUndefined$1 = (s) => isNone$1(s) ? void 0 : s.value;
+const last$1 = ((s) => {
+	switch (s._tag) {
+		case "none": return;
+		case "one": return s.value;
+		case "two": return s.values[1];
+		case "three": return s.values[2];
+	}
+});
+const min$1 = ((s) => {
+	switch (s._tag) {
+		case "none": return;
+		case "one": return s.value;
+		case "two": return Math.min(s.values[0], s.values[1]);
+		case "three": return Math.min(s.values[0], s.values[1], s.values[2]);
+	}
+});
+const max$1 = ((s) => {
+	switch (s._tag) {
+		case "none": return;
+		case "one": return s.value;
+		case "two": return Math.max(s.values[0], s.values[1]);
+		case "three": return Math.max(s.values[0], s.values[1], s.values[2]);
+	}
+});
+const unsafeLast$1 = (s) => {
+	invariant(isSome$1(s), "Solution.unsafeLast on empty Solution");
+	return last$1(s);
+};
+const unsafeMin$1 = (s) => {
+	invariant(isSome$1(s), "Solution.unsafeMin on empty Solution");
+	return min$1(s);
+};
+const unsafeMax$1 = (s) => {
+	invariant(isSome$1(s), "Solution.unsafeMax on empty Solution");
+	return max$1(s);
+};
+const filter$1 = (s, predicate) => {
+	switch (s._tag) {
+		case "none": return s;
+		case "one": return predicate(s.value) ? s : NONE_INSTANCE;
+		case "two": {
+			const a = predicate(s.values[0]);
+			const b = predicate(s.values[1]);
+			if (a && b) return s;
+			if (a) return one$1(s.values[0]);
+			if (b) return one$1(s.values[1]);
+			return NONE_INSTANCE;
+		}
+		case "three": {
+			const survivors = [];
+			if (predicate(s.values[0])) survivors.push(s.values[0]);
+			if (predicate(s.values[1])) survivors.push(s.values[1]);
+			if (predicate(s.values[2])) survivors.push(s.values[2]);
+			return fromArray$1(survivors);
+		}
+	}
+};
+const clip$1 = dual(2, (s, i) => filter$1(s, (v) => contains(i, v)));
+const map$1 = dual(2, (s, f) => {
+	switch (s._tag) {
+		case "none": return s;
+		case "one": return one$1(f(s.value));
+		case "two": return two$1(f(s.values[0]), f(s.values[1]));
+		case "three": return three$1(f(s.values[0]), f(s.values[1]), f(s.values[2]));
+	}
+});
+const match$1 = dual(2, (self, matcher) => isNone$1(self) ? matcher.onNone() : matcher.onSome(self));
+//#endregion
+//#region src/solution/solution.ts
+var solution_exports = /* @__PURE__ */ __exportAll({
+	clip: () => clip,
+	filter: () => filter,
+	fromArray: () => fromArray,
+	isNone: () => isNone,
+	isSome: () => isSome,
+	last: () => last,
+	map: () => map,
+	match: () => match,
+	max: () => max,
+	min: () => min,
+	none: () => none,
+	one: () => one,
+	three: () => three,
+	two: () => two,
+	unsafeLast: () => unsafeLast,
+	unsafeMax: () => unsafeMax,
+	unsafeMin: () => unsafeMin,
+	valueOrUndefined: () => valueOrUndefined
+});
+/**
+* The empty solution. Reused across calls — never reallocated.
+*
+* @since 2.0.0
+*/
+const none = none$1;
+/**
+* Constructs a single-value solution.
+*
+* @since 2.0.0
+*/
+const one = one$1;
+/**
+* Constructs a two-value solution.
+*
+* @since 2.0.0
+*/
+const two = two$1;
+/**
+* Constructs a three-value solution.
+*
+* @since 2.0.0
+*/
+const three = three$1;
+/**
+* Constructs a `Solution<T>` from a runtime array. Throws if the array has
+* more than three elements.
+*
+* @since 2.0.0
+*/
+const fromArray = fromArray$1;
+/**
+* Type-narrowing predicate: refines `Solution<T>` to `None`.
+*
+* @since 2.0.0
+*/
+const isNone = isNone$1;
+/**
+* Type-narrowing predicate: refines `Solution<T>` to `Some<T>` (non-empty).
+* After narrowing, `.value` is directly accessible without further checks.
+*
+* @since 2.0.0
+*/
+const isSome = isSome$1;
+/**
+* Returns the primary (first) value if the solution is non-empty, or
+* `undefined` if empty. Pair with `.value` access on `Some<T>`-narrowed
+* inputs to avoid the `undefined` possibility.
+*
+* @since 2.0.0
+*/
+const valueOrUndefined = valueOrUndefined$1;
+/**
+* Returns the last value in the solution, or `undefined` if empty. When
+* called on a `Some<T>`, the result is guaranteed to be `T`.
+*
+* @since 2.0.0
+*/
+const last = last$1;
+/**
+* Returns the smallest numeric value in the solution, or `undefined` if empty.
+* When called on a `Some<number>`, the result is guaranteed to be `number`.
+*
+* @since 2.0.0
+*/
+const min = min$1;
+/**
+* Returns the largest numeric value in the solution, or `undefined` if empty.
+* When called on a `Some<number>`, the result is guaranteed to be `number`.
+*
+* @since 2.0.0
+*/
+const max = max$1;
+/**
+* Returns the last value in the solution. Throws if empty.
+*
+* @since 2.0.0
+*/
+const unsafeLast = unsafeLast$1;
+/**
+* Returns the smallest numeric value in the solution. Throws on empty.
+*
+* @since 2.0.0
+*/
+const unsafeMin = unsafeMin$1;
+/**
+* Returns the largest numeric value in the solution. Throws on empty.
+*
+* @since 2.0.0
+*/
+const unsafeMax = unsafeMax$1;
+/**
+* Filters the solution by a predicate. Result cardinality is at most that of
+* the input.
+*
+* @since 2.0.0
+*/
+const filter = filter$1;
+/**
+* Restricts the solution to values contained within an interval. Endpoint
+* inclusivity follows the interval's `kind` — pass an open variant (e.g.
+* `Interval.makeOpen(0, 1)` or `Interval.unitOpen`) for strict containment.
+*
+* @param s - The solution to clip.
+* @param i - The interval to retain values within.
+* @since 2.0.0
+*/
+const clip = clip$1;
+/**
+* Maps every value in the solution to a new value. Result cardinality matches
+* the input.
+*
+* @since 2.0.0
+*/
+const map = map$1;
+/**
+* Pattern matches on a solution, calling `onNone` for the empty case and
+* `onSome` for any non-empty case. The `onSome` parameter is typed against
+* the input's narrowed shape — for an `AtMostOne<T>` input, `onSome` receives
+* `One<T>` and can read `.value` directly.
+*
+* @example
+* ```ts
+* const result = polynomial.pipe(
+*   LinearPolynomial.solveInverse(0),
+*   Solution.match({
+*     onNone: () => null,
+*     onSome: ({ value }) => Math.abs(value),
+*   }),
+* )
+* ```
+*
+* @since 2.0.0
+*/
+const match = match$1;
+//#endregion
+export { match as a, solution_exports as c, map as i, two as l, fromArray as n, none as o, isNone as r, one as s, clip as t };
+
+//# sourceMappingURL=solution-CrtLfqEq.mjs.map

package/dist/shared/solution-CrtLfqEq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"solution-CrtLfqEq.mjs","names":["none","one","two","three","fromArray","isNone","isSome","valueOrUndefined","last","min","max","unsafeLast","unsafeMin","unsafeMax","filter","clip","Interval.contains","map","match","internal.none","internal.one","internal.two","internal.three","internal.fromArray","internal.isNone","internal.isSome","internal.valueOrUndefined","internal.last","internal.min","internal.max","internal.unsafeLast","internal.unsafeMin","internal.unsafeMax","internal.filter","internal.clip","internal.map","internal.match"],"sources":["../../src/solution/solution.internal.ts","../../src/solution/solution.ts"],"sourcesContent":["import * as Interval from '../interval/interval'\nimport { dual, Pipeable } from '../utils'\nimport type {\n  AtMostOne,\n  AtMostThree,\n  AtMostTwo,\n  None,\n  One,\n  Solution,\n  Some,\n  Three,\n  Two,\n} from './solution'\nimport { invariant } from '../utils'\n\n// Empty iterator — shared across all None instances since None has no data.\nconst EMPTY_ITERATOR: Iterator<never> = {\n  next: () => ({ done: true, value: undefined as never }),\n}\n\nclass NoneImpl extends Pipeable implements None {\n  readonly _tag = 'none' as const\n  readonly length = 0 as const;\n\n  [Symbol.iterator](): Iterator<never> {\n    return EMPTY_ITERATOR\n  }\n}\n\nclass OneImpl<T> extends Pipeable implements One<T> {\n  readonly _tag = 'one' as const\n  readonly length = 1 as const\n\n  constructor(readonly value: T) {\n    super()\n  }\n\n  [Symbol.iterator](): Iterator<T> {\n    return [this.value][Symbol.iterator]()\n  }\n}\n\nclass TwoImpl<T> extends Pipeable implements Two<T> {\n  readonly _tag = 'two' as const\n  readonly length = 2 as const\n\n  constructor(readonly values: readonly [T, T]) {\n    super()\n  }\n\n  get value(): T {\n    return this.values[0]\n  }\n\n  [Symbol.iterator](): Iterator<T> {\n    return this.values[Symbol.iterator]()\n  }\n}\n\nclass ThreeImpl<T> extends Pipeable implements Three<T> {\n  readonly _tag = 'three' as const\n  readonly length = 3 as const\n\n  constructor(readonly values: readonly [T, T, T]) {\n    super()\n  }\n\n  get value(): T {\n    return this.values[0]\n  }\n\n  [Symbol.iterator](): Iterator<T> {\n    return this.values[Symbol.iterator]()\n  }\n}\n\nexport const NONE_INSTANCE: None = new NoneImpl()\n\nexport const none: None = NONE_INSTANCE\n\nexport const one = <T>(value: T): One<T> => new OneImpl(value)\n\nexport const two = <T>(a: T, b: T): Two<T> => new TwoImpl([a, b])\n\nexport const three = <T>(a: T, b: T, c: T): Three<T> => new ThreeImpl([a, b, c])\n\nexport const fromArray = <T>(arr: ReadonlyArray<T>): Solution<T> => {\n  switch (arr.length) {\n    case 0:\n      return NONE_INSTANCE\n    case 1:\n      return one(arr[0] as T)\n    case 2:\n      return two(arr[0] as T, arr[1] as T)\n    case 3:\n      return three(arr[0] as T, arr[1] as T, arr[2] as T)\n    default:\n      invariant(false, `Solution can hold at most 3 values, got ${arr.length}`)\n  }\n}\n\nexport const isNone = <T>(s: Solution<T>): s is None => s._tag === 'none'\n\nexport const isSome = <T>(s: Solution<T>): s is Some<T> => s._tag !== 'none'\n\nexport const valueOrUndefined = <T>(s: Solution<T>): T | undefined =>\n  isNone(s) ? undefined : s.value\n\nexport const last: {\n  <T>(s: Some<T>): T\n  <T>(s: Solution<T>): T | undefined\n} = (<T>(s: Solution<T>): T | undefined => {\n  switch (s._tag) {\n    case 'none':\n      return undefined\n    case 'one':\n      return s.value\n    case 'two':\n      return s.values[1]\n    case 'three':\n      return s.values[2]\n  }\n}) as never\n\nexport const min: {\n  (s: Some<number>): number\n  (s: Solution<number>): number | undefined\n} = ((s: Solution<number>): number | undefined => {\n  switch (s._tag) {\n    case 'none':\n      return undefined\n    case 'one':\n      return s.value\n    case 'two':\n      return Math.min(s.values[0], s.values[1])\n    case 'three':\n      return Math.min(s.values[0], s.values[1], s.values[2])\n  }\n}) as never\n\nexport const max: {\n  (s: Some<number>): number\n  (s: Solution<number>): number | undefined\n} = ((s: Solution<number>): number | undefined => {\n  switch (s._tag) {\n    case 'none':\n      return undefined\n    case 'one':\n      return s.value\n    case 'two':\n      return Math.max(s.values[0], s.values[1])\n    case 'three':\n      return Math.max(s.values[0], s.values[1], s.values[2])\n  }\n}) as never\n\nexport const unsafeLast = <T>(s: Solution<T>): T => {\n  invariant(isSome(s), 'Solution.unsafeLast on empty Solution')\n  return last(s)\n}\n\nexport const unsafeMin = (s: Solution<number>): number => {\n  invariant(isSome(s), 'Solution.unsafeMin on empty Solution')\n  return min(s)\n}\n\nexport const unsafeMax = (s: Solution<number>): number => {\n  invariant(isSome(s), 'Solution.unsafeMax on empty Solution')\n  return max(s)\n}\n\nexport const filter = <T>(s: Solution<T>, predicate: (v: T) => boolean): Solution<T> => {\n  switch (s._tag) {\n    case 'none':\n      return s\n    case 'one':\n      return predicate(s.value) ? s : NONE_INSTANCE\n    case 'two': {\n      const a = predicate(s.values[0])\n      const b = predicate(s.values[1])\n      if (a && b) {\n        return s\n      }\n      if (a) {\n        return one(s.values[0])\n      }\n      if (b) {\n        return one(s.values[1])\n      }\n      return NONE_INSTANCE\n    }\n    case 'three': {\n      const survivors: Array<T> = []\n      if (predicate(s.values[0])) {\n        survivors.push(s.values[0])\n      }\n      if (predicate(s.values[1])) {\n        survivors.push(s.values[1])\n      }\n      if (predicate(s.values[2])) {\n        survivors.push(s.values[2])\n      }\n      return fromArray(survivors)\n    }\n  }\n}\n\nexport const clip = dual(\n  2,\n  (s: Solution<number>, i: Interval.Interval): Solution<number> =>\n    filter(s, (v) => Interval.contains(i, v)),\n)\n\nexport const map = dual(2, <A, B>(s: Solution<A>, f: (v: A) => B): Solution<B> => {\n  switch (s._tag) {\n    case 'none':\n      return s\n    case 'one':\n      return one(f(s.value))\n    case 'two':\n      return two(f(s.values[0]), f(s.values[1]))\n    case 'three':\n      return three(f(s.values[0]), f(s.values[1]), f(s.values[2]))\n  }\n})\n\nexport const match = dual(\n  2,\n  <T, A, B>(\n    self: Solution<T>,\n    matcher: { readonly onNone: () => A; readonly onSome: (s: Some<T>) => B },\n  ): A | B => (isNone(self) ? matcher.onNone() : matcher.onSome(self)),\n)\n\n// Re-export type aliases that the namespace consumers expect to see at runtime.\n// (Pure type re-exports — no runtime cost.)\nexport type { AtMostOne, AtMostThree, AtMostTwo, None, One, Solution, Some, Three, Two }\n","import type { Interval } from '../interval/interval'\nimport type { Pipeable } from '../utils'\nimport * as internal from './solution.internal'\n\n/**\n * A `Solution<T>` represents the result of an operation that may produce\n * between zero and three values of `T`. It generalizes the zoo of \"0 or 1\",\n * \"0 to 2\", \"0 to 3\" return shapes used throughout curvy under one type, and\n * provides a small namespace of operations (`value`, `last`, `min`, `max`,\n * `filter`, `map`, `match`, …) for working with the result.\n *\n * Each variant carries a `_tag` discriminator and a `length` field, is\n * iterable via `Symbol.iterator` (so existing `for..of` and spread patterns\n * keep working), and is `Pipeable` (so a `Solution` value can be the head of\n * a `pipe` chain).\n *\n * Variant-specific accessors:\n * - `One<T>`, `Two<T>`, and `Three<T>` all expose `.value: T` (the first /\n *   primary value).\n * - `Two<T>` and `Three<T>` additionally expose `.values: readonly [T, ...]`\n *   for explicit positional access.\n *\n * Operations that return narrower cardinalities (e.g. inverse-solving a\n * monotonic polynomial) use the `AtMost{One,Two,Three}` aliases to express\n * \"this could be empty, but it'll have at most N values.\"\n *\n * @since 2.0.0\n */\nexport type Solution<T> = None | One<T> | Two<T> | Three<T>\n\n/**\n * The empty solution.\n *\n * @since 2.0.0\n */\nexport interface None extends Pipeable, Iterable<never> {\n  readonly _tag: 'none'\n  readonly length: 0\n}\n\n/** @since 2.0.0 */\nexport interface One<T> extends Pipeable, Iterable<T> {\n  readonly _tag: 'one'\n  readonly length: 1\n  readonly value: T\n}\n\n/** @since 2.0.0 */\nexport interface Two<T> extends Pipeable, Iterable<T> {\n  readonly _tag: 'two'\n  readonly length: 2\n  readonly value: T\n  readonly values: readonly [T, T]\n}\n\n/** @since 2.0.0 */\nexport interface Three<T> extends Pipeable, Iterable<T> {\n  readonly _tag: 'three'\n  readonly length: 3\n  readonly value: T\n  readonly values: readonly [T, T, T]\n}\n\n/**\n * Any non-empty solution. All `Some<T>` values expose `.value: T` directly —\n * no narrowing required to read the primary value.\n *\n * @since 2.0.0\n */\nexport type Some<T> = One<T> | Two<T> | Three<T>\n\n/**\n * `None | One<T>` — return type of operations that produce at most one value\n * (e.g. inverse-solving a strictly monotonic polynomial).\n *\n * @since 2.0.0\n */\nexport type AtMostOne<T> = None | One<T>\n\n/**\n * `None | One<T> | Two<T>` — return type of operations that produce at most\n * two values (e.g. inverse-solving an unrestricted quadratic polynomial).\n *\n * @since 2.0.0\n */\nexport type AtMostTwo<T> = None | One<T> | Two<T>\n\n/**\n * `None | One<T> | Two<T> | Three<T>` — equivalent to `Solution<T>`.\n *\n * @since 2.0.0\n */\nexport type AtMostThree<T> = Solution<T>\n\n/**\n * The empty solution. Reused across calls — never reallocated.\n *\n * @since 2.0.0\n */\nexport const none: None = internal.none\n\n/**\n * Constructs a single-value solution.\n *\n * @since 2.0.0\n */\nexport const one: <T>(value: T) => One<T> = internal.one\n\n/**\n * Constructs a two-value solution.\n *\n * @since 2.0.0\n */\nexport const two: <T>(a: T, b: T) => Two<T> = internal.two\n\n/**\n * Constructs a three-value solution.\n *\n * @since 2.0.0\n */\nexport const three: <T>(a: T, b: T, c: T) => Three<T> = internal.three\n\n/**\n * Constructs a `Solution<T>` from a runtime array. Throws if the array has\n * more than three elements.\n *\n * @since 2.0.0\n */\nexport const fromArray: <T>(arr: ReadonlyArray<T>) => Solution<T> = internal.fromArray\n\n/**\n * Type-narrowing predicate: refines `Solution<T>` to `None`.\n *\n * @since 2.0.0\n */\nexport const isNone: <T>(s: Solution<T>) => s is None = internal.isNone\n\n/**\n * Type-narrowing predicate: refines `Solution<T>` to `Some<T>` (non-empty).\n * After narrowing, `.value` is directly accessible without further checks.\n *\n * @since 2.0.0\n */\nexport const isSome: <T>(s: Solution<T>) => s is Some<T> = internal.isSome\n\n/**\n * Returns the primary (first) value if the solution is non-empty, or\n * `undefined` if empty. Pair with `.value` access on `Some<T>`-narrowed\n * inputs to avoid the `undefined` possibility.\n *\n * @since 2.0.0\n */\nexport const valueOrUndefined: <T>(s: Solution<T>) => T | undefined = internal.valueOrUndefined\n\n/**\n * Returns the last value in the solution, or `undefined` if empty. When\n * called on a `Some<T>`, the result is guaranteed to be `T`.\n *\n * @since 2.0.0\n */\nexport const last: {\n  <T>(s: Some<T>): T\n  <T>(s: Solution<T>): T | undefined\n} = internal.last\n\n/**\n * Returns the smallest numeric value in the solution, or `undefined` if empty.\n * When called on a `Some<number>`, the result is guaranteed to be `number`.\n *\n * @since 2.0.0\n */\nexport const min: {\n  (s: Some<number>): number\n  (s: Solution<number>): number | undefined\n} = internal.min\n\n/**\n * Returns the largest numeric value in the solution, or `undefined` if empty.\n * When called on a `Some<number>`, the result is guaranteed to be `number`.\n *\n * @since 2.0.0\n */\nexport const max: {\n  (s: Some<number>): number\n  (s: Solution<number>): number | undefined\n} = internal.max\n\n/**\n * Returns the last value in the solution. Throws if empty.\n *\n * @since 2.0.0\n */\nexport const unsafeLast: <T>(s: Solution<T>) => T = internal.unsafeLast\n\n/**\n * Returns the smallest numeric value in the solution. Throws on empty.\n *\n * @since 2.0.0\n */\nexport const unsafeMin: (s: Solution<number>) => number = internal.unsafeMin\n\n/**\n * Returns the largest numeric value in the solution. Throws on empty.\n *\n * @since 2.0.0\n */\nexport const unsafeMax: (s: Solution<number>) => number = internal.unsafeMax\n\n/**\n * Filters the solution by a predicate. Result cardinality is at most that of\n * the input.\n *\n * @since 2.0.0\n */\nexport const filter: <T>(s: Solution<T>, predicate: (v: T) => boolean) => Solution<T> =\n  internal.filter\n\n/**\n * Restricts the solution to values contained within an interval. Endpoint\n * inclusivity follows the interval's `kind` — pass an open variant (e.g.\n * `Interval.makeOpen(0, 1)` or `Interval.unitOpen`) for strict containment.\n *\n * @param s - The solution to clip.\n * @param i - The interval to retain values within.\n * @since 2.0.0\n */\nexport const clip: {\n  (i: Interval): (s: Solution<number>) => Solution<number>\n  (s: Solution<number>, i: Interval): Solution<number>\n} = internal.clip\n\n/**\n * Maps every value in the solution to a new value. Result cardinality matches\n * the input.\n *\n * @since 2.0.0\n */\nexport const map: {\n  <A, B>(s: Solution<A>, f: (v: A) => B): Solution<B>\n  <A, B>(f: (v: A) => B): (s: Solution<A>) => Solution<B>\n} = internal.map\n\n// Drops `None` from the union of the input solution type — used by `match` to\n// give `onSome` a tighter parameter type. Distributive: a `Solution.AtMostOne<T>`\n// becomes `One<T>`; a full `Solution<T>` keeps `Some<T>`.\ntype SomeOf<S> = S extends None ? never : S\n\n/**\n * Pattern matches on a solution, calling `onNone` for the empty case and\n * `onSome` for any non-empty case. The `onSome` parameter is typed against\n * the input's narrowed shape — for an `AtMostOne<T>` input, `onSome` receives\n * `One<T>` and can read `.value` directly.\n *\n * @example\n * ```ts\n * const result = polynomial.pipe(\n *   LinearPolynomial.solveInverse(0),\n *   Solution.match({\n *     onNone: () => null,\n *     onSome: ({ value }) => Math.abs(value),\n *   }),\n * )\n * ```\n *\n * @since 2.0.0\n */\nexport const match: {\n  <S extends Solution<unknown>, A, B>(\n    self: S,\n    matcher: { readonly onNone: () => A; readonly onSome: (s: SomeOf<S>) => B },\n  ): A | B\n  <S extends Solution<unknown>, A, B>(matcher: {\n    readonly onNone: () => A\n    readonly onSome: (s: SomeOf<S>) => B\n  }): (self: S) => A | B\n} = internal.match as never\n"],"mappings":"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"}

package/dist/shared/solution-sNQ-ZVhN.d.mts

@@ -0,0 +1,251 @@
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+import { r as Interval } from "./interval-Dy-RMEE3.mjs";
+
+//#region src/solution/solution.d.ts
+declare namespace solution_d_exports {
+  export { AtMostOne, AtMostThree, AtMostTwo, None, One, Solution, Some, Three, Two, clip, filter, fromArray, isNone, isSome, last, map, match, max, min, none, one, three, two, unsafeLast, unsafeMax, unsafeMin, valueOrUndefined };
+}
+/**
+ * A `Solution<T>` represents the result of an operation that may produce
+ * between zero and three values of `T`. It generalizes the zoo of "0 or 1",
+ * "0 to 2", "0 to 3" return shapes used throughout curvy under one type, and
+ * provides a small namespace of operations (`value`, `last`, `min`, `max`,
+ * `filter`, `map`, `match`, …) for working with the result.
+ *
+ * Each variant carries a `_tag` discriminator and a `length` field, is
+ * iterable via `Symbol.iterator` (so existing `for..of` and spread patterns
+ * keep working), and is `Pipeable` (so a `Solution` value can be the head of
+ * a `pipe` chain).
+ *
+ * Variant-specific accessors:
+ * - `One<T>`, `Two<T>`, and `Three<T>` all expose `.value: T` (the first /
+ *   primary value).
+ * - `Two<T>` and `Three<T>` additionally expose `.values: readonly [T, ...]`
+ *   for explicit positional access.
+ *
+ * Operations that return narrower cardinalities (e.g. inverse-solving a
+ * monotonic polynomial) use the `AtMost{One,Two,Three}` aliases to express
+ * "this could be empty, but it'll have at most N values."
+ *
+ * @since 2.0.0
+ */
+type Solution<T> = None | One<T> | Two<T> | Three<T>;
+/**
+ * The empty solution.
+ *
+ * @since 2.0.0
+ */
+interface None extends Pipeable, Iterable<never> {
+  readonly _tag: 'none';
+  readonly length: 0;
+}
+/** @since 2.0.0 */
+interface One<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'one';
+  readonly length: 1;
+  readonly value: T;
+}
+/** @since 2.0.0 */
+interface Two<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'two';
+  readonly length: 2;
+  readonly value: T;
+  readonly values: readonly [T, T];
+}
+/** @since 2.0.0 */
+interface Three<T> extends Pipeable, Iterable<T> {
+  readonly _tag: 'three';
+  readonly length: 3;
+  readonly value: T;
+  readonly values: readonly [T, T, T];
+}
+/**
+ * Any non-empty solution. All `Some<T>` values expose `.value: T` directly —
+ * no narrowing required to read the primary value.
+ *
+ * @since 2.0.0
+ */
+type Some<T> = One<T> | Two<T> | Three<T>;
+/**
+ * `None | One<T>` — return type of operations that produce at most one value
+ * (e.g. inverse-solving a strictly monotonic polynomial).
+ *
+ * @since 2.0.0
+ */
+type AtMostOne<T> = None | One<T>;
+/**
+ * `None | One<T> | Two<T>` — return type of operations that produce at most
+ * two values (e.g. inverse-solving an unrestricted quadratic polynomial).
+ *
+ * @since 2.0.0
+ */
+type AtMostTwo<T> = None | One<T> | Two<T>;
+/**
+ * `None | One<T> | Two<T> | Three<T>` — equivalent to `Solution<T>`.
+ *
+ * @since 2.0.0
+ */
+type AtMostThree<T> = Solution<T>;
+/**
+ * The empty solution. Reused across calls — never reallocated.
+ *
+ * @since 2.0.0
+ */
+declare const none: None;
+/**
+ * Constructs a single-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const one: <T>(value: T) => One<T>;
+/**
+ * Constructs a two-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const two: <T>(a: T, b: T) => Two<T>;
+/**
+ * Constructs a three-value solution.
+ *
+ * @since 2.0.0
+ */
+declare const three: <T>(a: T, b: T, c: T) => Three<T>;
+/**
+ * Constructs a `Solution<T>` from a runtime array. Throws if the array has
+ * more than three elements.
+ *
+ * @since 2.0.0
+ */
+declare const fromArray: <T>(arr: ReadonlyArray<T>) => Solution<T>;
+/**
+ * Type-narrowing predicate: refines `Solution<T>` to `None`.
+ *
+ * @since 2.0.0
+ */
+declare const isNone: <T>(s: Solution<T>) => s is None;
+/**
+ * Type-narrowing predicate: refines `Solution<T>` to `Some<T>` (non-empty).
+ * After narrowing, `.value` is directly accessible without further checks.
+ *
+ * @since 2.0.0
+ */
+declare const isSome: <T>(s: Solution<T>) => s is Some<T>;
+/**
+ * Returns the primary (first) value if the solution is non-empty, or
+ * `undefined` if empty. Pair with `.value` access on `Some<T>`-narrowed
+ * inputs to avoid the `undefined` possibility.
+ *
+ * @since 2.0.0
+ */
+declare const valueOrUndefined: <T>(s: Solution<T>) => T | undefined;
+/**
+ * Returns the last value in the solution, or `undefined` if empty. When
+ * called on a `Some<T>`, the result is guaranteed to be `T`.
+ *
+ * @since 2.0.0
+ */
+declare const last: {
+  <T>(s: Some<T>): T;
+  <T>(s: Solution<T>): T | undefined;
+};
+/**
+ * Returns the smallest numeric value in the solution, or `undefined` if empty.
+ * When called on a `Some<number>`, the result is guaranteed to be `number`.
+ *
+ * @since 2.0.0
+ */
+declare const min: {
+  (s: Some<number>): number;
+  (s: Solution<number>): number | undefined;
+};
+/**
+ * Returns the largest numeric value in the solution, or `undefined` if empty.
+ * When called on a `Some<number>`, the result is guaranteed to be `number`.
+ *
+ * @since 2.0.0
+ */
+declare const max: {
+  (s: Some<number>): number;
+  (s: Solution<number>): number | undefined;
+};
+/**
+ * Returns the last value in the solution. Throws if empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeLast: <T>(s: Solution<T>) => T;
+/**
+ * Returns the smallest numeric value in the solution. Throws on empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeMin: (s: Solution<number>) => number;
+/**
+ * Returns the largest numeric value in the solution. Throws on empty.
+ *
+ * @since 2.0.0
+ */
+declare const unsafeMax: (s: Solution<number>) => number;
+/**
+ * Filters the solution by a predicate. Result cardinality is at most that of
+ * the input.
+ *
+ * @since 2.0.0
+ */
+declare const filter: <T>(s: Solution<T>, predicate: (v: T) => boolean) => Solution<T>;
+/**
+ * Restricts the solution to values contained within an interval. Endpoint
+ * inclusivity follows the interval's `kind` — pass an open variant (e.g.
+ * `Interval.makeOpen(0, 1)` or `Interval.unitOpen`) for strict containment.
+ *
+ * @param s - The solution to clip.
+ * @param i - The interval to retain values within.
+ * @since 2.0.0
+ */
+declare const clip: {
+  (i: Interval): (s: Solution<number>) => Solution<number>;
+  (s: Solution<number>, i: Interval): Solution<number>;
+};
+/**
+ * Maps every value in the solution to a new value. Result cardinality matches
+ * the input.
+ *
+ * @since 2.0.0
+ */
+declare const map: {
+  <A, B>(s: Solution<A>, f: (v: A) => B): Solution<B>;
+  <A, B>(f: (v: A) => B): (s: Solution<A>) => Solution<B>;
+};
+type SomeOf<S> = S extends None ? never : S;
+/**
+ * Pattern matches on a solution, calling `onNone` for the empty case and
+ * `onSome` for any non-empty case. The `onSome` parameter is typed against
+ * the input's narrowed shape — for an `AtMostOne<T>` input, `onSome` receives
+ * `One<T>` and can read `.value` directly.
+ *
+ * @example
+ * ```ts
+ * const result = polynomial.pipe(
+ *   LinearPolynomial.solveInverse(0),
+ *   Solution.match({
+ *     onNone: () => null,
+ *     onSome: ({ value }) => Math.abs(value),
+ *   }),
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ */
+declare const match: {
+  <S extends Solution<unknown>, A, B>(self: S, matcher: {
+    readonly onNone: () => A;
+    readonly onSome: (s: SomeOf<S>) => B;
+  }): A | B;
+  <S extends Solution<unknown>, A, B>(matcher: {
+    readonly onNone: () => A;
+    readonly onSome: (s: SomeOf<S>) => B;
+  }): (self: S) => A | B;
+};
+//#endregion
+export { solution_d_exports as a, One as i, AtMostThree as n, AtMostTwo as r, AtMostOne as t };
+//# sourceMappingURL=solution-sNQ-ZVhN.d.mts.map