@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/dist/ParseError.js.map

@@ -1 +1 @@
-{"version":3,"file":"ParseError.js","names":[],"sources":["../src/ParseError.ts"],"sourcesContent":["/**\n * The error type produced when running a parser.\n *\n * `ParseError` merges winnow's `ContextError`/`ParseError` and nom's\n * `VerboseError`. It records where parsing failed, what was expected there,\n * the context labels that were active, and an optional typed `cause`\n * produced by `Parser.fail`, `Parser.tryMap` and friends. Its `message`\n * shows the failing position in the input:\n *\n * ```text\n * Parse error at line 1, column 4:\n * 1 | [1,,2]\n *   |    ^\n * expected digit\n * ```\n *\n * `ParseError` is a `Data.TaggedError`, so it can be yielded directly inside\n * `Effect.gen`.\n *\n * @since 0.1.0\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Data from \"effect/Data\"\nimport * as Option from \"effect/Option\"\nimport * as Result from \"effect/Result\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { ErrMode, Failure, Input } from \"./Input.js\"\nimport * as text from \"./internal/text.js\"\n\n/**\n * The kind of parser that produced an error, in the spirit of nom's\n * `ErrorKind`.\n *\n * `\"TooDeep\"` is not produced by a parser: the runners report it when\n * deeply nested input exhausts the call stack (see `Parser.suspend`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type ErrorKind =\n  | \"Alpha\"\n  | \"AlphaNumeric\"\n  | \"Alt\"\n  | \"Assert\"\n  | \"Bits\"\n  | \"Complete\"\n  | \"CrLf\"\n  | \"Digit\"\n  | \"Dispatch\"\n  | \"Eof\"\n  | \"Escaped\"\n  | \"Fail\"\n  | \"Float\"\n  | \"HexDigit\"\n  | \"Incomplete\"\n  | \"LineEnding\"\n  | \"Literal\"\n  | \"Many\"\n  | \"MultiSpace\"\n  | \"NoneOf\"\n  | \"Not\"\n  | \"OctDigit\"\n  | \"OneOf\"\n  | \"Permutation\"\n  | \"Separated\"\n  | \"Slice\"\n  | \"Space\"\n  | \"Take\"\n  | \"TakeUntil\"\n  | \"TakeWhile\"\n  | \"Token\"\n  | \"TooDeep\"\n  | \"Verify\"\n\n/**\n * @since 0.1.0\n * @category type ids\n */\nexport const TypeId = \"~effect-parse/ParseError\" as const\n\n/**\n * An error produced by running a parser.\n *\n * @since 0.1.0\n * @category models\n */\nexport class ParseError<out E = never>\n  extends /*#__PURE__*/ Data.TaggedError(\"ParseError\")<{\n    /** The input that was being parsed. */\n    readonly input: Input\n    /** The offset of the failure in the input. */\n    readonly offset: number\n    /** The kind of parser that failed. */\n    readonly kind: ErrorKind\n    /** How the error propagated before parsing stopped. */\n    readonly mode: ErrMode\n    /** Descriptions of what was expected at `offset`. */\n    readonly expected: ReadonlyArray<string>\n    /** Context labels (`Parser.context`), innermost first. */\n    readonly context: ReadonlyArray<string>\n    /** The user supplied cause, if any. */\n    readonly cause: E | undefined\n    /** An optional free-form description. */\n    readonly description: string | undefined\n    /**\n     * For byte inputs parsed by `Text` parsers, the text encoding. Errors\n     * then show the input as text, with line and column numbers.\n     */\n    readonly encoding?: Encoding<Uint8Array> | undefined\n  }>\n{\n  /**\n   * @since 0.1.0\n   */\n  readonly [TypeId]: typeof TypeId = TypeId\n\n  /**\n   * The 1-based line and column of the failure (for strings and encoded\n   * text; for other inputs the line is 1 and the column is `offset + 1`).\n   *\n   * @since 0.1.0\n   */\n  get position(): LineColumn {\n    return lineColumn(this.input, this.offset, this.encoding)\n  }\n\n  /**\n   * The rendered, human-readable error message.\n   *\n   * @since 0.1.0\n   */\n  override get message(): string {\n    return render(this)\n  }\n\n  /**\n   * @since 0.1.0\n   */\n  override toString(): string {\n    return `ParseError: ${this.message}`\n  }\n}\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isParseError = (u: unknown): u is ParseError<unknown> => Predicate.isObjectOrArray(u) && TypeId in u\n\n/**\n * Builds a `ParseError` from the failure details recorded while parsing.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const fromFailure = <E = never>(\n  input: Input,\n  failure: Failure,\n  mode: ErrMode,\n  encoding?: Encoding<any> | undefined\n): ParseError<E> =>\n  new ParseError<E>({\n    input,\n    offset: failure.offset,\n    kind: failure.kind,\n    mode,\n    expected: failure.expected,\n    context: failure.context,\n    cause: failure.hasCause ? (failure.cause as E) : undefined,\n    description: failure.message,\n    encoding: input instanceof Uint8Array ? encoding : undefined\n  })\n\n/**\n * The user supplied cause of an error, if any.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const getCause = <E>(self: ParseError<E>): Option.Option<E> =>\n  self.cause === undefined ? Option.none() : Option.some(self.cause)\n\n/**\n * A 1-based line/column position.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LineColumn {\n  readonly line: number\n  readonly column: number\n}\n\n/**\n * Computes the 1-based line and column (in code points) of an offset. Lines\n * are separated by `\\n`. Byte inputs are read as text when an `encoding`\n * is given. For other inputs the line is always 1 and the column is\n * `offset + 1`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const lineColumn = (input: Input, offset: number, encoding?: Encoding<any> | undefined): LineColumn => {\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    let line = 1\n    let column = 1\n    text.walk(encoding, input, 0, Math.min(offset, input.length), (cp) => {\n      if (cp === 10) {\n        line++\n        column = 1\n      } else {\n        column++\n      }\n    })\n    return { line, column }\n  }\n  if (!Predicate.isString(input)) return { line: 1, column: offset + 1 }\n  let line = 1\n  let lineStart = 0\n  for (let i = 0; i < offset && i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) {\n      line++\n      lineStart = i + 1\n    }\n  }\n  return { line, column: codePointCount(input, lineStart, Math.min(offset, input.length)) + 1 }\n}\n\nconst codePointCount = (s: string, start: number, end: number): number => {\n  let n = 0\n  for (let i = start; i < end; i++) {\n    const c = s.charCodeAt(i)\n    if (c >= 0xd800 && c <= 0xdbff && i + 1 < end) {\n      const d = s.charCodeAt(i + 1)\n      if (d >= 0xdc00 && d <= 0xdfff) i++\n    }\n    n++\n  }\n  return n\n}\n\n/**\n * Formats a list of expectations: `a`, `a or b`, `a, b or c`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const formatExpected = (expected: ReadonlyArray<string>): string => {\n  if (Arr.isReadonlyArrayEmpty(expected)) return \"\"\n  if (expected.length === 1) return expected[0]\n  return `${expected.slice(0, -1).join(\", \")} or ${expected[expected.length - 1]}`\n}\n\nconst hexBytes = (bytes: Uint8Array): string =>\n  Array.from(bytes, (b) => `0x${b.toString(16).padStart(2, \"0\")}`).join(\" \")\n\nconst describeFound = (input: Input, offset: number, encoding: Encoding<any> | undefined): string => {\n  if (offset >= input.length) return \"end of input\"\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    const cp = encoding.decode(input, offset, input.length)\n    if (cp >= 0) return JSON.stringify(String.fromCodePoint(cp))\n    const bad = input.subarray(offset, Math.min(input.length, offset + Math.max(encoding.unit, 1)))\n    return cp === text.Truncated\n      ? `incomplete ${encoding.name} sequence ${hexBytes(input.subarray(offset))}`\n      : `invalid ${encoding.name} ${hexBytes(bad)}`\n  }\n  if (Predicate.isString(input)) {\n    const cp = input.codePointAt(offset) ?? Number.NaN\n    return JSON.stringify(String.fromCodePoint(cp))\n  }\n  if (input instanceof Uint8Array) {\n    return `0x${input[offset].toString(16).padStart(2, \"0\")}`\n  }\n  return inspectToken(input[offset])\n}\n\n/** @internal */\nexport const inspectToken = (u: unknown): string => {\n  if (Predicate.isString(u)) return JSON.stringify(u)\n  if (Predicate.isObjectOrArray(u)) {\n    // `JSON.stringify` throws on cycles and `BigInt`s\n    return Result.getOrElse(\n      Result.try(() => JSON.stringify(u)),\n      () => String(u)\n    )\n  }\n  return String(u)\n}\n\nconst causeMessage = (cause: unknown): string | undefined => {\n  if (cause === undefined) return undefined\n  if (Predicate.isString(cause)) return cause\n  // An `Error`'s message, or any other object's string `message`\n  if (Predicate.isObjectOrArray(cause) && \"message\" in cause && Predicate.isString(cause.message)) {\n    return cause.message\n  }\n  return inspectToken(cause)\n}\n\nconst renderSnippet = (input: Input, offset: number, encoding: Encoding<any> | undefined): Array<string> => {\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    // Find the line containing `offset`, then decode it\n    let lineStart = 0\n    let end = input.length\n    let column = 1\n    text.walk(encoding, input, 0, input.length, (cp, i, w) => {\n      if (i >= offset && cp === 10) {\n        end = i\n        return false\n      }\n      if (i < offset) {\n        if (cp === 10) {\n          lineStart = i + w\n          column = 1\n        } else {\n          column++\n        }\n      }\n    })\n    let line = text.lenientText(encoding, input, lineStart, end)\n    if (line.endsWith(\"\\r\")) line = line.slice(0, -1)\n    const gutter = String(lineColumn(input, offset, encoding).line)\n    const pad = \" \".repeat(gutter.length)\n    return [`${gutter} | ${line}`, `${pad} | ${\" \".repeat(column - 1)}^`]\n  }\n  if (Predicate.isString(input)) {\n    const { column, line } = lineColumn(input, offset)\n    let start = offset\n    while (start > 0 && input.charCodeAt(start - 1) !== 10) start--\n    let end = offset\n    while (end < input.length && input.charCodeAt(end) !== 10) end++\n    let text = input.slice(start, end)\n    if (text.endsWith(\"\\r\")) text = text.slice(0, -1)\n    const gutter = String(line)\n    const pad = \" \".repeat(gutter.length)\n    return [`${gutter} | ${text}`, `${pad} | ${\" \".repeat(column - 1)}^`]\n  }\n  if (input instanceof Uint8Array) {\n    const start = Math.max(0, offset - 8)\n    const end = Math.min(input.length, offset + 8)\n    const bytes: Array<string> = []\n    for (let i = start; i < end; i++) bytes.push(input[i].toString(16).padStart(2, \"0\"))\n    const caret = (offset - start) * 3\n    return [`${start.toString(16).padStart(8, \"0\")} | ${bytes.join(\" \")}`, `${\" \".repeat(8)} | ${\" \".repeat(caret)}^`]\n  }\n  return []\n}\n\nconst render = (error: ParseError<unknown>): string => {\n  const { encoding, input, offset } = error\n  const lines: Array<string> = []\n  if (Predicate.isString(input)) {\n    const { column, line } = lineColumn(input, offset)\n    lines.push(`Parse error at line ${line}, column ${column}:`)\n  } else if (encoding !== undefined) {\n    const { column, line } = lineColumn(input, offset, encoding)\n    lines.push(`Parse error at line ${line}, column ${column} (byte ${offset}):`)\n  } else {\n    lines.push(`Parse error at offset ${offset}:`)\n  }\n  lines.push(...renderSnippet(input, offset, encoding))\n  for (let i = error.context.length - 1; i >= 0; i--) {\n    lines.push(`while parsing ${error.context[i]}`)\n  }\n  const cause = causeMessage(error.cause)\n  if (cause !== undefined) lines.push(cause)\n  if (error.description !== undefined) lines.push(error.description)\n  if (error.mode === \"Incomplete\") {\n    lines.push(\"unexpected end of input (incomplete)\")\n  } else if (Arr.isReadonlyArrayNonEmpty(error.expected)) {\n    lines.push(`expected ${formatExpected(error.expected)}, found ${describeFound(input, offset, encoding)}`)\n  } else if (cause === undefined && error.description === undefined) {\n    lines.push(`unexpected ${describeFound(input, offset, encoding)} (${error.kind})`)\n  }\n  return lines.join(\"\\n\")\n}\n"],"mappings":"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"}
+{"version":3,"file":"ParseError.js","names":[],"sources":["../src/ParseError.ts"],"sourcesContent":["/**\n * The error type produced when running a parser.\n *\n * `ParseError` merges winnow's `ContextError`/`ParseError` and nom's\n * `VerboseError`. It records where parsing failed, what was expected there,\n * the context labels that were active, and an optional typed `cause`\n * produced by `Parser.fail`, `Parser.tryMap` and friends. Its `message`\n * shows the failing position in the input:\n *\n * ```text\n * Parse error at line 1, column 4:\n * 1 | [1,,2]\n *   |    ^\n * expected digit\n * ```\n *\n * `ParseError` is a `Data.TaggedError`, so it can be yielded directly inside\n * `Effect.gen`.\n *\n * @since 0.1.0\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Data from \"effect/Data\"\nimport * as Option from \"effect/Option\"\nimport * as Result from \"effect/Result\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { ErrMode, Failure, Input } from \"./Input.js\"\nimport * as text from \"./internal/text.js\"\n\n/**\n * The kind of parser that produced an error, in the spirit of nom's\n * `ErrorKind`.\n *\n * `\"TooDeep\"` is not produced by a parser: the runners report it when\n * deeply nested input exhausts the call stack (see `Parser.suspend`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type ErrorKind =\n  | \"Alpha\"\n  | \"AlphaNumeric\"\n  | \"Alt\"\n  | \"Assert\"\n  | \"Bits\"\n  | \"Complete\"\n  | \"CrLf\"\n  | \"Digit\"\n  | \"Dispatch\"\n  | \"Eof\"\n  | \"Escaped\"\n  | \"Fail\"\n  | \"Float\"\n  | \"HexDigit\"\n  | \"Incomplete\"\n  | \"LineEnding\"\n  | \"Literal\"\n  | \"Many\"\n  | \"MultiSpace\"\n  | \"NoneOf\"\n  | \"Not\"\n  | \"OctDigit\"\n  | \"OneOf\"\n  | \"Permutation\"\n  | \"Separated\"\n  | \"Slice\"\n  | \"Space\"\n  | \"Take\"\n  | \"TakeUntil\"\n  | \"TakeWhile\"\n  | \"Token\"\n  | \"TooDeep\"\n  | \"Verify\"\n\n/**\n * @since 0.1.0\n * @category type ids\n */\nexport const TypeId = \"~effect-parse/ParseError\" as const\n\n/**\n * An error produced by running a parser.\n *\n * @since 0.1.0\n * @category models\n */\nexport class ParseError<out E = never>\n  extends /*#__PURE__*/ Data.TaggedError(\"ParseError\")<{\n    /** The input that was being parsed. */\n    readonly input: Input\n    /** The offset of the failure in the input. */\n    readonly offset: number\n    /** The kind of parser that failed. */\n    readonly kind: ErrorKind\n    /** How the error propagated before parsing stopped. */\n    readonly mode: ErrMode\n    /** Descriptions of what was expected at `offset`. */\n    readonly expected: ReadonlyArray<string>\n    /** Context labels (`Parser.context`), innermost first. */\n    readonly context: ReadonlyArray<string>\n    /** The user supplied cause, if any. */\n    readonly cause: E | undefined\n    /** An optional free-form description. */\n    readonly description: string | undefined\n    /**\n     * For byte inputs parsed by `Text` parsers, the text encoding. Errors\n     * then show the input as text, with line and column numbers.\n     */\n    readonly encoding?: Encoding<Uint8Array> | undefined\n  }>\n{\n  /**\n   * @since 0.1.0\n   */\n  readonly [TypeId]: typeof TypeId = TypeId\n\n  /**\n   * The 1-based line and column of the failure (for strings and encoded\n   * text; for other inputs the line is 1 and the column is `offset + 1`).\n   *\n   * @since 0.1.0\n   */\n  get position(): LineColumn {\n    return lineColumn(this.input, this.offset, this.encoding)\n  }\n\n  /**\n   * The rendered, human-readable error message.\n   *\n   * @since 0.1.0\n   */\n  override get message(): string {\n    return render(this)\n  }\n\n  /**\n   * @since 0.1.0\n   */\n  override toString(): string {\n    return `ParseError: ${this.message}`\n  }\n}\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isParseError = (u: unknown): u is ParseError<unknown> => Predicate.isObjectOrArray(u) && TypeId in u\n\n/**\n * Builds a `ParseError` from the failure details recorded while parsing.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const fromFailure = <E = never>(\n  input: Input,\n  failure: Failure,\n  mode: ErrMode,\n  encoding?: Encoding<any>\n): ParseError<E> =>\n  new ParseError<E>({\n    input,\n    offset: failure.offset,\n    kind: failure.kind,\n    mode,\n    expected: failure.expected,\n    context: failure.context,\n    // SAFETY: `E` is the user error type of the parser whose run recorded\n    // `failure`; a failure with `hasCause` carries a cause raised by that\n    // parser's `fail` / `mapError`\n    cause: failure.hasCause ? (failure.cause as E) : undefined,\n    description: failure.message,\n    encoding: input instanceof Uint8Array ? encoding : undefined\n  })\n\n/**\n * The user supplied cause of an error, if any.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const getCause = <E>(self: ParseError<E>): Option.Option<E> =>\n  self.cause === undefined ? Option.none() : Option.some(self.cause)\n\n/**\n * A 1-based line/column position.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LineColumn {\n  readonly line: number\n  readonly column: number\n}\n\n/**\n * Computes the 1-based line and column (in code points) of an offset. Lines\n * are separated by `\\n`. Byte inputs are read as text when an `encoding`\n * is given. For other inputs the line is always 1 and the column is\n * `offset + 1`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const lineColumn = (input: Input, offset: number, encoding?: Encoding<any>): LineColumn => {\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    let line = 1\n    let column = 1\n    text.walk(encoding, input, 0, Math.min(offset, input.length), (cp) => {\n      if (cp === 10) {\n        line++\n        column = 1\n      } else {\n        column++\n      }\n    })\n    return { line, column }\n  }\n  if (!Predicate.isString(input)) return { line: 1, column: offset + 1 }\n  let line = 1\n  let lineStart = 0\n  for (let i = 0; i < offset && i < input.length; i++) {\n    if (input.charCodeAt(i) === 10) {\n      line++\n      lineStart = i + 1\n    }\n  }\n  return { line, column: codePointCount(input, lineStart, Math.min(offset, input.length)) + 1 }\n}\n\nconst codePointCount = (s: string, start: number, end: number): number => {\n  let n = 0\n  for (let i = start; i < end; i++) {\n    const c = s.charCodeAt(i)\n    if (c >= 0xd800 && c <= 0xdbff && i + 1 < end) {\n      const d = s.charCodeAt(i + 1)\n      if (d >= 0xdc00 && d <= 0xdfff) i++\n    }\n    n++\n  }\n  return n\n}\n\n/**\n * Formats a list of expectations: `a`, `a or b`, `a, b or c`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const formatExpected = (expected: ReadonlyArray<string>): string => {\n  if (Arr.isReadonlyArrayEmpty(expected)) return \"\"\n  if (expected.length === 1) return expected[0]\n  return `${expected.slice(0, -1).join(\", \")} or ${expected[expected.length - 1]}`\n}\n\nconst hexBytes = (bytes: Uint8Array): string =>\n  Array.from(bytes, (b) => `0x${b.toString(16).padStart(2, \"0\")}`).join(\" \")\n\nconst describeFound = (input: Input, offset: number, encoding: Encoding<any> | undefined): string => {\n  if (offset >= input.length) return \"end of input\"\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    const cp = encoding.decode(input, offset, input.length)\n    if (cp >= 0) return JSON.stringify(String.fromCodePoint(cp))\n    const bad = input.subarray(offset, Math.min(input.length, offset + Math.max(encoding.unit, 1)))\n    return cp === text.Truncated\n      ? `incomplete ${encoding.name} sequence ${hexBytes(input.subarray(offset))}`\n      : `invalid ${encoding.name} ${hexBytes(bad)}`\n  }\n  if (Predicate.isString(input)) {\n    const cp = input.codePointAt(offset) ?? Number.NaN\n    return JSON.stringify(String.fromCodePoint(cp))\n  }\n  if (input instanceof Uint8Array) {\n    return `0x${input[offset].toString(16).padStart(2, \"0\")}`\n  }\n  return inspectToken(input[offset])\n}\n\n/** @internal */\nexport const inspectToken = (u: unknown): string => {\n  if (Predicate.isString(u)) return JSON.stringify(u)\n  if (Predicate.isObjectOrArray(u)) {\n    // `JSON.stringify` throws on cycles and `BigInt`s. Fall back to what\n    // `String` gives an array (its elements joined) or an object's tag\n    // (`[object Map]`), never a user `toString` that might throw in turn.\n    return Result.getOrElse(\n      Result.try(() => JSON.stringify(u)),\n      () => (Array.isArray(u) ? u.join(\",\") : Object.prototype.toString.call(u))\n    )\n  }\n  return String(u)\n}\n\nconst causeMessage = (cause: unknown): string | undefined => {\n  if (cause === undefined) return undefined\n  if (Predicate.isString(cause)) return cause\n  // An `Error`'s message, or any other object's string `message`\n  if (Predicate.isObjectOrArray(cause) && \"message\" in cause && Predicate.isString(cause.message)) {\n    return cause.message\n  }\n  return inspectToken(cause)\n}\n\nconst renderSnippet = (input: Input, offset: number, encoding: Encoding<any> | undefined): Array<string> => {\n  if (encoding !== undefined && input instanceof Uint8Array) {\n    // Find the line containing `offset`, then decode it\n    let lineStart = 0\n    let end = input.length\n    let column = 1\n    text.walk(encoding, input, 0, input.length, (cp, i, w) => {\n      if (i >= offset && cp === 10) {\n        end = i\n        return false\n      }\n      if (i < offset) {\n        if (cp === 10) {\n          lineStart = i + w\n          column = 1\n        } else {\n          column++\n        }\n      }\n    })\n    let line = text.lenientText(encoding, input, lineStart, end)\n    if (line.endsWith(\"\\r\")) line = line.slice(0, -1)\n    const gutter = String(lineColumn(input, offset, encoding).line)\n    const pad = \" \".repeat(gutter.length)\n    return [`${gutter} | ${line}`, `${pad} | ${\" \".repeat(column - 1)}^`]\n  }\n  if (Predicate.isString(input)) {\n    const { column, line } = lineColumn(input, offset)\n    let start = offset\n    while (start > 0 && input.charCodeAt(start - 1) !== 10) start--\n    let end = offset\n    while (end < input.length && input.charCodeAt(end) !== 10) end++\n    let text = input.slice(start, end)\n    if (text.endsWith(\"\\r\")) text = text.slice(0, -1)\n    const gutter = String(line)\n    const pad = \" \".repeat(gutter.length)\n    return [`${gutter} | ${text}`, `${pad} | ${\" \".repeat(column - 1)}^`]\n  }\n  if (input instanceof Uint8Array) {\n    const start = Math.max(0, offset - 8)\n    const end = Math.min(input.length, offset + 8)\n    const bytes: Array<string> = []\n    for (let i = start; i < end; i++) bytes.push(input[i].toString(16).padStart(2, \"0\"))\n    const caret = (offset - start) * 3\n    return [`${start.toString(16).padStart(8, \"0\")} | ${bytes.join(\" \")}`, `${\" \".repeat(8)} | ${\" \".repeat(caret)}^`]\n  }\n  return []\n}\n\nconst render = (error: ParseError<unknown>): string => {\n  const { encoding, input, offset } = error\n  const lines: Array<string> = []\n  if (Predicate.isString(input)) {\n    const { column, line } = lineColumn(input, offset)\n    lines.push(`Parse error at line ${line}, column ${column}:`)\n  } else if (encoding !== undefined) {\n    const { column, line } = lineColumn(input, offset, encoding)\n    lines.push(`Parse error at line ${line}, column ${column} (byte ${offset}):`)\n  } else {\n    lines.push(`Parse error at offset ${offset}:`)\n  }\n  lines.push(...renderSnippet(input, offset, encoding))\n  for (let i = error.context.length - 1; i >= 0; i--) {\n    lines.push(`while parsing ${error.context[i]}`)\n  }\n  const cause = causeMessage(error.cause)\n  if (cause !== undefined) lines.push(cause)\n  if (error.description !== undefined) lines.push(error.description)\n  if (error.mode === \"Incomplete\") {\n    lines.push(\"unexpected end of input (incomplete)\")\n  } else if (Arr.isReadonlyArrayNonEmpty(error.expected)) {\n    lines.push(`expected ${formatExpected(error.expected)}, found ${describeFound(input, offset, encoding)}`)\n  } else if (cause === undefined && error.description === undefined) {\n    lines.push(`unexpected ${describeFound(input, offset, encoding)} (${error.kind})`)\n  }\n  return lines.join(\"\\n\")\n}\n"],"mappings":"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"}

