{"version":3,"sources":["../src/pipe.ts"],"names":[],"mappings":";;;AAoEO,SAAS,IAAA,CACd,UACG,IAAA,EAC8B;AACjC,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,GAAA,GAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AACvB,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,IACd;AACA,IAAA,OAAO,GAAA;AAAA,EACT,CAAA;AACF","file":"pipe.cjs","sourcesContent":["/**\n * Variadic point-free composition — chains up to nine unary fns left-to-right\n * into one reusable function. The first fn may take multiple arguments; the\n * rest are unary. Use {@link pipe} from `@onrails/result` when you already\n * have a starting value; use {@link flow} to define a reusable composed\n * function with no value yet.\n *\n * @example\n * ```ts\n * const parseUserName = flow(\n *   (raw: string) => parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n *\n * parseUserName(raw); // Result<string, ParseError | { kind: \"missing\" }>\n * ```\n */\nexport function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;\nexport function flow<A extends readonly unknown[], B, C>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends readonly unknown[], B, C, D>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends readonly unknown[], B, C, D, E>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends readonly unknown[], B, C, D, E, F>(\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): (...a: A) => F;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G>(\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): (...a: A) => G;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(\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): (...a: A) => H;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(\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): (...a: A) => I;\nexport function flow(\n  first: (...args: unknown[]) => unknown,\n  ...rest: ReadonlyArray<(x: unknown) => unknown>\n): (...args: unknown[]) => unknown {\n  return (...args: unknown[]) => {\n    let acc = first(...args);\n    for (const fn of rest) {\n      acc = fn(acc);\n    }\n    return acc;\n  };\n}\n"]}