{"version":3,"file":"solution-B2JdOZpe.mjs","names":["none","one","two","three","fromArray","isNone","isSome","valueOrUndefined","last","min","max","unsafeValue","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.unsafeValue","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.ts'\nimport { dual, Pipeable } from '../utils.ts'\nimport type {\n  AtMostOne,\n  AtMostThree,\n  AtMostTwo,\n  None,\n  One,\n  Solution,\n  Some,\n  Three,\n  Two,\n} from './solution.ts'\nimport { invariant } from '../utils.ts'\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\n/** @internal */\nexport const NONE_INSTANCE: None = new NoneImpl()\n\n/** @internal */\nexport const none: None = NONE_INSTANCE\n\n/** @internal */\nexport const one = <T>(value: T): One<T> => new OneImpl(value)\n\n/** @internal */\nexport const two = <T>(a: T, b: T): Two<T> => new TwoImpl([a, b])\n\n/** @internal */\nexport const three = <T>(a: T, b: T, c: T): Three<T> => new ThreeImpl([a, b, c])\n\n/** @internal */\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\n/** @internal */\nexport const isNone = <T>(s: Solution<T>): s is None => s._tag === 'none'\n\n/** @internal */\nexport const isSome = <T>(s: Solution<T>): s is Some<T> => s._tag !== 'none'\n\n/** @internal */\nexport const valueOrUndefined = <T>(s: Solution<T>): T | undefined =>\n  isNone(s) ? undefined : s.value\n\n/** @internal */\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\n/** @internal */\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\n/** @internal */\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\n/** @internal */\nexport const unsafeValue = <T>(s: Solution<T>, message?: string): T => {\n  invariant(isSome(s), message ?? 'Solution.unsafeValue on empty Solution')\n  return s.value\n}\n\n/** @internal */\nexport const unsafeLast = <T>(s: Solution<T>): T => {\n  invariant(isSome(s), 'Solution.unsafeLast on empty Solution')\n  return last(s)\n}\n\n/** @internal */\nexport const unsafeMin = (s: Solution<number>): number => {\n  invariant(isSome(s), 'Solution.unsafeMin on empty Solution')\n  return min(s)\n}\n\n/** @internal */\nexport const unsafeMax = (s: Solution<number>): number => {\n  invariant(isSome(s), 'Solution.unsafeMax on empty Solution')\n  return max(s)\n}\n\n/** @internal */\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\n/** @internal */\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\n/** @internal */\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\n/** @internal */\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.ts'\nimport type { Pipeable } from '../utils.ts'\nimport * as internal from './solution.internal.ts'\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 primary value of the solution (i.e. `s.value`). Throws on\n * `None`, optionally with a caller-provided message.\n *\n * Useful when the type system can't prove non-emptiness but you have a domain\n * reason to assert it — e.g. inverting a polynomial you know to be monotonic\n * without going through the trait refiner first:\n *\n * ```ts\n * const x = CubicPolynomial.solveInverse(p, y).pipe(\n *   Solution.unsafeValue('expected a monotonic inverse'),\n * )\n * ```\n *\n * @since 2.0.0\n */\nexport const unsafeValue: {\n  <T>(s: Solution<T>, message?: string): T\n  (message: string): <T>(s: Solution<T>) => T\n} = ((...args: ReadonlyArray<unknown>) => {\n  if (args.length >= 1 && typeof args[0] === 'object' && args[0] !== null) {\n    return internal.unsafeValue(args[0] as Solution<unknown>, args[1] as string | undefined)\n  }\n  const message = args[0] as string\n  return <T>(s: Solution<T>) => internal.unsafeValue(s, message)\n}) as never\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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"}