package/dist/Parser.d.ts

@@ -1,12 +1,12 @@
 import * as Result from "effect/Result";
-import { Fail, Input, Slice, Source, State, TraceEvent } from "./Input.js";
+import { ErrMode, Fail, Input, Slice, Source, State, TraceEvent } from "./Input.js";
 import * as Option from "effect/Option";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Pipeable } from "effect/Pipeable";
 import * as ParseError from "./ParseError.js";
 import { ErrorKind } from "./ParseError.js";
-import { Node } from "./internal/node.js";
+import { Defer as Defer$1, Node } from "./internal/node.js";
 import { Contravariant, Covariant, Simplify } from "effect/Types";
 /**
  * @since 0.1.0
@@ -33,6 +33,8 @@ export interface Parser<out A, out E = never, out R = never, in I extends Input
   /** A human-readable name, used by `toString` and tracing. */
   readonly name: string | undefined;
   [Symbol.iterator](): ParserIterator<Parser<A, E, R, I>>;
+  /** Describes the parser: `Parser(<name>)`, or `Parser` when it has no name. */
+  toString(): string;
 }
 /**
  * The iterator used by `yield*` inside {@link gen}.
@@ -88,6 +90,13 @@ export declare namespace Parser {
    * @since 0.1.0
    */
   type InputOf<P> = [P] extends [never] ? Input : [P] extends [Parser<infer _A, infer _E, infer _R, infer I>] ? I : never;
