@nicolastoulemont/std 0.5.1 → 0.6.0

package/README.md

@@ -1 +1,342 @@
 # @nicolastoulemont/std
+
+## Introduction
+
+`@nicolastoulemont/std` is a functional TypeScript toolkit for modeling domain data, handling failures explicitly, and composing sync or async workflows.
+It is designed for application code where clear control flow, predictable typing, and dependency-aware orchestration matter.
+The API is small, pipe-friendly, and built around practical primitives you can combine incrementally.
+
+## Installation
+
+```bash
+pnpm add @nicolastoulemont/std
+```
+
+## Quick Start
+
+```ts
+import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+
+class InvalidPortError extends TaggedError("InvalidPortError")<{ input: string }> {}
+
+const parsePort = (input: string) =>
+  pipe(
+    Result.try(() => Number.parseInt(input, 10)),
+    Result.filter((n) => Number.isInteger(n) && n > 0, () => new InvalidPortError({ input })),
+  )
+```
+
+```ts
+import { Fx, Layer, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+
+const Config = serviceTag<{ baseUrl: string }>("Config")
+
+const ConfigLive = Layer.ok(Config, { baseUrl: "https://api.example.com" })
+
+const program = Fx.gen(function* () {
+  const config = yield* Config
+  return config.baseUrl
+})
+
+const exit = Fx.run(pipe(program, provide(ConfigLive)))
+
+const response = Fx.match(exit, {
+  Ok: (ok) => ({ status: 200, body: ok.value }),
+  Err: (err) => ({ status: 400, body: err.error }),
+  Defect: (defect) => ({ status: 500, body: String(defect.defect) }),
+})
+```
+
+## Main Modules
+
+### Result
+
+Result models success/failure with typed errors so transformations stay explicit and composable.
+
+#### Abstract Example
+
+```ts
+import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+
+class NotPositiveIntegerError extends TaggedError("NotPositiveIntegerError")<{ input: string }> {}
+
+const parsePositiveInt = (input: string) => {
+  const parsed = Number.parseInt(input, 10)
+  return pipe(
+    Result.ok(parsed),
+    Result.filter((n) => Number.isInteger(n) && n > 0, () => new NotPositiveIntegerError({ input })),
+  )
+}
+```
+
+#### Real-World Example
+
+```ts
+import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+
+class ValidationError extends TaggedError("ValidationError")<{ message: string }> {}
+class ConflictError extends TaggedError("ConflictError")<{ message: string }> {}
+type SignupError = ValidationError | ConflictError
+
+const validateEmail = (email: string) =>
+  email.includes("@")
+    ? Result.ok(email)
+    : Result.err<SignupError>(new ValidationError({ message: "Invalid email" }))
+
+const createUser = (email: string) =>
+  email === "taken@example.com"
+    ? Result.err<SignupError>(new ConflictError({ message: "Email already used" }))
+    : Result.ok({ id: "u_123", email })
+
+const signup = (email: string) => pipe(validateEmail(email), Result.flatMap(createUser))
+```
+
+### Option
+
+Option models optional presence/absence when missing data is expected and not an error condition.
+
+#### Abstract Example
+
+```ts
+import { Option, pipe } from "@nicolastoulemont/std"
+
+const normalizedName = (value: string | undefined) =>
+  pipe(
+    Option.fromNullable(value),
+    Option.map((name) => name.trim()),
+    Option.filter((name) => name.length > 0),
+    Option.unwrapOr("Anonymous"),
+  )
+```
+
+#### Real-World Example
+
+```ts
+import { Option, pipe } from "@nicolastoulemont/std"
+
+const readPagination = (query: URLSearchParams) => ({
+  page: pipe(
+    Option.fromNullable(query.get("page")),
+    Option.map((raw) => Number.parseInt(raw, 10)),
+    Option.filter((n) => Number.isInteger(n) && n > 0),
+    Option.unwrapOr(1),
+  ),
+  limit: pipe(
+    Option.fromNullable(query.get("limit")),
+    Option.map((raw) => Number.parseInt(raw, 10)),
+    Option.filter((n) => Number.isInteger(n) && n > 0 && n <= 100),
+    Option.unwrapOr(20),
+  ),
+})
+```
+
+### Either
+
+Either models two valid branches where both sides are meaningful outcomes rather than success versus failure.
+
+#### Abstract Example
+
+```ts
+import { Either } from "@nicolastoulemont/std"
+
+const parseSource = (input: "local" | "remote") =>
+  input === "local" ? Either.left("LOCAL") : Either.right("REMOTE")
+
+const label = Either.match(parseSource("local"), {
+  Left: (source) => `Source: ${source}`,
+  Right: (source) => `Source: ${source}`,
+})
+```
+
+#### Real-World Example
+
+```ts
+import { Either, pipe } from "@nicolastoulemont/std"
+
+type Source = "cache" | "database"
+type User = { id: string; name: string }
+
+const findUser = (id: string) =>
+  id.startsWith("cached:")
+    ? Either.left<Source, User>("cache")
+    : Either.right<Source, User>({ id, name: "Ada" })
+
+const responseMeta = (id: string) =>
+  pipe(
+    findUser(id),
+    Either.match({
+      Left: (source) => ({ source, stale: true }),
+      Right: (user) => ({ source: "database" as const, stale: false, user }),
+    }),
+  )
+```
+
+### Fx
+
+Fx models generator-based effects with typed dependencies and short-circuiting typed failures.
+
+#### Abstract Example
+
+```ts
+import { Fx, Layer, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+
+const Clock = serviceTag<{ now: () => number }>("Clock")
+const ClockLive = Layer.ok(Clock, { now: () => Date.now() })
+
+const program = Fx.gen(function* () {
+  const clock = yield* Clock
+  return clock.now()
+})
+
+const exit = Fx.run(pipe(program, provide(ClockLive)))
+
+const timestamp = Fx.match(exit, {
+  Ok: (ok) => ok.value,
+  Err: () => 0,
+  Defect: () => 0,
+})
+```
+
+#### Real-World Example
+
+```ts
+import { Fx, Layer, Result, TaggedError, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+
+const Api = serviceTag<{ postOrder: (input: { sku: string; qty: number }) => Promise<{ orderId: string }> }>("Api")
+const ApiLive = Layer.ok(Api, {
+  postOrder: async () => ({ orderId: "ord_42" }),
+})
+
+class InvalidQuantityError extends TaggedError("InvalidQuantityError")<{ qty: number }> {}
+
+const submitOrder = Fx.gen(function* (payload: { sku?: string; qty: number }) {
+  const api = yield* Api
+  const sku = yield* Fx.option(payload.sku)
+  const validQty = yield* Result.filter(
+    Result.ok(payload.qty),
+    (qty) => qty > 0,
+    (qty) => new InvalidQuantityError({ qty }),
+  )
+  return yield* Fx.try(() => api.postOrder({ sku, qty: validQty }))
+})
+
+const exit = Fx.run(pipe(submitOrder({ sku: "book-1", qty: 2 }), provide(ApiLive)))
+
+const httpResponse = Fx.match(exit, {
+  Ok: (ok) => ({ status: 201, body: ok.value }),
+  Err: (err) => ({ status: 400, body: String(err.error) }),
+  Defect: () => ({ status: 500, body: "Unexpected defect" }),
+})
+```
+
+### Adt
+
+Adt provides schema-backed tagged variants so you can model domain state with exhaustive pattern matching.
+
+#### Abstract Example
+
+```ts
+import { Adt, type AdtInfer } from "@nicolastoulemont/std"
+import { z } from "zod"
+
+const Shape = Adt.union("Shape", {
+  Circle: z.object({ radius: z.number() }),
+  Square: z.object({ side: z.number() }),
+})
+type Shape = AdtInfer<typeof Shape>
+
+const describeShape = (shape: Shape) =>
+  Adt.match(shape, {
+    Circle: (value) => `circle(${value.radius})`,
+    Square: (value) => `square(${value.side})`,
+  })
+```
+
+#### Real-World Example
+
+```ts
+import { Adt, type AdtInfer } from "@nicolastoulemont/std"
+import { z } from "zod"
+
+const OrderState = Adt.union("OrderState", {
+  Draft: z.object({ id: z.string() }),
+  Confirmed: z.object({ id: z.string(), paymentId: z.string() }),
+  Shipped: z.object({ id: z.string(), trackingId: z.string() }),
+})
+type OrderState = AdtInfer<typeof OrderState>
+
+const badgeLabel = (state: OrderState) =>
+  Adt.match(state, {
+    Draft: () => "Waiting for payment",
+    Confirmed: () => "Preparing shipment",
+    Shipped: (value) => `Shipped: ${value.trackingId}`,
+  })
+```
+
+### Data
+
+Data creates immutable structural value objects (`Data.struct`, `Data.tuple`, `Data.array`, `Data.tagged`) with stable equality and hashing semantics.
+
+#### Abstract Example
+
+```ts
+import { Data } from "@nicolastoulemont/std"
+
+const a = Data.struct({ env: "prod", retries: 3 })
+const b = Data.struct({ env: "prod", retries: 3 })
+
+const same = a.equals(b) // true
+```
+
+#### Real-World Example
+
+```ts
+import { Data } from "@nicolastoulemont/std"
+
+const previous = Data.struct({ search: "books", sort: "price-asc" })
+const next = Data.struct({ search: "books", sort: "price-asc" })
+
+if (previous.equals(next)) {
+  // Skip redundant fetch because filter state is structurally identical
+}
+```
+
+### pipe / flow
+
+pipe and flow compose sync/async transformations into readable, type-inferred data pipelines.
+
+#### Abstract Example
+
+```ts
+import { pipe, flow } from "@nicolastoulemont/std"
+
+const toLabel = flow(
+  (n: number) => n * 2,
+  (n) => n.toString(),
+  (s) => `value:${s}`,
+)
+
+const result = pipe(10, (n) => n + 1, toLabel) // "value:22"
+```
+
+#### Real-World Example
+
+```ts
+import { pipe } from "@nicolastoulemont/std"
+
+type RawProfile = { name?: string; age?: string }
+
+const normalizeProfile = (input: RawProfile) =>
+  pipe(
+    input,
+    (p) => ({ name: p.name?.trim() ?? "", age: Number.parseInt(p.age ?? "0", 10) }),
+    (p) => ({ ...p, age: Number.isNaN(p.age) ? 0 : p.age }),
+    (p) => ({ ...p, isAdult: p.age >= 18 }),
+  )
+```
+
+## Documentation
+
+- Usage examples: `EXAMPLES.md`
+- Fx integration notes: `docs/fx-react-integration.md`
+- JSDoc conventions: `docs/jsdoc-style.md`

