@nicolastoulemont/std 0.9.0 → 0.11.0

package/dist/multithread-CovZ2ioL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multithread-CovZ2ioL.mjs","names":["Context.empty"],"sources":["../src/multithread/multithread.ts"],"sourcesContent":["/**\n * Parallel worker orchestration helpers built on the optional `multithreading` runtime.\n *\n * **Mental model**\n * - `MultithreadOp` represents cancelable worker execution.\n * - Use `fx` inside `Fx.gen` when each execution should start a fresh worker operation.\n * - Use `run`, `task`, and collection combinators for lower-level operation control.\n *\n * **Common tasks**\n * - Execute one worker operation with `Multithread.run`.\n * - Run worker-backed effects inside `Fx.gen` with `Multithread.fx`.\n * - Create reusable tasks with `Multithread.task`.\n * - Process collections in parallel with `Multithread.map` / `forEach`.\n * - Configure worker-pool lifecycle with `Multithread.configure` or `Multithread.layer`.\n *\n * **Gotchas**\n * - Requires optional `multithreading` peer dependency.\n * - Runtime should be configured before first operation.\n * - Worker callbacks are serialized, so they should be self-contained.\n * - Cancellation is cooperative: call `ctx.throwIfCancelled()` inside long-running work.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((input: string, ctx) => {\n *   ctx.throwIfCancelled()\n *   return input.toUpperCase()\n * }, \"hello\")\n *\n * const result = await op.result()\n * // => { _tag: \"Ok\", value: \"HELLO\" }\n * ```\n *\n * @module\n */\nimport * as Context from \"../context/context\"\nimport { interruptibleAsync } from \"../fx/fx.runtime\"\nimport type { RuntimeState } from \"../fx/fx.runtime\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { AsyncFx, FxYield } from \"../fx/fx.types\"\nimport { err, ok } from \"../result/result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type {\n  MultithreadAllFailedError,\n  MultithreadCancelledError,\n  MultithreadCtx,\n  MultithreadError,\n  MultithreadFilter,\n  MultithreadFilterWorker,\n  MultithreadFirstSuccess,\n  MultithreadFlatMap,\n  MultithreadFlatMapWorker,\n  MultithreadForEach,\n  MultithreadFx,\n  MultithreadLayer,\n  MultithreadMap,\n  MultithreadMapWorker,\n  MultithreadOp,\n  MultithreadParallelOptions,\n  MultithreadRace,\n  MultithreadRun,\n  MultithreadRuntimeAlreadyInitializedError,\n  MultithreadRuntimeSnapshot,\n  MultithreadRuntimeUnavailableError,\n  MultithreadSignal,\n  MultithreadTask,\n  MultithreadWorkerExecutionError,\n  WorkerReturn,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported worker context passed to multithread workers.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadCtx\n   * ```\n   *\n   */\n  type MultithreadCtx,\n  type MultithreadRuntimeSnapshot,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported union of multithread runtime and worker errors.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadError\n   * ```\n   *\n   */\n  type MultithreadError,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported cancelable multithread operation type.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadOp<unknown, unknown>\n   * ```\n   *\n   */\n  type MultithreadOp,\n} from \"./multithread.types\"\n\n/**\n * Internal runtime shape loaded from the optional \"multithreading\" peer dependency.\n */\ntype MultithreadingRuntime = {\n  initRuntime(config: { maxWorkers: number }): void\n  shutdown(): void\n  move<Args extends unknown[]>(...args: Args): unknown\n  spawn<R>(\n    payload: unknown,\n    fn: (...args: unknown[]) => R | Promise<R>,\n  ): {\n    join(): Promise<{ ok: boolean; value?: R; error?: Error }>\n    abort(): void\n  }\n}\n\ntype WorkerLike = (...args: unknown[]) => unknown\ntype WorkerEntrypoint = (...args: unknown[]) => Promise<unknown>\n\ntype InternalCancelController = {\n  readonly signal: MultithreadSignal\n  isCancelled(): boolean\n  cancel(): void\n  onCancel(listener: () => void): void\n}\n\nconst CANCELLED_ERROR_MESSAGE = \"@nicolastoulemont/std/multithread/cancelled\"\n\nlet runtimeConfig: { maxWorkers: number } | undefined\nlet runtimeInitialized = false\nlet runtimeImportPromise: Promise<MultithreadingRuntime> | undefined\n\nconst workerEntrypointCache = new WeakMap<object, WorkerEntrypoint>()\n\nconst emptyRuntimeSnapshot = (): MultithreadRuntimeSnapshot => ({\n  fiberId: undefined,\n  logFields: {},\n  trace: undefined,\n})\n\nconst isSpanContext = (\n  value: unknown,\n): value is { readonly traceId: string; readonly spanId: string; readonly traceFlags?: number } =>\n  typeof value === \"object\" &&\n  value !== null &&\n  \"traceId\" in value &&\n  typeof value.traceId === \"string\" &&\n  \"spanId\" in value &&\n  typeof value.spanId === \"string\"\n\nconst runtimeTraceSnapshot = (span: unknown): MultithreadRuntimeSnapshot[\"trace\"] => {\n  if (typeof span !== \"object\" || span === null) {\n    return undefined\n  }\n\n  if (\"context\" in span && isSpanContext(span.context)) {\n    return {\n      traceId: span.context.traceId,\n      spanId: span.context.spanId,\n      ...(span.context.traceFlags === undefined ? {} : { traceFlags: span.context.traceFlags }),\n    }\n  }\n\n  if (isSpanContext(span)) {\n    return {\n      traceId: span.traceId,\n      spanId: span.spanId,\n      ...(span.traceFlags === undefined ? {} : { traceFlags: span.traceFlags }),\n    }\n  }\n\n  return undefined\n}\n\nconst runtimeSnapshotFromState = (state: RuntimeState): MultithreadRuntimeSnapshot => ({\n  fiberId: state.fiberId,\n  logFields: { ...state.logFields },\n  trace: runtimeTraceSnapshot(state.currentSpan),\n})\n\nconst makeRuntimeUnavailableError = (\n  cause?: unknown,\n  message = 'Optional peer dependency \"multithreading\" is unavailable. Install it to use Multithread APIs.',\n): MultithreadRuntimeUnavailableError => ({\n  _tag: \"MultithreadRuntimeUnavailableError\",\n  message,\n  cause,\n})\n\nconst makeRuntimeAlreadyInitializedError = (\n  message = \"Multithread runtime is already initialized and can no longer be configured.\",\n): MultithreadRuntimeAlreadyInitializedError => ({\n  _tag: \"MultithreadRuntimeAlreadyInitializedError\",\n  message,\n})\n\nconst makeWorkerExecutionError = (message: string, cause: unknown): MultithreadWorkerExecutionError => ({\n  _tag: \"MultithreadWorkerExecutionError\",\n  message,\n  cause,\n})\n\nconst makeCancelledError = (\n  message = \"Multithread operation was cancelled before completion.\",\n): MultithreadCancelledError => ({\n  _tag: \"MultithreadCancelledError\",\n  message,\n})\n\nconst makeAllFailedError = (message: string, errors: readonly unknown[]): MultithreadAllFailedError => ({\n  _tag: \"MultithreadAllFailedError\",\n  message,\n  errors,\n})\n\nconst getErrorMessage = (cause: unknown): string | undefined =>\n  cause instanceof Error ? cause.message : typeof cause === \"string\" ? cause : undefined\n\nconst isCancelledCause = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return message === CANCELLED_ERROR_MESSAGE || message === \"Task aborted\"\n}\n\nconst isCallerLocationFailure = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return typeof message === \"string\" && message.startsWith(\"Could not parse coordinates from:\")\n}\n\nconst isResultLike = (value: unknown): value is ResultType<unknown, unknown> => {\n  if (typeof value !== \"object\" || value === null || !(\"_tag\" in value)) return false\n  const tag = Reflect.get(value, \"_tag\")\n  if (tag === \"Ok\") return \"value\" in value\n  if (tag === \"Err\") return \"error\" in value\n  return false\n}\n\nconst resultOk = <A>(value: A): ResultType<A, never> => ok(value)\nconst resultErr = <E>(error: E): ResultType<never, E> => err(error)\n\nconst normalizeWorkerReturn = <A, E>(value: unknown): ResultType<A, E> => {\n  if (isResultLike(value)) {\n    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- isResultLike confirms runtime shape; generic channels are erased.\n    return value as ResultType<A, E>\n  }\n  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Worker return value is user-defined and mapped to generic success type.\n  return resultOk(value as A)\n}\n\nconst runFromInputResult = (\n  input: unknown,\n  execute: (value: unknown) => MultithreadOp<unknown, unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> => {\n  if (!isResultLike(input)) {\n    return execute(input)\n  }\n\n  if (input._tag === \"Err\") {\n    return Promise.resolve(resultErr(input.error))\n  }\n\n  return execute(input.value).result()\n}\n\nconst normalizeParallelism = (parallelism: number | undefined, fallback: number): number => {\n  if (typeof parallelism !== \"number\" || !Number.isFinite(parallelism)) return fallback\n  const rounded = Math.floor(parallelism)\n  return rounded > 0 ? rounded : fallback\n}\n\nconst isWorkerLike = (value: unknown): value is WorkerLike => typeof value === \"function\"\n\nconst isParallelOptions = (value: unknown): value is MultithreadParallelOptions =>\n  typeof value === \"object\" && value !== null\n\nconst resolveParallelOptions = (value: unknown): MultithreadParallelOptions | undefined =>\n  isParallelOptions(value) ? value : undefined\n\nconst getDefaultParallelism = (): number => {\n  if (runtimeConfig !== undefined) {\n    return runtimeConfig.maxWorkers\n  }\n  if (typeof navigator !== \"undefined\" && typeof navigator.hardwareConcurrency === \"number\") {\n    return normalizeParallelism(navigator.hardwareConcurrency, 4)\n  }\n  return 4\n}\n\nconst createSharedSignal = (): MultithreadSignal => {\n  if (typeof SharedArrayBuffer !== \"function\") return null\n  return new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT))\n}\n\nconst createCancelController = (): InternalCancelController => {\n  const signal = createSharedSignal()\n  const listeners = new Set<() => void>()\n  let cancelled = false\n\n  const isCancelled = (): boolean => cancelled || (signal !== null && Atomics.load(signal, 0) === 1)\n\n  const cancel = (): void => {\n    if (cancelled) return\n    cancelled = true\n\n    if (signal !== null) {\n      Atomics.store(signal, 0, 1)\n      Atomics.notify(signal, 0)\n    }\n\n    const activeListeners = Array.from(listeners)\n    listeners.clear()\n\n    for (const listener of activeListeners) {\n      try {\n        listener()\n      } catch {\n        // Intentionally ignore listener disposal errors during cancellation fanout.\n      }\n    }\n  }\n\n  const onCancel = (listener: () => void): void => {\n    if (cancelled) {\n      listener()\n      return\n    }\n    listeners.add(listener)\n  }\n\n  return {\n    signal,\n    isCancelled,\n    cancel,\n    onCancel,\n  }\n}\n\nconst loadRuntimeModule = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  try {\n    runtimeImportPromise ??= import(\"multithreading\") as Promise<MultithreadingRuntime>\n    return resultOk(await runtimeImportPromise)\n  } catch (cause) {\n    return resultErr(makeRuntimeUnavailableError(cause))\n  }\n}\n\nconst getRuntime = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") return runtimeResult\n\n  const runtime = runtimeResult.value\n\n  if (!runtimeInitialized) {\n    try {\n      if (runtimeConfig !== undefined) {\n        runtime.initRuntime(runtimeConfig)\n      }\n      runtimeInitialized = true\n    } catch (cause) {\n      return resultErr(makeWorkerExecutionError(\"Failed to initialize multithreading runtime.\", cause))\n    }\n  }\n\n  return resultOk(runtime)\n}\n\nconst createWorkerEntrypoint = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): WorkerEntrypoint => {\n  const cached = workerEntrypointCache.get(worker)\n  if (cached !== undefined) {\n    return cached\n  }\n\n  const source = worker.toString()\n  // oxlint-disable-next-line typescript-eslint/no-implied-eval, typescript-eslint/no-unsafe-type-assertion -- Worker code must be reconstructed from serialized callback source and typed at runtime.\n  const factory = new Function(\n    `\nreturn async function (...__args) {\n  const __runtime = __args.pop()\n  const __signal = __args.pop()\n  const __isCancelled = () => __signal !== null && Atomics.load(__signal, 0) === 1\n  const __throwIfCancelled = () => {\n    if (__isCancelled()) {\n      throw new Error(${JSON.stringify(CANCELLED_ERROR_MESSAGE)})\n    }\n  }\n  const __ctx = {\n    signal: __signal,\n    runtime: __runtime,\n    isCancelled: __isCancelled,\n    throwIfCancelled: __throwIfCancelled,\n  }\n  const __worker = (${source})\n  return await __worker(...__args, __ctx)\n}\n`,\n  ) as () => WorkerEntrypoint\n\n  const entrypoint = factory()\n  workerEntrypointCache.set(worker, entrypoint)\n  return entrypoint\n}\n\nconst createMultithreadOperation = <A, E>(\n  execute: (\n    controller: InternalCancelController,\n    runtimeSnapshot: MultithreadRuntimeSnapshot,\n  ) => Promise<ResultType<A, E | MultithreadError>>,\n): MultithreadOp<A, E | MultithreadError> => {\n  const controller = createCancelController()\n  let runPromise: Promise<ResultType<A, E | MultithreadError>> | undefined\n\n  const start = (\n    runtimeSnapshot: MultithreadRuntimeSnapshot = emptyRuntimeSnapshot(),\n  ): Promise<ResultType<A, E | MultithreadError>> => {\n    if (runPromise !== undefined) return runPromise\n\n    if (controller.isCancelled()) {\n      runPromise = Promise.resolve(resultErr(makeCancelledError()))\n      return runPromise\n    }\n\n    runPromise = execute(controller, runtimeSnapshot)\n      .catch((cause: unknown) => resultErr(makeWorkerExecutionError(\"Multithread operation failed.\", cause)))\n      .then((result) => {\n        if (controller.isCancelled()) {\n          return resultErr(makeCancelledError())\n        }\n        return result\n      })\n\n    return runPromise\n  }\n\n  const then: PromiseLike<ResultType<A, E | MultithreadError>>[\"then\"] = (onfulfilled, onrejected) =>\n    start().then(onfulfilled, onrejected)\n\n  return {\n    _tag: \"MultithreadOp\",\n    [FxTypeId]: {\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _A: () => undefined as unknown as A,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _E: () => undefined as unknown as E | MultithreadError,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _R: () => undefined as never,\n    },\n    result: start,\n    abort: () => {\n      controller.cancel()\n    },\n    // oxlint-disable-next-line eslint-plugin-unicorn/no-thenable -- MultithreadOp is intentionally PromiseLike for `await op` ergonomics.\n    then,\n    async *[Symbol.asyncIterator](): AsyncGenerator<E | MultithreadError, A, unknown> {\n      const fx = interruptibleAsync(\n        (state) => start(runtimeSnapshotFromState(state)),\n        () => {\n          controller.cancel()\n        },\n      ) as unknown as {\n        [Symbol.asyncIterator](): AsyncGenerator<E | MultithreadError, A, unknown>\n      }\n      return yield* fx\n    },\n  }\n}\n\nconst runWorkerLocally = async <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n  controller: InternalCancelController,\n  runtimeSnapshot: MultithreadRuntimeSnapshot,\n): Promise<ResultType<A, E | MultithreadError>> => {\n  if (controller.isCancelled()) {\n    return resultErr(makeCancelledError())\n  }\n\n  const ctx: MultithreadCtx = {\n    signal: controller.signal,\n    runtime: runtimeSnapshot,\n    isCancelled: () => controller.isCancelled(),\n    throwIfCancelled: () => {\n      if (controller.isCancelled()) throw new Error(CANCELLED_ERROR_MESSAGE)\n    },\n  }\n\n  try {\n    const value = await worker(...args, ctx)\n\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const normalized = normalizeWorkerReturn<A, E>(value)\n    if (normalized._tag === \"Err\") {\n      return resultErr(normalized.error)\n    }\n\n    return resultOk(normalized.value)\n  } catch (cause) {\n    if (controller.isCancelled() || isCancelledCause(cause)) {\n      return resultErr(makeCancelledError())\n    }\n    return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", cause))\n  }\n}\n\nconst runDataFirst = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation(async (controller, runtimeSnapshot): Promise<ResultType<A, E | MultithreadError>> => {\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const runtimeResult = await getRuntime()\n    if (runtimeResult._tag === \"Err\") return resultErr(runtimeResult.error)\n\n    const runtime = runtimeResult.value\n    const entrypoint = createWorkerEntrypoint(worker)\n\n    let joinHandle: ReturnType<MultithreadingRuntime[\"spawn\"]> | undefined\n\n    try {\n      const movedPayload = runtime.move(...args, controller.signal, runtimeSnapshot)\n      joinHandle = runtime.spawn(movedPayload, entrypoint)\n      controller.onCancel(() => {\n        joinHandle?.abort()\n      })\n    } catch (cause) {\n      if (isCallerLocationFailure(cause)) {\n        return runWorkerLocally(worker, args, controller, runtimeSnapshot)\n      }\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to start multithread worker.\", cause))\n    }\n\n    try {\n      const joined = await joinHandle.join()\n\n      if (controller.isCancelled()) {\n        return resultErr(makeCancelledError())\n      }\n\n      if (!joined.ok) {\n        const joinError = joined.error ?? new Error(\"Multithread worker returned an unknown error.\")\n        if (isCancelledCause(joinError)) {\n          return resultErr(makeCancelledError())\n        }\n        return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", joinError))\n      }\n\n      const normalized = normalizeWorkerReturn<A, E>(joined.value)\n      if (normalized._tag === \"Err\") {\n        return resultErr(normalized.error)\n      }\n      return resultOk(normalized.value)\n    } catch (cause) {\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to join multithread worker.\", cause))\n    }\n  })\n\nfunction runOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  ...args: Args\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload(worker: unknown, ...args: unknown[]): MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.run expects a worker function as first argument.\")\n  }\n  return runDataFirst(worker, args)\n}\n\n/**\n * Execute one worker task as a cancelable `MultithreadOp`.\n *\n * Use `run` when you need direct `result()`, `abort()`, `await op`, or explicit\n * sharing of one memoized operation.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((input: string, ctx) => {\n *   ctx.throwIfCancelled()\n *   return input.toUpperCase()\n * }, \"hello\")\n *\n * const result = await op.result()\n * // => { _tag: \"Ok\", value: \"HELLO\" }\n * ```\n */\nexport const run: MultithreadRun = runOverload\n\nfunction taskOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): () => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): (...args: Args) => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload(worker: unknown): (...args: unknown[]) => MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.task expects a worker function.\")\n  }\n  return (...args: unknown[]) => runDataFirst(worker, args)\n}\n\n/**\n * Create a reusable worker task factory.\n *\n * Each call to the returned function creates a fresh `MultithreadOp`.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const uppercase = Multithread.task((input: string, ctx) => {\n *   ctx.throwIfCancelled()\n *   return input.toUpperCase()\n * })\n *\n * const result = await uppercase(\"hello\").result()\n * // => { _tag: \"Ok\", value: \"HELLO\" }\n * ```\n */\nexport const task: MultithreadTask = taskOverload\n\nfunction fxOverload<A, E = never>(worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>): AsyncFx<A, E | MultithreadError>\nfunction fxOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  ...args: Args\n): AsyncFx<A, E | MultithreadError>\nfunction fxOverload(worker: unknown, ...args: unknown[]): AsyncFx<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.fx expects a worker function as first argument.\")\n  }\n\n  return {\n    _tag: \"AsyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as unknown,\n      _E: () => undefined as unknown,\n      _R: () => undefined as never,\n    },\n    async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<unknown, never>, unknown, unknown> {\n      return yield* runDataFirst(worker, args)\n    },\n  } as AsyncFx<unknown, unknown>\n}\n\n/**\n * Create a fresh worker-backed Fx for each execution.\n *\n * Prefer this inside reusable `Fx.gen` programs. Use `run` when you need a\n * lower-level operation handle, manual cancellation, or explicit sharing.\n *\n * @example\n * ```ts\n * import { Fx, Multithread } from \"@nicolastoulemont/std\"\n *\n * const program = Fx.gen(async function* () {\n *   return yield* Multithread.fx((input: number, ctx) => {\n *     ctx.throwIfCancelled()\n *     return input * 2\n *   }, 21)\n * })\n *\n * const exit = await Fx.run(program)\n * // => { _tag: \"Ok\", value: 42 }\n * ```\n */\nexport const fx: MultithreadFx = fxOverload\n\nconst executeInParallel = <A, B, E>(\n  values: readonly A[],\n  createItemOperation: (value: A, index: number) => MultithreadOp<B, E | MultithreadError>,\n  parallelism: number,\n  controller: InternalCancelController,\n): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n  if (values.length === 0) {\n    return Promise.resolve(resultOk<readonly B[]>([]))\n  }\n\n  return new Promise<ResultType<readonly B[], E | MultithreadError>>((resolve) => {\n    const operations = new Map<number, MultithreadOp<B, E | MultithreadError>>()\n    const output: B[] = []\n\n    let inFlight = 0\n    let nextIndex = 0\n    let completed = 0\n    let settled = false\n\n    const abortAll = (): void => {\n      for (const operation of operations.values()) {\n        operation.abort()\n      }\n      operations.clear()\n    }\n\n    const settle = (result: ResultType<readonly B[], E | MultithreadError>): void => {\n      if (settled) return\n      settled = true\n      abortAll()\n      resolve(result)\n    }\n\n    controller.onCancel(() => {\n      settle(resultErr(makeCancelledError()))\n    })\n\n    const handleOperation = (index: number, operation: MultithreadOp<B, E | MultithreadError>): void => {\n      void (async () => {\n        try {\n          const result = await operation.result()\n\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (result._tag === \"Err\") {\n            settle(resultErr(result.error))\n            return\n          }\n\n          output[index] = result.value\n          completed += 1\n\n          if (completed === values.length) {\n            settled = true\n            resolve(resultOk(output))\n            return\n          }\n\n          launch()\n        } catch (cause) {\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (controller.isCancelled() || isCancelledCause(cause)) {\n            settle(resultErr(makeCancelledError()))\n            return\n          }\n\n          settle(resultErr(makeWorkerExecutionError(\"Failed while executing multithread batch.\", cause)))\n        }\n      })()\n    }\n\n    const launch = (): void => {\n      while (!settled && inFlight < parallelism && nextIndex < values.length) {\n        const index = nextIndex\n        nextIndex += 1\n\n        const operation = createItemOperation(values[index]!, index)\n        operations.set(index, operation)\n        inFlight += 1\n\n        handleOperation(index, operation)\n      }\n    }\n\n    launch()\n  })\n}\n\nconst mapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation((controller) => {\n    const parallelism = normalizeParallelism(options?.parallelism, getDefaultParallelism())\n    return executeInParallel(values, (value, index) => runDataFirst(worker, [value, index]), parallelism, controller)\n  })\n\nfunction mapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction mapOverload<A, B, E = never>(\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        mapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.map(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    mapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Map a collection in parallel.\n *\n * The `parallelism` option controls how many item operations this call keeps in\n * flight. Runtime execution is still bounded by the configured worker count.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const result = await Multithread.map(\n *   [1, 2, 3],\n *   (value, _index, ctx) => {\n *     ctx.throwIfCancelled()\n *     return value * 2\n *   },\n *   { parallelism: 2 },\n * ).result()\n * // => { _tag: \"Ok\", value: [2, 4, 6] }\n * ```\n */\nexport const map: MultithreadMap = mapOverload\n\nconst forEachDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<void, E | MultithreadError>> => {\n    const mapped = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (mapped._tag === \"Err\") return resultErr(mapped.error)\n    return resultOk(undefined)\n  })\n\nfunction forEachOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<void, E | InputE | MultithreadError>>\nfunction forEachOverload<A, E = never>(\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n  : MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, unknown, E>,\n  workerOrOptions?: MultithreadMapWorker<A, unknown, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<void, E | MultithreadError>\n  | Promise<ResultType<void, E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        forEachDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.forEach(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    forEachDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as MultithreadOp<void, E | MultithreadError> | Promise<ResultType<void, E | InputE | MultithreadError>>\n}\n\n/**\n * Run side-effecting parallel work for each item.\n *\n * Use this when only completion matters. If you need collected values, use\n * `map`.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const result = await Multithread.forEach([\"a\", \"b\"], (value, _index, ctx) => {\n *   ctx.throwIfCancelled()\n *   return value.toUpperCase()\n * }).result()\n * // => { _tag: \"Ok\", value: undefined }\n * ```\n */\nexport const forEach: MultithreadForEach = forEachOverload\n\nconst filterDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly A[], E | MultithreadError>> => {\n    const decisions = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (decisions._tag === \"Err\") return resultErr(decisions.error)\n\n    const filtered: A[] = []\n    for (let index = 0; index < values.length; index += 1) {\n      if (decisions.value[index] === true) {\n        filtered.push(values[index]!)\n      }\n    }\n\n    return resultOk(filtered)\n  })\n\nfunction filterOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\nfunction filterOverload<A, E = never>(\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFilterWorker<A, E>,\n  workerOrOptions?: MultithreadFilterWorker<A, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly A[], E | MultithreadError>\n  | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        filterDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.filter(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    filterDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly A[], E | MultithreadError>\n    | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n}\n\n/**\n * Filter a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const result = await Multithread.filter([1, 2, 3, 4], (value, _index, ctx) => {\n *   ctx.throwIfCancelled()\n *   return value % 2 === 0\n * }).result()\n * // => { _tag: \"Ok\", value: [2, 4] }\n * ```\n */\nexport const filter: MultithreadFilter = filterOverload\n\nconst flatMapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n    const chunks = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (chunks._tag === \"Err\") return resultErr(chunks.error)\n\n    const flattened: B[] = []\n    for (const chunk of chunks.value) {\n      flattened.push(...chunk)\n    }\n\n    return resultOk(flattened)\n  })\n\nfunction flatMapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction flatMapOverload<A, B, E = never>(\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFlatMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadFlatMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        flatMapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.flatMap(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    flatMapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Flat-map a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const result = await Multithread.flatMap([1, 2], (value, _index, ctx) => {\n *   ctx.throwIfCancelled()\n *   return [value, value * 10]\n * }).result()\n * // => { _tag: \"Ok\", value: [1, 10, 2, 20] }\n * ```\n */\nexport const flatMap: MultithreadFlatMap = flatMapOverload\n\nconst raceDataFirst = <A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(resultErr(makeAllFailedError(\"Cannot race an empty list of operations.\", [])))\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n            settle(result)\n          } catch (cause) {\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            settle(resultErr(makeWorkerExecutionError(\"Multithread race failed.\", cause)))\n          }\n        })()\n      }\n\n      for (const operation of operations) {\n        watchOperation(operation)\n      }\n    })\n  })\n\nfunction raceOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction raceOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction raceOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    raceDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Resolve with the first settled operation.\n *\n * The winner may be successful or failed. All remaining operations are aborted\n * after the first operation settles.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const fast = Multithread.run(() => \"fast\")\n * const slow = Multithread.run(async () => {\n *   await new Promise((resolve) => {\n *     setTimeout(resolve, 50)\n *   })\n *   return \"slow\"\n * })\n *\n * const result = await Multithread.race([fast, slow]).result()\n * // => { _tag: \"Ok\", value: \"fast\" }\n * ```\n */\nexport const race: MultithreadRace = raceOverload\n\nconst firstSuccessDataFirst = <A, E>(\n  operations: readonly MultithreadOp<A, E>[],\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(\n        resultErr(makeAllFailedError(\"Cannot select a first success from an empty list of operations.\", [])),\n      )\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      const failures: unknown[] = Array.from({ length: operations.length })\n      let pending = operations.length\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>, index: number): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n\n            if (settled) return\n\n            if (result._tag === \"Ok\") {\n              settle(resultOk(result.value))\n              return\n            }\n\n            failures[index] = result.error\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          } catch (cause) {\n            if (settled) return\n\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            failures[index] = makeWorkerExecutionError(\"Multithread operation rejected unexpectedly.\", cause)\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          }\n        })()\n      }\n\n      operations.forEach((operation, index) => {\n        watchOperation(operation, index)\n      })\n    })\n  })\n\nfunction firstSuccessOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction firstSuccessOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction firstSuccessOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    firstSuccessDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Return the first successful operation, aggregating failures if none succeed.\n *\n * @example\n * ```ts\n * import { Multithread, Result } from \"@nicolastoulemont/std\"\n *\n * const fail = Multithread.run(() => Result.err(\"boom\"))\n * const pass = Multithread.run(() => Result.ok(1))\n *\n * const result = await Multithread.firstSuccess([fail, pass]).result()\n * // => { _tag: \"Ok\", value: 1 }\n * ```\n */\nexport const firstSuccess: MultithreadFirstSuccess = firstSuccessOverload\n\n/**\n * Configure max worker count used by the underlying runtime.\n *\n * Must be called before first multithread operation starts.\n * Use `layer` instead when the worker runtime should follow an `Fx` scope.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const configured = Multithread.configure({ maxWorkers: 4 })\n * // => { _tag: \"Ok\", value: undefined }\n * ```\n */\nexport const configure = (config: { maxWorkers: number }): ResultType<void, MultithreadError> => {\n  if (runtimeInitialized) {\n    return resultErr(makeRuntimeAlreadyInitializedError())\n  }\n\n  runtimeConfig = {\n    maxWorkers: normalizeParallelism(config.maxWorkers, 1),\n  }\n\n  return resultOk(undefined)\n}\n\nconst makeShutdownDefect = (cause: MultithreadError): Error => {\n  const defect = new Error(\"Failed to shutdown multithread runtime while closing scope.\") as Error & { cause?: unknown }\n  defect.cause = cause\n  return defect\n}\n\n/**\n * Create an Fx layer that configures and shuts down the shared worker runtime.\n *\n * The underlying `multithreading` runtime is process-global, so the layer makes\n * that lifecycle visible to `Fx` scopes rather than creating a per-fiber pool.\n *\n * @example\n * ```ts\n * import { Fx, Multithread, Provide } from \"@nicolastoulemont/std\"\n *\n * const program = Provide.layer(Multithread.layer({ maxWorkers: 2 }))(\n *   Fx.gen(async function* () {\n *     return yield* Multithread.fx(() => 42)\n *   }),\n * )\n *\n * const exit = await Fx.run(program)\n * // => { _tag: \"Ok\", value: 42 }\n * ```\n */\nexport const layer: MultithreadLayer = (config) => ({\n  _tag: \"Layer\",\n  _ROut: undefined as never,\n  _E: undefined as unknown as MultithreadError,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as false,\n  build: (_memoMap, scope): AsyncFx<Context.Context, MultithreadError> => ({\n    _tag: \"AsyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as unknown as Context.Context,\n      _E: () => undefined as unknown as MultithreadError,\n      _R: () => undefined as never,\n    },\n    async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<MultithreadError, never>, Context.Context, unknown> {\n      const configured = configure(config)\n      if (configured._tag === \"Err\") {\n        yield configured.error\n        throw new Error(\"Unreachable: Fx runtime should short-circuit on yielded Multithread layer errors.\")\n      }\n\n      const runtimeResult = await getRuntime()\n      if (runtimeResult._tag === \"Err\") {\n        yield runtimeResult.error\n        throw new Error(\"Unreachable: Fx runtime should short-circuit on yielded Multithread layer errors.\")\n      }\n\n      yield* scope.addFinalizer(() => ({\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined,\n          _E: () => undefined as never,\n          _R: () => undefined as never,\n        },\n        // oxlint-disable-next-line require-yield\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<never, never>, void, unknown> {\n          const result = await shutdown()\n          if (result._tag === \"Err\") {\n            throw makeShutdownDefect(result.error)\n          }\n        },\n      }))\n\n      return Context.empty()\n    },\n  }),\n})\n\n/**\n * Shutdown worker runtime.\n *\n * This function is idempotent.\n * Direct users can call it in test cleanup or process teardown. `layer` calls it\n * automatically when the owning scope closes.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const result = await Multithread.shutdown()\n * // => { _tag: \"Ok\", value: undefined }\n * ```\n */\nexport const shutdown = async (): Promise<ResultType<void, MultithreadError>> => {\n  if (!runtimeInitialized) {\n    return resultOk(undefined)\n  }\n\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") {\n    runtimeInitialized = false\n    return resultErr(runtimeResult.error)\n  }\n\n  try {\n    runtimeResult.value.shutdown()\n    return resultOk(undefined)\n  } catch (cause) {\n    return resultErr(makeWorkerExecutionError(\"Failed to shutdown multithreading runtime.\", cause))\n  } finally {\n    runtimeInitialized = false\n  }\n}\n"],"mappings":"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"}

package/dist/option/index.d.mts

@@ -1,2 +1,2 @@
-import { t as option_d_exports } from "../index-BqJ1GWAF.mjs";
+import { t as option_d_exports } from "../index-D_JbOTtg.mjs";
 export { option_d_exports as Option };

package/dist/option/index.mjs

@@ -1 +1 @@
-import{r as e}from"../option-C2iCxAuJ.mjs";export{e as Option};
+import{r as e}from"../option-BlyP5LA2.mjs";export{e as Option};

package/dist/{option-C2iCxAuJ.mjs → option-BlyP5LA2.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./fx.types-DyQVgTS8.mjs";import{t as n}from"./dual-fN6OUwN_.mjs";import{n as r}from"./flow-CNyLsPGb.mjs";import{t as i}from"./pipeable-Dp1_23zH.mjs";import{t as a}from"./option.types-CbY_swma.mjs";var o=e({NoSuchElementError:()=>s,all:()=>_,filter:()=>g,flatMap:()=>p,fromNullable:()=>S,fromTry:()=>C,isNone:()=>d,isSome:()=>u,map:()=>f,match:()=>b,none:()=>l,orElse:()=>h,some:()=>c,tap:()=>m,unwrapOr:()=>v,unwrapOrElse:()=>y});const s=a,c=e=>({_tag:`Some`,value:e,[t]:{_A:()=>e,_E:()=>void 0,_R:()=>void 0},pipe:i,*[Symbol.iterator](){return e}}),l=()=>({_tag:`None`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},pipe:i,*[Symbol.iterator](){throw yield new s,Error(`Unreachable: Fx.gen should short-circuit on NoSuchElementError`)}}),u=e=>e._tag===`Some`,d=e=>e._tag===`None`,f=n(2,(e,t)=>{if(e._tag===`None`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(c):c(n)}),p=n(2,(e,t)=>e._tag===`Some`?t(e.value):e),m=n(2,(e,t)=>{if(e._tag===`None`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),h=n(2,(e,t)=>e._tag===`Some`?e:t()),g=n(2,(e,t)=>e._tag===`None`||t(e.value)?e:l()),_=e=>{if(Array.isArray(e)){let t=[];for(let n of e){if(n._tag===`None`)return n;t.push(n.value)}return c(t)}let t={};for(let[n,r]of Object.entries(e)){let e=r;if(e._tag===`None`)return r;t[n]=e.value}return c(t)},v=n(2,(e,t)=>e._tag===`Some`?e.value:t),y=n(2,(e,t)=>e._tag===`Some`?e.value:t()),b=n(2,(e,t)=>e._tag===`Some`?t.Some(e.value):t.None()),x=e=>e!=null,S=e=>x(e)?c(e):l(),C=e=>{try{let t=e();return r(t)?Promise.resolve(t).then(c).catch(()=>l()):c(t)}catch{return l()}};export{c as i,l as n,o as r,S as t};
-//# sourceMappingURL=option-C2iCxAuJ.mjs.map
+import{t as e}from"./chunk-6rpU2rUb.mjs";import{t}from"./fx.types-Bg-Mmdm5.mjs";import{t as n}from"./dual-CZhzZslG.mjs";import{n as r}from"./flow-D8_tllWl.mjs";import{t as i}from"./pipeable-COGyGMUV.mjs";import{t as a}from"./option.types-bFFSErJ-.mjs";var o=e({NoSuchElementError:()=>s,all:()=>_,filter:()=>g,flatMap:()=>p,fromNullable:()=>S,fromTry:()=>C,isNone:()=>d,isSome:()=>u,map:()=>f,match:()=>b,none:()=>l,orElse:()=>h,some:()=>c,tap:()=>m,unwrapOr:()=>v,unwrapOrElse:()=>y});const s=a,c=e=>({_tag:`Some`,value:e,[t]:{_A:()=>e,_E:()=>void 0,_R:()=>void 0},pipe:i,*[Symbol.iterator](){return e}}),l=()=>({_tag:`None`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},pipe:i,*[Symbol.iterator](){throw yield new s,Error(`Unreachable: Fx.gen should short-circuit on NoSuchElementError`)}}),u=e=>e._tag===`Some`,d=e=>e._tag===`None`,f=n(2,(e,t)=>{if(e._tag===`None`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(c):c(n)}),p=n(2,(e,t)=>e._tag===`Some`?t(e.value):e),m=n(2,(e,t)=>{if(e._tag===`None`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),h=n(2,(e,t)=>e._tag===`Some`?e:t()),g=n(2,(e,t)=>e._tag===`None`||t(e.value)?e:l()),_=e=>{if(Array.isArray(e)){let t=[];for(let n of e){if(n._tag===`None`)return n;t.push(n.value)}return c(t)}let t={};for(let[n,r]of Object.entries(e)){let e=r;if(e._tag===`None`)return r;t[n]=e.value}return c(t)},v=n(2,(e,t)=>e._tag===`Some`?e.value:t),y=n(2,(e,t)=>e._tag===`Some`?e.value:t()),b=n(2,(e,t)=>e._tag===`Some`?t.Some(e.value):t.None()),x=e=>e!=null,S=e=>x(e)?c(e):l(),C=e=>{try{let t=e();return r(t)?Promise.resolve(t).then(c).catch(()=>l()):c(t)}catch{return l()}};export{c as i,l as n,o as r,S as t};
+//# sourceMappingURL=option-BlyP5LA2.mjs.map

package/dist/{option-C2iCxAuJ.mjs.map → option-BlyP5LA2.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"option-C2iCxAuJ.mjs","names":["NoSuchElementErrorCtor","values"],"sources":["../src/option/option.ts"],"sourcesContent":["/**\n * Optional value primitives for modeling presence (`Some`) and absence (`None`).\n *\n * **Mental model**\n * - `Option<A>` is either a value or no value.\n * - Prefer `Option` when missing data is expected and not exceptional.\n *\n * **Common tasks**\n * - Construct with `Option.some`, `Option.none`, `Option.fromNullable`.\n * - Transform with `Option.map`, `Option.flatMap`, `Option.filter`.\n * - Extract with `Option.unwrapOr`, `Option.match`.\n *\n * **Gotchas**\n * - `Option.none` short-circuits in `Fx.gen`.\n * - Use `Option.match` for exhaustive branch handling.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const name = Option.fromNullable(\"Ada\")\n * const upper = Option.map(name, (value) => value.toUpperCase())\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeable } from \"../shared/pipeable\"\nimport { NoSuchElementError as NoSuchElementErrorCtor } from \"./option.types\"\nimport type {\n  Option as OptionType,\n  OptionAll,\n  OptionFlatMap,\n  OptionMap,\n  OptionMatch,\n  OptionTap,\n  OptionOrElse,\n  OptionFilter,\n  OptionUnwrapOr,\n  OptionUnwrapOrElse,\n  FromTryReturn,\n} from \"./option.types\"\n\n/**\n * Re-exported error type used when yielding `Option.none()` in `Fx.gen`.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const error = new Option.NoSuchElementError()\n * // => error.name === \"NoSuchElementError\"\n * ```\n */\nexport const NoSuchElementError = NoSuchElementErrorCtor\n\n/**\n * Re-exported `NoSuchElementError` instance type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.NoSuchElementError\n * ```\n */\nexport type NoSuchElementError = InstanceType<typeof NoSuchElementErrorCtor>\n\n/**\n * Re-exported `Option` type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.Option<unknown>\n * ```\n */\nexport type Option<T> = OptionType<T>\n\n/* oxlint-disable no-unsafe-type-assertion -- Option runtime values carry erased Fx phantom channels that require explicit marker assertions. */\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create an Option with a value.\n *\n * @param value - The value to wrap\n * @returns An Option with `_tag: \"Some\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.some(42)\n * // => { _tag: \"Some\", value: 42 }\n * ```\n */\nexport const some = <T>(value: T): OptionType<T> => ({\n  _tag: \"Some\",\n  value,\n  [FxTypeId]: {\n    _A: () => value,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  pipe: pipeable,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<NoSuchElementError, T, unknown> {\n    return value\n  },\n})\n\n/**\n * Create an Option with no value.\n *\n * @returns An Option with `_tag: \"None\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.none<number>()\n * // => { _tag: \"None\" }\n * ```\n */\nexport const none = <T = never>(): OptionType<T> => ({\n  _tag: \"None\",\n  [FxTypeId]: {\n    _A: () => undefined as never,\n    _E: () => undefined as unknown as NoSuchElementError,\n    _R: () => undefined as never,\n  },\n  pipe: pipeable,\n  *[Symbol.iterator](): Generator<NoSuchElementError, never, unknown> {\n    yield new NoSuchElementError()\n    throw new Error(\"Unreachable: Fx.gen should short-circuit on NoSuchElementError\")\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if an Option has a value.\n *\n * @param option - The Option to check\n * @returns true if the Option is some\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isSome(Option.some(1))\n * // => true\n * ```\n */\nexport const isSome = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"Some\" }> =>\n  option._tag === \"Some\"\n\n/**\n * isNone utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isNone(Option.none())\n * // => true\n * ```\n */\nexport const isNone = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"None\" }> =>\n  option._tag === \"None\"\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the value of an Option.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(option, fn)`\n * - Data-last: `pipe(option, map(fn))`\n *\n * Supports both sync and async callbacks:\n * - Sync fn: returns U\n * - Async fn: returns Promise<U>\n *\n * @param fn - Function that transforms the contained value\n * @returns The mapped Option in data-first form, or a function that maps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.map(input, (n) => n + 1)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.map((n: number) => n + 1)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: OptionMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const mapped = fn(option.value)\n  if (isPromise(mapped)) {\n    return Promise.resolve(mapped).then(some) as any\n  }\n  return some(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Options.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(option, fn)`\n * - Data-last: `pipe(option, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that takes a value and returns an Option (or Promise<Option>)\n * @returns The resulting Option in data-first form, or a function that flatMaps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.flatMap(input, (n) => Option.some(n + 1))\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.flatMap((n: number) => Option.some(n + 1))(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: OptionFlatMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) =>\n  option._tag === \"Some\" ? fn(option.value) : option,\n)\n\n/**\n * Perform a side effect on the value without modifying the Option.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Option is none, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(option, fn)`\n * - Data-last: `pipe(option, tap(fn))`\n *\n * Supports both sync and async side effects:\n * - Sync fn: returns any value (ignored)\n * - Async fn: returns Promise<unknown>\n *\n * @param fn - Function to call with the value (return value is ignored)\n * @returns The original Option in data-first form, or a function that taps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * let seen = 0\n * const input = Option.some(2)\n * const dataFirst = Option.tap(input, (n) => {\n *   seen = n\n * })\n * // => { _tag: \"Some\", value: 2 }\n *\n * const dataLast = Option.tap((n: number) => {\n *   seen = n\n * })(input)\n * // => { _tag: \"Some\", value: 2 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: OptionTap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const sideEffect = fn(option.value)\n  if (isPromise(sideEffect)) {\n    return Promise.resolve(sideEffect).then(() => option) as any\n  }\n  return option as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from none by providing an alternative Option.\n * If the Option is some, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(option, fn)`\n * - Data-last: `pipe(option, orElse(fn))`\n *\n * Supports both sync and async fallback functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that returns an alternative Option\n * @returns The original or fallback Option in data-first form, or a function that recovers from none in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.orElse(input, () => Option.some(0))\n * // => { _tag: \"Some\", value: 0 }\n *\n * const dataLast = Option.orElse(() => Option.some(0))(input)\n * // => { _tag: \"Some\", value: 0 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: OptionOrElse = dual(2, (option: OptionType<unknown>, fn: () => unknown) =>\n  option._tag === \"Some\" ? option : fn(),\n)\n\n/**\n * Filter an Option based on a predicate.\n * If the predicate returns false, converts to none.\n * If the Option is already none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(option, predicate)`\n * - Data-last: `pipe(option, filter(predicate))`\n *\n * @param predicate - Function that returns true to keep the value\n * @returns The filtered Option in data-first form, or a function that filters an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(3)\n * const dataFirst = Option.filter(input, (n) => n > 0)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.filter((n: number) => n > 0)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\nexport const filter: OptionFilter = dual(2, (option: OptionType<unknown>, predicate: (value: unknown) => boolean) => {\n  if (option._tag === \"None\") return option\n  return predicate(option.value) ? option : none()\n})\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Options into a single Option.\n * Supports both array and object inputs.\n *\n * - If all Options are some, returns some with all values\n * - If any Option is none, returns none (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const combined = Option.all([Option.some(1), Option.some(2)] as const)\n * // => { _tag: \"Some\", value: [1, 2] }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: OptionAll = (options: any): any => {\n  if (Array.isArray(options)) {\n    const values: unknown[] = []\n    for (const option of options) {\n      if (option._tag === \"None\") return option\n      values.push(option.value)\n    }\n    return some(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, option] of Object.entries(options)) {\n    const o = option as OptionType<unknown>\n    if (o._tag === \"None\") return option\n    values[key] = o.value\n  }\n  return some(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(option, defaultValue)`\n * - Data-last: `pipe(option, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Option is none\n * @returns The unwrapped value in data-first form, or a function that unwraps an Option with a default in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOr(input, 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOr(0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOr: OptionUnwrapOr = dual(\n  2,\n  <T>(option: OptionType<T>, defaultValue: NoInfer<T>): T => (option._tag === \"Some\" ? option.value : defaultValue),\n)\n\n/**\n * Get the value or compute a value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(option, fn)`\n * - Data-last: `pipe(option, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value\n * @returns The unwrapped value in data-first form, or a function that unwraps an Option lazily in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOrElse(input, () => 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOrElse(() => 0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOrElse: OptionUnwrapOrElse = dual(\n  2,\n  <T>(option: OptionType<T>, fn: () => T): T => (option._tag === \"Some\" ? option.value : fn()),\n)\n\n/**\n * Pattern match on an Option, handling both some and none cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(option, { Some: ..., None: ... })`\n * - Data-last: `pipe(option, match({ Some: ..., None: ... }))`\n *\n * @param handlers - Object with `Some` and `None` handlers\n * @returns The handler result in data-first form, or a function that matches an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.match(input, {\n *   Some: (value) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })\n * // => \"some:2\"\n *\n * const dataLast = Option.match({\n *   Some: (value: number) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })(input)\n * // => \"some:2\"\n * ```\n */\nexport const match: OptionMatch = dual(\n  2,\n  <T, U>(option: OptionType<T>, handlers: { Some: (value: T) => U; None: () => U }): U =>\n    option._tag === \"Some\" ? handlers.Some(option.value) : handlers.None(),\n)\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a nullable value to an Option.\n * `null` and `undefined` become `Option.none()`, other values become `Option.some(value)`.\n * The return type narrows to `Option<NonNullable<T>>`.\n *\n * @param value - The value to convert\n * @returns An Option\n *\n * @example\n * ```ts\n * fromNullable(42) // { _tag: \"Some\", value: 42 }\n * fromNullable(null) // { _tag: \"None\" }\n * fromNullable(undefined) // { _tag: \"None\" }\n *\n * const maybeName = \"Alice\" as string | undefined\n * const option = fromNullable(maybeName) // Option<string>\n * ```\n */\nconst isNonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined\n\n/**\n * fromNullable utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.fromNullable(\"Ada\")\n * // => { _tag: \"Some\", value: \"Ada\" }\n * ```\n */\nexport const fromNullable = <T>(value: T): OptionType<NonNullable<T>> => (isNonNullable(value) ? some(value) : none())\n\n/**\n * Wrap a function that might throw into an Option.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Option<unknown>> | Option<any>` that won't work\n * with Option utilities like `isSome` or `isNone`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns An Option with the return value or none\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const parsed = Option.fromTry(() => Number.parseInt(\"42\", 10))\n * // => { _tag: \"Some\", value: 42 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return Promise.resolve(result)\n        .then(some)\n        .catch(() => none()) as unknown as FromTryReturn<T>\n    }\n    return some(result) as unknown as FromTryReturn<T>\n  } catch {\n    return none() as unknown as FromTryReturn<T>\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"qeA0DA,MAAa,EAAqBA,EA8CrB,EAAW,IAA6B,CACnD,KAAM,OACN,SACC,GAAW,CACV,OAAU,EACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EAEN,EAAE,OAAO,WAAuD,CAC9D,OAAO,GAEV,EAeY,OAAwC,CACnD,KAAM,QACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EACN,EAAE,OAAO,WAA2D,CAElE,MADA,MAAM,IAAI,EACA,MAAM,iEAAiE,EAEpF,EAoBY,EAAa,GACxB,EAAO,OAAS,OAaL,EAAa,GACxB,EAAO,OAAS,OAkCL,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAS,EAAG,EAAO,MAAM,CAI/B,OAHI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAAK,EAAK,CAEpC,EAAK,EAAO,EACnB,CA+BW,EAAyB,EAAK,GAAI,EAA6B,IAC1E,EAAO,OAAS,OAAS,EAAG,EAAO,MAAM,CAAG,EAC7C,CAoCY,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAa,EAAG,EAAO,MAAM,CAInC,OAHI,EAAU,EAAW,CAChB,QAAQ,QAAQ,EAAW,CAAC,SAAW,EAAO,CAEhD,GACP,CA+BW,EAAuB,EAAK,GAAI,EAA6B,IACxE,EAAO,OAAS,OAAS,EAAS,GAAI,CACvC,CA0BY,EAAuB,EAAK,GAAI,EAA6B,IACpE,EAAO,OAAS,QACb,EAAU,EAAO,MAAM,CADK,EACO,GAAM,CAChD,CAyBW,EAAkB,GAAsB,CACnD,GAAI,MAAM,QAAQ,EAAQ,CAAE,CAC1B,IAAMC,EAAoB,EAAE,CAC5B,IAAK,IAAM,KAAU,EAAS,CAC5B,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,EAAO,KAAK,EAAO,MAAM,CAE3B,OAAO,EAAKA,EAAO,CAGrB,IAAM,EAAkC,EAAE,CAC1C,IAAK,GAAM,CAAC,EAAK,KAAW,OAAO,QAAQ,EAAQ,CAAE,CACnD,IAAM,EAAI,EACV,GAAI,EAAE,OAAS,OAAQ,OAAO,EAC9B,EAAO,GAAO,EAAE,MAElB,OAAO,EAAK,EAAO,EAgCR,EAA2B,EACtC,GACI,EAAuB,IAAiC,EAAO,OAAS,OAAS,EAAO,MAAQ,EACrG,CAwBY,EAAmC,EAC9C,GACI,EAAuB,IAAoB,EAAO,OAAS,OAAS,EAAO,MAAQ,GAAI,CAC5F,CA8BY,EAAqB,EAChC,GACO,EAAuB,IAC5B,EAAO,OAAS,OAAS,EAAS,KAAK,EAAO,MAAM,CAAG,EAAS,MAAM,CACzE,CAwBK,EAAoB,GAAsC,GAAU,KAa7D,EAAmB,GAA0C,EAAc,EAAM,CAAG,EAAK,EAAM,CAAG,GAAM,CA2BxG,EAAc,GAAkC,CAC3D,GAAI,CACF,IAAM,EAAS,GAAI,CAMnB,OALI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAC3B,KAAK,EAAK,CACV,UAAY,GAAM,CAAC,CAEjB,EAAK,EAAO,MACb,CACN,OAAO,GAAM"}
+{"version":3,"file":"option-BlyP5LA2.mjs","names":["NoSuchElementErrorCtor","values"],"sources":["../src/option/option.ts"],"sourcesContent":["/**\n * Optional value primitives for modeling presence (`Some`) and absence (`None`).\n *\n * **Mental model**\n * - `Option<A>` is either a value or no value.\n * - Prefer `Option` when missing data is expected and not exceptional.\n *\n * **Common tasks**\n * - Construct with `Option.some`, `Option.none`, `Option.fromNullable`.\n * - Transform with `Option.map`, `Option.flatMap`, `Option.filter`.\n * - Extract with `Option.unwrapOr`, `Option.match`.\n *\n * **Gotchas**\n * - `Option.none` short-circuits in `Fx.gen`.\n * - Use `Option.match` for exhaustive branch handling.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const name = Option.fromNullable(\"Ada\")\n * const upper = Option.map(name, (value) => value.toUpperCase())\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeable } from \"../shared/pipeable\"\nimport { NoSuchElementError as NoSuchElementErrorCtor } from \"./option.types\"\nimport type {\n  Option as OptionType,\n  OptionAll,\n  OptionFlatMap,\n  OptionMap,\n  OptionMatch,\n  OptionTap,\n  OptionOrElse,\n  OptionFilter,\n  OptionUnwrapOr,\n  OptionUnwrapOrElse,\n  FromTryReturn,\n} from \"./option.types\"\n\n/**\n * Re-exported error type used when yielding `Option.none()` in `Fx.gen`.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const error = new Option.NoSuchElementError()\n * // => error.name === \"NoSuchElementError\"\n * ```\n */\nexport const NoSuchElementError = NoSuchElementErrorCtor\n\n/**\n * Re-exported `NoSuchElementError` instance type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.NoSuchElementError\n * ```\n */\nexport type NoSuchElementError = InstanceType<typeof NoSuchElementErrorCtor>\n\n/**\n * Re-exported `Option` type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.Option<unknown>\n * ```\n */\nexport type Option<T> = OptionType<T>\n\n/* oxlint-disable no-unsafe-type-assertion -- Option runtime values carry erased Fx phantom channels that require explicit marker assertions. */\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create an Option with a value.\n *\n * @param value - The value to wrap\n * @returns An Option with `_tag: \"Some\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.some(42)\n * // => { _tag: \"Some\", value: 42 }\n * ```\n */\nexport const some = <T>(value: T): OptionType<T> => ({\n  _tag: \"Some\",\n  value,\n  [FxTypeId]: {\n    _A: () => value,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  pipe: pipeable,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<NoSuchElementError, T, unknown> {\n    return value\n  },\n})\n\n/**\n * Create an Option with no value.\n *\n * @returns An Option with `_tag: \"None\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.none<number>()\n * // => { _tag: \"None\" }\n * ```\n */\nexport const none = <T = never>(): OptionType<T> => ({\n  _tag: \"None\",\n  [FxTypeId]: {\n    _A: () => undefined as never,\n    _E: () => undefined as unknown as NoSuchElementError,\n    _R: () => undefined as never,\n  },\n  pipe: pipeable,\n  *[Symbol.iterator](): Generator<NoSuchElementError, never, unknown> {\n    yield new NoSuchElementError()\n    throw new Error(\"Unreachable: Fx.gen should short-circuit on NoSuchElementError\")\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if an Option has a value.\n *\n * @param option - The Option to check\n * @returns true if the Option is some\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isSome(Option.some(1))\n * // => true\n * ```\n */\nexport const isSome = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"Some\" }> =>\n  option._tag === \"Some\"\n\n/**\n * isNone utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isNone(Option.none())\n * // => true\n * ```\n */\nexport const isNone = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"None\" }> =>\n  option._tag === \"None\"\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the value of an Option.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(option, fn)`\n * - Data-last: `pipe(option, map(fn))`\n *\n * Supports both sync and async callbacks:\n * - Sync fn: returns U\n * - Async fn: returns Promise<U>\n *\n * @param fn - Function that transforms the contained value\n * @returns The mapped Option in data-first form, or a function that maps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.map(input, (n) => n + 1)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.map((n: number) => n + 1)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: OptionMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const mapped = fn(option.value)\n  if (isPromise(mapped)) {\n    return Promise.resolve(mapped).then(some) as any\n  }\n  return some(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Options.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(option, fn)`\n * - Data-last: `pipe(option, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that takes a value and returns an Option (or Promise<Option>)\n * @returns The resulting Option in data-first form, or a function that flatMaps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.flatMap(input, (n) => Option.some(n + 1))\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.flatMap((n: number) => Option.some(n + 1))(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: OptionFlatMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) =>\n  option._tag === \"Some\" ? fn(option.value) : option,\n)\n\n/**\n * Perform a side effect on the value without modifying the Option.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Option is none, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(option, fn)`\n * - Data-last: `pipe(option, tap(fn))`\n *\n * Supports both sync and async side effects:\n * - Sync fn: returns any value (ignored)\n * - Async fn: returns Promise<unknown>\n *\n * @param fn - Function to call with the value (return value is ignored)\n * @returns The original Option in data-first form, or a function that taps an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * let seen = 0\n * const input = Option.some(2)\n * const dataFirst = Option.tap(input, (n) => {\n *   seen = n\n * })\n * // => { _tag: \"Some\", value: 2 }\n *\n * const dataLast = Option.tap((n: number) => {\n *   seen = n\n * })(input)\n * // => { _tag: \"Some\", value: 2 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: OptionTap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const sideEffect = fn(option.value)\n  if (isPromise(sideEffect)) {\n    return Promise.resolve(sideEffect).then(() => option) as any\n  }\n  return option as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from none by providing an alternative Option.\n * If the Option is some, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(option, fn)`\n * - Data-last: `pipe(option, orElse(fn))`\n *\n * Supports both sync and async fallback functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that returns an alternative Option\n * @returns The original or fallback Option in data-first form, or a function that recovers from none in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.orElse(input, () => Option.some(0))\n * // => { _tag: \"Some\", value: 0 }\n *\n * const dataLast = Option.orElse(() => Option.some(0))(input)\n * // => { _tag: \"Some\", value: 0 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: OptionOrElse = dual(2, (option: OptionType<unknown>, fn: () => unknown) =>\n  option._tag === \"Some\" ? option : fn(),\n)\n\n/**\n * Filter an Option based on a predicate.\n * If the predicate returns false, converts to none.\n * If the Option is already none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(option, predicate)`\n * - Data-last: `pipe(option, filter(predicate))`\n *\n * @param predicate - Function that returns true to keep the value\n * @returns The filtered Option in data-first form, or a function that filters an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(3)\n * const dataFirst = Option.filter(input, (n) => n > 0)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.filter((n: number) => n > 0)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n */\nexport const filter: OptionFilter = dual(2, (option: OptionType<unknown>, predicate: (value: unknown) => boolean) => {\n  if (option._tag === \"None\") return option\n  return predicate(option.value) ? option : none()\n})\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Options into a single Option.\n * Supports both array and object inputs.\n *\n * - If all Options are some, returns some with all values\n * - If any Option is none, returns none (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const combined = Option.all([Option.some(1), Option.some(2)] as const)\n * // => { _tag: \"Some\", value: [1, 2] }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: OptionAll = (options: any): any => {\n  if (Array.isArray(options)) {\n    const values: unknown[] = []\n    for (const option of options) {\n      if (option._tag === \"None\") return option\n      values.push(option.value)\n    }\n    return some(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, option] of Object.entries(options)) {\n    const o = option as OptionType<unknown>\n    if (o._tag === \"None\") return option\n    values[key] = o.value\n  }\n  return some(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(option, defaultValue)`\n * - Data-last: `pipe(option, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Option is none\n * @returns The unwrapped value in data-first form, or a function that unwraps an Option with a default in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOr(input, 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOr(0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOr: OptionUnwrapOr = dual(\n  2,\n  <T>(option: OptionType<T>, defaultValue: NoInfer<T>): T => (option._tag === \"Some\" ? option.value : defaultValue),\n)\n\n/**\n * Get the value or compute a value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(option, fn)`\n * - Data-last: `pipe(option, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value\n * @returns The unwrapped value in data-first form, or a function that unwraps an Option lazily in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOrElse(input, () => 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOrElse(() => 0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOrElse: OptionUnwrapOrElse = dual(\n  2,\n  <T>(option: OptionType<T>, fn: () => T): T => (option._tag === \"Some\" ? option.value : fn()),\n)\n\n/**\n * Pattern match on an Option, handling both some and none cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(option, { Some: ..., None: ... })`\n * - Data-last: `pipe(option, match({ Some: ..., None: ... }))`\n *\n * @param handlers - Object with `Some` and `None` handlers\n * @returns The handler result in data-first form, or a function that matches an Option in data-last form\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.match(input, {\n *   Some: (value) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })\n * // => \"some:2\"\n *\n * const dataLast = Option.match({\n *   Some: (value: number) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })(input)\n * // => \"some:2\"\n * ```\n */\nexport const match: OptionMatch = dual(\n  2,\n  <T, U>(option: OptionType<T>, handlers: { Some: (value: T) => U; None: () => U }): U =>\n    option._tag === \"Some\" ? handlers.Some(option.value) : handlers.None(),\n)\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a nullable value to an Option.\n * `null` and `undefined` become `Option.none()`, other values become `Option.some(value)`.\n * The return type narrows to `Option<NonNullable<T>>`.\n *\n * @param value - The value to convert\n * @returns An Option\n *\n * @example\n * ```ts\n * fromNullable(42) // { _tag: \"Some\", value: 42 }\n * fromNullable(null) // { _tag: \"None\" }\n * fromNullable(undefined) // { _tag: \"None\" }\n *\n * const maybeName = \"Alice\" as string | undefined\n * const option = fromNullable(maybeName) // Option<string>\n * ```\n */\nconst isNonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined\n\n/**\n * fromNullable utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.fromNullable(\"Ada\")\n * // => { _tag: \"Some\", value: \"Ada\" }\n * ```\n */\nexport const fromNullable = <T>(value: T): OptionType<NonNullable<T>> => (isNonNullable(value) ? some(value) : none())\n\n/**\n * Wrap a function that might throw into an Option.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Option<unknown>> | Option<any>` that won't work\n * with Option utilities like `isSome` or `isNone`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns An Option with the return value or none\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const parsed = Option.fromTry(() => Number.parseInt(\"42\", 10))\n * // => { _tag: \"Some\", value: 42 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return Promise.resolve(result)\n        .then(some)\n        .catch(() => none()) as unknown as FromTryReturn<T>\n    }\n    return some(result) as unknown as FromTryReturn<T>\n  } catch {\n    return none() as unknown as FromTryReturn<T>\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"qeA0DA,MAAa,EAAqBA,EA8CrB,EAAW,IAA6B,CACnD,KAAM,OACN,SACC,GAAW,CACV,OAAU,EACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EAEN,EAAE,OAAO,WAAuD,CAC9D,OAAO,GAEV,EAeY,OAAwC,CACnD,KAAM,QACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EACN,EAAE,OAAO,WAA2D,CAElE,MADA,MAAM,IAAI,EACA,MAAM,iEAAiE,EAEpF,EAoBY,EAAa,GACxB,EAAO,OAAS,OAaL,EAAa,GACxB,EAAO,OAAS,OAkCL,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAS,EAAG,EAAO,MAAM,CAI/B,OAHI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAAK,EAAK,CAEpC,EAAK,EAAO,EACnB,CA+BW,EAAyB,EAAK,GAAI,EAA6B,IAC1E,EAAO,OAAS,OAAS,EAAG,EAAO,MAAM,CAAG,EAC7C,CAoCY,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAa,EAAG,EAAO,MAAM,CAInC,OAHI,EAAU,EAAW,CAChB,QAAQ,QAAQ,EAAW,CAAC,SAAW,EAAO,CAEhD,GACP,CA+BW,EAAuB,EAAK,GAAI,EAA6B,IACxE,EAAO,OAAS,OAAS,EAAS,GAAI,CACvC,CA0BY,EAAuB,EAAK,GAAI,EAA6B,IACpE,EAAO,OAAS,QACb,EAAU,EAAO,MAAM,CADK,EACO,GAAM,CAChD,CAyBW,EAAkB,GAAsB,CACnD,GAAI,MAAM,QAAQ,EAAQ,CAAE,CAC1B,IAAMC,EAAoB,EAAE,CAC5B,IAAK,IAAM,KAAU,EAAS,CAC5B,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,EAAO,KAAK,EAAO,MAAM,CAE3B,OAAO,EAAKA,EAAO,CAGrB,IAAM,EAAkC,EAAE,CAC1C,IAAK,GAAM,CAAC,EAAK,KAAW,OAAO,QAAQ,EAAQ,CAAE,CACnD,IAAM,EAAI,EACV,GAAI,EAAE,OAAS,OAAQ,OAAO,EAC9B,EAAO,GAAO,EAAE,MAElB,OAAO,EAAK,EAAO,EAgCR,EAA2B,EACtC,GACI,EAAuB,IAAiC,EAAO,OAAS,OAAS,EAAO,MAAQ,EACrG,CAwBY,EAAmC,EAC9C,GACI,EAAuB,IAAoB,EAAO,OAAS,OAAS,EAAO,MAAQ,GAAI,CAC5F,CA8BY,EAAqB,EAChC,GACO,EAAuB,IAC5B,EAAO,OAAS,OAAS,EAAS,KAAK,EAAO,MAAM,CAAG,EAAS,MAAM,CACzE,CAwBK,EAAoB,GAAsC,GAAU,KAa7D,EAAmB,GAA0C,EAAc,EAAM,CAAG,EAAK,EAAM,CAAG,GAAM,CA2BxG,EAAc,GAAkC,CAC3D,GAAI,CACF,IAAM,EAAS,GAAI,CAMnB,OALI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAC3B,KAAK,EAAK,CACV,UAAY,GAAM,CAAC,CAEjB,EAAK,EAAO,MACb,CACN,OAAO,GAAM"}

package/dist/{option.types-D9hrKcfa.d.mts → option.types-Po1qwxiW.d.mts}

@@ -1,5 +1,5 @@
-import { i as Fx } from "./fx.types-BdN1EWxr.mjs";
-import { t as Pipeable } from "./pipeable-BIrevC0D.mjs";
+import { i as Fx } from "./fx.types-CpFKa-Jj.mjs";
+import { t as Pipeable } from "./pipeable-BY9yPsNK.mjs";
 
 //#region src/option/option.types.d.ts
 
@@ -154,4 +154,4 @@ type OptionMatch = {
 };
 //#endregion
 export { OptionFilter as a, OptionMatch as c, OptionUnwrapOr as d, OptionUnwrapOrElse as f, OptionAll as i, OptionOrElse as l, NoSuchElementError as n, OptionFlatMap as o, Option as r, OptionMap as s, FromTryReturn as t, OptionTap as u };
-//# sourceMappingURL=option.types-D9hrKcfa.d.mts.map
+//# sourceMappingURL=option.types-Po1qwxiW.d.mts.map

package/dist/{option.types-D9hrKcfa.d.mts.map → option.types-Po1qwxiW.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"option.types-D9hrKcfa.d.mts","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkBA;AAOC;AAWkB;AA0BnB;;;;AACK,cA7CQ,kBAAA,SAA2B,KAAA,CA6CnC;EAAG,SAAA,IAAA,GAAA,oBAAA;EAAN,WAAA,CAAA;;;;;KA7BG,IA+B6B,CAAA,CAAA,CAAA,GAAA;EAQtB,SAAA,IAAA,EAAA,MAAa;EAAM,SAAA,KAAA,EArCb,CAqCa;CAAU;;;;KA/BpC,IAAA,GA+BmF;EAAP,SAAA,IAAA,EAAA,MAAA;CAAM;AAAG;AAgB1F;;;;;;;;;;;AAGoD,KA9BxC,MA8BwC,CAAA,CAAA,CAAA,GAAA,CA9B3B,IA8B2B,CA9BtB,CA8BsB,CAAA,GA9BjB,IA8BiB,CAAA,GA7BlD,EA6BkD,CA7B/C,CA6B+C,EA7B5C,kBA6B4C,CAAA,GA5BlD,QA4BkD,GAAA;EACd,CAAA,MAAA,CAAA,QAAA,GAAA,EA5Bb,SA4Ba,CA5BH,kBA4BG,EA5BiB,CA4BjB,EAAA,OAAA,CAAA;CAAP;;;;;;AAA8C,KApBjE,aAoBiE,CAAA,CAAA,CAAA,GApB9C,CAoB8C,SApBpC,OAoBoC,CAAA,KAAA,EAAA,CAAA,GApBjB,OAoBiB,CApBT,MAoBS,CApBF,CAoBE,CAAA,CAAA,GApBI,MAoBJ,CApBW,CAoBX,CAAA;;;;;KAVxE,WAW+C,CAAA,CAAA,CAAA,GAX9B,CAW8B,SAAA;EAAP,SAAA,IAAA,EAAA,MAAA;EAAkB,SAAA,KAAA,EAAA,KAAA,EAAA;CAAP,GAAA,CAAA,GAAA,KAAA;;;;;AAAsC,KALlF,SAAA,GAKkF;EAAG,CAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CAHxE,MAGwE,CAHjE,CAGiE,CAAA,CAAA,CAAA,EAH3D,MAG2D,CAAA,CAHnD,CAGmD,CAAA,CAAA;EAAjB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CAFpD,MAEoD,CAF7C,CAE6C,CAAA,EAFzC,MAEyC,CAFlC,CAEkC,CAAA,CAAA,CAAA,EAF5B,MAE4B,CAAA,CAFpB,CAEoB,EAFjB,CAEiB,CAAA,CAAA;EACpC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CAFb,MAEa,CAFN,CAEM,CAAA,EAFF,MAEE,CAFK,CAEL,CAAA,EAFS,MAET,CAFgB,CAEhB,CAAA,CAAA,CAAA,EAFsB,MAEtB,CAAA,CAF8B,CAE9B,EAFiC,CAEjC,EAFoC,CAEpC,CAAA,CAAA;EAAP,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CADH,MACG,CADI,CACJ,CAAA,EADQ,MACR,CADe,CACf,CAAA,EADmB,MACnB,CAD0B,CAC1B,CAAA,EAD8B,MAC9B,CADqC,CACrC,CAAA,CAAA,CAAA,EAD2C,MAC3C,CAAA,CADmD,CACnD,EADsD,CACtD,EADyD,CACzD,EAD4D,CAC5D,CAAA,CAAA;EAAkB,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CAAlB,MAAkB,CAAX,CAAW,CAAA,EAAP,MAAO,CAAA,CAAA,CAAA,EAAI,MAAJ,CAAW,CAAX,CAAA,EAAe,MAAf,CAAsB,CAAtB,CAAA,EAA0B,MAA1B,CAAiC,CAAjC,CAAA,CAAA,CAAA,EAAuC,MAAvC,CAAA,CAA+C,CAA/C,EAAkD,CAAlD,EAAqD,CAArD,EAAwD,CAAxD,EAA2D,CAA3D,CAAA,CAAA;EAAP,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,OAAA,EAAA,SAAA,CAEzB,MAFyB,CAElB,CAFkB,CAAA,EAEd,MAFc,CAEP,CAFO,CAAA,EAEH,MAFG,CAEI,CAFJ,CAAA,EAEQ,MAFR,CAEe,CAFf,CAAA,EAEmB,MAFnB,CAE0B,CAF1B,CAAA,EAE8B,MAF9B,CAEqC,CAFrC,CAAA,CAAA,CAAA,EAG3C,MAH2C,CAAA,CAGnC,CAHmC,EAGhC,CAHgC,EAG7B,CAH6B,EAG1B,CAH0B,EAGvB,CAHuB,EAGpB,CAHoB,CAAA,CAAA;EAAkB,CAAA,UAAA,SAM5C,MAN4C,CAAA,OAAA,CAAA,EAAA,CAAA,CAAA,OAAA,EAMhB,CANgB,CAAA,EAMZ,MANY,CAAA,kBAAP,MAM0B,CAN1B,GAM8B,WAN9B,CAM0C,CAN1C,CAM4C,CAN5C,CAAA,CAAA,EAAkB,CAAA;EAAP,CAAA,UASzD,MATyD,CAAA,MAAA,EAS1C,MAT0C,CAAA,OAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EASf,CATe,CAAA,EASX,MATW,CAAA,kBAAkB,MASE,CATF,GASM,WATN,CASkB,CATlB,CASoB,CATpB,CAAA,CAAA,EAAP,CAAA;CAAqB;;;;;;AAExE,KAmBlB,aAAA,GAnBkB;EAAP,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAqBN,MArBM,CAqBC,CArBD,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EAqBiB,CArBjB,EAAA,GAqBuB,OArBvB,CAqB+B,MArB/B,CAqBsC,CArBtC,CAAA,CAAA,CAAA,EAqB4C,OArB5C,CAqBoD,MArBpD,CAqB2D,CArB3D,CAAA,CAAA;EAAkB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAsBxB,MAtBwB,CAsBjB,CAtBiB,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EAsBD,CAtBC,EAAA,GAsBK,MAtBL,CAsBY,CAtBZ,CAAA,CAAA,EAsBiB,MAtBjB,CAsBwB,CAtBxB,CAAA;EAAP,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAwBb,CAxBa,EAAA,GAwBP,OAxBO,CAwBC,MAxBD,CAwBQ,CAxBR,CAAA,CAAA,CAAA,EAAA,CAAA,MAAA,EAwBuB,MAxBvB,CAwB8B,CAxB9B,CAAA,EAAA,GAwBqC,OAxBrC,CAwB6C,MAxB7C,CAwBoD,CAxBpD,CAAA,CAAA;EAAkB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAyB/B,CAzB+B,EAAA,GAyBzB,MAzByB,CAyBlB,CAzBkB,CAAA,CAAA,EAAA,CAAA,MAAA,EAyBJ,MAzBI,CAyBG,CAzBH,CAAA,EAAA,GAyBU,MAzBV,CAyBiB,CAzBjB,CAAA;CAAP;;;;;;AAAiC,KAiClE,SAAA,GAjCkE;EACjE,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAkCI,MAlCJ,CAkCW,CAlCX,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EAkC2B,CAlC3B,EAAA,GAkCiC,OAlCjC,CAkCyC,CAlCzC,CAAA,CAAA,EAkC8C,OAlC9C,CAkCsD,MAlCtD,CAkC6D,CAlC7D,CAAA,CAAA;EAAG,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAmCC,MAnCD,CAmCQ,CAnCR,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EAmCwB,CAnCxB,EAAA,GAmC8B,CAnC9B,CAAA,EAmCkC,MAnClC,CAmCyC,CAnCzC,CAAA;EAAG,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAqCE,CArCF,EAAA,GAqCQ,OArCR,CAqCgB,CArChB,CAAA,CAAA,EAAA,CAAA,MAAA,EAqC8B,MArC9B,CAqCqC,CArCrC,CAAA,EAAA,GAqC4C,OArC5C,CAqCoD,MArCpD,CAqC2D,CArC3D,CAAA,CAAA;EAAG,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAsCD,CAtCC,EAAA,GAsCK,CAtCL,CAAA,EAAA,CAAA,MAAA,EAsCkB,MAtClB,CAsCyB,CAtCzB,CAAA,EAAA,GAsCgC,MAtChC,CAsCuC,CAtCvC,CAAA;CAAG;;;;;AAG4D,KA4CzE,SAAA,GA5CyE;EAAgB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EA8CpF,MA9CoF,CA8C7E,CA9C6E,CAAA,EAAA,EAAA,EAAA,CAAA,KAAA,EA8C7D,CA9C6D,EAAA,GA8CvD,CA9CuD,CAAA,EA8CnD,CA9CmD,SA8CzC,OA9CyC,CAAA,OAAA,CAAA,GA8CtB,OA9CsB,CA8Cd,MA9Cc,CA8CP,CA9CO,CAAA,CAAA,GA8CD,MA9CC,CA8CM,CA9CN,CAAA;EAAE,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAgDlF,CAhDkF,EAAA,GAgD5E,CAhD4E,CAAA,EAAA,CAAA,MAAA,EAgD/D,MAhD+D,CAgDxD,CAhDwD,CAAA,EAAA,GAgDjD,CAhDiD,SAgDvC,OAhDuC,CAAA,OAAA,CAAA,GAgDpB,OAhDoB,CAgDZ,MAhDY,CAgDL,CAhDK,CAAA,CAAA,GAgDC,MAhDD,CAgDQ,CAhDR,CAAA;CAAd;;;;;;AAGiB,KAqD9F,YAAA,GArD8F;EAAE,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAuD3F,MAvD2F,CAuDpF,CAvDoF,CAAA,EAAA,EAAA,EAAA,GAAA,GAuDtE,OAvDsE,CAuD9D,MAvD8D,CAuDvD,CAvDuD,CAAA,CAAA,CAAA,EAuDjD,OAvDiD,CAuDzC,MAvDyC,CAuDlC,CAvDkC,GAuD9B,CAvD8B,CAAA,CAAA;EAAd,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAwD7E,MAxD6E,CAwDtE,CAxDsE,CAAA,EAAA,EAAA,EAAA,GAAA,GAwDxD,MAxDwD,CAwDjD,CAxDiD,CAAA,CAAA,EAwD5C,MAxD4C,CAwDrC,CAxDqC,GAwDjC,CAxDiC,CAAA;EAAnC,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GA0DxC,OA1DwC,CA0DhC,MA1DgC,CA0DzB,CA1DyB,CAAA,CAAA,CAAA,EAAA,CAAA,MAAA,EA0DV,MA1DU,CA0DH,CA1DG,CAAA,EAAA,GA0DI,OA1DJ,CA0DY,MA1DZ,CA0DmB,CA1DnB,GA0DuB,CA1DvB,CAAA,CAAA;EAAM,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GA2D9C,MA3D8C,CA2DvC,CA3DuC,CAAA,CAAA,EAAA,CAAA,MAAA,EA2DzB,MA3DyB,CA2DlB,CA3DkB,CAAA,EAAA,GA2DX,MA3DW,CA2DJ,CA3DI,GA2DA,CA3DA,CAAA;AAYjE,CAAA;;;;;AAEsD,KAoD1C,YAAA,GApD0C;EAAR,CAAA,CAAA,CAAA,CAAA,MAAA,EAsDhC,MAtDgC,CAsDzB,CAtDyB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAsDF,CAtDE,EAAA,GAAA,OAAA,CAAA,EAsDc,MAtDd,CAsDqB,CAtDrB,CAAA;EAAoC,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAwDzD,CAxDyD,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,MAAA,EAwDhC,MAxDgC,CAwDzB,CAxDyB,CAAA,EAAA,GAwDlB,MAxDkB,CAwDX,CAxDW,CAAA;CAAP;;;;;;AAC7B,KA+DlC,cAAA,GA/DkC;EAAmB,CAAA,CAAA,CAAA,CAAA,MAAA,EAiEnD,MAjEmD,CAiE5C,CAjE4C,CAAA,EAAA,YAAA,EAiE1B,OAjE0B,CAiElB,CAjEkB,CAAA,CAAA,EAiEb,CAjEa;EAAP,CAAA,CAAA,CAAA,CAAA,YAAA,EAmEtC,OAnEsC,CAmE9B,CAnE8B,CAAA,CAAA,EAAA,CAAA,MAAA,EAmEhB,MAnEgB,CAmET,CAnES,CAAA,EAAA,GAmEF,CAnEE;CAErC;;;;;AAAoC,KAwE7C,kBAAA,GAxE6C;EAA6B,CAAA,CAAA,CAAA,CAAA,MAAA,EA0ExE,MA1EwE,CA0EjE,CA1EiE,CAAA,EAAA,EAAA,EAAA,GAAA,GA0EnD,CA1EmD,CAAA,EA0E/C,CA1E+C;EAAP,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GA4E/D,CA5E+D,CAAA,EAAA,CAAA,MAAA,EA4ElD,MA5EkD,CA4E3C,CA5E2C,CAAA,EAAA,GA4EpC,CA5EoC;CAAR;;;;;AACvB,KAkFpC,WAAA,GAlFoC;EAAqB,CAAA,CAAA,EAAA,GAAA,CAAA,CAAA,MAAA,EAoFpD,MApFoD,CAoF7C,CApF6C,CAAA,EAAA,QAAA,EAAA;IAAP,IAAA,EAAA,CAAA,KAAA,EAoFR,CApFQ,EAAA,GAoFF,GApFE;IAAM,IAAA,EAAA,GAAA,GAoFO,GApFP;EAQxD,CAAA,CAAA,EA4EqE,GA5ErE;EAEY,CAAA,CAAA,EAAA,GAAA,CAAA,CAAA,QAAA,EAAA;IAAP,IAAA,EAAA,CAAA,KAAA,EA4EkB,CA5ElB,EAAA,GA4EwB,GA5ExB;IAAuB,IAAA,EAAA,GAAA,GA4EgB,GA5EhB;EAAc,CAAA,CAAA,EAAA,CAAA,MAAA,EA4EiB,MA5EjB,CA4EwB,CA5ExB,CAAA,EAAA,GA4E+B,GA5E/B;CAAR"}
+{"version":3,"file":"option.types-Po1qwxiW.d.mts","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{option.types-CbY_swma.mjs → option.types-bFFSErJ-.mjs}

@@ -1,2 +1,2 @@
 var e=class extends Error{_tag=`NoSuchElementError`;constructor(){super(`Option is None - no element present`),this.name=`NoSuchElementError`}};export{e as t};
-//# sourceMappingURL=option.types-CbY_swma.mjs.map
+//# sourceMappingURL=option.types-bFFSErJ-.mjs.map

package/dist/{option.types-CbY_swma.mjs.map → option.types-bFFSErJ-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"option.types-CbY_swma.mjs","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":["import type { Fx } from \"../fx/fx.types\"\nimport type { Pipeable } from \"../shared/pipeable\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Option types expose Fx phantom channels through compile-time-only marker fields. */\n\n// ============================================================================\n// NoSuchElementError\n// ============================================================================\n\n/**\n * Error thrown when attempting to access a value from None.\n * Used as the error type when Option is yielded in Fx.gen().\n *\n * When you yield* Option.none() in Fx.gen(), the computation short-circuits\n * with this error, which becomes part of the error union type.\n *\n * This is the typed error channel for `Option.none()` in Fx computations.\n */\nexport class NoSuchElementError extends Error {\n  readonly _tag = \"NoSuchElementError\"\n\n  constructor() {\n    super(\"Option is None - no element present\")\n    this.name = \"NoSuchElementError\"\n  }\n}\n\n// ============================================================================\n// Option Variant Types\n// ============================================================================\n\n/**\n * Represents an Option with a value.\n */\ntype Some<T> = {\n  readonly _tag: \"Some\"\n  readonly value: T\n}\n\n/**\n * Represents an Option with no value.\n */\ntype None = {\n  readonly _tag: \"None\"\n}\n\n// ============================================================================\n// Option Type\n// ============================================================================\n\n/**\n * A discriminated union representing either a value (Some) or absence (None).\n * Uses _tag discriminator for unified API compatibility.\n * Compatible with ts-pattern for exhaustive matching.\n *\n * Implements Fx protocol: Option<T> is Fx<T, NoSuchElementError, never>\n * - Yielding Some in Fx.gen() returns the value\n * - Yielding None in Fx.gen() short-circuits with NoSuchElementError\n *\n * When yielded in a generator, yields NoSuchElementError\n * for proper type inference in both gen() and Fx.gen().\n */\nexport type Option<T> = (Some<T> | None) &\n  Fx<T, NoSuchElementError> &\n  Pipeable & {\n    [Symbol.iterator](): Generator<NoSuchElementError, T, unknown>\n  }\n\n/**\n * Compute the return type of `fromTry` based on whether fn returns a Promise.\n * - If fn returns Promise<T>, result is Promise<Option<T>>\n * - If fn returns T, result is Option<T>\n */\nexport type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>\n\n// ============================================================================\n// All/Combine types\n// ============================================================================\n\n/**\n * Extract the value type from an Option.\n * Uses structural matching to extract the value type from the Some branch.\n */\ntype OptionValue<O> = O extends { readonly _tag: \"Some\"; readonly value: infer T } ? T : never\n\n/**\n * Overloaded all() type with explicit tuple arities for better inference.\n * Provides tuple overloads for 1-6 elements so `as const` is not required.\n */\nexport type OptionAll = {\n  // Tuple overloads (1-6 elements)\n  <A>(options: readonly [Option<A>]): Option<[A]>\n  <A, B>(options: readonly [Option<A>, Option<B>]): Option<[A, B]>\n  <A, B, C>(options: readonly [Option<A>, Option<B>, Option<C>]): Option<[A, B, C]>\n  <A, B, C, D>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>]): Option<[A, B, C, D]>\n  <A, B, C, D, E>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>]): Option<[A, B, C, D, E]>\n  <A, B, C, D, E, F>(\n    options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>],\n  ): Option<[A, B, C, D, E, F]>\n\n  // Array fallback (longer tuples need `as const`)\n  <T extends readonly Option<unknown>[]>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n\n  // Object form\n  <T extends Record<string, Option<unknown>>>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n}\n\n// ============================================================================\n// Function Interfaces for improved pipe inference\n// ============================================================================\n\n/**\n * Interface for flatMap - using method syntax improves generic inference in pipe chains.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionFlatMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<Option<B>>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => Option<B>): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for map function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<B>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => B): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n\n/**\n * Interface for tap function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionTap = {\n  // Data-first overload\n  <A, R>(option: Option<A>, fn: (value: A) => R): R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n  // Data-last overload (curried for pipe)\n  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n}\n\n/**\n * Interface for orElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionOrElse = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: () => Promise<Option<B>>): Promise<Option<A | B>>\n  <A, B>(option: Option<A>, fn: () => Option<B>): Option<A | B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>\n  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>\n}\n\n/**\n * Interface for filter function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionFilter = {\n  // Data-first overload\n  <A>(option: Option<A>, predicate: (value: A) => boolean): Option<A>\n  // Data-last overload (curried for pipe)\n  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>\n}\n\n/**\n * Interface for unwrapOr function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Uses NoInfer to prevent type inference from the default value.\n */\nexport type OptionUnwrapOr = {\n  // Data-first overload\n  <T>(option: Option<T>, defaultValue: NoInfer<T>): T\n  // Data-last overload (curried for pipe)\n  <T>(defaultValue: NoInfer<T>): (option: Option<T>) => T\n}\n\n/**\n * Interface for unwrapOrElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionUnwrapOrElse = {\n  // Data-first overload\n  <T>(option: Option<T>, fn: () => T): T\n  // Data-last overload (curried for pipe)\n  <T>(fn: () => T): (option: Option<T>) => T\n}\n\n/**\n * Interface for match function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionMatch = {\n  // Data-first overload\n  <T, U>(option: Option<T>, handlers: { Some: (value: T) => U; None: () => U }): U\n  // Data-last overload (curried for pipe)\n  <T, U>(handlers: { Some: (value: T) => U; None: () => U }): (option: Option<T>) => U\n}\n"],"mappings":"AAkBA,IAAa,EAAb,cAAwC,KAAM,CAC5C,KAAgB,qBAEhB,aAAc,CACZ,MAAM,sCAAsC,CAC5C,KAAK,KAAO"}
+{"version":3,"file":"option.types-bFFSErJ-.mjs","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":["import type { Fx } from \"../fx/fx.types\"\nimport type { Pipeable } from \"../shared/pipeable\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Option types expose Fx phantom channels through compile-time-only marker fields. */\n\n// ============================================================================\n// NoSuchElementError\n// ============================================================================\n\n/**\n * Error thrown when attempting to access a value from None.\n * Used as the error type when Option is yielded in Fx.gen().\n *\n * When you yield* Option.none() in Fx.gen(), the computation short-circuits\n * with this error, which becomes part of the error union type.\n *\n * This is the typed error channel for `Option.none()` in Fx computations.\n */\nexport class NoSuchElementError extends Error {\n  readonly _tag = \"NoSuchElementError\"\n\n  constructor() {\n    super(\"Option is None - no element present\")\n    this.name = \"NoSuchElementError\"\n  }\n}\n\n// ============================================================================\n// Option Variant Types\n// ============================================================================\n\n/**\n * Represents an Option with a value.\n */\ntype Some<T> = {\n  readonly _tag: \"Some\"\n  readonly value: T\n}\n\n/**\n * Represents an Option with no value.\n */\ntype None = {\n  readonly _tag: \"None\"\n}\n\n// ============================================================================\n// Option Type\n// ============================================================================\n\n/**\n * A discriminated union representing either a value (Some) or absence (None).\n * Uses _tag discriminator for unified API compatibility.\n * Compatible with ts-pattern for exhaustive matching.\n *\n * Implements Fx protocol: Option<T> is Fx<T, NoSuchElementError, never>\n * - Yielding Some in Fx.gen() returns the value\n * - Yielding None in Fx.gen() short-circuits with NoSuchElementError\n *\n * When yielded in a generator, yields NoSuchElementError\n * for proper type inference in both gen() and Fx.gen().\n */\nexport type Option<T> = (Some<T> | None) &\n  Fx<T, NoSuchElementError> &\n  Pipeable & {\n    [Symbol.iterator](): Generator<NoSuchElementError, T, unknown>\n  }\n\n/**\n * Compute the return type of `fromTry` based on whether fn returns a Promise.\n * - If fn returns Promise<T>, result is Promise<Option<T>>\n * - If fn returns T, result is Option<T>\n */\nexport type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>\n\n// ============================================================================\n// All/Combine types\n// ============================================================================\n\n/**\n * Extract the value type from an Option.\n * Uses structural matching to extract the value type from the Some branch.\n */\ntype OptionValue<O> = O extends { readonly _tag: \"Some\"; readonly value: infer T } ? T : never\n\n/**\n * Overloaded all() type with explicit tuple arities for better inference.\n * Provides tuple overloads for 1-6 elements so `as const` is not required.\n */\nexport type OptionAll = {\n  // Tuple overloads (1-6 elements)\n  <A>(options: readonly [Option<A>]): Option<[A]>\n  <A, B>(options: readonly [Option<A>, Option<B>]): Option<[A, B]>\n  <A, B, C>(options: readonly [Option<A>, Option<B>, Option<C>]): Option<[A, B, C]>\n  <A, B, C, D>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>]): Option<[A, B, C, D]>\n  <A, B, C, D, E>(options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>]): Option<[A, B, C, D, E]>\n  <A, B, C, D, E, F>(\n    options: readonly [Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>],\n  ): Option<[A, B, C, D, E, F]>\n\n  // Array fallback (longer tuples need `as const`)\n  <T extends readonly Option<unknown>[]>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n\n  // Object form\n  <T extends Record<string, Option<unknown>>>(options: T): Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>\n}\n\n// ============================================================================\n// Function Interfaces for improved pipe inference\n// ============================================================================\n\n/**\n * Interface for flatMap - using method syntax improves generic inference in pipe chains.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionFlatMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<Option<B>>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => Option<B>): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for map function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionMap = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: (value: A) => Promise<B>): Promise<Option<B>>\n  <A, B>(option: Option<A>, fn: (value: A) => B): Option<B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n\n/**\n * Interface for tap function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionTap = {\n  // Data-first overload\n  <A, R>(option: Option<A>, fn: (value: A) => R): R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n  // Data-last overload (curried for pipe)\n  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n}\n\n/**\n * Interface for orElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionOrElse = {\n  // Data-first overloads (async first)\n  <A, B>(option: Option<A>, fn: () => Promise<Option<B>>): Promise<Option<A | B>>\n  <A, B>(option: Option<A>, fn: () => Option<B>): Option<A | B>\n  // Data-last overloads (curried for pipe)\n  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>\n  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>\n}\n\n/**\n * Interface for filter function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionFilter = {\n  // Data-first overload\n  <A>(option: Option<A>, predicate: (value: A) => boolean): Option<A>\n  // Data-last overload (curried for pipe)\n  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>\n}\n\n/**\n * Interface for unwrapOr function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n * Uses NoInfer to prevent type inference from the default value.\n */\nexport type OptionUnwrapOr = {\n  // Data-first overload\n  <T>(option: Option<T>, defaultValue: NoInfer<T>): T\n  // Data-last overload (curried for pipe)\n  <T>(defaultValue: NoInfer<T>): (option: Option<T>) => T\n}\n\n/**\n * Interface for unwrapOrElse function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionUnwrapOrElse = {\n  // Data-first overload\n  <T>(option: Option<T>, fn: () => T): T\n  // Data-last overload (curried for pipe)\n  <T>(fn: () => T): (option: Option<T>) => T\n}\n\n/**\n * Interface for match function.\n * Supports both data-first and data-last (curried) calling styles via dual().\n */\nexport type OptionMatch = {\n  // Data-first overload\n  <T, U>(option: Option<T>, handlers: { Some: (value: T) => U; None: () => U }): U\n  // Data-last overload (curried for pipe)\n  <T, U>(handlers: { Some: (value: T) => U; None: () => U }): (option: Option<T>) => U\n}\n"],"mappings":"AAkBA,IAAa,EAAb,cAAwC,KAAM,CAC5C,KAAgB,qBAEhB,aAAc,CACZ,MAAM,sCAAsC,CAC5C,KAAK,KAAO"}

package/dist/order/index.d.mts

@@ -1,2 +1,2 @@
-import { t as order_d_exports } from "../index-D8rDE60Y.mjs";
+import { t as order_d_exports } from "../index-BsCrdweM.mjs";
 export { order_d_exports as Order };

package/dist/order/index.mjs

@@ -1 +1 @@
-import{t as e}from"../order-BXOBEKvB.mjs";export{e as Order};
+import{t as e}from"../order-VTXpppmI.mjs";export{e as Order};

package/dist/{order-BXOBEKvB.mjs → order-VTXpppmI.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./dual-fN6OUwN_.mjs";var n=e({alwaysEqual:()=>u,array:()=>v,between:()=>D,bigint:()=>c,boolean:()=>s,by:()=>f,clamp:()=>E,collator:()=>a,date:()=>l,greaterThan:()=>S,greaterThanOrEqual:()=>C,lessThan:()=>b,lessThanOrEqual:()=>x,make:()=>r,max:()=>T,merge:()=>g,min:()=>w,number:()=>o,reverse:()=>d,sort:()=>O,sortBy:()=>A,sortWith:()=>k,string:()=>i,struct:()=>y,tuple:()=>_});function r(e){return(t,n)=>t===n?0:e(t,n)}const i=r((e,t)=>e<t?-1:1);function a(e){return r((t,n)=>{let r=e.compare(t,n);return r<0?-1:r>0?1:0})}const o=r((e,t)=>Number.isNaN(e)&&Number.isNaN(t)?0:Number.isNaN(e)?-1:Number.isNaN(t)?1:e<t?-1:1),s=r((e,t)=>e<t?-1:1),c=r((e,t)=>e<t?-1:1),l=r((e,t)=>o(e.getTime(),t.getTime()));function u(){return r(()=>0)}function d(e){return r((t,n)=>e(n,t))}const f=t(2,(e,t)=>r((n,r)=>e(t(n),t(r)))),p=(e,t)=>r((n,r)=>{let i=e(n,r);return i===0?t(n,r):i}),m=e=>{let t=Array.from(e);return t.length===0?u():t.length===1?t[0]:r((e,n)=>{for(let r of t){let t=r(e,n);if(t!==0)return t}return 0})};function h(e,t){if(t!==void 0){if(typeof e!=`function`)throw TypeError(`Order.merge(self, that) requires two order functions`);return p(e,t)}return typeof e==`function`?t=>p(t,e):m(e)}const g=h;function _(e){return r((t,n)=>{for(let r=0;r<e.length;r++){let i=e[r],a=i(t[r],n[r]);if(a!==0)return a}return 0})}function v(e){return r((t,n)=>{let r=Math.min(t.length,n.length);for(let i=0;i<r;i++){let r=e(t[i],n[i]);if(r!==0)return r}return o(t.length,n.length)})}function y(e){let t=Object.keys(e);return r((n,r)=>{for(let i of t){let t=e[i](n[i],r[i]);if(t!==0)return t}return 0})}const b=e=>t(2,(t,n)=>e(t,n)===-1),x=e=>t(2,(t,n)=>e(t,n)!==1),S=e=>t(2,(t,n)=>e(t,n)===1),C=e=>t(2,(t,n)=>e(t,n)!==-1),w=e=>t(2,(t,n)=>t===n||e(t,n)<1?t:n),T=e=>t(2,(t,n)=>t===n||e(t,n)>-1?t:n),E=e=>t(2,(t,n)=>w(e)(n.maximum,T(e)(n.minimum,t))),D=e=>t(2,(t,n)=>!b(e)(t,n.minimum)&&!S(e)(t,n.maximum)),O=t(2,(e,t)=>{let n=Array.from(e);return n.sort((e,n)=>t(e,n)),n}),k=t(3,(e,t,n)=>{let r=Array.from(e,e=>[e,t(e)]);return r.sort(([,e],[,t])=>n(e,t)),r.map(([e])=>e)}),A=(...e)=>{if(e.length===0)return e=>Array.from(e);let t=g(e);return e=>O(e,t)};export{n as t};
-//# sourceMappingURL=order-BXOBEKvB.mjs.map
+import{t as e}from"./chunk-6rpU2rUb.mjs";import{t}from"./dual-CZhzZslG.mjs";var n=e({alwaysEqual:()=>u,array:()=>v,between:()=>D,bigint:()=>c,boolean:()=>s,by:()=>f,clamp:()=>E,collator:()=>a,date:()=>l,greaterThan:()=>S,greaterThanOrEqual:()=>C,lessThan:()=>b,lessThanOrEqual:()=>x,make:()=>r,max:()=>T,merge:()=>g,min:()=>w,number:()=>o,reverse:()=>d,sort:()=>O,sortBy:()=>A,sortWith:()=>k,string:()=>i,struct:()=>y,tuple:()=>_});function r(e){return(t,n)=>t===n?0:e(t,n)}const i=r((e,t)=>e<t?-1:1);function a(e){return r((t,n)=>{let r=e.compare(t,n);return r<0?-1:r>0?1:0})}const o=r((e,t)=>Number.isNaN(e)&&Number.isNaN(t)?0:Number.isNaN(e)?-1:Number.isNaN(t)?1:e<t?-1:1),s=r((e,t)=>e<t?-1:1),c=r((e,t)=>e<t?-1:1),l=r((e,t)=>o(e.getTime(),t.getTime()));function u(){return r(()=>0)}function d(e){return r((t,n)=>e(n,t))}const f=t(2,(e,t)=>r((n,r)=>e(t(n),t(r)))),p=(e,t)=>r((n,r)=>{let i=e(n,r);return i===0?t(n,r):i}),m=e=>{let t=Array.from(e);return t.length===0?u():t.length===1?t[0]:r((e,n)=>{for(let r of t){let t=r(e,n);if(t!==0)return t}return 0})};function h(e,t){if(t!==void 0){if(typeof e!=`function`)throw TypeError(`Order.merge(self, that) requires two order functions`);return p(e,t)}return typeof e==`function`?t=>p(t,e):m(e)}const g=h;function _(e){return r((t,n)=>{for(let r=0;r<e.length;r++){let i=e[r],a=i(t[r],n[r]);if(a!==0)return a}return 0})}function v(e){return r((t,n)=>{let r=Math.min(t.length,n.length);for(let i=0;i<r;i++){let r=e(t[i],n[i]);if(r!==0)return r}return o(t.length,n.length)})}function y(e){let t=Object.keys(e);return r((n,r)=>{for(let i of t){let t=e[i](n[i],r[i]);if(t!==0)return t}return 0})}const b=e=>t(2,(t,n)=>e(t,n)===-1),x=e=>t(2,(t,n)=>e(t,n)!==1),S=e=>t(2,(t,n)=>e(t,n)===1),C=e=>t(2,(t,n)=>e(t,n)!==-1),w=e=>t(2,(t,n)=>t===n||e(t,n)<1?t:n),T=e=>t(2,(t,n)=>t===n||e(t,n)>-1?t:n),E=e=>t(2,(t,n)=>w(e)(n.maximum,T(e)(n.minimum,t))),D=e=>t(2,(t,n)=>!b(e)(t,n.minimum)&&!S(e)(t,n.maximum)),O=t(2,(e,t)=>{let n=Array.from(e);return n.sort((e,n)=>t(e,n)),n}),k=t(3,(e,t,n)=>{let r=Array.from(e,e=>[e,t(e)]);return r.sort(([,e],[,t])=>n(e,t)),r.map(([e])=>e)}),A=(...e)=>{if(e.length===0)return e=>Array.from(e);let t=g(e);return e=>O(e,t)};export{n as t};
+//# sourceMappingURL=order-VTXpppmI.mjs.map

package/dist/{order-BXOBEKvB.mjs.map → order-VTXpppmI.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"order-BXOBEKvB.mjs","names":["collator"],"sources":["../src/order/order.ts"],"sourcesContent":["/**\n * Ordering combinators and instances for deterministic sorting and comparisons.\n *\n * **Mental model**\n * - `Order<A>` compares two values and returns `-1 | 0 | 1`.\n * - Compose reusable comparators with `by`, `merge`, and `reverse`.\n *\n * **Common tasks**\n * - Use built-ins like `Order.number`, `Order.string`, `Order.date`.\n * - Build custom orders with `Order.make`, `Order.by`, `Order.struct`.\n * - Sort with `Order.sort`, `Order.sortWith`, `Order.sortBy`.\n *\n * **Gotchas**\n * - Orders should be total and stable for predictable sorting.\n * - `Order.merge` uses lexicographic tie-breaking.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byAge = Order.by(Order.number, (user: { age: number }) => user.age)\n * const sorted = Order.sort([{ age: 2 }, { age: 1 }], byAge)\n * ```\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport type { Order as OrderType, OrderBounds, Ordering as OrderingType } from \"./order.types\"\n\n/**\n * Re-exported `Order` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Order<unknown>\n * ```\n */\nexport type Order<A> = OrderType<A>\n\n/**\n * Re-exported `Ordering` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Ordering\n * ```\n */\nexport type Ordering = OrderingType\n\n/**\n * Create an `Order` from a comparison function.\n *\n * The created order short-circuits identical references (`===`) to `0`.\n *\n * @param compare - Comparison function returning `-1 | 0 | 1`\n * @returns An order function\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byLength = Order.make<string>((self, that) =>\n *   self.length < that.length ? -1 : self.length > that.length ? 1 : 0,\n * )\n * const result = byLength(\"a\", \"bbb\")\n * // => -1\n * ```\n */\nexport function make<A>(compare: (self: A, that: A) => Ordering): OrderType<A> {\n  return (self, that) => (self === that ? 0 : compare(self, that))\n}\n\n/**\n * `Order` instance for strings (lexicographic, case-sensitive).\n *\n * Use `Order.collator` for locale-aware human-facing ordering.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.string(\"a\", \"b\")\n * // => -1\n * ```\n */\nexport const string: OrderType<string> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * Create a locale-aware `Order` from an `Intl.Collator`.\n *\n * This is intended for human-facing sorting where locale rules matter.\n * Reuse a collator instance when sorting repeatedly.\n *\n * @param collator - Preconfigured collator controlling locale-sensitive ordering\n * @returns A string order normalized to `-1 | 0 | 1`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const collator = new Intl.Collator(\"en\", { numeric: true })\n * const result = Order.collator(collator)(\"2\", \"10\")\n * // => -1\n * ```\n */\nexport function collator(collator: Intl.Collator): OrderType<string> {\n  return make((self, that) => {\n    const result = collator.compare(self, that)\n    return result < 0 ? -1 : result > 0 ? 1 : 0\n  })\n}\n\n/**\n * `Order` instance for numbers.\n *\n * - `NaN` equals `NaN`\n * - `NaN` is less than any non-`NaN`\n * - `0` equals `-0`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.number(1, 2)\n * // => -1\n * ```\n */\nexport const number: OrderType<number> = make((self, that) => {\n  if (Number.isNaN(self) && Number.isNaN(that)) return 0\n  if (Number.isNaN(self)) return -1\n  if (Number.isNaN(that)) return 1\n  return self < that ? -1 : 1\n})\n\n/**\n * `Order` instance for booleans where `false < true`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.boolean(false, true)\n * // => -1\n * ```\n */\nexport const boolean: OrderType<boolean> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for bigints.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.bigint(1n, 2n)\n * // => -1\n * ```\n */\nexport const bigint: OrderType<bigint> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for dates based on `getTime()`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.date(new Date(\"2024-01-01\"), new Date(\"2024-01-02\"))\n * // => -1\n * ```\n */\nexport const date: OrderType<Date> = make((self, that) => number(self.getTime(), that.getTime()))\n\n/**\n * Create an order that treats all values as equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.alwaysEqual<number>()\n * const result = compare(1, 2)\n * // => 0\n * ```\n */\nexport function alwaysEqual<A>(): OrderType<A> {\n  return make(() => 0)\n}\n\n/**\n * Reverse an existing order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const desc = Order.reverse(Order.number)\n * const result = desc(1, 2)\n * // => 1\n * ```\n */\nexport function reverse<A>(order: OrderType<A>): OrderType<A> {\n  return make((self, that) => order(that, self))\n}\n\n/**\n * Map inputs before comparison.\n *\n * Supports data-first and data-last styles:\n * - `by(order, project)`\n * - `pipe(order, by(project))`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { age: number }\n * const dataFirst = Order.by(Order.number, (user: User) => user.age)\n * const compareFirst = dataFirst({ age: 1 }, { age: 2 })\n * // => -1\n *\n * const dataLast = Order.by((user: User) => user.age)(Order.number)\n * const compareLast = dataLast({ age: 1 }, { age: 2 })\n * // => -1\n * ```\n */\nexport const by: {\n  <B, A>(project: (value: B) => A): (order: OrderType<A>) => OrderType<B>\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B>\n} = dual(\n  2,\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B> =>\n    make((self, that) => order(project(self), project(that))),\n)\n\nconst mergeBinary = <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A> =>\n  make((a, b) => {\n    const result = self(a, b)\n    if (result !== 0) return result\n    return that(a, b)\n  })\n\nconst mergeAll = <A>(orders: Iterable<OrderType<A>>): OrderType<A> => {\n  const all = Array.from(orders)\n  if (all.length === 0) return alwaysEqual()\n  if (all.length === 1) return all[0]!\n\n  return make((a, b) => {\n    for (const order of all) {\n      const result = order(a, b)\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\nfunction mergeOverload<A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\nfunction mergeOverload<A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\nfunction mergeOverload<A>(orders: Iterable<OrderType<A>>): OrderType<A>\nfunction mergeOverload<A>(\n  selfOrThatOrOrders: OrderType<A> | Iterable<OrderType<A>>,\n  that?: OrderType<A>,\n): ((self: OrderType<A>) => OrderType<A>) | OrderType<A> {\n  if (that !== undefined) {\n    if (typeof selfOrThatOrOrders !== \"function\") {\n      throw new TypeError(\"Order.merge(self, that) requires two order functions\")\n    }\n    return mergeBinary(selfOrThatOrOrders, that)\n  }\n\n  if (typeof selfOrThatOrOrders === \"function\") {\n    return (self: OrderType<A>) => mergeBinary(self, selfOrThatOrOrders)\n  }\n\n  return mergeAll(selfOrThatOrOrders)\n}\n\n/**\n * Merge orders lexicographically.\n *\n * Supports three forms:\n * - `merge(self, that)`\n * - `merge(that)(self)`\n * - `merge([order1, order2, ...])`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { first: string; last: string }\n * const byLast = Order.by(Order.string, (user: User) => user.last)\n * const byFirst = Order.by(Order.string, (user: User) => user.first)\n * const compare = Order.merge([byLast, byFirst])({ first: \"Ada\", last: \"Lovelace\" }, { first: \"Alan\", last: \"Turing\" })\n * // => -1\n * ```\n */\nexport const merge: {\n  <A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\n  <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\n  <A>(orders: Iterable<OrderType<A>>): OrderType<A>\n} = mergeOverload\n\n/**\n * Create an order for tuples, compared left-to-right.\n */\ntype TupleOrders<Elements extends ReadonlyArray<unknown>> = {\n  readonly [K in keyof Elements]: OrderType<Elements[K]>\n}\n\n/**\n * tuple utility.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.tuple([Order.string, Order.number] as const)([\"a\", 1], [\"a\", 2])\n * // => -1\n * ```\n */\nexport function tuple<const Elements extends ReadonlyArray<unknown>>(\n  orders: TupleOrders<Elements>,\n): OrderType<Elements> {\n  return make((self, that) => {\n    for (let i = 0; i < orders.length; i++) {\n      const order = orders[i]!\n      const result = order(self[i], that[i])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Create an order for arrays.\n *\n * Arrays are compared element-by-element, then by length when all compared\n * elements are equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.array(Order.number)([1, 2], [1, 3])\n * // => -1\n * ```\n */\nexport function array<A>(order: OrderType<A>): OrderType<readonly A[]> {\n  return make((self, that) => {\n    const minLength = Math.min(self.length, that.length)\n    for (let i = 0; i < minLength; i++) {\n      const result = order(self[i]!, that[i]!)\n      if (result !== 0) return result\n    }\n    return number(self.length, that.length)\n  })\n}\n\n/**\n * Create an order for objects by key order in `fields`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.struct<{ id: number; name: string }>({\n *   id: Order.number,\n *   name: Order.string,\n * })({ id: 1, name: \"a\" }, { id: 1, name: \"b\" })\n * // => -1\n * ```\n */\nexport function struct<const R extends Record<string, unknown>>(fields: {\n  readonly [K in keyof R]: OrderType<R[K]>\n}): OrderType<R> {\n  const keys = Object.keys(fields) as Array<keyof R>\n\n  return make((self, that) => {\n    for (const key of keys) {\n      const result = fields[key](self[key], that[key])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Test strict less-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThan(Order.number)(1, 2)\n * // => true\n * ```\n */\nexport const lessThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === -1)\n\n/**\n * Test less-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const lessThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== 1)\n\n/**\n * Test strict greater-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThan(Order.number)(3, 2)\n * // => true\n * ```\n */\nexport const greaterThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === 1)\n\n/**\n * Test greater-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const greaterThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== -1)\n\n/**\n * Get the minimum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.min(Order.number)(3, 5)\n * // => 3\n * ```\n */\nexport const min = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) < 1 ? self : that))\n\n/**\n * Get the maximum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.max(Order.number)(3, 5)\n * // => 5\n * ```\n */\nexport const max = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) > -1 ? self : that))\n\n/**\n * Clamp a value to inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.clamp(Order.number)(7, { minimum: 0, maximum: 5 })\n * // => 5\n * ```\n */\nexport const clamp = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => A\n  (self: A, bounds: OrderBounds<A>): A\n} => dual(2, (self: A, bounds: OrderBounds<A>): A => min(order)(bounds.maximum, max(order)(bounds.minimum, self)))\n\n/**\n * Check whether a value is within inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const isBetween = Order.between(Order.number)(3, { minimum: 0, maximum: 5 })\n * // => true\n * ```\n */\nexport const between = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => boolean\n  (self: A, bounds: OrderBounds<A>): boolean\n} =>\n  dual(\n    2,\n    (self: A, bounds: OrderBounds<A>): boolean =>\n      !lessThan(order)(self, bounds.minimum) && !greaterThan(order)(self, bounds.maximum),\n  )\n\n/**\n * Sort an iterable by an order, returning a new array.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const values = [3, 1, 2]\n * const dataFirst = Order.sort(values, Order.number)\n * // => [1, 2, 3]\n *\n * const dataLast = Order.sort(Order.number)(values)\n * // => [1, 2, 3]\n * ```\n */\nexport const sort: {\n  <B>(order: OrderType<B>): <A extends B>(input: Iterable<A>) => A[]\n  <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[]\n} = dual(2, <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[] => {\n  const output = Array.from(input)\n  output.sort((self, that) => order(self, that))\n  return output\n})\n\n/**\n * Sort an iterable by a projected value.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2 }, { age: 1 }]\n * const dataFirst = Order.sortWith(users, (user) => user.age, Order.number)\n * // => [{ age: 1 }, { age: 2 }]\n *\n * const dataLast = Order.sortWith((user: { age: number }) => user.age, Order.number)(users)\n * // => [{ age: 1 }, { age: 2 }]\n * ```\n */\nexport const sortWith: {\n  <A, B>(project: (value: A) => B, order: OrderType<B>): (input: Iterable<A>) => A[]\n  <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[]\n} = dual(3, <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[] => {\n  const output = Array.from(input, (value) => [value, project(value)] as const)\n  output.sort(([, a], [, b]) => order(a, b))\n  return output.map(([value]) => value)\n})\n\n/**\n * Sort an iterable by multiple orders, in sequence.\n *\n * - first order has highest priority\n * - ties are broken by subsequent orders\n * - no orders returns a shallow copy preserving iteration order\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2, name: \"b\" }, { age: 1, name: \"a\" }]\n * const sorted = Order.sortBy(Order.by(Order.number, (user: { age: number; name: string }) => user.age))(users)\n * // => [{ age: 1, name: \"a\" }, { age: 2, name: \"b\" }]\n * ```\n */\nexport const sortBy = <A>(...orders: readonly OrderType<A>[]) => {\n  if (orders.length === 0) {\n    return (input: Iterable<A>): A[] => Array.from(input)\n  }\n\n  const merged = merge(orders)\n  return (input: Iterable<A>): A[] => sort(input, merged)\n}\n"],"mappings":"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"}
+{"version":3,"file":"order-VTXpppmI.mjs","names":["collator"],"sources":["../src/order/order.ts"],"sourcesContent":["/**\n * Ordering combinators and instances for deterministic sorting and comparisons.\n *\n * **Mental model**\n * - `Order<A>` compares two values and returns `-1 | 0 | 1`.\n * - Compose reusable comparators with `by`, `merge`, and `reverse`.\n *\n * **Common tasks**\n * - Use built-ins like `Order.number`, `Order.string`, `Order.date`.\n * - Build custom orders with `Order.make`, `Order.by`, `Order.struct`.\n * - Sort with `Order.sort`, `Order.sortWith`, `Order.sortBy`.\n *\n * **Gotchas**\n * - Orders should be total and stable for predictable sorting.\n * - `Order.merge` uses lexicographic tie-breaking.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byAge = Order.by(Order.number, (user: { age: number }) => user.age)\n * const sorted = Order.sort([{ age: 2 }, { age: 1 }], byAge)\n * ```\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport type { Order as OrderType, OrderBounds, Ordering as OrderingType } from \"./order.types\"\n\n/**\n * Re-exported `Order` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Order<unknown>\n * ```\n */\nexport type Order<A> = OrderType<A>\n\n/**\n * Re-exported `Ordering` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Ordering\n * ```\n */\nexport type Ordering = OrderingType\n\n/**\n * Create an `Order` from a comparison function.\n *\n * The created order short-circuits identical references (`===`) to `0`.\n *\n * @param compare - Comparison function returning `-1 | 0 | 1`\n * @returns An order function\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byLength = Order.make<string>((self, that) =>\n *   self.length < that.length ? -1 : self.length > that.length ? 1 : 0,\n * )\n * const result = byLength(\"a\", \"bbb\")\n * // => -1\n * ```\n */\nexport function make<A>(compare: (self: A, that: A) => Ordering): OrderType<A> {\n  return (self, that) => (self === that ? 0 : compare(self, that))\n}\n\n/**\n * `Order` instance for strings (lexicographic, case-sensitive).\n *\n * Use `Order.collator` for locale-aware human-facing ordering.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.string(\"a\", \"b\")\n * // => -1\n * ```\n */\nexport const string: OrderType<string> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * Create a locale-aware `Order` from an `Intl.Collator`.\n *\n * This is intended for human-facing sorting where locale rules matter.\n * Reuse a collator instance when sorting repeatedly.\n *\n * @param collator - Preconfigured collator controlling locale-sensitive ordering\n * @returns A string order normalized to `-1 | 0 | 1`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const collator = new Intl.Collator(\"en\", { numeric: true })\n * const result = Order.collator(collator)(\"2\", \"10\")\n * // => -1\n * ```\n */\nexport function collator(collator: Intl.Collator): OrderType<string> {\n  return make((self, that) => {\n    const result = collator.compare(self, that)\n    return result < 0 ? -1 : result > 0 ? 1 : 0\n  })\n}\n\n/**\n * `Order` instance for numbers.\n *\n * - `NaN` equals `NaN`\n * - `NaN` is less than any non-`NaN`\n * - `0` equals `-0`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.number(1, 2)\n * // => -1\n * ```\n */\nexport const number: OrderType<number> = make((self, that) => {\n  if (Number.isNaN(self) && Number.isNaN(that)) return 0\n  if (Number.isNaN(self)) return -1\n  if (Number.isNaN(that)) return 1\n  return self < that ? -1 : 1\n})\n\n/**\n * `Order` instance for booleans where `false < true`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.boolean(false, true)\n * // => -1\n * ```\n */\nexport const boolean: OrderType<boolean> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for bigints.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.bigint(1n, 2n)\n * // => -1\n * ```\n */\nexport const bigint: OrderType<bigint> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for dates based on `getTime()`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.date(new Date(\"2024-01-01\"), new Date(\"2024-01-02\"))\n * // => -1\n * ```\n */\nexport const date: OrderType<Date> = make((self, that) => number(self.getTime(), that.getTime()))\n\n/**\n * Create an order that treats all values as equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.alwaysEqual<number>()\n * const result = compare(1, 2)\n * // => 0\n * ```\n */\nexport function alwaysEqual<A>(): OrderType<A> {\n  return make(() => 0)\n}\n\n/**\n * Reverse an existing order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const desc = Order.reverse(Order.number)\n * const result = desc(1, 2)\n * // => 1\n * ```\n */\nexport function reverse<A>(order: OrderType<A>): OrderType<A> {\n  return make((self, that) => order(that, self))\n}\n\n/**\n * Map inputs before comparison.\n *\n * Supports data-first and data-last styles:\n * - `by(order, project)`\n * - `pipe(order, by(project))`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { age: number }\n * const dataFirst = Order.by(Order.number, (user: User) => user.age)\n * const compareFirst = dataFirst({ age: 1 }, { age: 2 })\n * // => -1\n *\n * const dataLast = Order.by((user: User) => user.age)(Order.number)\n * const compareLast = dataLast({ age: 1 }, { age: 2 })\n * // => -1\n * ```\n */\nexport const by: {\n  <B, A>(project: (value: B) => A): (order: OrderType<A>) => OrderType<B>\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B>\n} = dual(\n  2,\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B> =>\n    make((self, that) => order(project(self), project(that))),\n)\n\nconst mergeBinary = <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A> =>\n  make((a, b) => {\n    const result = self(a, b)\n    if (result !== 0) return result\n    return that(a, b)\n  })\n\nconst mergeAll = <A>(orders: Iterable<OrderType<A>>): OrderType<A> => {\n  const all = Array.from(orders)\n  if (all.length === 0) return alwaysEqual()\n  if (all.length === 1) return all[0]!\n\n  return make((a, b) => {\n    for (const order of all) {\n      const result = order(a, b)\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\nfunction mergeOverload<A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\nfunction mergeOverload<A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\nfunction mergeOverload<A>(orders: Iterable<OrderType<A>>): OrderType<A>\nfunction mergeOverload<A>(\n  selfOrThatOrOrders: OrderType<A> | Iterable<OrderType<A>>,\n  that?: OrderType<A>,\n): ((self: OrderType<A>) => OrderType<A>) | OrderType<A> {\n  if (that !== undefined) {\n    if (typeof selfOrThatOrOrders !== \"function\") {\n      throw new TypeError(\"Order.merge(self, that) requires two order functions\")\n    }\n    return mergeBinary(selfOrThatOrOrders, that)\n  }\n\n  if (typeof selfOrThatOrOrders === \"function\") {\n    return (self: OrderType<A>) => mergeBinary(self, selfOrThatOrOrders)\n  }\n\n  return mergeAll(selfOrThatOrOrders)\n}\n\n/**\n * Merge orders lexicographically.\n *\n * Supports three forms:\n * - `merge(self, that)`\n * - `merge(that)(self)`\n * - `merge([order1, order2, ...])`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { first: string; last: string }\n * const byLast = Order.by(Order.string, (user: User) => user.last)\n * const byFirst = Order.by(Order.string, (user: User) => user.first)\n * const compare = Order.merge([byLast, byFirst])({ first: \"Ada\", last: \"Lovelace\" }, { first: \"Alan\", last: \"Turing\" })\n * // => -1\n * ```\n */\nexport const merge: {\n  <A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\n  <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\n  <A>(orders: Iterable<OrderType<A>>): OrderType<A>\n} = mergeOverload\n\n/**\n * Create an order for tuples, compared left-to-right.\n */\ntype TupleOrders<Elements extends ReadonlyArray<unknown>> = {\n  readonly [K in keyof Elements]: OrderType<Elements[K]>\n}\n\n/**\n * tuple utility.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.tuple([Order.string, Order.number] as const)([\"a\", 1], [\"a\", 2])\n * // => -1\n * ```\n */\nexport function tuple<const Elements extends ReadonlyArray<unknown>>(\n  orders: TupleOrders<Elements>,\n): OrderType<Elements> {\n  return make((self, that) => {\n    for (let i = 0; i < orders.length; i++) {\n      const order = orders[i]!\n      const result = order(self[i], that[i])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Create an order for arrays.\n *\n * Arrays are compared element-by-element, then by length when all compared\n * elements are equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.array(Order.number)([1, 2], [1, 3])\n * // => -1\n * ```\n */\nexport function array<A>(order: OrderType<A>): OrderType<readonly A[]> {\n  return make((self, that) => {\n    const minLength = Math.min(self.length, that.length)\n    for (let i = 0; i < minLength; i++) {\n      const result = order(self[i]!, that[i]!)\n      if (result !== 0) return result\n    }\n    return number(self.length, that.length)\n  })\n}\n\n/**\n * Create an order for objects by key order in `fields`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.struct<{ id: number; name: string }>({\n *   id: Order.number,\n *   name: Order.string,\n * })({ id: 1, name: \"a\" }, { id: 1, name: \"b\" })\n * // => -1\n * ```\n */\nexport function struct<const R extends Record<string, unknown>>(fields: {\n  readonly [K in keyof R]: OrderType<R[K]>\n}): OrderType<R> {\n  const keys = Object.keys(fields) as Array<keyof R>\n\n  return make((self, that) => {\n    for (const key of keys) {\n      const result = fields[key](self[key], that[key])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Test strict less-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThan(Order.number)(1, 2)\n * // => true\n * ```\n */\nexport const lessThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === -1)\n\n/**\n * Test less-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const lessThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== 1)\n\n/**\n * Test strict greater-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThan(Order.number)(3, 2)\n * // => true\n * ```\n */\nexport const greaterThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === 1)\n\n/**\n * Test greater-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const greaterThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== -1)\n\n/**\n * Get the minimum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.min(Order.number)(3, 5)\n * // => 3\n * ```\n */\nexport const min = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) < 1 ? self : that))\n\n/**\n * Get the maximum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.max(Order.number)(3, 5)\n * // => 5\n * ```\n */\nexport const max = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) > -1 ? self : that))\n\n/**\n * Clamp a value to inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.clamp(Order.number)(7, { minimum: 0, maximum: 5 })\n * // => 5\n * ```\n */\nexport const clamp = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => A\n  (self: A, bounds: OrderBounds<A>): A\n} => dual(2, (self: A, bounds: OrderBounds<A>): A => min(order)(bounds.maximum, max(order)(bounds.minimum, self)))\n\n/**\n * Check whether a value is within inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const isBetween = Order.between(Order.number)(3, { minimum: 0, maximum: 5 })\n * // => true\n * ```\n */\nexport const between = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => boolean\n  (self: A, bounds: OrderBounds<A>): boolean\n} =>\n  dual(\n    2,\n    (self: A, bounds: OrderBounds<A>): boolean =>\n      !lessThan(order)(self, bounds.minimum) && !greaterThan(order)(self, bounds.maximum),\n  )\n\n/**\n * Sort an iterable by an order, returning a new array.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const values = [3, 1, 2]\n * const dataFirst = Order.sort(values, Order.number)\n * // => [1, 2, 3]\n *\n * const dataLast = Order.sort(Order.number)(values)\n * // => [1, 2, 3]\n * ```\n */\nexport const sort: {\n  <B>(order: OrderType<B>): <A extends B>(input: Iterable<A>) => A[]\n  <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[]\n} = dual(2, <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[] => {\n  const output = Array.from(input)\n  output.sort((self, that) => order(self, that))\n  return output\n})\n\n/**\n * Sort an iterable by a projected value.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2 }, { age: 1 }]\n * const dataFirst = Order.sortWith(users, (user) => user.age, Order.number)\n * // => [{ age: 1 }, { age: 2 }]\n *\n * const dataLast = Order.sortWith((user: { age: number }) => user.age, Order.number)(users)\n * // => [{ age: 1 }, { age: 2 }]\n * ```\n */\nexport const sortWith: {\n  <A, B>(project: (value: A) => B, order: OrderType<B>): (input: Iterable<A>) => A[]\n  <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[]\n} = dual(3, <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[] => {\n  const output = Array.from(input, (value) => [value, project(value)] as const)\n  output.sort(([, a], [, b]) => order(a, b))\n  return output.map(([value]) => value)\n})\n\n/**\n * Sort an iterable by multiple orders, in sequence.\n *\n * - first order has highest priority\n * - ties are broken by subsequent orders\n * - no orders returns a shallow copy preserving iteration order\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2, name: \"b\" }, { age: 1, name: \"a\" }]\n * const sorted = Order.sortBy(Order.by(Order.number, (user: { age: number; name: string }) => user.age))(users)\n * // => [{ age: 1, name: \"a\" }, { age: 2, name: \"b\" }]\n * ```\n */\nexport const sortBy = <A>(...orders: readonly OrderType<A>[]) => {\n  if (orders.length === 0) {\n    return (input: Iterable<A>): A[] => Array.from(input)\n  }\n\n  const merged = merge(orders)\n  return (input: Iterable<A>): A[] => sort(input, merged)\n}\n"],"mappings":"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"}

package/dist/{pipeable-BIrevC0D.d.mts → pipeable-BY9yPsNK.d.mts}

@@ -17,4 +17,4 @@ type Pipeable = {
 };
 //#endregion
 export { Pipeable as t };
-//# sourceMappingURL=pipeable-BIrevC0D.d.mts.map
+//# sourceMappingURL=pipeable-BY9yPsNK.d.mts.map

package/dist/{pipeable-BIrevC0D.d.mts.map → pipeable-BY9yPsNK.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"pipeable-BIrevC0D.d.mts","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"pipeable-BY9yPsNK.d.mts","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/pipeable-COGyGMUV.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./flow-D8_tllWl.mjs";function t(...t){return t.length===0?this:e(...t)(this)}export{t};
+//# sourceMappingURL=pipeable-COGyGMUV.mjs.map

package/dist/{pipeable-Dp1_23zH.mjs.map → pipeable-COGyGMUV.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"pipeable-Dp1_23zH.mjs","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":["import { flow } from \"../functions/flow\"\n\n/**\n * Pipeable interface for fluent method chaining.\n * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)\n */\nexport type Pipeable = {\n  pipe<A>(this: A): A\n  pipe<A, B>(this: A, ab: (a: A) => B): B\n  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C\n  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D\n  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E\n  pipe<A, B, C, D, E, F>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n  ): F\n  pipe<A, B, C, D, E, F, G>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n  ): G\n  pipe<A, B, C, D, E, F, G, H>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n  ): H\n  pipe<A, B, C, D, E, F, G, H, I>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n  ): I\n  pipe<A, B, C, D, E, F, G, H, I, J>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n    ij: (i: I) => J,\n  ): J\n}\n\ntype UnaryFn = (arg: unknown) => unknown\n\n/**\n * Create a pipe method implementation.\n * Returns a function that pipes the value through provided functions.\n * This is designed to be used as an object method, so it uses `this` binding.\n */\n// oxlint-disable no-explicit-any, no-this-in-exported-function\nexport function pipeable<A>(this: A, ...fns: UnaryFn[]): any {\n  if (fns.length === 0) return this\n  // oxlint-disable-next-line no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion\n  return (flow as any)(...fns)(this)\n}\n// oxlint-enable no-explicit-any, no-this-in-exported-function\n"],"mappings":"wCAwEA,SAAgB,EAAqB,GAAG,EAAqB,CAG3D,OAFI,EAAI,SAAW,EAAU,KAErB,EAAa,GAAG,EAAI,CAAC,KAAK"}
+{"version":3,"file":"pipeable-COGyGMUV.mjs","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":["import { flow } from \"../functions/flow\"\n\n/**\n * Pipeable interface for fluent method chaining.\n * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)\n */\nexport type Pipeable = {\n  pipe<A>(this: A): A\n  pipe<A, B>(this: A, ab: (a: A) => B): B\n  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C\n  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D\n  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E\n  pipe<A, B, C, D, E, F>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n  ): F\n  pipe<A, B, C, D, E, F, G>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n  ): G\n  pipe<A, B, C, D, E, F, G, H>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n  ): H\n  pipe<A, B, C, D, E, F, G, H, I>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n  ): I\n  pipe<A, B, C, D, E, F, G, H, I, J>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n    ij: (i: I) => J,\n  ): J\n}\n\ntype UnaryFn = (arg: unknown) => unknown\n\n/**\n * Create a pipe method implementation.\n * Returns a function that pipes the value through provided functions.\n * This is designed to be used as an object method, so it uses `this` binding.\n */\n// oxlint-disable no-explicit-any, no-this-in-exported-function\nexport function pipeable<A>(this: A, ...fns: UnaryFn[]): any {\n  if (fns.length === 0) return this\n  // oxlint-disable-next-line no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion\n  return (flow as any)(...fns)(this)\n}\n// oxlint-enable no-explicit-any, no-this-in-exported-function\n"],"mappings":"wCAwEA,SAAgB,EAAqB,GAAG,EAAqB,CAG3D,OAFI,EAAI,SAAW,EAAU,KAErB,EAAa,GAAG,EAAI,CAAC,KAAK"}

package/dist/predicate/index.d.mts

@@ -1,2 +1,2 @@
-import { t as predicate_d_exports } from "../index-CNTYbcY9.mjs";
+import { t as predicate_d_exports } from "../index-Pma2THAy.mjs";
 export { predicate_d_exports as Predicate };