+  /**
+   * The steps {@link combinator}'s `build` receives: one per parser, in
+   * order, each returning its parser's output or `Fail`.
+   *
+   * @since 0.5.0
+   */
+  type Steps<Ps extends ReadonlyArray<Any>> = { readonly [K in keyof Ps]: (state: State<InputOf<Ps[number]>>) => Success<Ps[K]> | Fail; };
 }
 /**
  * A repetition range, in the spirit of winnow's `impl Into<Range>`:
@@ -169,6 +178,51 @@ export declare const make: <A, E = never, R = never, I extends Input = string>(s
  * @internal
  */
 export declare const described: <A, E = never, R = never, I extends Input = string>(step: (state: State<I>) => A | Fail, name: string | undefined, node: Node) => Parser<A, E, R, I>;
+/**
+ * Creates a combinator over `parsers` that compiles: `build` makes the
+ * combinator's step from the parsers' steps. Write combinators with it
+ * rather than with {@link make} when they run other parsers: a `make`
+ * parser is opaque to the compilers, so in a compiled grammar it runs
+ * interpreted, and so does every parser it runs. Interpreted, `build`
+ * receives the parsers' own steps; compiled (see the `Compiler` module), it
+ * receives their compiled steps, so the parsers inside compile with the
+ * grammar.
+ *
+ * Each step runs its parser on the state it is given, as `Parser.run` does,
+ * and returns the parser's output or `Fail`. The steps must run on the
+ * combinator's own state (they are compiled for its input kind): a
+ * combinator that runs a parser on another input, as {@link mapParser}
+ * does, is written with `make`. `build` may be called more than once (once
+ * interpreted, and once for each compiled build), so state its step shares
+ * between calls belongs inside `build`.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Input, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * // One or more `item`s separated by `sep`, returning their count
+ * const count = <A, B>(item: Parser.Parser<A>, sep: Parser.Parser<B>) =>
+ *   Parser.combinator([item, sep], ([itemStep, sepStep]) => (state) => {
+ *     if (itemStep(state) === Input.Fail) return Input.Fail
+ *     let n = 1
+ *     while (true) {
+ *       const start = state.pos
+ *       if (sepStep(state) === Input.Fail || itemStep(state) === Input.Fail) {
+ *         if (state.mode !== "Backtrack") return Input.Fail
+ *         state.rewind(start)
+ *         return n
+ *       }
+ *       n++
+ *     }
+ *   })
+ *
+ * Parser.parse(count(Ascii.digit1, Token.literal(",")), "1,22,333") // Result.succeed(3)
+ * ```
+ *
+ * @since 0.5.0
+ * @category constructors
+ */
+export declare const combinator: <const Ps extends ReadonlyArray<Parser.Any>, A, E = never>(parsers: Ps, build: (steps: Parser.Steps<Ps>) => (state: State<Parser.InputOf<Ps[number]>>) => A | Fail, name?: string) => Parser<A, E | Parser.Error<Ps[number]>, Parser.Services<Ps[number]>, Parser.InputOf<Ps[number]>>;
 /**
  * Gives a parser a name, used by `toString`.
  *
@@ -216,6 +270,34 @@ export declare const void_: Parser<void, never, never, Input>;
  * @category constructors
  */
 export declare const fail: <E>(error: E) => Parser<never, E, never, Input>;