package/dist/adt/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as VariantNames, a as record, c as CodecDef, d as Infer, f as InferInput, g as ValidationError, h as RecordObject, i as data, l as CodecError, m as RecordDef, n as MatchHandlers, o as ADT, p as InferOutput, r as match, s as CodecConstraint, t as createCodecError, u as ExtractSchema, v as VariantOf } from "../index-DLlx9jiG.mjs";
-export { ADT, CodecConstraint, CodecDef, CodecError, ExtractSchema, Infer, InferInput, InferOutput, MatchHandlers, RecordDef, RecordObject, ValidationError, VariantNames, VariantOf, createCodecError, data, match, record };
+import { a as AdtCodecError, c as AdtInferInput, d as AdtValidationError, f as AdtVariant, g as AdtMatchHandlers, h as AdtVariantOf, i as AdtCodecDef, l as AdtInferOutput, m as AdtVariantNames, n as Adt, o as AdtExtractSchema, p as AdtVariantDef, r as AdtCodecConstraint, s as AdtInfer, t as createCodecError, u as AdtUnion } from "../index-C4v_3f3-.mjs";
+export { Adt, AdtCodecConstraint, AdtCodecDef, AdtCodecError, AdtExtractSchema, AdtInfer, AdtInferInput, AdtInferOutput, AdtMatchHandlers, AdtUnion, AdtValidationError, AdtVariant, AdtVariantDef, AdtVariantNames, AdtVariantOf, createCodecError };

package/dist/adt/index.mjs

@@ -1 +1 @@
-import{i as e,n as t,r as n,t as r}from"../adt-DZmVJG4P.mjs";export{e as createCodecError,t as data,r as match,n as record};
+import{n as e,t}from"../adt-CkRcY_GA.mjs";export{t as Adt,e as createCodecError};

package/dist/adt-CkRcY_GA.mjs

@@ -0,0 +1,2 @@
+import{i as e,n as t,r as n,t as r}from"./equality-CD4_A1Op.mjs";import{n as i}from"./flow-CYjiodlC.mjs";import{f as a,r as o}from"./result-CgGYLp0L.mjs";function s(e,t){let n=t[e._tag];return n(e)}function c(e){return typeof e!=`object`||!e?!1:Object.getPrototypeOf(e)===null||Object.getPrototypeOf(e)===Object.prototype}function l(e){return typeof e==`function`&&`_variant`in e&&e._variant===!0}function u(e){return e.issues?o({issues:e.issues.map(e=>({message:e.message,path:e.path?.map(e=>typeof e==`object`&&`key`in e?e.key:e)}))}):a(e.value)}function d(e,t,n){let r=e[`~standard`].validate(t);if(i(r))throw Error(`Async validation not supported. Schema for "${n}" returned a Promise. Use a synchronous schema or handle async validation separately.`);return u(r)}function f(e){return t=>c(t)&&`_tag`in t&&t._tag===e}function p(e){let t=new Set(e);return e=>c(e)&&`_tag`in e&&typeof e._tag==`string`&&t.has(e._tag)}function m(e,t,n,r){return n!==void 0&&r!==void 0?{kind:e,message:t,cause:n,validationIssues:r}:n===void 0?r===void 0?{kind:e,message:t}:{kind:e,message:t,validationIssues:r}:{kind:e,message:t,cause:n}}function h(e){return{to:e=>JSON.stringify(e),from:e=>{try{let t=JSON.parse(e);if(typeof t==`object`&&t&&`_tag`in t){let{_tag:e,...n}=t;return n}return t}catch{return null}}}}function g(e,t,n){let r=h(e),i={json:n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(r.to(i.value))}catch(e){return o(m(`EncodingError`,`JSON encoding failed: ${e instanceof Error?e.message:String(e)}`,e))}}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(s.to(i.value))}catch(e){return o(m(`EncodingError`,`Encoding with codec '${r}' failed: ${e instanceof Error?e.message:String(e)}`,e))}};return i}function _(e,t,n){let r=h(e),i={json:n=>{let i=r.from(n);if(i===null)return o(m(`DecodingError`,`Invalid JSON format`));let s=d(t,{...i,_tag:e},e);return s._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,s.error.issues)):a({...s.value,_tag:e})}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i;try{i=s.from(n)}catch(e){return o(m(`DecodingError`,`Decoding with codec '${r}' threw an error`,e))}if(i===null)return o(m(`DecodingError`,`Codec '${r}' failed to decode input`));let c=d(t,{...i,_tag:e},e);return c._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,c.error.issues)):a({...c.value,_tag:e})};return i}function v(t,r,i){let s=f(t),c=g(t,r,i),l=_(t,r,i),u=n(t),p=e(t),m=e=>{let n=d(r,{...e,_tag:t},t);return n._tag===`Err`?o(n.error):a({...n.value,_tag:t})};return m._variant=!0,m._tag=t,m.schema=r,i&&(m.codecs=i),m.is=s,m.to=c,m.from=l,m.equals=u,m.hash=p,m}function y(e,n){let i=Object.keys(n),a={};for(let[e,t]of Object.entries(n))l(t)?t._tag===e?a[e]=t:t.codecs?a[e]=v(e,t.schema,t.codecs):a[e]=v(e,t.schema):a[e]=v(e,t);return{_name:e,is:p(i),equals:r(i),hash:t(i),...a}}const b={union:y,variant:v,match:s};export{m as n,b as t};
+//# sourceMappingURL=adt-CkRcY_GA.mjs.map