+/**
+ * A parser that fails (backtracks) with the given user error, reporting it
+ * at `offset` rather than where the parser runs. Use it for a check that
+ * can only run once a whole construct has parsed but should point at the
+ * part at fault: return it from a {@link flatMap} continuation, with an
+ * offset taken from {@link location} or {@link withSpan}. Like any failure,
+ * one at a later offset is preferred over the failures of other
+ * alternatives (the furthest failure wins). The offset is clamped to the
+ * input.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const tag = (open: string) => Parser.delimited(Token.literal(open), Ascii.alpha1, Token.literal(">"))
+ * const element = Parser.seq(tag("<"), Parser.location, tag("</")).pipe(
+ *   Parser.flatMap(([start, at, end]) =>
+ *     start === end ? Parser.succeed(start) : Parser.failAt(at, `expected </${start}>`)
+ *   )
+ * )
+ * // The error points at the end tag (offset 3), not at the start of the element
+ * Parser.parse(element, "<a></b>")
+ * ```
+ *
+ * @since 0.5.0
+ * @category constructors
+ */
+export declare const failAt: <E>(offset: number, error: E) => Parser<never, E, never, Input>;
 /**
  * A parser that always fails (backtracks) without a cause. This is winnow's
  * `fail` and nom's `fail()`.
@@ -396,6 +478,40 @@ export declare const tryMap: {
   <A, B, E2>(f: (a: A) => Result.Result<B, E2>): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | E2, R, I>;
   <A, E, R, I extends Input, B, E2>(self: Parser<A, E, R, I>, f: (a: A) => Result.Result<B, E2>): Parser<B, E | E2, R, I>;
 };
+/**
+ * Transforms the output of a parser with a function that returns
+ * `Input.Fail` to reject it: the allocation-free form of {@link tryMap} and
+ * {@link filterMap}, for checks that run on nearly every token. Compiled
+ * code compares the result with the sentinel instead of allocating and
+ * unwrapping a `Result` or an `Option` on every success.
+ *
+ * On failure the parser backtracks to where it started. With `orFailWith`,
+ * the user error it builds (only on failure) becomes the `cause` of the
+ * `ParseError`, as with `tryMap`; without, the failure has no cause, as
+ * with `filterMap`.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Input, Parser } from "@thomasfosterau/effect-parse"
+ *
+ * const byte = Ascii.decUint.pipe(
+ *   Parser.mapOrFail(
+ *     (n) => (n < 256 ? n : Input.Fail),
+ *     (n) => `${n} is not a byte`
+ *   )
+ * )
+ * Parser.parse(byte, "300") // fails with the cause "300 is not a byte"
+ * ```
+ *
+ * @since 0.5.0
+ * @category mapping
+ */
+export declare const mapOrFail: {
+  <A, B>(f: (a: A) => B | Fail): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Exclude<B, Fail>, E, R, I>;
+  <A, B, E2>(f: (a: A) => B | Fail, orFailWith: (a: A) => E2): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<Exclude<B, Fail>, E | E2, R, I>;
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B | Fail): Parser<Exclude<B, Fail>, E, R, I>;
+  <A, E, R, I extends Input, B, E2>(self: Parser<A, E, R, I>, f: (a: A) => B | Fail, orFailWith: (a: A) => E2): Parser<Exclude<B, Fail>, E | E2, R, I>;
+};
 /**
  * Like {@link tryMap}, but the function may throw. Thrown values become the
  * `cause` of the error.
@@ -404,8 +520,8 @@ export declare const tryMap: {
  * @category mapping
  */
 export declare const tryMapUnknown: {
-  <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | unknown, R, I>;
-  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E | unknown, R, I>;
+  <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, unknown, R, I>;
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, unknown, R, I>;
 };
 /**
  * Transforms the output of a parser with a function returning an `Option`;
@@ -477,6 +593,28 @@ export declare const span: <A, E, R, I extends Input>(self: Parser<A, E, R, I>)
  * @category consumed input
  */
 export declare const withSpan: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<[output: A, span: Span], E, R, I>;
+/**
+ * Transforms the output of a parser together with the offsets it consumed,
+ * `[start, end)`: the allocation-free spelling of
+ * `map(withSpan(p), ([a, span]) => f(a, span.start, span.end))`, which
+ * builds a tuple and a span object on every success. Compiled code passes
+ * the offsets to `f` directly.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Parser } from "@thomasfosterau/effect-parse"
+ *
+ * const name = Ascii.alpha1.pipe(Parser.mapSpan((text, start, end) => ({ text, start, end })))
+ * Parser.parse(name, "abc") // Result.succeed({ text: "abc", start: 0, end: 3 })
+ * ```
+ *
+ * @since 0.5.0
+ * @category consumed input
+ */
+export declare const mapSpan: {
+  <A, B>(f: (a: A, start: number, end: number) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>;
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A, start: number, end: number) => B): Parser<B, E, R, I>;
+};
 /**
  * Commits to the current branch: recoverable failures of the parser become
  * unrecoverable, so enclosing `alt`, `opt`, `repeat`, ... do not try
@@ -535,6 +673,146 @@ export declare const expected: {
   (description: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>;
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I>;
 };
+/**
+ * Runs a parser without letting it add to the expectations of later errors
+ * (chumsky's `quiet`). Use it on skippers, such as whitespace and comments,
+ * that may appear between any two tokens: they stop by failing, and without
+ * `quiet` what they would have accepted (`" "`, `"(:"`, ...) is listed in
+ * every error raised after them.
+ *
+ * When the parser succeeds, the hints and the furthest failure it recorded
+ * are forgotten, as after a lookahead that succeeded. When it fails
+ * recoverably without consuming input, its failure expects nothing, so an
+ * enclosing `alt` or `opt` reports only the other alternatives. A failure
+ * after consuming input (an unterminated comment) or an unrecoverable one
+ * is kept as it is. `Parser.expected` cannot do this: it relabels a failure,
+ * and a skipper that matches zero or more times never fails.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const comment = Parser.delimited(Token.literal("(:"), Token.takeTill(":"), Token.literal(":)"))
+ * const skip = Parser.quiet(Parser.repeat(Parser.alt(Ascii.multispace1, comment)))
+ * const number = Parser.preceded(skip, Ascii.digit1)
+ * // Fails expecting only a digit: without `quiet`, also whitespace and "(:"
+ * Parser.parse(number, " (: one :) x")
+ * ```
+ *
+ * @since 0.5.0
+ * @category error management
+ */
+export declare const quiet: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>;
+/**
+ * What a fast path (see {@link withFastPath}) returns to leave the input at
+ * the current offset to its grammar.
+ *
+ * @since 0.5.0
+ * @category fast paths
+ */
+export declare const Defer: typeof Defer$1;
+/**
+ * The type of {@link Defer}.
+ *
+ * @since 0.5.0
+ * @category fast paths
+ */
+export type Defer = typeof Defer$1;
+/**
+ * Puts a hand-written fast path in front of a grammar, which stays the
+ * specification: `fast` runs on the state, at the offset where the grammar
+ * would, and either returns the value the grammar would return, with
+ * `state.pos` where the grammar would stop, or returns {@link Defer}, and
+ * the grammar runs from that offset instead. Use it where a scanner written
+ * by hand (`indexOf`, a lookup table, interned names) beats compiled code on
+ * the tokens that dominate an input, and let the grammar handle everything
+ * else.
+ *
+ * The fast path runs in compiled code only (see the `Compiler` module).
+ * Interpreted runs, and so every error, every `Syntax` tree and every trace,
+ * come from the grammar alone, so they are exactly the grammar's. It must
+ * defer wherever it would not return exactly what the grammar returns, and
+ * on partial input wherever the grammar might report `Incomplete`; check it
+ * against the grammar with {@link verifyFastPath}.
+ *
+ * @example
+ * ```ts
+ * import { Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const text = Token.takeTill("<", { min: 1 })
+ * // The same run, found with `indexOf`; anything else (an empty run, the end of a partial input) defers
+ * const fastText = Compiler.jit(
+ *   Parser.withFastPath(text, (state) => {
+ *     const end = state.input.indexOf("<", state.pos)
+ *     if (end <= state.pos || end > state.end) return Parser.Defer
+ *     const value = state.input.slice(state.pos, end)
+ *     state.pos = end
+ *     return value
+ *   })
+ * )
+ * ```
+ *
+ * @since 0.5.0
+ * @category fast paths
+ */
+export declare const withFastPath: {
+  <A, I extends Input>(fast: (state: State<I>) => A | Defer): <E, R>(grammar: Parser<A, E, R, I>) => Parser<A, E, R, I>;
+  <A, E, R, I extends Input>(grammar: Parser<A, E, R, I>, fast: (state: State<I>) => A | Defer): Parser<A, E, R, I>;
+};
+/**
+ * A place where a fast path disagrees with its grammar (see
+ * {@link verifyFastPath}).
+ *
+ * @since 0.5.0
+ * @category fast paths
+ */
+export interface FastPathMismatch<A, I extends Input> {
+  readonly input: I;
+  readonly offset: number;
+  readonly partial: boolean;
+  /** What the fast path returned, and where it stopped. */
+  readonly fast: {
+    readonly value: A;
+    readonly end: number;
+  };
+  /** What the grammar returned, and where it stopped, or how it failed. */
+  readonly grammar: {
+    readonly value: A;
+    readonly end: number;
+  } | {
+    readonly failed: ErrMode;
+  };
+}
+/**
+ * Checks a fast path against its grammar (see {@link withFastPath}): on
+ * every input, at every offset, on complete and on partial input, wherever
+ * `fast` returns a value, the grammar (run interpreted) must return an
+ * equal value (by `Equal.equals`, or `options.equivalence`) and stop at the
+ * same offset. Returns every place where it doesn't, so a test asserts that
+ * the result is empty; generated inputs, mutated and truncated, find the
+ * most. Grammars that use services are not supported.
+ *
+ * @example
+ * ```ts
+ * import { Input, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const text = Token.takeTill("<", { min: 1 })
+ * const fast = (state: Input.State<string>) => {
+ *   const end = state.input.indexOf("<", state.pos)
+ *   if (end <= state.pos || end > state.end) return Parser.Defer
+ *   const value = state.input.slice(state.pos, end)
+ *   state.pos = end
+ *   return value
+ * }
+ * Parser.verifyFastPath(text, fast, ["a<b", "<", "abc"]) // []
+ * ```
+ *
+ * @since 0.5.0
+ * @category fast paths
+ */
+export declare const verifyFastPath: <A, E, I extends Input>(grammar: Parser<A, E, never, I>, fast: (state: State<I>) => A | Defer, inputs: Iterable<I>, options?: {
+  readonly equivalence?: ((a: A, b: A) => boolean) | undefined;
+}) => ReadonlyArray<FastPathMismatch<A, I>>;
 /**
  * Transforms the user error (cause) of a parser's failures.
  *
@@ -631,6 +909,28 @@ export declare const allConsuming: <A, E, R, I extends Input>(self: Parser<A, E,
  * @category sequencing
  */
 export declare const seq: <const Ps extends ReadonlyArray<Parser.Any>>(...parsers: Ps) => Parser<{ -readonly [K in keyof Ps]: Parser.Success<Ps[K]>; }, Parser.Error<Ps[number]>, Parser.Services<Ps[number]>, Parser.InputOf<Ps[number]>>;