package/dist/adt-CkRcY_GA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adt-CkRcY_GA.mjs","names":[],"sources":["../src/adt/adt.match.ts","../src/shared/is-plain-object.ts","../src/adt/adt.utils.ts","../src/adt/adt.codec.ts","../src/adt/adt.variant.ts","../src/adt/adt.union.ts","../src/adt/adt.ts"],"sourcesContent":["/**\n * Handler functions for each variant in a discriminated union.\n * Each key maps to a function that receives the variant value and returns TResult.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n */\nexport type AdtMatchHandlers<T extends { readonly _tag: string }, TResult> = {\n  [K in T[\"_tag\"]]: (value: Extract<T, { readonly _tag: K }>) => TResult\n}\n\n/**\n * Exhaustive pattern matching for discriminated unions.\n *\n * TypeScript will error if any variant is missing from handlers,\n * ensuring exhaustive handling of all cases.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n * @template Handlers - The handler object type (inferred)\n * @param value - A discriminated union value with _tag\n * @param handlers - An object with a handler function for each variant\n * @returns The result of calling the matching handler\n *\n * @see {@link union} for creating discriminated unions\n * @see {@link variant} for creating individual variant types\n *\n * @example\n * ```ts\n * const Shape = union('Shape', { Circle, Square })\n * type Shape = AdtInfer<typeof Shape>\n *\n * function describeShape(shape: Shape): string {\n *   return match(shape, {\n *     Circle: (c) => `Circle with radius ${c.radius}`,\n *     Square: (s) => `Square with size ${s.size}`,\n *   })\n * }\n * ```\n */\nexport function match<\n  T extends { readonly _tag: string },\n  TResult,\n  Handlers extends AdtMatchHandlers<T, TResult> = AdtMatchHandlers<T, TResult>,\n>(value: T, handlers: Handlers): TResult {\n  const tag = value._tag as keyof Handlers\n  const handler = handlers[tag]\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-argument, no-unsafe-type-assertion -- Required for variant dispatch\n  return handler(value as any)\n}\n","/**\n * Check if a value is a plain object.\n * A plain object is an object created with `{}`, `Object.create(null)`, or `new Object()`.\n * Arrays, functions, dates, maps, etc. are not considered plain objects.\n */\nexport function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (value === null || typeof value !== \"object\") {\n    return false\n  }\n\n  return Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === Object.prototype\n}\n","import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport { isPlainObject } from \"../shared/is-plain-object\"\nimport { isPromise } from \"../shared/is-promise\"\nimport type { AdtVariant, AdtValidationError } from \"./adt.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Check if a value is an AdtVariant created by variant().\n * AdtVariants are callable functions with static properties.\n */\nexport function isVariant(value: unknown): value is AdtVariant {\n  return typeof value === \"function\" && \"_variant\" in value && value[\"_variant\"] === true\n}\n\n/**\n * Wrap Standard Schema validation result into our Result type.\n */\nfunction wrapValidationResult<T>(result: StandardSchemaV1.Result<T>): Result<T, AdtValidationError> {\n  if (result.issues) {\n    return err({\n      issues: result.issues.map((issue) => ({\n        message: issue.message,\n        path: issue.path?.map((segment) => (typeof segment === \"object\" && \"key\" in segment ? segment.key : segment)),\n      })),\n    })\n  }\n  return ok(result.value)\n}\n\n/**\n * Validate data using a Standard Schema, enforcing sync-only validation.\n * Throws if the schema returns a Promise.\n */\nexport function validateSync<T>(\n  schema: StandardSchemaV1<unknown, T>,\n  data: unknown,\n  _tag: string,\n): Result<T, AdtValidationError> {\n  const result = schema[\"~standard\"].validate(data)\n\n  if (isPromise(result)) {\n    throw new Error(\n      `Async validation not supported. Schema for \"${_tag}\" returned a Promise. ` +\n        `Use a synchronous schema or handle async validation separately.`,\n    )\n  }\n\n  return wrapValidationResult(result)\n}\n\n/**\n * Create a type guard function for a specific _tag.\n */\nexport function createIsGuard<Tag extends string, T>(\n  _tag: Tag,\n): (value: unknown) => value is T & { readonly _tag: Tag } {\n  return (value: unknown): value is T & { readonly _tag: Tag } => {\n    return isPlainObject(value) && \"_tag\" in value && value[\"_tag\"] === _tag\n  }\n}\n\n/**\n * Create a type guard function for multiple _tags (AdtUnion root guard).\n */\nexport function createIsAnyGuard<T>(_tags: readonly string[]): (value: unknown) => value is T {\n  const _tagSet = new Set(_tags)\n  return (value: unknown): value is T => {\n    return isPlainObject(value) && \"_tag\" in value && typeof value[\"_tag\"] === \"string\" && _tagSet.has(value[\"_tag\"])\n  }\n}\n","import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type {\n  AdtCodecConstraint,\n  AdtCodecDef,\n  AdtCodecError,\n  AdtInferInput,\n  AdtInferOutput,\n  AdtValidationError,\n  ToMethods,\n  FromMethods,\n} from \"./adt.types\"\nimport { validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a AdtCodecError with consistent structure.\n */\nexport function createCodecError(\n  kind: AdtCodecError[\"kind\"],\n  message: string,\n  cause?: unknown,\n  validationIssues?: AdtValidationError[\"issues\"],\n): AdtCodecError {\n  if (cause !== undefined && validationIssues !== undefined) {\n    return { kind, message, cause, validationIssues }\n  }\n  if (cause !== undefined) {\n    return { kind, message, cause }\n  }\n  if (validationIssues !== undefined) {\n    return { kind, message, validationIssues }\n  }\n  return { kind, message }\n}\n\n/**\n * Built-in JSON codec that works with any schema.\n * Encodes to JSON string and decodes with JSON.parse.\n */\nfunction createJsonCodec<Tag extends string, S extends StandardSchemaV1>(\n  _tag: Tag,\n): AdtCodecDef<AdtInferOutput<S> & Discriminator<Tag>, string, AdtInferInput<S>> {\n  return {\n    to: (value) => {\n      // JSON.stringify can throw for circular references, BigInt, etc.\n      // We let it throw and catch it in the wrapper\n      return JSON.stringify(value)\n    },\n    /* oxlint-disable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return -- Required for JSON parsing which returns unknown types */\n    from: (input: string) => {\n      try {\n        const parsed = JSON.parse(input)\n        // Return parsed object without _tag - it will be added during validation\n        if (typeof parsed === \"object\" && parsed !== null && \"_tag\" in parsed) {\n          const { _tag: _, ...rest } = parsed\n          return rest as AdtInferInput<S>\n        }\n        return parsed\n      } catch {\n        return null\n      }\n    },\n    /* oxlint-enable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return */\n  }\n}\n\n/**\n * Create the \"to\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createToMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): ToMethods<S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const to: Record<string, (value: AdtInferInput<S>) => Result<any, AdtCodecError>> = {\n    json: (value: AdtInferInput<S>): Result<string, AdtCodecError> => {\n      // First, create a validated variant to ensure the encoded payload is well-typed.\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input into object\n      const taggedInput = { ...(value as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\n            \"ValidationError\",\n            `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n            undefined,\n            result.error.issues,\n          ),\n        )\n      }\n\n      try {\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n        return ok(jsonCodec.to(result.value as Output))\n      } catch (e) {\n        return err(\n          createCodecError(\"EncodingError\", `JSON encoding failed: ${e instanceof Error ? e.message : String(e)}`, e),\n        )\n      }\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      to[name] = (value: AdtInferInput<S>): Result<any, AdtCodecError> => {\n        // Validate input first\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n        const taggedInput = { ...(value as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        try {\n          // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n          return ok(codec.to(result.value as Output))\n        } catch (e) {\n          return err(\n            createCodecError(\n              \"EncodingError\",\n              `Encoding with codec '${name}' failed: ${e instanceof Error ? e.message : String(e)}`,\n              e,\n            ),\n          )\n        }\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return to as ToMethods<S, Codecs>\n}\n\n/**\n * Create the \"from\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createFromMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): FromMethods<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const from: Record<string, (input: any) => Result<Output, AdtCodecError>> = {\n    json: (input: string): Result<Output, AdtCodecError> => {\n      // Decode\n      const decoded = jsonCodec.from(input)\n      if (decoded === null) {\n        return err(createCodecError(\"DecodingError\", \"Invalid JSON format\"))\n      }\n\n      // Validate through schema\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n      const taggedInput = { ...(decoded as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\"ValidationError\", \"Decoded data failed schema validation\", undefined, result.error.issues),\n        )\n      }\n\n      // Ensure _tag in output\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n      const output = { ...(result.value as object), _tag } as Output\n      return ok(output)\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      from[name] = (input: unknown): Result<Output, AdtCodecError> => {\n        // Decode\n        let decoded: unknown\n        try {\n          decoded = codec.from(input)\n        } catch (e) {\n          return err(createCodecError(\"DecodingError\", `Decoding with codec '${name}' threw an error`, e))\n        }\n\n        if (decoded === null) {\n          return err(createCodecError(\"DecodingError\", `Codec '${name}' failed to decode input`))\n        }\n\n        // Validate through schema\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n        const taggedInput = { ...(decoded as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              \"Decoded data failed schema validation\",\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        // Ensure _tag in output\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n        const output = { ...(result.value as object), _tag } as Output\n        return ok(output)\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return from as FromMethods<Tag, S, Codecs>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport { createToMethods, createFromMethods } from \"./adt.codec\"\nimport type { AdtCodecConstraint, AdtInferInput, AdtInferOutput, AdtVariant, AdtValidationError } from \"./adt.types\"\nimport { createIsGuard, validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a standalone tagged variant from a Standard Schema with optional codecs.\n *\n * Variants can be used independently or composed into an AdtUnion via union().\n * All defaults should be defined at the schema level (e.g., Zod's .default()).\n *\n * @template Tag - The string literal type for the _tag discriminator\n * @template S - The Standard Schema type for validation\n * @template Codecs - Optional codec definitions for custom serialization formats\n * @param _tag - The _tag discriminator value\n * @param schema - A Standard Schema compliant validator\n * @param codecs - Optional codec definitions for custom serialization formats\n * @returns A callable AdtVariant with is(), to, and from methods\n *\n * @see {@link union} for composing variants into discriminated unions\n * @see {@link tagged} for unvalidated tagged value constructors\n *\n * @example\n * ```ts\n * const CircleSchema = z.object({\n *   radius: z.number().positive(),\n *   color: z.string().default('blue')\n * })\n *\n * // Basic variant with JSON codec (always included)\n * const Circle = variant('Circle', CircleSchema)\n *\n * const result = Circle({ radius: 10 })\n * // { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 10, color: \"blue\" } }\n *\n * Circle.is(someValue) // type guard\n *\n * const json = Circle.to.json({ radius: 10 }) // JSON string\n * const result2 = Circle.from.json(json) // Result<Circle, AdtCodecError>\n *\n * // Variant with custom codec\n * const Circle2 = variant('Circle', CircleSchema, {\n *   graphic: {\n *     to: (circle) => `(${circle.radius})`,\n *     from: (input: string) => {\n *       const match = input.match(/^\\((\\d+)\\)$/)\n *       return match ? { radius: parseInt(match[1]!) } : null\n *     }\n *   }\n * })\n *\n * const graphic = Circle2.to.graphic({ radius: 10 }) // \"(10)\"\n * const result3 = Circle2.from.graphic(\"(10)\") // Result<Circle, AdtCodecError>\n * ```\n */\n// Overload: with codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag, S>>(\n  _tag: Tag,\n  schema: S,\n  codecs: Codecs,\n): AdtVariant<Tag, S, Codecs>\n\n// Overload: without codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1>(_tag: Tag, schema: S): AdtVariant<Tag, S>\n\n// Implementation\nexport function variant<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined,\n>(_tag: Tag, schema: S, codecs?: Codecs): AdtVariant<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const isGuard = createIsGuard<Tag, Output>(_tag)\n  const to = createToMethods(_tag, schema, codecs)\n  const from = createFromMethods(_tag, schema, codecs)\n  const equals = createEqualsMethod<Tag, AdtInferOutput<S>>(_tag)\n  const hash = createHashMethod<Tag, AdtInferOutput<S>>(_tag)\n\n  // Constructor function\n  const constructor = (input: AdtInferInput<S>): Result<Output, AdtValidationError> => {\n    // Add _tag to the input before validation\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n    const taggedInput = { ...(input as object), _tag }\n\n    // Validate using the schema\n    const result = validateSync(schema, taggedInput, _tag)\n\n    if (result._tag === \"Err\") {\n      return err(result.error)\n    }\n\n    // Ensure _tag is in the output (schema might strip unknown keys)\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n    const output = { ...(result.value as object), _tag } as Output\n    return ok(output)\n  }\n\n  // Attach static properties to constructor function\n  constructor._variant = true as const\n  constructor._tag = _tag\n  constructor.schema = schema\n  if (codecs) {\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Conditional assignment of codecs\n    ;(constructor as { codecs?: Codecs }).codecs = codecs\n  }\n  constructor.is = isGuard\n  constructor.to = to\n  constructor.from = from\n  constructor.equals = equals\n  constructor.hash = hash\n\n  return constructor as AdtVariant<Tag, S, Codecs>\n}\n","import { createADTEqualsMethod, createADTHashMethod } from \"../equality/equality\"\nimport { variant } from \"./adt.variant\"\nimport type { AdtUnion, AdtVariantDef, AdtVariant } from \"./adt.types\"\nimport { createIsAnyGuard, isVariant } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Compose records or schemas into a discriminated union (AdtUnion).\n *\n * Accepts either:\n * - Pre-built AdtVariants from variant() (codecs are preserved)\n * - Raw Standard Schema validators (will be wrapped internally)\n *\n * When using pre-built records, the object key overrides the original _tag.\n *\n * @template R - Record of variant names to AdtVariants or StandardSchema validators\n * @param name - The name of this AdtUnion (for identification)\n * @param records - An object mapping _tag names to AdtVariants or schemas\n * @returns An AdtUnion object with accessors for each variant\n *\n * @see {@link variant} for creating individual variant types\n * @see {@link match} for exhaustive pattern matching on AdtUnion values\n *\n * @example\n * ```ts\n * // From pre-built variants\n * const Circle = variant('Circle', CircleSchema)\n * const Square = variant('Square', SquareSchema)\n * const Shape = union('Shape', { Circle, Square })\n *\n * // From raw schemas (JSON codec is automatically included)\n * const Shape = union('Shape', {\n *   Circle: CircleSchema,\n *   Square: SquareSchema\n * })\n *\n * // JSON codec works on all variants\n * Shape.Circle.to.json({ radius: 10 })\n * Shape.Circle.from.json(jsonString)\n *\n * // Mixed\n * const Shape = union('Shape', {\n *   Circle,              // Pre-built variant\n *   Square: SquareSchema // Raw schema\n * })\n *\n * // Usage\n * Shape.Circle({ radius: 10 })\n * Shape.is(someValue)        // type guard for any variant\n * Shape.Circle.is(someValue) // type guard for Circle\n * ```\n */\nexport function union<R extends Record<string, AdtVariantDef>>(name: string, records: R): AdtUnion<R> {\n  const tags = Object.keys(records)\n  const variants: Record<string, AdtVariant> = {}\n\n  for (const [_tag, def] of Object.entries(records)) {\n    if (isVariant(def)) {\n      // Pre-built AdtVariant - key overrides original _tag\n      if (def._tag === _tag) {\n        // _tag matches key, use as-is (preserves codecs)\n        variants[_tag] = def\n        // oxlint-disable-next-line strict-boolean-expressions -- codecs can be undefined\n      } else if (def.codecs) {\n        // _tag differs from key - create new variant with key as _tag\n        // Preserve codecs\n        variants[_tag] = variant(_tag, def.schema, def.codecs)\n      } else {\n        // _tag differs from key and no codecs\n        variants[_tag] = variant(_tag, def.schema)\n      }\n    } else {\n      // Raw schema - wrap in variant\n      // Note: Even without custom codecs, this still gets JSON codec!\n      // oxlint-disable-next-line no-unsafe-type-assertion -- def is a StandardSchemaV1 in this branch\n      variants[_tag] = variant(_tag, def as StandardSchemaV1)\n    }\n  }\n\n  // Create the root type guard for any variant\n  const isAnyVariant = createIsAnyGuard(tags)\n  const equals = createADTEqualsMethod(tags)\n  const hash = createADTHashMethod(tags)\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic AdtUnion return type\n  return {\n    _name: name,\n    is: isAnyVariant,\n    equals,\n    hash,\n    ...variants,\n  } as AdtUnion<R>\n}\n","import { match } from \"./adt.match\"\nimport { union } from \"./adt.union\"\nimport { variant } from \"./adt.variant\"\n\nexport const Adt = {\n  union,\n  variant,\n  match,\n} as const\n"],"mappings":"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"}

package/dist/{apply-fn.types-CMgY6WQe.d.mts → apply-fn.types-0g_9eXRy.d.mts}

@@ -5,4 +5,4 @@ type λ<TA extends any[] = any[], TR = any> = (...args: TA) => TR;
 type ApplyFn<F extends λ, Arg> = F extends ((arg: Arg) => infer R) ? R : F extends ((arg: any) => infer R) ? R : never;
 //#endregion
 export { λ as n, ApplyFn as t };
-//# sourceMappingURL=apply-fn.types-CMgY6WQe.d.mts.map
+//# sourceMappingURL=apply-fn.types-0g_9eXRy.d.mts.map

package/dist/{apply-fn.types-CMgY6WQe.d.mts.map → apply-fn.types-0g_9eXRy.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"apply-fn.types-CMgY6WQe.d.mts","names":[],"sources":["../src/shared/lambda.types.ts","../src/shared/apply-fn.types.ts"],"sourcesContent":[],"mappings":";KACY,kDAAkD,OAAO;;;ACMzD,KAAA,OAAO,CAAA,UAAW,CAAX,EAAA,GAAA,CAAA,GAAqB,CAArB,UAAA,CAAA,GAAA,EAAqC,GAArC,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAEf,CAFe,UAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,KAAA"}
+{"version":3,"file":"apply-fn.types-0g_9eXRy.d.mts","names":[],"sources":["../src/shared/lambda.types.ts","../src/shared/apply-fn.types.ts"],"sourcesContent":[],"mappings":";KACY,kDAAkD,OAAO;;;ACMzD,KAAA,OAAO,CAAA,UAAW,CAAX,EAAA,GAAA,CAAA,GAAqB,CAArB,UAAA,CAAA,GAAA,EAAqC,GAArC,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAEf,CAFe,UAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,KAAA"}

package/dist/brand/index.d.mts

@@ -1,2 +1,2 @@
-import { a as unsafeMake, c as BrandKey, d as Unbrand, i as refine, l as BrandRefinement, n as is, o as Brand$1, r as make, s as BrandError, t as Brand, u as Branded } from "../index-DjjJIDaA.mjs";
+import { a as unsafeMake, c as BrandKey, d as Unbrand, i as refine, l as BrandRefinement, n as is, o as Brand$1, r as make, s as BrandError, t as Brand, u as Branded } from "../index-jeC5jyRh.mjs";
 export { Brand, BrandError, BrandKey, BrandRefinement, Brand$1 as BrandType, Branded, Unbrand, is, make, refine, unsafeMake };

package/dist/brand/index.mjs

@@ -1 +1 @@
-import{a as e,i as t,n,r,t as i}from"../brand-BUqMmkzC.mjs";export{i as Brand,n as is,r as make,t as refine,e as unsafeMake};
+import{a as e,i as t,n,r,t as i}from"../brand-Gy0kW6-n.mjs";export{i as Brand,n as is,r as make,t as refine,e as unsafeMake};

package/dist/{brand-BUqMmkzC.mjs → brand-Gy0kW6-n.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./result-B68pxC7l.mjs";const t=e=>e,n=e=>e,r=e=>t=>e(t),i=(t,n)=>r=>{if(!t(r)){let t=typeof n==`function`?n(r):n??`Brand validation failed`;return e.err({_tag:`BrandError`,value:r,message:t})}return e.ok(r)},a={make:t,unsafeMake:n,is:r,refine:i};export{n as a,i,r as n,t as r,a as t};
-//# sourceMappingURL=brand-BUqMmkzC.mjs.map
+import{t as e}from"./result-CgGYLp0L.mjs";const t=e=>e,n=e=>e,r=e=>t=>e(t),i=(t,n)=>r=>{if(!t(r)){let t=typeof n==`function`?n(r):n??`Brand validation failed`;return e.err({_tag:`BrandError`,value:r,message:t})}return e.ok(r)},a={make:t,unsafeMake:n,is:r,refine:i};export{n as a,i,r as n,t as r,a as t};
+//# sourceMappingURL=brand-Gy0kW6-n.mjs.map

package/dist/brand-Gy0kW6-n.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-Gy0kW6-n.mjs","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type { BrandError, Branded, Unbrand, Validator } from \"./brand.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Branding is a deliberate nominal cast at the type level and requires explicit assertions. */\n\n/**\n * Create a branded value without validation.\n * This is a type-level cast with zero runtime cost.\n *\n * Use this when you trust the value source (e.g., from a database)\n * or when validation happens elsewhere.\n *\n * @template B - The branded type\n * @param value - The value to brand\n * @returns The value as a branded type\n *\n * @example\n * ```ts\n * type UserId = Branded<string, \"UserId\">\n *\n * // Trust the value from database\n * const userId = Brand.make<UserId>(row.id)\n *\n * // Or use in a validated factory\n * function createUserId(input: string): UserId {\n *   if (!input.startsWith(\"user_\")) throw new Error(\"Invalid\")\n *   return Brand.make<UserId>(input)\n * }\n * ```\n */\nexport const make = <B extends Branded<unknown, string>>(value: Unbrand<B>): B => {\n  return value as B\n}\n\n/**\n * Alias for make() - explicitly indicates no validation occurs.\n * Prefer this when readability about the lack of validation is important.\n *\n * @template B - The branded type\n * @param value - The value to brand (unchecked)\n * @returns The value as a branded type\n *\n * @example\n * ```ts\n * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * // Explicitly unsafe - reader knows no validation\n * const n = Brand.unsafeMake<PositiveNumber>(-5) // No error, but logically wrong\n * ```\n */\nexport const unsafeMake = <B extends Branded<unknown, string>>(value: Unbrand<B>): B => {\n  return value as B\n}\n\n/**\n * Create a type guard with validation for a branded type.\n * Returns a refinement predicate that narrows to the branded type.\n *\n * @template T - The base type\n * @template K - The brand key (string literal)\n * @param validator - A function that validates the base value\n * @returns A type guard that returns true if validation passes\n *\n * @example\n * ```ts\n * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * const isPositive = Brand.is<number, \"PositiveNumber\">(n => n > 0)\n *\n * const value: number = 42\n * if (isPositive(value)) {\n *   // value is now PositiveNumber\n *   acceptPositive(value) // OK\n * }\n * ```\n */\nexport const is = <T, K extends string>(validator: Validator<T>): ((value: T) => value is Branded<T, K>) => {\n  return (value: T): value is Branded<T, K> => validator(value)\n}\n\n/**\n * Create a validated branded value wrapped in a Result.\n * Returns `Result.ok(brandedValue)` on success, `Result.err(BrandError)` on failure.\n *\n * The returned Result is yieldable in Fx.gen computations via `yield*`.\n *\n * @template B - The branded type\n * @param validator - A function that validates the base value\n * @param errorMessage - Optional custom error message (or function)\n * @returns A function that takes a value and returns a Result\n *\n * @example\n * ```ts\n * type Email = Branded<string, \"Email\">\n *\n * const parseEmail = Brand.refine<Email>(\n *   s => s.includes(\"@\"),\n *   (v) => `Invalid email: ${v}`\n * )\n *\n * // Basic usage\n * const result = parseEmail(\"user@example.com\")\n * // { _tag: \"Ok\", value: \"user@example.com\" }\n *\n * const bad = parseEmail(\"not-an-email\")\n * // { _tag: \"Err\", error: { _tag: \"BrandError\", value: \"not-an-email\", message: \"...\" } }\n *\n * // With Fx.gen computation\n * const computation = Fx.gen(function* () {\n *   const email = yield* parseEmail(input)\n *   return email\n * })\n *\n * // With pipe\n * pipe(\n *   userInput,\n *   parseEmail,\n *   Result.map(email => sendTo(email)),\n *   Result.unwrapOr(defaultEmail)\n * )\n * ```\n */\nexport const refine = <B extends Branded<unknown, string>>(\n  validator: Validator<Unbrand<B>>,\n  errorMessage?: string | ((value: Unbrand<B>) => string),\n): ((value: Unbrand<B>) => ResultType<B, BrandError<Unbrand<B>>>) => {\n  return (value: Unbrand<B>) => {\n    if (!validator(value)) {\n      const msg = typeof errorMessage === \"function\" ? errorMessage(value) : (errorMessage ?? \"Brand validation failed\")\n      return Result.err({ _tag: \"BrandError\" as const, value, message: msg })\n    }\n    return Result.ok(value as B)\n  }\n}\n\n/**\n * Brand namespace containing utilities for nominal typing in TypeScript.\n *\n * Brand types add type-level distinctiveness to primitive types without\n * any runtime overhead. This prevents accidental mixing of semantically\n * different values that share the same structural type.\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n * import type { Branded } from \"@nicolastoulemont/std\"\n *\n * // Define branded types\n * type UserId = Branded<string, \"UserId\">\n * type Email = Branded<string, \"Email\">\n *\n * // Create values\n * const userId = Brand.make<UserId>(\"user-123\")\n * const isValidEmail = Brand.is<Email>(s => s.includes(\"@\"))\n *\n * // Type safety\n * function sendEmail(email: Email) { ... }\n * sendEmail(userId) // Type error! UserId is not Email\n * ```\n */\nexport const Brand = {\n  make,\n  unsafeMake,\n  is,\n  refine,\n} as const\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"0CA+BA,MAAa,EAA4C,GAChD,EAmBI,EAAkD,GACtD,EAyBI,EAA2B,GAC9B,GAAqC,EAAU,EAAM,CA6ClD,GACX,EACA,IAEQ,GAAsB,CAC5B,GAAI,CAAC,EAAU,EAAM,CAAE,CACrB,IAAM,EAAM,OAAO,GAAiB,WAAa,EAAa,EAAM,CAAI,GAAgB,0BACxF,OAAO,EAAO,IAAI,CAAE,KAAM,aAAuB,QAAO,QAAS,EAAK,CAAC,CAEzE,OAAO,EAAO,GAAG,EAAW,EA6BnB,EAAQ,CACnB,OACA,aACA,KACA,SACD"}

package/dist/chunk-DAexk1S7.mjs

@@ -0,0 +1 @@
+var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n&&e(r,Symbol.toStringTag,{value:`Module`}),r};export{t};

package/dist/data/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ArrayValue, c as TaggedValue, i as tagged, l as TupleValue, n as tuple, o as StructValue, r as struct, s as TaggedConstructor, t as array } from "../index-DtAPrec7.mjs";
-export { ArrayValue, StructValue, TaggedConstructor, TaggedValue, TupleValue, array, struct, tagged, tuple };
+import { a as TaggedValue, i as TaggedConstructor, n as ArrayValue, o as TupleValue, r as StructValue, t as Data } from "../index-BzYtgdX0.mjs";
+export { ArrayValue, Data, StructValue, TaggedConstructor, TaggedValue, TupleValue };