+/**
+ * Runs parsers in sequence and combines their outputs with `f`, which
+ * receives one argument per parser: the allocation-free spelling of
+ * `map(seq(...parsers), ([a, b, ...]) => f(a, b, ...))`, which builds a
+ * tuple on every success. Compiled code calls `f` with the values directly.
+ * {@link zipWith} is the two-parser, pipeable form.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const point = Parser.seqWith(
+ *   [Ascii.decInt, Token.literal(","), Ascii.decInt],
+ *   (x, _, y) => ({ x, y })
+ * )
+ * Parser.parse(point, "3,-4") // Result.succeed({ x: 3, y: -4 })
+ * ```
+ *
+ * @since 0.5.0
+ * @category sequencing
+ */
+export declare const seqWith: <const Ps extends ReadonlyArray<Parser.Any>, B>(parsers: Ps, f: (...values: { -readonly [K in keyof Ps]: Parser.Success<Ps[K]>; }) => B) => Parser<B, Parser.Error<Ps[number]>, Parser.Services<Ps[number]>, Parser.InputOf<Ps[number]>>;
 /**
  * Runs a record of parsers in sequence (in key order), collecting their
  * outputs in a record. This is the Effect counterpart to winnow's
@@ -804,6 +1104,16 @@ declare const let_: {
  * @category choice
  */
 export declare const alt: <const Ps extends ReadonlyArray<Parser.Any>>(...parsers: Ps) => Parser<Parser.Success<Ps[number]>, Parser.Error<Ps[number]>, Parser.Services<Ps[number]>, Parser.InputOf<Ps[number]>>;
+/**
+ * The overloads of {@link dispatch}.
+ *
+ * @since 0.5.0
+ * @category choice
+ */
+export interface DispatchFn {
+  <K, E, R, I extends Input, P extends Parser.Any>(selector: Parser<K, E, R, I>, cases: (key: K) => P | undefined): Parser<Parser.Success<P>, E | Parser.Error<P>, R | Parser.Services<P>, I & Parser.InputOf<P>>;
+  <K extends PropertyKey, E, R, I extends Input, const Cases extends { readonly [key in K]?: Parser.Any; }, Otherwise extends Parser.Any = never>(selector: Parser<K, E, R, I>, cases: Cases, otherwise?: Otherwise): Parser<Parser.Success<NonNullable<Cases[keyof Cases]> | Otherwise>, E | Parser.Error<NonNullable<Cases[keyof Cases]> | Otherwise>, R | Parser.Services<NonNullable<Cases[keyof Cases]> | Otherwise>, I & Parser.InputOf<NonNullable<Cases[keyof Cases]> | Otherwise>>;
+}
 /**
  * Selects the parser to run next based on the output of `selector`, like a
  * `match` over the input (winnow's `dispatch!`). If no case matches, the
@@ -838,10 +1148,7 @@ export declare const alt: <const Ps extends ReadonlyArray<Parser.Any>>(...parser
  * @since 0.1.0
  * @category choice
  */