package/dist/data/index.mjs

@@ -1 +1 @@
-import{i as e,n as t,r as n,t as r}from"../data-DzqKBCQg.mjs";export{r as array,n as struct,e as tagged,t as tuple};
+import{t as e}from"../data-C0_3MGwm.mjs";export{e as Data};

package/dist/data-C0_3MGwm.mjs

@@ -0,0 +1,2 @@
+import{a as e,i as t,o as n,r}from"./equality-CD4_A1Op.mjs";function i(t){let r=[...t];Object.defineProperty(r,`equals`,{value:t=>e(r,t),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(r,`hash`,{value:()=>n(r),enumerable:!1,writable:!1,configurable:!1});let a=r.map.bind(r);Object.defineProperty(r,`map`,{value:e=>i(a(e)),enumerable:!1,writable:!1,configurable:!1});let o=r.filter.bind(r);Object.defineProperty(r,`filter`,{value:e=>i(o(e)),enumerable:!1,writable:!1,configurable:!1});let s=r.slice.bind(r);Object.defineProperty(r,`slice`,{value:(e,t)=>i(s(e,t)),enumerable:!1,writable:!1,configurable:!1});let c=r.concat.bind(r);return Object.defineProperty(r,`concat`,{value:(...e)=>i(c(...e)),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(r)}function a(t){let r={...t};return Object.defineProperty(r,`equals`,{value:t=>e(r,t),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(r,`hash`,{value:()=>n(r),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(r)}function o(e){let n=t=>Object.freeze({...t,_tag:e});return n.is=t=>typeof t==`object`&&!!t&&`_tag`in t&&t._tag===e,n.equals=r(e),n.hash=t(e),n._tag=e,n}function s(...t){let r=[...t];return Object.defineProperty(r,`equals`,{value:t=>e(r,t),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(r,`hash`,{value:()=>n(r),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(r)}const c={tagged:o,struct:a,tuple:s,array:i};export{c as t};
+//# sourceMappingURL=data-C0_3MGwm.mjs.map

package/dist/data-C0_3MGwm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-C0_3MGwm.mjs","names":[],"sources":["../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":["import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { ArrayValue } from \"./data.types\"\n\n/**\n * Create an array with structural equality.\n *\n * The returned array is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * The map() and filter() methods are overridden to return ArrayValue,\n * enabling method chaining with preserved equality semantics.\n *\n * @template T - The element type of the array\n * @param items - The array elements\n * @returns A frozen array with equals(), hash(), map(), and filter()\n *\n * @see {@link tuple} for fixed-length typed tuples\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const arr1 = array([1, 2, 3])\n * const arr2 = array([1, 2, 3])\n *\n * arr1.equals(arr2) // true\n * arr1.hash() // number\n *\n * // Chainable operations return ArrayValue\n * arr1.map(x => x * 2) // ArrayValue<number>\n * arr1.filter(x => x > 1) // ArrayValue<number>\n *\n * // Chained equality check\n * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true\n *\n * // Array is frozen\n * arr1[0] = 5 // TypeError\n * arr1.push(4) // TypeError\n * ```\n */\nexport function array<T>(items: readonly T[]): ArrayValue<T> {\n  const value = [...items]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly T[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override map to return ArrayValue\n  const originalMap = value.map.bind(value)\n  Object.defineProperty(value, \"map\", {\n    value: <U>(fn: (item: T, index: number, arr: readonly T[]) => U): ArrayValue<U> => {\n      return array(originalMap(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override filter to return ArrayValue\n  const originalFilter = value.filter.bind(value)\n  Object.defineProperty(value, \"filter\", {\n    value: (fn: (item: T, index: number, arr: readonly T[]) => boolean): ArrayValue<T> => {\n      return array(originalFilter(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override slice to return ArrayValue\n  const originalSlice = value.slice.bind(value)\n  Object.defineProperty(value, \"slice\", {\n    value: (start?: number, end?: number): ArrayValue<T> => {\n      return array(originalSlice(start, end))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override concat to return ArrayValue\n  const originalConcat = value.concat.bind(value)\n  Object.defineProperty(value, \"concat\", {\n    value: (...args: readonly (T | readonly T[])[]): ArrayValue<T> => {\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for concat argument spread\n      return array(originalConcat(...(args as T[][])))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic array return type\n  return Object.freeze(value) as unknown as ArrayValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { StructValue } from \"./data.types\"\n\n/**\n * Create a frozen value object with structural equality.\n *\n * Unlike tagged(), struct() does not add a _tag discriminator.\n * Use this for simple value objects that don't need discrimination.\n *\n * The returned object is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The object shape type\n * @param input - The object to wrap\n * @returns A frozen object with equals() and hash() methods\n *\n * @see {@link tagged} for discriminated value objects with _tag\n * @see {@link array} for array value types\n *\n * @example\n * ```ts\n * const point = struct({ x: 10, y: 20 })\n * const point2 = struct({ x: 10, y: 20 })\n *\n * point.equals(point2) // true\n * point.hash() // number\n *\n * // Object is frozen\n * point.x = 5 // TypeError\n *\n * // equals/hash are non-enumerable\n * Object.keys(point) // [\"x\", \"y\"]\n * ```\n */\nexport function struct<T extends Record<string, unknown>>(input: T): StructValue<T> {\n  const value = { ...input }\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: T) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic struct return type\n  return Object.freeze(value) as StructValue<T>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type { TaggedConstructor, TaggedValue } from \"./data.types\"\n\n/**\n * Create a tagged value constructor without schema validation.\n *\n * Unlike variant(), this creates values directly without validation.\n * Values are frozen and have structural equality via equals() and hash() methods.\n *\n * @template T - The data shape type (excluding _tag)\n * @param tag - The _tag discriminator value\n * @returns A constructor function with is(), equals(), and hash() methods\n *\n * @see {@link variant} for validated variant with schema support\n * @see {@link struct} for untagged value objects\n *\n * @example\n * ```ts\n * const Person = tagged<{ name: string; age: number }>(\"Person\")\n *\n * const alice = Person({ name: \"Alice\", age: 30 })\n * // => { _tag: \"Person\", name: \"Alice\", age: 30 }\n *\n * Person.equals(alice, Person({ name: \"Alice\", age: 30 })) // true\n * Person.is(alice) // true\n *\n * // Type guard usage\n * if (Person.is(unknownValue)) {\n *   console.log(unknownValue.name) // TypeScript knows it's a Person\n * }\n *\n * // Values are frozen (immutable)\n * alice.name = \"Bob\" // TypeError\n * ```\n */\nexport function tagged<T extends Record<string, unknown>>(tag: string): TaggedConstructor<typeof tag, T> {\n  type Output = TaggedValue<typeof tag, T>\n\n  // Constructor function\n  const constructor = (input: T): Output => {\n    return Object.freeze({ ...input, _tag: tag }) as Output\n  }\n\n  // Type guard\n  constructor.is = (value: unknown): value is Output => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"_tag\" in value &&\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Already checked with 'in' operator\n      (value as Discriminator)._tag === tag\n    )\n  }\n\n  // Equality (static method on constructor)\n  constructor.equals = createEqualsMethod<typeof tag, T>(tag)\n\n  // Hashing (static method on constructor)\n  constructor.hash = createHashMethod<typeof tag, T>(tag)\n\n  // Store tag for reflection\n  constructor._tag = tag\n\n  return constructor as TaggedConstructor<typeof tag, T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { TupleValue } from \"./data.types\"\n\n/**\n * Create a tuple with structural equality.\n *\n * The returned tuple is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The tuple type as a readonly array of element types\n * @param args - The tuple elements\n * @returns A frozen tuple-like array with equals() and hash() methods\n *\n * @see {@link array} for variable-length arrays with equality\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const t1 = tuple(1, \"hello\", true)\n * const t2 = tuple(1, \"hello\", true)\n *\n * t1.equals(t2) // true\n * t1.hash() // number\n *\n * // Access elements (typed)\n * t1[0] // number\n * t1[1] // string\n * t1[2] // boolean\n *\n * // Tuple is frozen\n * t1[0] = 5 // TypeError\n * ```\n */\nexport function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T> {\n  const value = [...args]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly unknown[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic tuple return type\n  return Object.freeze(value) as unknown as TupleValue<T>\n}\n","import { array } from \"./data.array\"\nimport { struct } from \"./data.struct\"\nimport { tagged } from \"./data.tagged\"\nimport { tuple } from \"./data.tuple\"\n\nexport const Data = {\n  tagged,\n  struct,\n  tuple,\n  array,\n} as const\n"],"mappings":"4DAuCA,SAAgB,EAAS,EAAoC,CAC3D,IAAM,EAAQ,CAAC,GAAG,EAAM,CAGxB,OAAO,eAAe,EAAO,SAAU,CACrC,MAAQ,GAAwB,EAAW,EAAO,EAAM,CACxD,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,OAAO,eAAe,EAAO,OAAQ,CACnC,UAAa,EAAS,EAAM,CAC5B,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,IAAM,EAAc,EAAM,IAAI,KAAK,EAAM,CACzC,OAAO,eAAe,EAAO,MAAO,CAClC,MAAW,GACF,EAAM,EAAY,EAAG,CAAC,CAE/B,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,IAAM,EAAiB,EAAM,OAAO,KAAK,EAAM,CAC/C,OAAO,eAAe,EAAO,SAAU,CACrC,MAAQ,GACC,EAAM,EAAe,EAAG,CAAC,CAElC,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,IAAM,EAAgB,EAAM,MAAM,KAAK,EAAM,CAC7C,OAAO,eAAe,EAAO,QAAS,CACpC,OAAQ,EAAgB,IACf,EAAM,EAAc,EAAO,EAAI,CAAC,CAEzC,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,IAAM,EAAiB,EAAM,OAAO,KAAK,EAAM,CAY/C,OAXA,OAAO,eAAe,EAAO,SAAU,CACrC,OAAQ,GAAG,IAEF,EAAM,EAAe,GAAI,EAAe,CAAC,CAElD,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGK,OAAO,OAAO,EAAM,CCtE7B,SAAgB,EAA0C,EAA0B,CAClF,IAAM,EAAQ,CAAE,GAAG,EAAO,CAmB1B,OAhBA,OAAO,eAAe,EAAO,SAAU,CACrC,MAAQ,GAAa,EAAW,EAAO,EAAM,CAC7C,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,OAAO,eAAe,EAAO,OAAQ,CACnC,UAAa,EAAS,EAAM,CAC5B,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGK,OAAO,OAAO,EAAM,CClB7B,SAAgB,EAA0C,EAA+C,CAIvG,IAAM,EAAe,GACZ,OAAO,OAAO,CAAE,GAAG,EAAO,KAAM,EAAK,CAAC,CAuB/C,MAnBA,GAAY,GAAM,GAEd,OAAO,GAAU,YACjB,GACA,SAAU,GAET,EAAwB,OAAS,EAKtC,EAAY,OAAS,EAAkC,EAAI,CAG3D,EAAY,KAAO,EAAgC,EAAI,CAGvD,EAAY,KAAO,EAEZ,EC/BT,SAAgB,EAAoC,GAAG,EAAwB,CAC7E,IAAM,EAAQ,CAAC,GAAG,EAAK,CAmBvB,OAhBA,OAAO,eAAe,EAAO,SAAU,CACrC,MAAQ,GAA8B,EAAW,EAAO,EAAM,CAC9D,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGF,OAAO,eAAe,EAAO,OAAQ,CACnC,UAAa,EAAS,EAAM,CAC5B,WAAY,GACZ,SAAU,GACV,aAAc,GACf,CAAC,CAGK,OAAO,OAAO,EAAM,CChD7B,MAAa,EAAO,CAClB,SACA,SACA,QACA,QACD"}

package/dist/{discriminator.types-DkThfvNE.d.mts → discriminator.types-9PxvrZki.d.mts}

@@ -4,4 +4,4 @@ type Discriminator<Tag extends string = string> = {
 };
 //#endregion
 export { Discriminator as t };
-//# sourceMappingURL=discriminator.types-DkThfvNE.d.mts.map
+//# sourceMappingURL=discriminator.types-9PxvrZki.d.mts.map

package/dist/discriminator.types-9PxvrZki.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.types-9PxvrZki.d.mts","names":[],"sources":["../src/shared/discriminator.types.ts"],"sourcesContent":[],"mappings":";KAAY;EAAA,SAAA,IAAA,EAA8D,GAAjD"}

package/dist/either/index.d.mts

@@ -1,2 +1,2 @@
-import { A as FlatMapReturn, C as unwrapOr, D as BimapReturn, E as AllObjectReturn, F as OrElseReturn, I as Right, L as RightValue, M as LeftValue, N as MapLeftReturn, O as Either$1, P as MapReturn, R as TapReturn, S as toResult, T as AllArrayReturn, _ as right, a as flatMap, b as tapLeft, c as fromPredicate, d as isRight, f as left, g as orElse, h as match, i as filter, j as Left, k as FilterReturn, l as fromResult, m as mapLeft, n as all, o as fromNullable, p as map, r as bimap, s as fromOption, t as Either, u as isLeft, v as swap, w as unwrapOrElse, x as toOption, y as tap } from "../index-Bs5TTFlK.mjs";
+import { A as FlatMapReturn, C as unwrapOr, D as BimapReturn, E as AllObjectReturn, F as OrElseReturn, I as Right, L as RightValue, M as LeftValue, N as MapLeftReturn, O as Either$1, P as MapReturn, R as TapReturn, S as toResult, T as AllArrayReturn, _ as right, a as flatMap, b as tapLeft, c as fromPredicate, d as isRight, f as left, g as orElse, h as match, i as filter, j as Left, k as FilterReturn, l as fromResult, m as mapLeft, n as all, o as fromNullable, p as map, r as bimap, s as fromOption, t as Either, u as isLeft, v as swap, w as unwrapOrElse, x as toOption, y as tap } from "../index-CklRfom5.mjs";
 export { AllArrayReturn, AllObjectReturn, BimapReturn, Either, Either$1 as EitherType, FilterReturn, FlatMapReturn, Left, LeftValue, MapLeftReturn, MapReturn, OrElseReturn, Right, RightValue, TapReturn, all, bimap, filter, flatMap, fromNullable, fromOption, fromPredicate, fromResult, isLeft, isRight, left, map, mapLeft, match, orElse, right, swap, tap, tapLeft, toOption, toResult, unwrapOr, unwrapOrElse };

package/dist/either/index.mjs

@@ -1 +1 @@
-import{C as e,S as t,_ as n,a as r,b as i,c as a,d as o,f as s,g as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,w as x,x as S,y as C}from"../either-BDY9T5oz.mjs";export{v as Either,p as all,g as bimap,u as filter,r as flatMap,m as fromNullable,_ as fromOption,a as fromPredicate,d as fromResult,y as isLeft,o as isRight,s as left,h as map,f as mapLeft,l as match,c as orElse,n as right,b as swap,C as tap,i as tapLeft,S as toOption,t as toResult,e as unwrapOr,x as unwrapOrElse};
+import{C as e,S as t,_ as n,a as r,b as i,c as a,d as o,f as s,g as c,h as l,i as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,u as y,v as b,w as x,x as S,y as C}from"../either-CPzK-s8W.mjs";export{v as Either,p as all,g as bimap,u as filter,r as flatMap,m as fromNullable,_ as fromOption,a as fromPredicate,d as fromResult,y as isLeft,o as isRight,s as left,h as map,f as mapLeft,l as match,c as orElse,n as right,b as swap,C as tap,i as tapLeft,S as toOption,t as toResult,e as unwrapOr,x as unwrapOrElse};

package/dist/either-CPzK-s8W.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./fx.types-CDVjDn_3.mjs";import{n as t,t as n}from"./pipeable-BA0mXhs4.mjs";import{n as r}from"./flow-CYjiodlC.mjs";import{t as i}from"./result-CgGYLp0L.mjs";import{i as a,n as o}from"./option-DawZC1cE.mjs";const s=t=>({_tag:`Right`,value:t,[e]:{_A:()=>t,_E:()=>void 0,_R:()=>void 0},pipe:n,*[Symbol.iterator](){return t}}),c=t=>({_tag:`Left`,value:t,[e]:{_A:()=>t,_E:()=>void 0,_R:()=>void 0},pipe:n,*[Symbol.iterator](){return t}}),l=e=>e._tag===`Right`,u=e=>e._tag===`Left`,d=t(2,(e,t)=>{if(e._tag===`Left`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(s):s(n)}),f=t(2,(e,t)=>{if(e._tag===`Right`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(c):c(n)}),p=t(3,(e,t,n)=>{if(e._tag===`Right`){let t=n(e.value);return r(t)?Promise.resolve(t).then(s):s(t)}let i=t(e.value);return r(i)?Promise.resolve(i).then(c):c(i)}),m=t(2,(e,t)=>e._tag===`Left`?e:t(e.value)),h=t(2,(e,t)=>{if(e._tag===`Left`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),g=t(2,(e,t)=>{if(e._tag===`Right`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),_=t(2,(e,t)=>e._tag===`Right`?e:t(e.value)),v=()=>e=>e._tag===`Left`?s(e.value):c(e.value),y=t(3,(e,t,n)=>e._tag===`Left`||t(e.value)?e:c(n(e.value))),b=e=>{if(Array.isArray(e)){let t=[];for(let n of e){if(n._tag===`Left`)return n;t.push(n.value)}return s(t)}let t={};for(let n in e){let r=e[n];if(r._tag===`Left`)return r;t[n]=r.value}return s(t)},x=t(2,(e,t)=>e._tag===`Right`?e.value:t),S=t(2,(e,t)=>e._tag===`Right`?e.value:t(e.value)),C=t(2,(e,t)=>e._tag===`Right`?t.Right(e.value):t.Left(e.value)),w=e=>e._tag===`Ok`?s(e.value):c(e.error),T=e=>e._tag===`Right`?i.ok(e.value):i.err(e.value),E=(e,t)=>e._tag===`Some`?s(e.value):c(t()),D=e=>e._tag===`Right`?a(e.value):o(),O=(e,t)=>e==null?c(t()):s(e),k=(e,t,n)=>t(e)?s(e):c(n(e)),A={left:c,right:s,isLeft:u,isRight:l,map:d,mapLeft:f,bimap:p,flatMap:m,tap:h,tapLeft:g,orElse:_,swap:v,filter:y,all:b,unwrapOr:x,unwrapOrElse:S,match:C,fromResult:w,toResult:T,fromOption:E,toOption:D,fromNullable:O,fromPredicate:k};export{x as C,T as S,s as _,m as a,g as b,k as c,l as d,c as f,_ as g,C as h,y as i,w as l,f as m,b as n,O as o,d as p,p as r,E as s,A as t,u,v,S as w,D as x,h as y};
+//# sourceMappingURL=either-CPzK-s8W.mjs.map