-export declare const dispatch: {
-  <K, E, R, I extends Input, P extends Parser.Any>(selector: Parser<K, E, R, I>, cases: (key: K) => P | undefined): Parser<Parser.Success<P>, E | Parser.Error<P>, R | Parser.Services<P>, I & Parser.InputOf<P>>;
-  <K extends PropertyKey, E, R, I extends Input, const Cases extends { readonly [key in K]?: Parser.Any; }, Otherwise extends Parser.Any = never>(selector: Parser<K, E, R, I>, cases: Cases, otherwise?: Otherwise): Parser<Parser.Success<NonNullable<Cases[keyof Cases]> | Otherwise>, E | Parser.Error<NonNullable<Cases[keyof Cases]> | Otherwise>, R | Parser.Services<NonNullable<Cases[keyof Cases]> | Otherwise>, I & Parser.InputOf<NonNullable<Cases[keyof Cases]> | Otherwise>>;
-};
+export declare const dispatch: DispatchFn;
 /**
  * Applies every parser exactly once, in whatever order they match, and
  * returns their outputs in the order the parsers were given (winnow's and
@@ -1130,6 +1437,16 @@ export interface ParseOptions {
 export interface ParseOptionsWithContext<R> extends ParseOptions {
   readonly context: Context.Context<R>;
 }
+/**
+ * The overloads of {@link parse}.
+ *
+ * @since 0.5.0
+ * @category running
+ */
+export interface ParseFn {
+  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<A, ParseError.ParseError<E>>;
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<A, ParseError.ParseError<E>>;
+}
 /**
  * Runs a parser against a complete input, requiring the whole input to be
  * consumed (winnow's `Parser::parse`).
@@ -1146,20 +1463,34 @@ export interface ParseOptionsWithContext<R> extends ParseOptions {
  * @since 0.1.0
  * @category running
  */
-export declare const parse: {
-  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<A, ParseError.ParseError<E>>;
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<A, ParseError.ParseError<E>>;
-};
+export declare const parse: ParseFn;
 /**
- * Like {@link parse}, but throws the `ParseError` on failure.
+ * The overloads of {@link parseSync}.
  *
- * @since 0.1.0
+ * @since 0.5.0
  * @category running
  */
-export declare const parseSync: {
+export interface ParseSyncFn {
   <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): A;
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): A;
-};
+}
+/**
+ * Like {@link parse}, but throws the `ParseError` on failure.
+ *
+ * @since 0.1.0
+ * @category running
+ */
+export declare const parseSync: ParseSyncFn;
+/**
+ * The overloads of {@link parsePeek}.
+ *
+ * @since 0.5.0
+ * @category running
+ */
+export interface ParsePeekFn {
+  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>;
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>;
+}
 /**
  * Runs a parser against the start of an input, returning the remaining
  * input along with the output, nom-style (winnow's `parse_peek`, nom's
@@ -1172,10 +1503,7 @@ export declare const parseSync: {
  * @since 0.1.0
  * @category running
  */
-export declare const parsePeek: {
-  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>;
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<[remaining: Slice<I>, output: A], ParseError.ParseError<E>>;
-};
+export declare const parsePeek: ParsePeekFn;
 /**
  * The outcome of parsing a partial (streaming) input.
  *
@@ -1193,6 +1521,16 @@ export type PartialResult<A> = {
   readonly _tag: "Incomplete";
   readonly needed: Option.Option<number>;
 };
+/**
+ * The overloads of {@link parsePartial}.
+ *
+ * @since 0.5.0
+ * @category running
+ */
+export interface ParsePartialFn {
+  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<PartialResult<A>, ParseError.ParseError<E>>;
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<PartialResult<A>, ParseError.ParseError<E>>;
+}
 /**
  * Runs a parser against a *partial* input, i.e. a chunk of a stream that may
  * be followed by more data (winnow's `Partial`, nom's `streaming` parsers).
@@ -1222,10 +1560,7 @@ export type PartialResult<A> = {
  * @since 0.1.0
  * @category running
  */
-export declare const parsePartial: {
-  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): Result.Result<PartialResult<A>, ParseError.ParseError<E>>;
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): Result.Result<PartialResult<A>, ParseError.ParseError<E>>;
-};
+export declare const parsePartial: ParsePartialFn;
 /**
  * Runs a parser against a complete input as an `Effect`. Services required
  * by the parser are taken from the Effect's context.
@@ -1328,6 +1663,16 @@ export interface RecoverableResult<A, E> {
   /** Every error encountered: recovered ones, then the fatal one (if any). */
   readonly errors: ReadonlyArray<ParseError.ParseError<E>>;
 }
+/**
+ * The overloads of {@link parseRecoverable}.
+ *
+ * @since 0.5.0
+ * @category running
+ */
+export interface ParseRecoverableFn {
+  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): RecoverableResult<A, E>;
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): RecoverableResult<A, E>;
+}
 /**
  * Runs a parser with error recovery enabled (winnow's `Recoverable`
  * stream). Failures handled by {@link resumeAfter} and {@link retryAfter}
@@ -1336,9 +1681,6 @@ export interface RecoverableResult<A, E> {
  * @since 0.1.0
  * @category running
  */
-export declare const parseRecoverable: {
-  <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): RecoverableResult<A, E>;
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): RecoverableResult<A, E>;
-};
+export declare const parseRecoverable: ParseRecoverableFn;
 export { type ErrorKind, let_ as let, void_ as void };
 //# sourceMappingURL=Parser.d.ts.map