@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/dist/Expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"Expression.js","names":["makeParser"],"sources":["../src/Expression.ts"],"sourcesContent":["/**\n * Operator-precedence expression parsing with a Pratt parser (from\n * `nom-language`'s `precedence`, and winnow's expression parser).\n *\n * Describe the operand parser and a table of prefix, postfix and infix\n * operators with their precedence (higher binds tighter) and associativity.\n * Each operator carries a function that folds its operands into a result.\n *\n * @example\n * ```ts\n * import { Ascii, Expression, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const op = (s: string) => Parser.delimited(Ascii.space0, Token.literal(s), Ascii.space0)\n *\n * const arithmetic: Parser.Parser<number, string> = Expression.make({\n *   operand: Parser.alt(\n *     Ascii.decInt,\n *     Parser.delimited(op(\"(\"), Parser.suspend(() => arithmetic), op(\")\"))\n *   ),\n *   operators: [\n *     Expression.prefix(op(\"-\"), 4, (_, x) => -x),\n *     Expression.postfix(op(\"!\"), 5, (x) => factorial(x)),\n *     Expression.infixRight(op(\"^\"), 3, (l, _, r) => l ** r),\n *     Expression.infixLeft(op(\"*\"), 2, (l, _, r) => l * r),\n *     Expression.infixLeft(op(\"/\"), 2, (l, _, r) => l / r),\n *     Expression.infixLeft(op(\"+\"), 1, (l, _, r) => l + r),\n *     Expression.infixLeft(op(\"-\"), 1, (l, _, r) => l - r)\n *   ]\n * })\n *\n * declare const factorial: (n: number) => number\n * Parser.parse(arithmetic, \"1 + 2 * 3 ^ 2\") // Result.succeed(19)\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { make as makeParser } from \"./Parser.js\"\nimport { TiedFailures } from \"./internal/ties.js\"\n\n/**\n * An operator in an expression grammar.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Operator<A, E = never, R = never, I extends Input = string> =\n  | Prefix<A, E, R, I>\n  | Postfix<A, E, R, I>\n  | Infix<A, E, R, I>\n\ninterface OperatorBase<E, R, I extends Input> {\n  readonly parser: Parser<unknown, E, R, I>\n  readonly precedence: number\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Prefix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Prefix\"\n  readonly fold: (op: any, operand: A) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Postfix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Postfix\"\n  readonly fold: (operand: A, op: any) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Infix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Infix\"\n  readonly associativity: \"left\" | \"right\"\n  readonly fold: (left: A, op: any, right: A) => A\n}\n\n/**\n * A prefix operator, e.g. unary minus.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const prefix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (op: O, operand: A) => A\n): Prefix<A, E, R, I> => ({ _tag: \"Prefix\", parser, precedence, fold })\n\n/**\n * A postfix operator, e.g. factorial or a function call suffix.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const postfix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (operand: A, op: O) => A\n): Postfix<A, E, R, I> => ({ _tag: \"Postfix\", parser, precedence, fold })\n\n/**\n * A left-associative infix operator: `a - b - c` is `(a - b) - c`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixLeft = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"left\", parser, precedence, fold })\n\n/**\n * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixRight = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"right\", parser, precedence, fold })\n\ntype OpError<Op> = Op extends OperatorBase<infer E, infer _R, infer _I> ? E : never\ntype OpServices<Op> = Op extends OperatorBase<infer _E, infer R, infer _I> ? R : never\ntype OpInput<Op> = [Op] extends [never] ? Input : [Op] extends [OperatorBase<infer _E, infer _R, infer I>] ? I : never\n\n/**\n * Builds an expression parser from an operand parser and an operator table.\n *\n * Precedences are compared numerically: higher binds tighter. A prefix\n * operator applies to everything that binds tighter than it, so with `-`\n * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.\n *\n * When several operators of the same kind match, the first one in the\n * table wins, so list longer operators (`<=`) before their prefixes (`<`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<Operator<A, any, any, any>>>(options: {\n  readonly operand: Parser<A, E, R, I>\n  readonly operators: Ops\n}): Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>> => {\n  const operand = options.operand.step\n  const prefixes = options.operators.filter((o): o is Prefix<A, any, any, any> => Predicate.isTagged(o, \"Prefix\"))\n  const postfixes = options.operators.filter((o): o is Postfix<A, any, any, any> => Predicate.isTagged(o, \"Postfix\"))\n  const infixes = options.operators.filter((o): o is Infix<A, any, any, any> => Predicate.isTagged(o, \"Infix\"))\n\n  // Attempts each operator in turn. Returns the index of the first match\n  // (with its output in `matched`), -1 if none matched, or -2 on a fatal\n  // failure. Failed attempts are folded into `failures`, merged only when\n  // read (#44): a round in which an operator matches discards them unmerged.\n  // Like `matched`, it is shared by nested expressions, which clear it.\n  let matched: unknown\n  const failures = new TiedFailures()\n  const tryOps = (state: State<any>, ops: ReadonlyArray<OperatorBase<any, any, any>>, mustConsume: boolean): number => {\n    const start = state.pos\n    for (let i = 0; i < ops.length; i++) {\n      const out = ops[i].parser.step(state)\n      if (out !== Fail) {\n        // A prefix or postfix operator matching nothing would apply forever\n        if (mustConsume && state.pos === start) {\n          state.failMessage(\"Cut\", \"Assert\", \"prefix and postfix operators must always consume\")\n          return -2\n        }\n        matched = out\n        return i\n      }\n      if (state.mode !== \"Backtrack\") return -2\n      state.rewind(start)\n      failures.add(state)\n    }\n    return -1\n  }\n\n  const expr = (state: State<any>, minPower: number): A | Fail => {\n    let lhs: A | Fail\n    failures.clear()\n    const p = tryOps(state, prefixes, true)\n    if (p === -2) return Fail\n    if (p >= 0) {\n      const op = prefixes[p]\n      const opOut = matched\n      const operandValue = expr(state, op.precedence * 2)\n      if (operandValue === Fail) return Fail\n      lhs = op.fold(opOut, operandValue)\n    } else {\n      const prefixFailure = failures.failure\n      const prefixTie1 = failures.tie1\n      const prefixTie2 = failures.tie2\n      lhs = operand(state)\n      if (lhs === Fail) {\n        if (prefixFailure !== undefined && state.mode === \"Backtrack\") {\n          // The operand may have parsed nested expressions, which reuse `failures`\n          failures.failure = prefixFailure\n          failures.tie1 = prefixTie1\n          failures.tie2 = prefixTie2\n          failures.add(state)\n          failures.fail(state)\n        }\n        return Fail\n      }\n    }\n\n    while (true) {\n      const start = state.pos\n      failures.clear()\n      const q = tryOps(state, postfixes, true)\n      if (q === -2) return Fail\n      if (q >= 0) {\n        const op = postfixes[q]\n        if (op.precedence * 2 < minPower) {\n          state.rewind(start)\n          break\n        }\n        lhs = op.fold(lhs, matched)\n        continue\n      }\n      // The infix attempts are folded on top of the postfix ones\n      const i = tryOps(state, infixes, false)\n      if (i === -2) return Fail\n      if (i < 0) {\n        failures.hint(state)\n        break\n      }\n      const op = infixes[i]\n      const leftPower = op.precedence * 2\n      if (leftPower < minPower) {\n        state.rewind(start)\n        break\n      }\n      const opOut = matched\n      const rhs = expr(state, op.associativity === \"left\" ? leftPower + 1 : leftPower)\n      if (rhs === Fail) return Fail\n      lhs = op.fold(lhs, opOut, rhs)\n    }\n    return lhs\n  }\n\n  return makeParser((state: State<any>) => expr(state, 0), \"expression\")\n}\n"],"mappings":"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"}
+{"version":3,"file":"Expression.js","names":[],"sources":["../src/Expression.ts"],"sourcesContent":["/**\n * Operator-precedence expression parsing with a Pratt parser (from\n * `nom-language`'s `precedence`, and winnow's expression parser).\n *\n * Describe the operand parser and a table of prefix, postfix and infix\n * operators with their precedence (higher binds tighter) and associativity.\n * Each operator carries a function that folds its operands into a result.\n *\n * @example\n * ```ts\n * import { Ascii, Expression, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const op = (s: string) => Parser.delimited(Ascii.space0, Token.literal(s), Ascii.space0)\n *\n * const arithmetic: Parser.Parser<number, string> = Expression.make({\n *   operand: Parser.alt(\n *     Ascii.decInt,\n *     Parser.delimited(op(\"(\"), Parser.suspend(() => arithmetic), op(\")\"))\n *   ),\n *   operators: [\n *     Expression.prefix(op(\"-\"), 4, (_, x) => -x),\n *     Expression.postfix(op(\"!\"), 5, (x) => factorial(x)),\n *     Expression.infixRight(op(\"^\"), 3, (l, _, r) => l ** r),\n *     Expression.infixLeft(op(\"*\"), 2, (l, _, r) => l * r),\n *     Expression.infixLeft(op(\"/\"), 2, (l, _, r) => l / r),\n *     Expression.infixLeft(op(\"+\"), 1, (l, _, r) => l + r),\n *     Expression.infixLeft(op(\"-\"), 1, (l, _, r) => l - r)\n *   ]\n * })\n *\n * declare const factorial: (n: number) => number\n * Parser.parse(arithmetic, \"1 + 2 * 3 ^ 2\") // Result.succeed(19)\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { combinator } from \"./Parser.js\"\n\n/** A parser's step, interpreted or compiled. */\ntype Step = (state: State<any>) => unknown\nimport { TiedFailures } from \"./internal/ties.js\"\n\n/**\n * An operator in an expression grammar.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Operator<A, E = never, R = never, I extends Input = string> =\n  | Prefix<A, E, R, I>\n  | Postfix<A, E, R, I>\n  | Infix<A, E, R, I>\n\ninterface OperatorBase<E, R, I extends Input> {\n  readonly parser: Parser<unknown, E, R, I>\n  readonly precedence: number\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Prefix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Prefix\"\n  readonly fold: (op: any, operand: A) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Postfix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Postfix\"\n  readonly fold: (operand: A, op: any) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Infix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Infix\"\n  readonly associativity: \"left\" | \"right\"\n  readonly fold: (left: A, op: any, right: A) => A\n}\n\n/**\n * A prefix operator, e.g. unary minus.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const prefix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (op: O, operand: A) => A\n): Prefix<A, E, R, I> => ({ _tag: \"Prefix\", parser, precedence, fold })\n\n/**\n * A postfix operator, e.g. factorial or a function call suffix.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const postfix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (operand: A, op: O) => A\n): Postfix<A, E, R, I> => ({ _tag: \"Postfix\", parser, precedence, fold })\n\n/**\n * A left-associative infix operator: `a - b - c` is `(a - b) - c`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixLeft = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"left\", parser, precedence, fold })\n\n/**\n * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixRight = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"right\", parser, precedence, fold })\n\ntype OpError<Op> = Op extends OperatorBase<infer E, infer _R, infer _I> ? E : never\ntype OpServices<Op> = Op extends OperatorBase<infer _E, infer R, infer _I> ? R : never\ntype OpInput<Op> = [Op] extends [never] ? Input : [Op] extends [OperatorBase<infer _E, infer _R, infer I>] ? I : never\n\n/**\n * Builds an expression parser from an operand parser and an operator table.\n *\n * Precedences are compared numerically: higher binds tighter. A prefix\n * operator applies to everything that binds tighter than it, so with `-`\n * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.\n *\n * When several operators of the same kind match, the first one in the\n * table wins, so list longer operators (`<=`) before their prefixes (`<`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<Operator<A, any, any, any>>>(options: {\n  readonly operand: Parser<A, E, R, I>\n  readonly operators: Ops\n}): Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>> => {\n  const prefixes = options.operators.filter((o): o is Prefix<A, any, any, any> => Predicate.isTagged(o, \"Prefix\"))\n  const postfixes = options.operators.filter((o): o is Postfix<A, any, any, any> => Predicate.isTagged(o, \"Postfix\"))\n  const infixes = options.operators.filter((o): o is Infix<A, any, any, any> => Predicate.isTagged(o, \"Infix\"))\n  const operators = [...prefixes, ...postfixes, ...infixes]\n  const parsers = [options.operand, ...operators.map((o) => o.parser)]\n  // Builds the step from the operand's and the operators' steps, in that\n  // order: their own steps when interpreted, compiled ones when compiled\n  const build = (steps: ReadonlyArray<Step>) => {\n    const operand = steps[0]\n    const prefixSteps = steps.slice(1, 1 + prefixes.length)\n    const postfixSteps = steps.slice(1 + prefixes.length, 1 + prefixes.length + postfixes.length)\n    const infixSteps = steps.slice(1 + prefixes.length + postfixes.length)\n\n    // Attempts each operator in turn. Returns the index of the first match\n    // (with its output in `matched`), -1 if none matched, or -2 on a fatal\n    // failure. Failed attempts are folded into `failures`, merged only when\n    // read (#44): a round in which an operator matches discards them unmerged.\n    // Like `matched`, it is shared by nested expressions, which clear it.\n    let matched: unknown\n    const failures = new TiedFailures()\n    const tryOps = (state: State<any>, ops: ReadonlyArray<Step>, mustConsume: boolean): number => {\n      const start = state.pos\n      for (let i = 0; i < ops.length; i++) {\n        const out = ops[i](state)\n        if (out !== Fail) {\n          // A prefix or postfix operator matching nothing would apply forever\n          if (mustConsume && state.pos === start) {\n            state.failMessage(\"Cut\", \"Assert\", \"prefix and postfix operators must always consume\")\n            return -2\n          }\n          matched = out\n          return i\n        }\n        if (state.mode !== \"Backtrack\") return -2\n        state.rewind(start)\n        failures.add(state)\n      }\n      return -1\n    }\n\n    const expr = (state: State<any>, minPower: number): A | Fail => {\n      let lhs: A | Fail\n      failures.clear()\n      const p = tryOps(state, prefixSteps, true)\n      if (p === -2) return Fail\n      if (p >= 0) {\n        const op = prefixes[p]\n        const opOut = matched\n        const operandValue = expr(state, op.precedence * 2)\n        if (operandValue === Fail) return Fail\n        lhs = op.fold(opOut, operandValue)\n      } else {\n        const prefixFailure = failures.failure\n        const prefixTie1 = failures.tie1\n        const prefixTie2 = failures.tie2\n        // SAFETY: the operand's step, interpreted or compiled, returns its output (an `A`) or `Fail`\n        lhs = operand(state) as A | Fail\n        if (lhs === Fail) {\n          if (prefixFailure !== undefined && state.mode === \"Backtrack\") {\n            // The operand may have parsed nested expressions, which reuse `failures`\n            failures.failure = prefixFailure\n            failures.tie1 = prefixTie1\n            failures.tie2 = prefixTie2\n            failures.add(state)\n            failures.fail(state)\n          }\n          return Fail\n        }\n      }\n\n      while (true) {\n        const start = state.pos\n        failures.clear()\n        const q = tryOps(state, postfixSteps, true)\n        if (q === -2) return Fail\n        if (q >= 0) {\n          const op = postfixes[q]\n          if (op.precedence * 2 < minPower) {\n            state.rewind(start)\n            break\n          }\n          lhs = op.fold(lhs, matched)\n          continue\n        }\n        // The infix attempts are folded on top of the postfix ones\n        const i = tryOps(state, infixSteps, false)\n        if (i === -2) return Fail\n        if (i < 0) {\n          failures.hint(state)\n          break\n        }\n        const op = infixes[i]\n        const leftPower = op.precedence * 2\n        if (leftPower < minPower) {\n          state.rewind(start)\n          break\n        }\n        const opOut = matched\n        const rhs = expr(state, op.associativity === \"left\" ? leftPower + 1 : leftPower)\n        if (rhs === Fail) return Fail\n        lhs = op.fold(lhs, opOut, rhs)\n      }\n      return lhs\n    }\n    return (state: State<any>) => expr(state, 0)\n  }\n  return combinator(parsers, build, \"expression\")\n}\n"],"mappings":"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"}

package/dist/Input.d.ts

@@ -1,3 +1,4 @@
+import { AsciiRun } from "./internal/text.js";
 import * as Context from "effect/Context";
 import { ErrorKind } from "./ParseError.js";
 import { Builder } from "./internal/syntax.js";
@@ -35,6 +36,16 @@ export type BinaryInput = ArrayBufferLike | ArrayBufferView;
  * @category models
  */
 export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never);
+/**
+ * The overloads of {@link fromSource}.
+ *
+ * @since 0.5.0
+ * @category constructors
+ */
+export interface FromSourceFn {
+  (source: BinaryInput): Uint8Array;
+  <I extends Input>(source: Source<I>): I;
+}
 /**
  * Converts a {@link Source} to the input parsers read: binary data becomes a
  * `Uint8Array` view of the same memory, everything else is returned as is.
@@ -49,10 +60,7 @@ export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never);
  * @since 0.1.0
  * @category constructors
  */
-export declare const fromSource: {
-  (source: BinaryInput): Uint8Array;
-  <I extends Input>(source: Source<I>): I;
-};
+export declare const fromSource: FromSourceFn;
 /**
  * The type of a single token of an input.
  *
@@ -245,6 +253,31 @@ export declare class State<I extends Input = Input> {
    * @internal
    */
   syntax: Builder | undefined;
+  /**
+   * Where the stop characters of compiled `takeTill`s next occur in this
+   * state's input, by search site; created on first use. It lives as long
+   * as the state (whose input never changes), and `reset` clears it with
+   * the other per-run fields.
+   *
+   * @internal
+   */
+  searches: Map<object, Array<number>> | undefined;
+  /**
+   * A run of ASCII bytes of this state's UTF-8 input, decoded once, from
+   * which `Text.utf8` slices the long strings it decodes (see
+   * `internal/text.ts`); `reset` clears it with the other per-run fields.
+   *
+   * @internal
+   */
+  asciiRun: AsciiRun | undefined;
+  /**
+   * A `DataView` of this state's byte input, for the `Binary` parsers;
+   * created on first use. It lives as long as the state, whose input never
+   * changes: one per read cost most of a number's time.
+   *
+   * @internal
+   */
+  view: DataView | undefined;
   constructor(source: I | Source<I>, options?: {
     readonly partial?: boolean | undefined;
     readonly context?: Context.Context<never> | undefined;

package/dist/Input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Input.d.ts","names":["SyntaxBuilder"],"sources":["../src/Input.ts"],"mappings":";;;;;;;;;;;;;;;YAiCY,iBAAiB,aAAa;;;;;;;;;;;;;YAc9B,cAAc,kBAAkB;;;;;;;;YAShC,OAAO,KAAK,MAAM,YAAY,cAAc;;;;;;;;;;;;;;;qBAgB3C;GACV,QAAQ,cAAc;GACtB,UAAU,OAAO,QAAQ,OAAO,KAAK;;;;;;;;YAkB5B,MAAM,KAAK,4BAEnB,UAAU,sBAER,UAAU,oBAAoB,KAC5B;;;;;;;YASI,MAAM,KAAK,4BAEnB,UAAU,aACR,aACA,UAAU,oBAAoB,KAC5B,cAAc;;;;;;;;qBAUT;;;;;YAMD,cAAc;;;;;;;;;;;YAYd;;;;;;;qBAQC;;WAGA;;WAEA,MAAM;;WAEN,UAAU;;WAEV,SAAS;;WAET;;WAEA;;WAEA;;WAEA;;;EAdA;;EAEA,MAAM;;EAEN,UAAU;;EAEV,SAAS;;EAET;;EAEA;;EAEA;;EAEA;;;qBAUA;;;;;;;iBAQI;WACN;WACA;WACA;WACA;;WAEA,gBAAgB;;WAEhB;WACA,OAAO;;;;;;;;qBASL,MAAM,UAAU,QAAQ;;WAE1B,OAAO;;;;;EAKhB;;EAEA;;WAES;;EAET;;EAEA,SAAS,QAAQ;;EAEjB,MAAM;;;;;;;;;;;EAWN,aAAa;;EAEb,aAAa;;EAEb,aAAa;;EAEb,gBAAgB;;;;;;;;EAQhB;;;;;;;EAOA;;EAEA,cAAc;;;;;;;;;;MAUV,WAAW;MAIX,QAAQ,SAAS;;EAKrB,WAAW,MAAM;;EAEjB,UAAU,OAAO;;EAEjB;;;;;EAKA,UAAU;;;;;;;EAOV,QAAQ,YAAY;;;;;;;EAOpB,QAAQA;EAGN,YAAA,QAAQ,IAAI,OAAO,IACnB;aACW;aACA,UAAU,QAAQ;aAClB;;;MAcT,WAAW;MAIX,QAAQ,SAAS;;UAQb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6CR,MACE,iBACA;aACW;aACA,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgD/B,OAAO;;;;EASP;;;;EAOA;;;;EAOA,MAAM,eAAe,cAAc,MAAM;;;;EAezC,UAAU,MAAM,WAAW,WAAU,uBAA+B,kBAA4B;;;;EAOhG,IAAI,MAAM,WAAW,WAAU,uBAA+B,kBAA4B;;;;;EAQ1F,WAAW,gBAAgB,WAAU,wBAAgC;;;;;EAWrE,IAAI,MAAM,WAAW,UAAU,uBAAuB,iBAAiB;;;;EAOvE,UAAU,MAAM,SAAS,MAAM,WAAW,gBAAgB,kBAA4B;;;;EAOtF,YAAY,MAAM,SAAS,MAAM,WAAW,iBAAiB,kBAA4B;;;;EAOzF,SAAS,MAAM,SAAS,SAAS,UAAU;;;;;;;;EAwB3C,SAAS,MAAM,SAAS,MAAM,SAAS,MAAM,sBAAsB;;;;;EAenE,eAAe,SAAS;;;;;;EAUxB,mBAAmB;;;;;;EAwBnB,QAAQ,gBAAgB,UAAU;;EAWlC,YAAY,gBAAgB,MAAM,WAAW,UAAU,wBAAwB;;;qBASpE,gBAAiB,GAAG,uBAAuB,GAAG,0BAAwB;;;;;;;qBAgBtE,gBAAiB,GAAG,SAAS,GAAG,YAAU;;;;;;;;qBAa1C,oBAAqB,GAAG,SAAS,GAAG,SAAS,UAAU,0BAAwB"}
+{"version":3,"file":"Input.d.ts","names":["SyntaxBuilder"],"sources":["../src/Input.ts"],"mappings":";;;;;;;;;;;;;;;;YAkCY,iBAAiB,aAAa;;;;;;;;;;;;;YAc9B,cAAc,kBAAkB;;;;;;;;YAShC,OAAO,KAAK,MAAM,YAAY,cAAc;;;;;;;iBAQvC;GACd,QAAQ,cAAc;GACtB,UAAU,OAAO,QAAQ,OAAO,KAAK;;;;;;;;;;;;;;;;qBAiB3B,YAAY;;;;;;;YAiBb,MAAM,KAAK,4BAEnB,UAAU,sBAER,UAAU,oBAAoB,KAC5B;;;;;;;YASI,MAAM,KAAK,4BAEnB,UAAU,aACR,aACA,UAAU,oBAAoB,KAC5B,cAAc;;;;;;;;qBAUT;;;;;YAMD,cAAc;;;;;;;;;;;YAYd;;;;;;;qBAQC;;WAGA;;WAEA,MAAM;;WAEN,UAAU;;WAEV,SAAS;;WAET;;WAEA;;WAEA;;WAEA;;;EAdA;;EAEA,MAAM;;EAEN,UAAU;;EAEV,SAAS;;EAET;;EAEA;;EAEA;;EAEA;;;qBAUA;;;;;;;iBAQI;WACN;WACA;WACA;WACA;;WAEA,gBAAgB;;WAEhB;WACA,OAAO;;;;;;;;qBASL,MAAM,UAAU,QAAQ;;WAE1B,OAAO;;;;;EAKhB;;EAEA;;WAES;;EAET;;EAEA,SAAS,QAAQ;;EAEjB,MAAM;;;;;;;;;;;EAWN,aAAa;;EAEb,aAAa;;EAEb,aAAa;;EAEb,gBAAgB;;;;;;;;EAQhB;;;;;;;EAOA;;EAEA,cAAc;;;;;;;;;;MAUV,WAAW;MAIX,QAAQ,SAAS;;EAKrB,WAAW,MAAM;;EAEjB,UAAU,OAAO;;EAEjB;;;;;EAKA,UAAU;;;;;;;EAOV,QAAQ,YAAY;;;;;;;EAOpB,QAAQA;;;;;;;;;EASR,UAAU,YAAY;;;;;;;;EAQtB,UAAU;;;;;;;;EAQV,MAAM;EAGJ,YAAA,QAAQ,IAAI,OAAO,IACnB;aACW;aACA,UAAU,QAAQ;aAClB;;;MAcT,WAAW;MAIX,QAAQ,SAAS;;UAQb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6CR,MACE,iBACA;aACW;aACA,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkD/B,OAAO;;;;EASP;;;;EAOA;;;;EAOA,MAAM,eAAe,cAAc,MAAM;;;;EAsBzC,UAAU,MAAM,WAAW,WAAU,uBAA+B,kBAA4B;;;;EAOhG,IAAI,MAAM,WAAW,WAAU,uBAA+B,kBAA4B;;;;;EAQ1F,WAAW,gBAAgB,WAAU,wBAAgC;;;;;EAWrE,IAAI,MAAM,WAAW,UAAU,uBAAuB,iBAAiB;;;;EAOvE,UAAU,MAAM,SAAS,MAAM,WAAW,gBAAgB,kBAA4B;;;;EAOtF,YAAY,MAAM,SAAS,MAAM,WAAW,iBAAiB,kBAA4B;;;;EAOzF,SAAS,MAAM,SAAS,SAAS,UAAU;;;;;;;;EAwB3C,SAAS,MAAM,SAAS,MAAM,SAAS,MAAM,sBAAsB;;;;;EAenE,eAAe,SAAS;;;;;;EAUxB,mBAAmB;;;;;;EAwBnB,QAAQ,gBAAgB,UAAU;;EAWlC,YAAY,gBAAgB,MAAM,WAAW,UAAU,wBAAwB;;;qBAoBpE,gBAAiB,GAAG,uBAAuB,GAAG,0BAAwB;;;;;;;qBAqBtE,gBAAiB,GAAG,SAAS,GAAG,YAAU;;;;;;;;qBAa1C,oBAAqB,GAAG,SAAS,GAAG,SAAS,UAAU,0BAAwB"}

package/dist/Input.js

@@ -177,6 +177,31 @@ var State = class {
 	* @internal
 	*/
 	syntax = void 0;
+	/**
+	* Where the stop characters of compiled `takeTill`s next occur in this
+	* state's input, by search site; created on first use. It lives as long
+	* as the state (whose input never changes), and `reset` clears it with
+	* the other per-run fields.
+	*
+	* @internal
+	*/
+	searches = void 0;
+	/**
+	* A run of ASCII bytes of this state's UTF-8 input, decoded once, from
+	* which `Text.utf8` slices the long strings it decodes (see
+	* `internal/text.ts`); `reset` clears it with the other per-run fields.
+	*
+	* @internal
+	*/
+	asciiRun = void 0;
+	/**
+	* A `DataView` of this state's byte input, for the `Binary` parsers;
+	* created on first use. It lives as long as the state, whose input never
+	* changes: one per read cost most of a number's time.
+	*
+	* @internal
+	*/
+	view = void 0;
 	constructor(source, options) {
 		const input = fromSource(source);
 		this.input = input;
@@ -261,6 +286,8 @@ var State = class {
 		this.depth = 0;
 		this.encoding = void 0;
 		this.resume = void 0;
+		this.searches = void 0;
+		this.asciiRun = void 0;
 		return this;
 	}
 	/**
@@ -426,12 +453,27 @@ var State = class {
 		return new Failure(offset, kind, expected, empty, false, void 0, void 0, 0);
 	}
 };
+/**
+* The last merges {@link mergeExpected} made, as `[a, b, merged]` triples. A
+* parse merges the same few pairs of expectation arrays over and over (a
+* whitespace skipper's hint with a repetition's, then with the failure of
+* the token after them), and expectation arrays are never mutated, so a
+* merge seen recently returns its earlier result, which in turn keeps the
+* next merge's input the same array.
+*/
+const merges = /*#__PURE__*/ new Array(12).fill(empty);
+let mergeSlot = 0;
 /** @internal */
 const mergeExpected = (a, b) => {
 	if (Arr.isReadonlyArrayEmpty(a)) return b;
 	if (Arr.isReadonlyArrayEmpty(b)) return a;
+	for (let i = 0; i < 12; i += 3) if (merges[i] === a && merges[i + 1] === b) return merges[i + 2];
 	const out = a.slice();
 	for (const e of b) if (!out.includes(e)) out.push(e);
+	merges[mergeSlot] = a;
+	merges[mergeSlot + 1] = b;
+	merges[mergeSlot + 2] = out;
+	mergeSlot = mergeSlot === 9 ? 0 : mergeSlot + 3;
 	return out;
 };
 /**

package/dist/Input.js.map

@@ -1 +1 @@
-{"version":3,"file":"Input.js","names":[],"sources":["../src/Input.ts"],"sourcesContent":["/**\n * Input types and the mutable parse {@link State} cursor.\n *\n * Like winnow, effect-parse parsers advance a mutable cursor rather than\n * returning the remaining input. A {@link State} wraps the original input\n * together with the current offset, the streaming (partial) flag, the\n * services available to the parser, and the details of the most recent\n * failure.\n *\n * Most users never touch `State` directly. It is exposed for writing custom\n * low-level parsers with `Parser.make`, and for drivers that run a parser's\n * `step` many times over one input, reusing a state with {@link State.reset}.\n *\n * @since 0.1.0\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Context from \"effect/Context\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Builder as SyntaxBuilder } from \"./internal/syntax.js\"\n\n/**\n * The kinds of input a parser can consume.\n *\n * - `string`: tokens are Unicode code points (returned as strings), offsets\n *   are UTF-16 code-unit indices.\n * - `Uint8Array`: tokens are bytes (numbers), slices are `subarray` views.\n * - `ReadonlyArray<T>`: tokens are elements, e.g. the output of a lexer.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Input = string | Uint8Array | ReadonlyArray<unknown>\n\n/**\n * Binary data that can be passed wherever a `Uint8Array` input is expected:\n * an `ArrayBuffer`, a `SharedArrayBuffer`, a `DataView` or any typed array.\n *\n * It is viewed, not copied, as a `Uint8Array` of its bytes. A typed array\n * with wider elements is viewed in the platform's byte order, which is\n * little endian on all common platforms, so a `Uint16Array` of UTF-16 code\n * units can be parsed with `Text.utf16le`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type BinaryInput = ArrayBufferLike | ArrayBufferView\n\n/**\n * What the runners accept for a parser over `I`: the input itself, or, for\n * byte parsers, any {@link BinaryInput}.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)\n\n/**\n * Converts a {@link Source} to the input parsers read: binary data becomes a\n * `Uint8Array` view of the same memory, everything else is returned as is.\n *\n * @example\n * ```ts\n * import { Input } from \"@thomasfosterau/effect-parse\"\n *\n * Input.fromSource(new Uint16Array([0x41]).buffer) // Uint8Array [0x41, 0x00]\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const fromSource: {\n  (source: BinaryInput): Uint8Array\n  <I extends Input>(source: Source<I>): I\n} = (source: Input | BinaryInput): any => {\n  if (Predicate.isString(source) || source instanceof Uint8Array || Array.isArray(source)) return source\n  if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n  // An explicit length fixes the view's size even for a resizable buffer\n  if (isArrayBufferLike(source)) return new Uint8Array(source, 0, source.byteLength)\n  return source\n}\n\nconst isArrayBufferLike = (u: Input | BinaryInput): u is ArrayBufferLike =>\n  u instanceof ArrayBuffer || (globalThis.SharedArrayBuffer !== undefined && u instanceof SharedArrayBuffer)\n\n/**\n * The type of a single token of an input.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Token<I> = I extends string\n  ? string\n  : I extends Uint8Array\n    ? number\n    : I extends ReadonlyArray<infer T>\n      ? T\n      : never\n\n/**\n * The type of a contiguous slice of an input.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Slice<I> = I extends string\n  ? string\n  : I extends Uint8Array\n    ? Uint8Array\n    : I extends ReadonlyArray<infer T>\n      ? ReadonlyArray<T>\n      : never\n\n/**\n * Sentinel returned by a parser step to signal failure. The failure details\n * are stored on the {@link State}.\n *\n * @since 0.1.0\n * @category failure\n */\nexport const Fail: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/Fail\")\n\n/**\n * @since 0.1.0\n * @category failure\n */\nexport type Fail = typeof Fail\n\n/**\n * How a failure propagates (winnow's `ErrMode`, nom's `Err`).\n *\n * - `Backtrack`: recoverable; `alt`, `opt`, `repeat`, ... try something else.\n * - `Cut`: unrecoverable; alternatives are not attempted.\n * - `Incomplete`: a partial (streaming) input ran out; more data is needed.\n *\n * @since 0.1.0\n * @category failure\n */\nexport type ErrMode = \"Backtrack\" | \"Cut\" | \"Incomplete\"\n\n/**\n * The details of a parse failure.\n *\n * @since 0.1.0\n * @category failure\n */\nexport class Failure {\n  constructor(\n    /** Offset into the input where the failure occurred. */\n    readonly offset: number,\n    /** The kind of parser that failed. */\n    readonly kind: ErrorKind,\n    /** Rendered descriptions of what was expected at `offset`. */\n    readonly expected: ReadonlyArray<string>,\n    /** Context labels added by `Parser.context`, innermost first. */\n    readonly context: ReadonlyArray<string>,\n    /** Whether a user supplied cause is present. */\n    readonly hasCause: boolean,\n    /** A user supplied (typed) cause. */\n    readonly cause: unknown,\n    /** An optional free-form message. */\n    readonly message: string | undefined,\n    /** For `Incomplete` failures, how many more tokens are needed (0 if unknown). */\n    readonly needed: number\n  ) {}\n}\n\nconst empty: ReadonlyArray<string> = []\n\n/** The failure a {@link State} starts with, before any step has failed. */\nconst initialFailure = /*#__PURE__*/ new Failure(0, \"Fail\", empty, empty, false, undefined, undefined, 0)\n\n/** @internal */\nexport const emptyStrings = empty\n\n/**\n * A tracing event emitted by `Parser.trace`.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport interface TraceEvent {\n  readonly _tag: \"Enter\" | \"Exit\"\n  readonly name: string\n  readonly depth: number\n  readonly offset: number\n  /** For `Exit` events: the outcome. */\n  readonly result?: \"Ok\" | ErrMode\n  /** For `Exit` events: the offset reached. */\n  readonly endOffset?: number\n  readonly state: State\n}\n\n/**\n * The mutable parsing cursor.\n *\n * @since 0.1.0\n * @category models\n */\nexport class State<I extends Input = Input> {\n  /** The full input being parsed. */\n  readonly input: I\n  /**\n   * The current offset. Parsers advance it by assigning it; moving it back\n   * (backtracking, or after a lookahead) goes through {@link rewind}.\n   */\n  pos: number\n  /** The end offset (the input's length; in bits inside `Bits.bits`). */\n  end: number\n  /** 0 = string, 1 = Uint8Array, 2 = array. */\n  readonly inputKind: 0 | 1 | 2\n  /** Whether the input is partial (streaming): running out yields `Incomplete`. */\n  partial: boolean\n  /** Services available to `Parser.service`. */\n  context: Context.Context<never>\n  /** Mode of the latest failure. Only meaningful after a step returned {@link Fail}. */\n  mode: ErrMode = \"Backtrack\"\n  /**\n   * The latest failure, kept unmerged: the failure is `failureHead` merged\n   * (as `mergeFailures` does) with `failureTie1` and then `failureTie2`, all\n   * at the same offset. `Parser.alt` records its tied branch failures here\n   * with {@link failTies} instead of merging them, so that an enclosing `alt`\n   * whose next branch succeeds never pays for the merge. Reading\n   * {@link failure} performs the merge, once.\n   *\n   * @internal\n   */\n  failureHead: Failure\n  /** @internal */\n  failureTie1: Failure | undefined = undefined\n  /** @internal */\n  failureTie2: Failure | undefined = undefined\n  /** Backs {@link deepest}. @internal */\n  deepestFailure: Failure | undefined = undefined\n  /**\n   * Whether the furthest failure is the latest failure, still unmerged, so\n   * that {@link deepest} is that failure once merged. Only set while\n   * `failureTie1` is.\n   *\n   * @internal\n   */\n  deepestIsLatest = false\n  /**\n   * The offset of a recoverable failure that occurred without consuming\n   * input (for example the last attempt of a `repeat`). Its\n   * expectations are merged into new failures at the same offset, producing\n   * messages like `expected digit or \")\"`.\n   */\n  hintOffset = -1\n  /** The expectations of the hint at {@link hintOffset}. */\n  hintExpected: ReadonlyArray<string> = empty\n  /**\n   * The furthest recoverable failure seen so far, including failures that\n   * were later swallowed by backtracking (for example a trailing separator\n   * followed by an invalid element). It is reported instead of the final\n   * failure when it lies further into the input. This is the classic PEG\n   * \"farthest failure\" heuristic. `Parser.cut` keeps only the failures\n   * recorded inside it when it commits, and `Parser.peek` and `Parser.not`\n   * forget the failures of a lookahead that succeeded.\n   */\n  get deepest(): Failure | undefined {\n    if (this.deepestIsLatest) this.settleFailure()\n    return this.deepestFailure\n  }\n  set deepest(failure: Failure | undefined) {\n    this.deepestIsLatest = false\n    this.deepestFailure = failure\n  }\n  /** When defined, `Parser.resumeAfter`/`retryAfter` record failures here. */\n  recovered: Array<Failure> | undefined = undefined\n  /** When defined, `Parser.trace` reports events here. */\n  tracer: ((event: TraceEvent) => void) | undefined = undefined\n  /** Current tracing depth. */\n  depth = 0\n  /**\n   * The text encoding of a byte input, recorded by `Text` parsers when they\n   * fail so that errors can show the input as text.\n   */\n  encoding: Encoding<any> | undefined = undefined\n  /**\n   * The checkpoints of a resumable streaming parse (see\n   * `ParserStream.parseAll`); `undefined` otherwise.\n   *\n   * @internal\n   */\n  resume: Map<object, Map<number, unknown>> | undefined = undefined\n  /**\n   * The tree builder of a `Syntax` parse; `undefined` otherwise. A builder\n   * rather than a subclass of `State`, so that every state has one shape.\n   *\n   * @internal\n   */\n  syntax: SyntaxBuilder | undefined = undefined\n\n  constructor(\n    source: I | Source<I>,\n    options?: {\n      readonly partial?: boolean | undefined\n      readonly context?: Context.Context<never> | undefined\n      readonly offset?: number | undefined\n    }\n  ) {\n    const input = fromSource(source as Input) as I\n    this.input = input\n    this.end = input.length\n    this.pos = options?.offset ?? 0\n    this.partial = options?.partial ?? false\n    this.context = options?.context ?? Context.empty()\n    this.inputKind = Predicate.isString(input) ? 0 : input instanceof Uint8Array ? 1 : 2\n    this.failureHead = initialFailure\n  }\n\n  /** Details of the latest failure. Only meaningful after a step returned {@link Fail}. */\n  get failure(): Failure {\n    if (this.failureTie1 !== undefined) this.settleFailure()\n    return this.failureHead\n  }\n  set failure(failure: Failure) {\n    if (this.deepestIsLatest) this.settleFailure()\n    this.failureHead = failure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n  }\n\n  /** Merges the latest failure's ties into it (see {@link failureHead}). */\n  private settleFailure(): void {\n    let failure = this.failureHead\n    const tie1 = this.failureTie1\n    if (tie1 !== undefined) {\n      failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))\n      const tie2 = this.failureTie2\n      if (tie2 !== undefined) failure = mergeTiedFailures(failure, tie2, mergeExpected(failure.expected, tie2.expected))\n      this.failureHead = failure\n      this.failureTie1 = undefined\n      this.failureTie2 = undefined\n    }\n    if (this.deepestIsLatest) {\n      this.deepestFailure = failure\n      this.deepestIsLatest = false\n    }\n  }\n\n  /**\n   * Prepares the state for another run over the same input, starting at\n   * `offset`: afterwards it behaves exactly like\n   * `new State(state.input, { ...options, offset })`, without allocating a\n   * new state.\n   *\n   * Every per-run field is reset: the cursor and end, the latest failure,\n   * hints and furthest failure, recorded recoveries, the tracer and tracing\n   * depth, the recorded encoding and streaming checkpoints. Like the\n   * constructor, `partial` defaults to `false` and `context` to the empty\n   * context, so pass them again on every reset.\n   *\n   * Use it to run many small parses over one buffer, for example one per\n   * token, with `parser.step`. A state can be reused after any run,\n   * including one that failed, returned `Incomplete` or threw.\n   *\n   * @example\n   * ```ts\n   * import { Ascii, Input } from \"@thomasfosterau/effect-parse\"\n   *\n   * const state = new Input.State(\"12 34\")\n   * Ascii.decUint.step(state) // 12\n   * state.reset(3)\n   * Ascii.decUint.step(state) // 34\n   * ```\n   *\n   * @since 0.2.0\n   */\n  reset(\n    offset: number = 0,\n    options?: {\n      readonly partial?: boolean | undefined\n      readonly context?: Context.Context<never> | undefined\n    }\n  ): this {\n    this.pos = offset\n    this.end = this.input.length\n    this.partial = options?.partial ?? false\n    this.context = options?.context ?? Context.empty()\n    this.mode = \"Backtrack\"\n    this.failureHead = initialFailure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n    this.hintOffset = -1\n    this.hintExpected = empty\n    this.deepestFailure = undefined\n    this.deepestIsLatest = false\n    this.recovered = undefined\n    this.tracer = undefined\n    this.depth = 0\n    this.encoding = undefined\n    this.resume = undefined\n    return this\n  }\n\n  /**\n   * Moves the cursor back to `offset`, abandoning what was parsed after it:\n   * how a parser backtracks, or returns to where a lookahead started. A step\n   * that moves the cursor backwards must use this rather than assigning\n   * {@link pos}, so that a `Syntax` parse drops the nodes the abandoned\n   * attempt built. Moving forward is an assignment.\n   *\n   * @example\n   * ```ts\n   * import { Input, Parser } from \"@thomasfosterau/effect-parse\"\n   *\n   * // Like `Parser.opt`, for one parser\n   * const optional = <A>(p: Parser.Parser<A>) =>\n   *   Parser.make<A | undefined>((state) => {\n   *     const start = state.pos\n   *     const a = p.step(state)\n   *     if (a !== Input.Fail) return a\n   *     if (state.mode !== \"Backtrack\") return Input.Fail\n   *     state.rewind(start)\n   *     return undefined\n   *   })\n   * ```\n   *\n   * @since 0.4.0\n   */\n  rewind(offset: number): void {\n    const syntax = this.syntax\n    if (syntax !== undefined && offset < this.pos) syntax.rewound(this.pos, offset)\n    this.pos = offset\n  }\n\n  /**\n   * The number of input units (code units, bytes or elements) remaining.\n   */\n  remaining(): number {\n    return this.end - this.pos\n  }\n\n  /**\n   * Whether the cursor is at the end of the input.\n   */\n  atEnd(): boolean {\n    return this.pos >= this.end\n  }\n\n  /**\n   * Extracts the slice `[start, end)` of the input.\n   */\n  slice(start: number, end: number): Slice<I> {\n    const input = this.input as any\n    switch (this.inputKind) {\n      case 0:\n        return input.slice(start, end)\n      case 1:\n        return input.subarray(start, end)\n      default:\n        return input.slice(start, end)\n    }\n  }\n\n  /**\n   * Records a recoverable failure at the current offset and returns {@link Fail}.\n   */\n  backtrack(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {\n    return this.failWith(\"Backtrack\", this.makeFailure(offset, kind, expected))\n  }\n\n  /**\n   * Records an unrecoverable failure at the current offset and returns {@link Fail}.\n   */\n  cut(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {\n    return this.failWith(\"Cut\", this.makeFailure(offset, kind, expected))\n  }\n\n  /**\n   * Records an `Incomplete` failure (only meaningful for partial input) and\n   * returns {@link Fail}.\n   */\n  incomplete(needed: number, expected: ReadonlyArray<string> = empty): Fail {\n    return this.failWith(\n      \"Incomplete\",\n      new Failure(this.pos, \"Incomplete\", expected, empty, false, undefined, undefined, needed)\n    )\n  }\n\n  /**\n   * Fails because the input ended: `Incomplete` for partial input, otherwise\n   * a `Backtrack` failure of the given kind.\n   */\n  eoi(kind: ErrorKind, expected: ReadonlyArray<string>, needed: number): Fail {\n    return this.partial ? this.incomplete(needed, expected) : this.backtrack(kind, expected)\n  }\n\n  /**\n   * Records a failure carrying a user supplied cause.\n   */\n  failCause(mode: ErrMode, kind: ErrorKind, cause: unknown, offset: number = this.pos): Fail {\n    return this.failWith(mode, new Failure(offset, kind, empty, empty, true, cause, undefined, 0))\n  }\n\n  /**\n   * Records a failure carrying a message.\n   */\n  failMessage(mode: ErrMode, kind: ErrorKind, message: string, offset: number = this.pos): Fail {\n    return this.failWith(mode, new Failure(offset, kind, empty, empty, false, undefined, message, 0))\n  }\n\n  /**\n   * Records the given failure and returns {@link Fail}.\n   */\n  failWith(mode: ErrMode, failure: Failure): Fail {\n    this.mode = mode\n    if (this.deepestIsLatest) {\n      // The furthest failure is the latest one: it is replaced below, unmerged, if `failure` is as far\n      if (mode === \"Backtrack\" && failure.offset >= this.failureHead.offset) this.deepestIsLatest = false\n      else this.settleFailure()\n    }\n    this.failureHead = failure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n    if (mode === \"Backtrack\" && (this.deepestFailure === undefined || failure.offset >= this.deepestFailure.offset)) {\n      this.deepestFailure = failure\n    }\n    if (this.syntax !== undefined) this.syntax.reach(failure.offset)\n    return Fail\n  }\n\n  /**\n   * Records a recoverable failure made of tied failures, merged only when\n   * read: `failWith(\"Backtrack\", f)` where `f` merges `head` with `tie1`\n   * and then `tie2` (all at the same offset), as `mergeFailures` would.\n   *\n   * @internal\n   */\n  failTies(head: Failure, tie1: Failure, tie2: Failure | undefined): Fail {\n    this.mode = \"Backtrack\"\n    if (this.deepestIsLatest && head.offset < this.failureHead.offset) this.settleFailure()\n    this.failureHead = head\n    this.failureTie1 = tie1\n    this.failureTie2 = tie2\n    this.deepestIsLatest = this.deepestFailure === undefined || head.offset >= this.deepestFailure.offset\n    if (this.syntax !== undefined) this.syntax.reach(head.offset)\n    return Fail\n  }\n\n  /**\n   * Replaces the details of the current failure (for example to add context),\n   * keeping the record of the furthest failure consistent.\n   */\n  replaceFailure(failure: Failure): void {\n    if (this.deepest === this.failure) this.deepest = failure\n    this.failure = failure\n  }\n\n  /**\n   * The failure to report to the user: the current failure, or the furthest\n   * failure if it lies beyond the current one and the current failure is a\n   * plain syntax error (no user cause or message).\n   */\n  reportedFailure(): Failure {\n    const f = this.failure\n    const d = this.deepest\n    if (\n      d === undefined ||\n      d === f ||\n      d.offset <= f.offset ||\n      this.mode === \"Incomplete\" ||\n      f.hasCause ||\n      f.message !== undefined\n    ) {\n      return f\n    }\n    const context = Arr.isReadonlyArrayEmpty(d.context)\n      ? f.context\n      : [...d.context, ...f.context.filter((l) => !d.context.includes(l))]\n    return new Failure(d.offset, d.kind, d.expected, context, d.hasCause, d.cause, d.message, d.needed)\n  }\n\n  /**\n   * Records that, at `offset`, any of `expected` could also have been\n   * accepted. Used by parsers that stop without failing, such as `opt`,\n   * `repeat` and `Ascii.digit1`.\n   */\n  setHint(offset: number, expected: ReadonlyArray<string>): void {\n    if (this.syntax !== undefined) this.syntax.reach(offset)\n    if (this.hintOffset === offset) {\n      this.hintExpected = mergeExpected(this.hintExpected, expected)\n    } else {\n      this.hintOffset = offset\n      this.hintExpected = expected\n    }\n  }\n\n  /** @internal */\n  makeFailure(offset: number, kind: ErrorKind, expected: ReadonlyArray<string>): Failure {\n    if (this.hintOffset === offset && Arr.isReadonlyArrayNonEmpty(this.hintExpected)) {\n      expected = mergeExpected(this.hintExpected, expected)\n    }\n    return new Failure(offset, kind, expected, empty, false, undefined, undefined, 0)\n  }\n}\n\n/** @internal */\nexport const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>): ReadonlyArray<string> => {\n  if (Arr.isReadonlyArrayEmpty(a)) return b\n  if (Arr.isReadonlyArrayEmpty(b)) return a\n  const out = a.slice()\n  for (const e of b) {\n    if (!out.includes(e)) out.push(e)\n  }\n  return out\n}\n\n/**\n * Combines the failures of two alternatives: the furthest failure wins, and\n * failures at the same offset have their expectations merged.\n *\n * @internal\n */\nexport const mergeFailures = (a: Failure, b: Failure): Failure => {\n  if (a.offset > b.offset) return a\n  if (b.offset > a.offset) return b\n  return mergeTiedFailures(a, b, mergeExpected(a.expected, b.expected))\n}\n\n/**\n * {@link mergeFailures} for two failures at the same offset, given their\n * merged expectations (`mergeExpected(a.expected, b.expected)`, possibly\n * memoised by the caller).\n *\n * @internal\n */\nexport const mergeTiedFailures = (a: Failure, b: Failure, expected: ReadonlyArray<string>): Failure => {\n  if (expected === b.expected) return b\n  return new Failure(\n    b.offset,\n    b.kind,\n    expected,\n    Arr.isReadonlyArrayNonEmpty(b.context) ? b.context : a.context,\n    b.hasCause || a.hasCause,\n    b.hasCause ? b.cause : a.cause,\n    b.message ?? a.message,\n    b.needed\n  )\n}\n"],"mappings":"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"}
+{"version":3,"file":"Input.js","names":[],"sources":["../src/Input.ts"],"sourcesContent":["/**\n * Input types and the mutable parse {@link State} cursor.\n *\n * Like winnow, effect-parse parsers advance a mutable cursor rather than\n * returning the remaining input. A {@link State} wraps the original input\n * together with the current offset, the streaming (partial) flag, the\n * services available to the parser, and the details of the most recent\n * failure.\n *\n * Most users never touch `State` directly. It is exposed for writing custom\n * low-level parsers with `Parser.make`, and for drivers that run a parser's\n * `step` many times over one input, reusing a state with {@link State.reset}.\n *\n * @since 0.1.0\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Context from \"effect/Context\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Builder as SyntaxBuilder } from \"./internal/syntax.js\"\nimport type { AsciiRun } from \"./internal/text.js\"\n\n/**\n * The kinds of input a parser can consume.\n *\n * - `string`: tokens are Unicode code points (returned as strings), offsets\n *   are UTF-16 code-unit indices.\n * - `Uint8Array`: tokens are bytes (numbers), slices are `subarray` views.\n * - `ReadonlyArray<T>`: tokens are elements, e.g. the output of a lexer.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Input = string | Uint8Array | ReadonlyArray<unknown>\n\n/**\n * Binary data that can be passed wherever a `Uint8Array` input is expected:\n * an `ArrayBuffer`, a `SharedArrayBuffer`, a `DataView` or any typed array.\n *\n * It is viewed, not copied, as a `Uint8Array` of its bytes. A typed array\n * with wider elements is viewed in the platform's byte order, which is\n * little endian on all common platforms, so a `Uint16Array` of UTF-16 code\n * units can be parsed with `Text.utf16le`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type BinaryInput = ArrayBufferLike | ArrayBufferView\n\n/**\n * What the runners accept for a parser over `I`: the input itself, or, for\n * byte parsers, any {@link BinaryInput}.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)\n\n/**\n * The overloads of {@link fromSource}.\n *\n * @since 0.5.0\n * @category constructors\n */\nexport interface FromSourceFn {\n  (source: BinaryInput): Uint8Array\n  <I extends Input>(source: Source<I>): I\n}\n\n/**\n * Converts a {@link Source} to the input parsers read: binary data becomes a\n * `Uint8Array` view of the same memory, everything else is returned as is.\n *\n * @example\n * ```ts\n * import { Input } from \"@thomasfosterau/effect-parse\"\n *\n * Input.fromSource(new Uint16Array([0x41]).buffer) // Uint8Array [0x41, 0x00]\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const fromSource: FromSourceFn = (source: Input | BinaryInput): any => {\n  if (Predicate.isString(source) || source instanceof Uint8Array || Array.isArray(source)) return source\n  if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n  // An explicit length fixes the view's size even for a resizable buffer\n  if (isArrayBufferLike(source)) return new Uint8Array(source, 0, source.byteLength)\n  return source\n}\n\nconst isArrayBufferLike = (u: Input | BinaryInput): u is ArrayBufferLike =>\n  u instanceof ArrayBuffer || (globalThis.SharedArrayBuffer !== undefined && u instanceof SharedArrayBuffer)\n\n/**\n * The type of a single token of an input.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Token<I> = I extends string\n  ? string\n  : I extends Uint8Array\n    ? number\n    : I extends ReadonlyArray<infer T>\n      ? T\n      : never\n\n/**\n * The type of a contiguous slice of an input.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Slice<I> = I extends string\n  ? string\n  : I extends Uint8Array\n    ? Uint8Array\n    : I extends ReadonlyArray<infer T>\n      ? ReadonlyArray<T>\n      : never\n\n/**\n * Sentinel returned by a parser step to signal failure. The failure details\n * are stored on the {@link State}.\n *\n * @since 0.1.0\n * @category failure\n */\nexport const Fail: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/Fail\")\n\n/**\n * @since 0.1.0\n * @category failure\n */\nexport type Fail = typeof Fail\n\n/**\n * How a failure propagates (winnow's `ErrMode`, nom's `Err`).\n *\n * - `Backtrack`: recoverable; `alt`, `opt`, `repeat`, ... try something else.\n * - `Cut`: unrecoverable; alternatives are not attempted.\n * - `Incomplete`: a partial (streaming) input ran out; more data is needed.\n *\n * @since 0.1.0\n * @category failure\n */\nexport type ErrMode = \"Backtrack\" | \"Cut\" | \"Incomplete\"\n\n/**\n * The details of a parse failure.\n *\n * @since 0.1.0\n * @category failure\n */\nexport class Failure {\n  constructor(\n    /** Offset into the input where the failure occurred. */\n    readonly offset: number,\n    /** The kind of parser that failed. */\n    readonly kind: ErrorKind,\n    /** Rendered descriptions of what was expected at `offset`. */\n    readonly expected: ReadonlyArray<string>,\n    /** Context labels added by `Parser.context`, innermost first. */\n    readonly context: ReadonlyArray<string>,\n    /** Whether a user supplied cause is present. */\n    readonly hasCause: boolean,\n    /** A user supplied (typed) cause. */\n    readonly cause: unknown,\n    /** An optional free-form message. */\n    readonly message: string | undefined,\n    /** For `Incomplete` failures, how many more tokens are needed (0 if unknown). */\n    readonly needed: number\n  ) {}\n}\n\nconst empty: ReadonlyArray<string> = []\n\n/** The failure a {@link State} starts with, before any step has failed. */\nconst initialFailure = /*#__PURE__*/ new Failure(0, \"Fail\", empty, empty, false, undefined, undefined, 0)\n\n/** @internal */\nexport const emptyStrings = empty\n\n/**\n * A tracing event emitted by `Parser.trace`.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport interface TraceEvent {\n  readonly _tag: \"Enter\" | \"Exit\"\n  readonly name: string\n  readonly depth: number\n  readonly offset: number\n  /** For `Exit` events: the outcome. */\n  readonly result?: \"Ok\" | ErrMode\n  /** For `Exit` events: the offset reached. */\n  readonly endOffset?: number\n  readonly state: State\n}\n\n/**\n * The mutable parsing cursor.\n *\n * @since 0.1.0\n * @category models\n */\nexport class State<I extends Input = Input> {\n  /** The full input being parsed. */\n  readonly input: I\n  /**\n   * The current offset. Parsers advance it by assigning it; moving it back\n   * (backtracking, or after a lookahead) goes through {@link rewind}.\n   */\n  pos: number\n  /** The end offset (the input's length; in bits inside `Bits.bits`). */\n  end: number\n  /** 0 = string, 1 = Uint8Array, 2 = array. */\n  readonly inputKind: 0 | 1 | 2\n  /** Whether the input is partial (streaming): running out yields `Incomplete`. */\n  partial: boolean\n  /** Services available to `Parser.service`. */\n  context: Context.Context<never>\n  /** Mode of the latest failure. Only meaningful after a step returned {@link Fail}. */\n  mode: ErrMode = \"Backtrack\"\n  /**\n   * The latest failure, kept unmerged: the failure is `failureHead` merged\n   * (as `mergeFailures` does) with `failureTie1` and then `failureTie2`, all\n   * at the same offset. `Parser.alt` records its tied branch failures here\n   * with {@link failTies} instead of merging them, so that an enclosing `alt`\n   * whose next branch succeeds never pays for the merge. Reading\n   * {@link failure} performs the merge, once.\n   *\n   * @internal\n   */\n  failureHead: Failure\n  /** @internal */\n  failureTie1: Failure | undefined = undefined\n  /** @internal */\n  failureTie2: Failure | undefined = undefined\n  /** Backs {@link deepest}. @internal */\n  deepestFailure: Failure | undefined = undefined\n  /**\n   * Whether the furthest failure is the latest failure, still unmerged, so\n   * that {@link deepest} is that failure once merged. Only set while\n   * `failureTie1` is.\n   *\n   * @internal\n   */\n  deepestIsLatest = false\n  /**\n   * The offset of a recoverable failure that occurred without consuming\n   * input (for example the last attempt of a `repeat`). Its\n   * expectations are merged into new failures at the same offset, producing\n   * messages like `expected digit or \")\"`.\n   */\n  hintOffset = -1\n  /** The expectations of the hint at {@link hintOffset}. */\n  hintExpected: ReadonlyArray<string> = empty\n  /**\n   * The furthest recoverable failure seen so far, including failures that\n   * were later swallowed by backtracking (for example a trailing separator\n   * followed by an invalid element). It is reported instead of the final\n   * failure when it lies further into the input. This is the classic PEG\n   * \"farthest failure\" heuristic. `Parser.cut` keeps only the failures\n   * recorded inside it when it commits, and `Parser.peek` and `Parser.not`\n   * forget the failures of a lookahead that succeeded.\n   */\n  get deepest(): Failure | undefined {\n    if (this.deepestIsLatest) this.settleFailure()\n    return this.deepestFailure\n  }\n  set deepest(failure: Failure | undefined) {\n    this.deepestIsLatest = false\n    this.deepestFailure = failure\n  }\n  /** When defined, `Parser.resumeAfter`/`retryAfter` record failures here. */\n  recovered: Array<Failure> | undefined = undefined\n  /** When defined, `Parser.trace` reports events here. */\n  tracer: ((event: TraceEvent) => void) | undefined = undefined\n  /** Current tracing depth. */\n  depth = 0\n  /**\n   * The text encoding of a byte input, recorded by `Text` parsers when they\n   * fail so that errors can show the input as text.\n   */\n  encoding: Encoding<any> | undefined = undefined\n  /**\n   * The checkpoints of a resumable streaming parse (see\n   * `ParserStream.parseAll`); `undefined` otherwise.\n   *\n   * @internal\n   */\n  resume: Map<object, Map<number, unknown>> | undefined = undefined\n  /**\n   * The tree builder of a `Syntax` parse; `undefined` otherwise. A builder\n   * rather than a subclass of `State`, so that every state has one shape.\n   *\n   * @internal\n   */\n  syntax: SyntaxBuilder | undefined = undefined\n  /**\n   * Where the stop characters of compiled `takeTill`s next occur in this\n   * state's input, by search site; created on first use. It lives as long\n   * as the state (whose input never changes), and `reset` clears it with\n   * the other per-run fields.\n   *\n   * @internal\n   */\n  searches: Map<object, Array<number>> | undefined = undefined\n  /**\n   * A run of ASCII bytes of this state's UTF-8 input, decoded once, from\n   * which `Text.utf8` slices the long strings it decodes (see\n   * `internal/text.ts`); `reset` clears it with the other per-run fields.\n   *\n   * @internal\n   */\n  asciiRun: AsciiRun | undefined = undefined\n  /**\n   * A `DataView` of this state's byte input, for the `Binary` parsers;\n   * created on first use. It lives as long as the state, whose input never\n   * changes: one per read cost most of a number's time.\n   *\n   * @internal\n   */\n  view: DataView | undefined = undefined\n\n  constructor(\n    source: I | Source<I>,\n    options?: {\n      readonly partial?: boolean | undefined\n      readonly context?: Context.Context<never> | undefined\n      readonly offset?: number | undefined\n    }\n  ) {\n    const input = fromSource<I>(source)\n    this.input = input\n    this.end = input.length\n    this.pos = options?.offset ?? 0\n    this.partial = options?.partial ?? false\n    this.context = options?.context ?? Context.empty()\n    this.inputKind = Predicate.isString(input) ? 0 : input instanceof Uint8Array ? 1 : 2\n    this.failureHead = initialFailure\n  }\n\n  /** Details of the latest failure. Only meaningful after a step returned {@link Fail}. */\n  get failure(): Failure {\n    if (this.failureTie1 !== undefined) this.settleFailure()\n    return this.failureHead\n  }\n  set failure(failure: Failure) {\n    if (this.deepestIsLatest) this.settleFailure()\n    this.failureHead = failure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n  }\n\n  /** Merges the latest failure's ties into it (see {@link failureHead}). */\n  private settleFailure(): void {\n    let failure = this.failureHead\n    const tie1 = this.failureTie1\n    if (tie1 !== undefined) {\n      failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))\n      const tie2 = this.failureTie2\n      if (tie2 !== undefined) failure = mergeTiedFailures(failure, tie2, mergeExpected(failure.expected, tie2.expected))\n      this.failureHead = failure\n      this.failureTie1 = undefined\n      this.failureTie2 = undefined\n    }\n    if (this.deepestIsLatest) {\n      this.deepestFailure = failure\n      this.deepestIsLatest = false\n    }\n  }\n\n  /**\n   * Prepares the state for another run over the same input, starting at\n   * `offset`: afterwards it behaves exactly like\n   * `new State(state.input, { ...options, offset })`, without allocating a\n   * new state.\n   *\n   * Every per-run field is reset: the cursor and end, the latest failure,\n   * hints and furthest failure, recorded recoveries, the tracer and tracing\n   * depth, the recorded encoding and streaming checkpoints. Like the\n   * constructor, `partial` defaults to `false` and `context` to the empty\n   * context, so pass them again on every reset.\n   *\n   * Use it to run many small parses over one buffer, for example one per\n   * token, with `parser.step`. A state can be reused after any run,\n   * including one that failed, returned `Incomplete` or threw.\n   *\n   * @example\n   * ```ts\n   * import { Ascii, Input } from \"@thomasfosterau/effect-parse\"\n   *\n   * const state = new Input.State(\"12 34\")\n   * Ascii.decUint.step(state) // 12\n   * state.reset(3)\n   * Ascii.decUint.step(state) // 34\n   * ```\n   *\n   * @since 0.2.0\n   */\n  reset(\n    offset: number = 0,\n    options?: {\n      readonly partial?: boolean | undefined\n      readonly context?: Context.Context<never> | undefined\n    }\n  ): this {\n    this.pos = offset\n    this.end = this.input.length\n    this.partial = options?.partial ?? false\n    this.context = options?.context ?? Context.empty()\n    this.mode = \"Backtrack\"\n    this.failureHead = initialFailure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n    this.hintOffset = -1\n    this.hintExpected = empty\n    this.deepestFailure = undefined\n    this.deepestIsLatest = false\n    this.recovered = undefined\n    this.tracer = undefined\n    this.depth = 0\n    this.encoding = undefined\n    this.resume = undefined\n    this.searches = undefined\n    this.asciiRun = undefined\n    return this\n  }\n\n  /**\n   * Moves the cursor back to `offset`, abandoning what was parsed after it:\n   * how a parser backtracks, or returns to where a lookahead started. A step\n   * that moves the cursor backwards must use this rather than assigning\n   * {@link pos}, so that a `Syntax` parse drops the nodes the abandoned\n   * attempt built. Moving forward is an assignment.\n   *\n   * @example\n   * ```ts\n   * import { Input, Parser } from \"@thomasfosterau/effect-parse\"\n   *\n   * // Like `Parser.opt`, for one parser\n   * const optional = <A>(p: Parser.Parser<A>) =>\n   *   Parser.make<A | undefined>((state) => {\n   *     const start = state.pos\n   *     const a = p.step(state)\n   *     if (a !== Input.Fail) return a\n   *     if (state.mode !== \"Backtrack\") return Input.Fail\n   *     state.rewind(start)\n   *     return undefined\n   *   })\n   * ```\n   *\n   * @since 0.4.0\n   */\n  rewind(offset: number): void {\n    const syntax = this.syntax\n    if (syntax !== undefined && offset < this.pos) syntax.rewound(this.pos, offset)\n    this.pos = offset\n  }\n\n  /**\n   * The number of input units (code units, bytes or elements) remaining.\n   */\n  remaining(): number {\n    return this.end - this.pos\n  }\n\n  /**\n   * Whether the cursor is at the end of the input.\n   */\n  atEnd(): boolean {\n    return this.pos >= this.end\n  }\n\n  /**\n   * Extracts the slice `[start, end)` of the input.\n   */\n  slice(start: number, end: number): Slice<I> {\n    // SAFETY: `inputKind` 1 is a `Uint8Array`, whose `subarray` returns a\n    // `Uint8Array` view (its `Slice`); 0 and 2 are a string and an array, whose\n    // `slice` returns a string and an array of the same elements (their\n    // `Slice`). `subarray` is only called for kind 1\n    const input = this.input as {\n      slice(start: number, end: number): Slice<I>\n      subarray(start: number, end: number): Slice<I>\n    } & I\n    switch (this.inputKind) {\n      case 0:\n        return input.slice(start, end)\n      case 1:\n        return input.subarray(start, end)\n      default:\n        return input.slice(start, end)\n    }\n  }\n\n  /**\n   * Records a recoverable failure at the current offset and returns {@link Fail}.\n   */\n  backtrack(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {\n    return this.failWith(\"Backtrack\", this.makeFailure(offset, kind, expected))\n  }\n\n  /**\n   * Records an unrecoverable failure at the current offset and returns {@link Fail}.\n   */\n  cut(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {\n    return this.failWith(\"Cut\", this.makeFailure(offset, kind, expected))\n  }\n\n  /**\n   * Records an `Incomplete` failure (only meaningful for partial input) and\n   * returns {@link Fail}.\n   */\n  incomplete(needed: number, expected: ReadonlyArray<string> = empty): Fail {\n    return this.failWith(\n      \"Incomplete\",\n      new Failure(this.pos, \"Incomplete\", expected, empty, false, undefined, undefined, needed)\n    )\n  }\n\n  /**\n   * Fails because the input ended: `Incomplete` for partial input, otherwise\n   * a `Backtrack` failure of the given kind.\n   */\n  eoi(kind: ErrorKind, expected: ReadonlyArray<string>, needed: number): Fail {\n    return this.partial ? this.incomplete(needed, expected) : this.backtrack(kind, expected)\n  }\n\n  /**\n   * Records a failure carrying a user supplied cause.\n   */\n  failCause(mode: ErrMode, kind: ErrorKind, cause: unknown, offset: number = this.pos): Fail {\n    return this.failWith(mode, new Failure(offset, kind, empty, empty, true, cause, undefined, 0))\n  }\n\n  /**\n   * Records a failure carrying a message.\n   */\n  failMessage(mode: ErrMode, kind: ErrorKind, message: string, offset: number = this.pos): Fail {\n    return this.failWith(mode, new Failure(offset, kind, empty, empty, false, undefined, message, 0))\n  }\n\n  /**\n   * Records the given failure and returns {@link Fail}.\n   */\n  failWith(mode: ErrMode, failure: Failure): Fail {\n    this.mode = mode\n    if (this.deepestIsLatest) {\n      // The furthest failure is the latest one: it is replaced below, unmerged, if `failure` is as far\n      if (mode === \"Backtrack\" && failure.offset >= this.failureHead.offset) this.deepestIsLatest = false\n      else this.settleFailure()\n    }\n    this.failureHead = failure\n    this.failureTie1 = undefined\n    this.failureTie2 = undefined\n    if (mode === \"Backtrack\" && (this.deepestFailure === undefined || failure.offset >= this.deepestFailure.offset)) {\n      this.deepestFailure = failure\n    }\n    if (this.syntax !== undefined) this.syntax.reach(failure.offset)\n    return Fail\n  }\n\n  /**\n   * Records a recoverable failure made of tied failures, merged only when\n   * read: `failWith(\"Backtrack\", f)` where `f` merges `head` with `tie1`\n   * and then `tie2` (all at the same offset), as `mergeFailures` would.\n   *\n   * @internal\n   */\n  failTies(head: Failure, tie1: Failure, tie2: Failure | undefined): Fail {\n    this.mode = \"Backtrack\"\n    if (this.deepestIsLatest && head.offset < this.failureHead.offset) this.settleFailure()\n    this.failureHead = head\n    this.failureTie1 = tie1\n    this.failureTie2 = tie2\n    this.deepestIsLatest = this.deepestFailure === undefined || head.offset >= this.deepestFailure.offset\n    if (this.syntax !== undefined) this.syntax.reach(head.offset)\n    return Fail\n  }\n\n  /**\n   * Replaces the details of the current failure (for example to add context),\n   * keeping the record of the furthest failure consistent.\n   */\n  replaceFailure(failure: Failure): void {\n    if (this.deepest === this.failure) this.deepest = failure\n    this.failure = failure\n  }\n\n  /**\n   * The failure to report to the user: the current failure, or the furthest\n   * failure if it lies beyond the current one and the current failure is a\n   * plain syntax error (no user cause or message).\n   */\n  reportedFailure(): Failure {\n    const f = this.failure\n    const d = this.deepest\n    if (\n      d === undefined ||\n      d === f ||\n      d.offset <= f.offset ||\n      this.mode === \"Incomplete\" ||\n      f.hasCause ||\n      f.message !== undefined\n    ) {\n      return f\n    }\n    const context = Arr.isReadonlyArrayEmpty(d.context)\n      ? f.context\n      : [...d.context, ...f.context.filter((l) => !d.context.includes(l))]\n    return new Failure(d.offset, d.kind, d.expected, context, d.hasCause, d.cause, d.message, d.needed)\n  }\n\n  /**\n   * Records that, at `offset`, any of `expected` could also have been\n   * accepted. Used by parsers that stop without failing, such as `opt`,\n   * `repeat` and `Ascii.digit1`.\n   */\n  setHint(offset: number, expected: ReadonlyArray<string>): void {\n    if (this.syntax !== undefined) this.syntax.reach(offset)\n    if (this.hintOffset === offset) {\n      this.hintExpected = mergeExpected(this.hintExpected, expected)\n    } else {\n      this.hintOffset = offset\n      this.hintExpected = expected\n    }\n  }\n\n  /** @internal */\n  makeFailure(offset: number, kind: ErrorKind, expected: ReadonlyArray<string>): Failure {\n    if (this.hintOffset === offset && Arr.isReadonlyArrayNonEmpty(this.hintExpected)) {\n      expected = mergeExpected(this.hintExpected, expected)\n    }\n    return new Failure(offset, kind, expected, empty, false, undefined, undefined, 0)\n  }\n}\n\n/**\n * The last merges {@link mergeExpected} made, as `[a, b, merged]` triples. A\n * parse merges the same few pairs of expectation arrays over and over (a\n * whitespace skipper's hint with a repetition's, then with the failure of\n * the token after them), and expectation arrays are never mutated, so a\n * merge seen recently returns its earlier result, which in turn keeps the\n * next merge's input the same array.\n */\nconst merges: Array<ReadonlyArray<string>> = /*#__PURE__*/ new Array(12).fill(empty)\nlet mergeSlot = 0\n\n/** @internal */\nexport const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>): ReadonlyArray<string> => {\n  if (Arr.isReadonlyArrayEmpty(a)) return b\n  if (Arr.isReadonlyArrayEmpty(b)) return a\n  for (let i = 0; i < 12; i += 3) if (merges[i] === a && merges[i + 1] === b) return merges[i + 2]\n  const out = a.slice()\n  for (const e of b) {\n    if (!out.includes(e)) out.push(e)\n  }\n  merges[mergeSlot] = a\n  merges[mergeSlot + 1] = b\n  merges[mergeSlot + 2] = out\n  mergeSlot = mergeSlot === 9 ? 0 : mergeSlot + 3\n  return out\n}\n\n/**\n * Combines the failures of two alternatives: the furthest failure wins, and\n * failures at the same offset have their expectations merged.\n *\n * @internal\n */\nexport const mergeFailures = (a: Failure, b: Failure): Failure => {\n  if (a.offset > b.offset) return a\n  if (b.offset > a.offset) return b\n  return mergeTiedFailures(a, b, mergeExpected(a.expected, b.expected))\n}\n\n/**\n * {@link mergeFailures} for two failures at the same offset, given their\n * merged expectations (`mergeExpected(a.expected, b.expected)`, possibly\n * memoised by the caller).\n *\n * @internal\n */\nexport const mergeTiedFailures = (a: Failure, b: Failure, expected: ReadonlyArray<string>): Failure => {\n  if (expected === b.expected) return b\n  return new Failure(\n    b.offset,\n    b.kind,\n    expected,\n    Arr.isReadonlyArrayNonEmpty(b.context) ? b.context : a.context,\n    b.hasCause || a.hasCause,\n    b.hasCause ? b.cause : a.cause,\n    b.message ?? a.message,\n    b.needed\n  )\n}\n"],"mappings":"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"}

package/dist/Nom.d.ts

@@ -1,30 +1,24 @@
 import * as Result from "effect/Result";
 import { Input, Slice, Token } from "./Input.js";
-import * as P from "./Parser.js";
 import { Parser } from "./Parser.js";
+import * as Token$1 from "./Token.js";
 import { TokenSet } from "./Token.js";
 import * as Option from "effect/Option";
+import * as Ascii from "./Ascii.js";
 /**
  * Matches a literal (nom's `tag`).
  *
  * @since 0.1.0
  * @category bytes
  */
-export declare const tag: {
-  <const L extends string>(literal: L): Parser<L, never, never, string>;
-  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>;
-  <const T>(literal: ReadonlyArray<T>): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>;
-};
+export declare const tag: Token$1.LiteralFn;
 /**
  * Matches a literal, ignoring ASCII case (nom's `tag_no_case`).
  *
  * @since 0.1.0
  * @category bytes
  */
-export declare const tagNoCase: {
-  (literal: string): Parser<string>;
-  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>;
-};
+export declare const tagNoCase: Ascii.CaselessFn;
 /**
  * Matches a single character (nom's `char`).
  *
@@ -102,11 +96,7 @@ export declare const takeTill1: <I extends Input = string>(predicate: (token: To
  * @since 0.1.0
  * @category bytes
  */
-export declare const takeUntil: {
-  (literal: string, range?: P.Range): Parser<string, never, never, string>;
-  (literal: Uint8Array, range?: P.Range): Parser<Uint8Array, never, never, Uint8Array>;
-  <T>(literal: ReadonlyArray<T>, range?: P.Range): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>;
-};
+export declare const takeUntil: Token$1.TakeUntilFn;
 /**
  * Recognizes an escaped string (nom's `escaped`).
  *

package/dist/Nom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Nom.d.ts","names":["TokenOf"],"sources":["../src/Nom.ts"],"mappings":"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"}
+{"version":3,"file":"Nom.d.ts","names":["Token","TokenOf"],"sources":["../src/Nom.ts"],"mappings":";;;;;;;;;;;;;qBA2Da,KAAGA,QAAA;;;;;;;qBAQH,WAAS,MAAA;;;;;;;qBAQT,aAAc,kBAAkB,GAAG,MAAI,OAAO;;;;;;;qBAQ9C,SAAS;;;;;qBAMT,QAAK,UAAA,gBAAA,KAAA,SAAA,OAAA,OAAAC,MAAA,QAAA,mBAAA,QAAA;;;;;qBAML,SAAM,UAAA,gBAAA,KAAA,SAAA,OAAA,OAAAA,MAAA,QAAA,mBAAA,QAAA;;;;;qBAMN,UAAO,UAAA,gBAAA,YAAA,OAAAA,MAAA,mBAAA,OAAAA,MAAA,QAAA,mBAAA,QAAA;;;;;;;qBAQP,MAAO,UAAU,gBAAgB,KAAK,SAAS,OAAK,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;qBASpG,QAAS,UAAU,gBAC9B,KAAK,SAAS,OACb,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAMtC,OAAI,UAAA,gBAAA,kBAAA,OAAA,MAAA,QAAA,mBAAA,QAAA;;;;;qBAMJ,YAAa,UAAU,gBAClC,YAAY,OAAOA,MAAQ,mBAC1B,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAQtC,aAAc,UAAU,gBACnC,YAAY,OAAOA,MAAQ,mBAC1B,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAQtC,cAAe,UAAU,gBACpC,WACA,WACA,YAAY,OAAOA,MAAQ,mBAC1B,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAQtC,WAAY,UAAU,gBACjC,YAAY,OAAOA,MAAQ,mBAC1B,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAQtC,YAAa,UAAU,gBAClC,YAAY,OAAOA,MAAQ,mBAC1B,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;qBAQtC,WAASD,QAAA;;;;;;;qBAQT,UAAO,GAAA,GAAA,GAAA,UAAA,OAAA,GAAA,IAAA,IAAA,WAAA,OAAA,QAAA,OAAA,GAAA,GAAA,GAAA,IAAA,0BAAA,WAAA,OAAA,GAAA,IAAA,IAAA,QAAA,OAAA,MAAA,IAAA,KAAA,IAAA,IAAA,IAAA,IAAA,IAAA;;;;;;;qBAQP,mBAAgB,GAAA,GAAA,UAAA,OAAA,IAAA,IAAA,WAAA,OAAA,QAAA,eAAA,GAAA,GAAA,IAAA,0BAAA,QAAA,eAAA,IAAA,IAAA,QAAA,eAAA,IAAA,IAAA,IAAA,IAAA,IAAA;;qBAGhB,QAAM;;qBAEN,QAAM;;qBAEN,QAAM;;qBAEN,QAAM;;qBAEN,WAAS;;qBAET,WAAS;;qBAET,WAAS;;qBAET,WAAS;;qBAET,eAAa;;qBAEb,eAAa;;qBAEb,QAAM;;qBAEN,QAAM;;qBAEN,aAAW;;qBAEX,aAAW;;qBAEX,YAAU;;qBAEV,SAAO;;qBAEP,KAAG;;qBAEH,MAAI;;;;;;;qBAOJ,eAAa;;;;;;;qBAOb,KAAG;;;;;;;qBAOH,KAAG;;;;;;;qBAYH,QAAM;;;;;;;qBAQN,gBAAgB;;;;;;;qBAQhB,QAAM;;qBAGN,MAAI,6BAAA,WAAA;;qBAEJ,MAAI,6BAAA,WAAA;;qBAEJ,MAAI,6BAAA,WAAA;;qBAEJ,MAAI,6BAAA,WAAA;;qBAEJ,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,QAAM,6BAAA,WAAA;;qBAEN,QAAM,6BAAA,WAAA;;qBAEN,QAAM,6BAAA,WAAA;;qBAEN,QAAM,6BAAA,WAAA;;qBAEN,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;qBAEL,OAAK,6BAAA,WAAA;;;;;;;qBAYL,QAAS,GAAG,GAAG,GAAG,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;qBASvF,QAAS,GAAG,GAAG,GAAG,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG,GAAG,OAAK,QAAQ,MAAM,MAAM,KAAK,GAAG,GAAG;;;;;;;qBAS/F,SAAU,GAAG,GAAG,GAAG,UAAU,OACxC,WACA,WACA,QAAQ,OAAO,GAAG,GAAG,GAAG,OACvB,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;qBAQb,QAAS,GAAG,GAAG,GAAG,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG,GAAG,IAAI,kBAAgB,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;qBAStG,WAAY,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OACvE,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,KAAK,OAAO,GAAG,IAAI,IAAI,QACtB,QAAQ,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;qBAShC,iBAAkB,GAAG,IAAI,IAAI,WAAW,OAAO,GAAG,GAAG,GAAG,UAAU,OAC7E,WAAW,OAAO,GAAG,IAAI,IAAI,KAC7B,QAAQ,OAAO,GAAG,GAAG,GAAG,OACvB,OAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;qBAS3B,iBAAkB,GAAG,IAAI,IAAI,WAAW,OAAO,GAAG,GAAG,GAAG,UAAU,OAC7E,WAAW,OAAO,GAAG,IAAI,IAAI,KAC7B,QAAQ,OAAO,GAAG,GAAG,GAAG,OACvB,QAAQ,MAAM,MAAM,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;qBAQnC,YAAa,GAAG,GAAG,GAAG,UAAU,OAAO,GAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,YAAY,GACZ,IAAI,KAAK,GAAG,GAAG,MAAM,MACpB,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,YAAa,GAAG,GAAG,GAAG,UAAU,OAAO,GAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,YAAY,GACZ,IAAI,KAAK,GAAG,GAAG,MAAM,MACpB,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,aAAc,GAAG,GAAG,GAAG,UAAU,OAAO,GACnD,WACA,WACA,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,YAAY,GACZ,IAAI,KAAK,GAAG,GAAG,MAAM,MACpB,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,aAAU,GAAA,GAAA,UAAA,QAAA,WAAA,kBAAA,OAAA,wBAAA,GAAA,GAAA,OAAA,OAAA,MAAA,IAAA,GAAA,GAAA;;;;;;;qBAQV,cAAW,GAAA,GAAA,UAAA,OAAA,GAAA,IAAA,IAAA,OAAA,wBAAA,GAAA,GAAA,IAAA,QAAA,OAAA,GAAA,IAAA,IAAA,MAAA,KAAA,WAAA,OAAA,GAAA,IAAA,IAAA,IAAA,IAAA;;;;;;;qBAQX,cAAW,GAAA,GAAA,UAAA,OAAA,GAAA,IAAA,IAAA,WAAA,OAAA,OAAA,wBAAA,GAAA,GAAA,IAAA,QAAA,OAAA,GAAA,IAAA,IAAA,QAAA,OAAA,MAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA;;;;;;;qBAYX,OAAQ,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OACnE,OAAO,OAAO,GAAG,GAAG,GAAG,IACvB,QAAQ,OAAO,GAAG,IAAI,IAAI,QACzB,QAAQ,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;qBAQzB,cAAK,WAAA,cAAA,OAAA,SAAA,SAAA,OAAA,oBAmJq9uC,WAAA,KAAA,OAAA,QAAA,GAAA,QAAA,OAAA,MAAA,aAAA,OAAA,SAAA,aAAA,OAAA,QAAA;;qBAhJ19uC,WAAQ,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,QAAA,OAAA,IAAA,IAAA,IAAA,KAAA,QAAA,OAAA,IAAA,IAAA,IAAA,QAAA,OAAA,IAAA,KAAA,IAAA,KAAA,IAAA,KAAA;;qBAER,aAAU,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,QAAA,OAAA,IAAA,IAAA,IAAA,KAAA,QAAA,OAAA,IAAA,IAAA,IAAA,QAAA,OAAA,IAAA,KAAA,IAAA,KAAA,IAAA,KAAA;;qBAEV,YAAS,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,MAAA,OAAA,IAAA,IAAA,IAAA,KAAA,QAAA,OAAA,IAAA,IAAA,IAAA,KAAA,OAAA,OAAA,IAAA,IAAA,IAAA,QAAA,OAAA,IAAA,KAAA,KAAA,IAAA,KAAA,KAAA,IAAA,KAAA,KAAA;;qBAET,gBAAa,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,IAAA,IAAA,IAAA,WAAA,OAAA,OAAA,OAAA,IAAA,IAAA,IAAA,KAAA,WAAA,OAAA,IAAA,IAAA,IAAA,KAAA,QAAA,OAAA,IAAA,IAAA,IAAA,QAAA,QAAA,IAAA,KAAA,KAAA,KAAA,IAAA,KAAA,KAAA,IAAA,KAAA,KAAA;;qBAEb,YAAG,WAAA,cAAA,OAAA,SAAA,SAAA,OAAA,OAAA,OAAA,QAAA,aAAA,OAAA,MAAA,aAAA,OAAA,SAAA,aAAA,OAAA,QAAA;;qBAEH,oBAAW,WAAA,cAAA,OAAA,SAAA,SAAA,OAAA,oBAsIsn2D,WAAA,KAAA,OAAA,QAAA,GAAA,QAAA,OAAA,MAAA,aAAA,OAAA,SAAA,aAAA,OAAA,QAAA;;;;;;;qBA1Hjo2D,MAAO,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,QAAQ,OAAO,GAAG,GAAG,GAAG,IAAI,IAAI,GAAG,MAAM,MAAI,OAAO,GAAG,GAAG,GAAG;;;;;;;qBASjG,SAAU,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,IAAI,GAAG,MAAM,OAAO,OAAO,GAAG,QAC7B,OAAO,GAAG,IAAI,IAAI,GAAG;;;;;;;qBAQX,SAAU,GAAG,GAAG,GAAG,UAAU,OAAO,GAC/C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,IAAI,GAAG,MAAM,OAAO,OAAO,OAC1B,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,YAAa,UAAU,OAAO,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IACvE,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,SAAS,OAAO,GAAG,IAAI,IAAI,OAC1B,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI;;;;;;;qBAQhB,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OACtE,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,IAAI,GAAG,MAAM,OAAO,GAAG,IAAI,IAAI,QAC9B,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;qBAQpB,QAAS,GAAG,GAAG,GAAG,GAAG,UAAU,OAAO,KAAK,GAAG,QAAQ,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAS3F,SAAU,GAAG,GAAG,GAAG,UAAU,OACxC,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,YAAY,GAAG,kBACd,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,YAAS,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,MAAA,IAAA,GAAA,GAAA;;;;;;;qBAQT,WAAY,GAAG,GAAG,GAAG,UAAU,OAAO,QAAQ,OAAO,GAAG,GAAG,GAAG,OAAK,QAAQ,MAAM,IAAI,IAAI,GAAG,GAAG;;qBAI/F,MAAG,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,OAAA,OAAA,IAAA,GAAA,GAAA;;qBAEH,OAAI,GAAA,GAAA,GAAA,UAAA,OAAA,oBAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,OAAA,OAAA,IAAA,GAAA,GAAA;;qBAEJ,OAAI,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,GAAA,GAAA,GAAA;;qBAEJ,MAAG,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,aAAA,GAAA,GAAA;;qBAEH,KAAG,2BAAA;;qBAEH,eAAY,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,GAAA,GAAA,GAAA;;qBAEZ,WAAQ,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,GAAA,GAAA,GAAA;;qBAER,MAAG,GAAA,GAAA,GAAA,UAAA,OAAA,MAAA,OAAA,GAAA,GAAA,GAAA,OAAA,OAAA,GAAA,GAAA,GAAA;;qBAEH,UAAO,GAAA,OAAA,MAAA,OAAA,iBAAA;;;;;;;qBAOP,MAAI,4BAAA;;qBAEJ,MAAI;;qBAEJ,SAAO,6BAAA;;;;;;;qBAQP,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,eAAe,QAAQ,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG"}

package/dist/Nom.js.map

@@ -1 +1 @@
-{"version":3,"file":"Nom.js","names":[],"sources":["../src/Nom.ts"],"sourcesContent":["/**\n * nom-flavoured names for effect-parse's parsers and combinators.\n *\n * effect-parse's main API follows winnow's naming (in camelCase). This module\n * offers the names, and argument orders, that nom users know, so grammars\n * can be ported with minimal changes:\n *\n * | nom | effect-parse |\n * |---|---|\n * | `tag(\"abc\")` | `Token.literal(\"abc\")` |\n * | `many0(p)` | `Parser.repeat(p)` |\n * | `separated_list1(sep, p)` | `Parser.separated(p, sep, { min: 1 })` |\n * | `map_res(p, f)` | `Parser.tryMap(p, f)` |\n * | `recognize(p)` | `Parser.taken(p)` |\n * | `value(v, p)` | `Parser.as(p, v)` |\n *\n * nom's `streaming` and `complete` variants are not separate functions here.\n * Whether input is partial is decided by the runner (`Parser.parsePartial`\n * vs `Parser.parse`).\n *\n * @example\n * ```ts\n * import { Result } from \"effect\"\n * import { Nom, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * const hexPrimary = Nom.mapRes(\n *   Nom.takeWhileMN(2, 2, (c: string) => /[0-9a-fA-F]/.test(c)),\n *   (s) => Result.succeed(parseInt(s, 16))\n * )\n * const hexColor = Nom.preceded(\n *   Nom.tag(\"#\"),\n *   Nom.tuple(hexPrimary, hexPrimary, hexPrimary)\n * )\n *\n * Parser.parse(hexColor, \"#2F14DF\") // Result.succeed([47, 20, 223])\n * ```\n *\n * @since 0.1.0\n */\nimport * as Option from \"effect/Option\"\nimport * as Result from \"effect/Result\"\nimport * as Ascii from \"./Ascii.js\"\nimport * as Binary from \"./Binary.js\"\nimport type { Input, Slice, Token as TokenOf } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as Token from \"./Token.js\"\nimport type { TokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// bytes / character\n// -----------------------------------------------------------------------------\n\n/**\n * Matches a literal (nom's `tag`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const tag = Token.literal\n\n/**\n * Matches a literal, ignoring ASCII case (nom's `tag_no_case`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const tagNoCase = Ascii.caseless\n\n/**\n * Matches a single character (nom's `char`).\n *\n * @since 0.1.0\n * @category character\n */\nexport const char = <const C extends string>(c: C): Parser<C> => Token.literal(c)\n\n/**\n * Matches any character (nom's `anychar`).\n *\n * @since 0.1.0\n * @category character\n */\nexport const anychar: Parser<string> = Token.any\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const oneOf = Token.oneOf\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const noneOf = Token.noneOf\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const satisfy = Token.satisfy\n\n/**\n * The longest non-empty run of tokens from a set (nom's `is_a`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const isA = <I extends Input = string>(set: TokenSet<I>): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  Token.takeWhile<I>(set, { min: 1 })\n\n/**\n * The longest non-empty run of tokens *not* from a set (nom's `is_not`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const isNot = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(set, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const take = Token.take\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhile = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any)\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhile1 = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhileMN = <I extends Input = string>(\n  m: number,\n  n: number,\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: m, max: n })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeTill = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any)\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeTill1 = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeUntil = Token.takeUntil\n\n/**\n * Recognizes an escaped string (nom's `escaped`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const escaped = Ascii.takeEscaped\n\n/**\n * Unescapes an escaped string (nom's `escaped_transform`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const escapedTransform = Ascii.escaped\n\n/** @since 0.1.0 @category character */\nexport const alpha0 = Ascii.alpha0\n/** @since 0.1.0 @category character */\nexport const alpha1 = Ascii.alpha1\n/** @since 0.1.0 @category character */\nexport const digit0 = Ascii.digit0\n/** @since 0.1.0 @category character */\nexport const digit1 = Ascii.digit1\n/** @since 0.1.0 @category character */\nexport const hexDigit0 = Ascii.hexDigit0\n/** @since 0.1.0 @category character */\nexport const hexDigit1 = Ascii.hexDigit1\n/** @since 0.1.0 @category character */\nexport const octDigit0 = Ascii.octDigit0\n/** @since 0.1.0 @category character */\nexport const octDigit1 = Ascii.octDigit1\n/** @since 0.1.0 @category character */\nexport const alphanumeric0 = Ascii.alphanumeric0\n/** @since 0.1.0 @category character */\nexport const alphanumeric1 = Ascii.alphanumeric1\n/** @since 0.1.0 @category character */\nexport const space0 = Ascii.space0\n/** @since 0.1.0 @category character */\nexport const space1 = Ascii.space1\n/** @since 0.1.0 @category character */\nexport const multispace0 = Ascii.multispace0\n/** @since 0.1.0 @category character */\nexport const multispace1 = Ascii.multispace1\n/** @since 0.1.0 @category character */\nexport const lineEnding = Ascii.lineEnding\n/** @since 0.1.0 @category character */\nexport const newline = Ascii.newline\n/** @since 0.1.0 @category character */\nexport const tab = Ascii.tab\n/** @since 0.1.0 @category character */\nexport const crlf = Ascii.crlf\n/**\n * nom's `not_line_ending`.\n *\n * @since 0.1.0\n * @category character\n */\nexport const notLineEnding = Ascii.tillLineEnding\n/**\n * A decimal unsigned integer (nom's `character::complete::u64` and friends).\n *\n * @since 0.1.0\n * @category character\n */\nexport const u64 = Ascii.decUint\n/**\n * A decimal signed integer (nom's `character::complete::i64` and friends).\n *\n * @since 0.1.0\n * @category character\n */\nexport const i64 = Ascii.decInt\n\n// -----------------------------------------------------------------------------\n// number\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `double` (and `float`).\n *\n * @since 0.1.0\n * @category number\n */\nexport const double = Ascii.float\n\n/**\n * nom's `recognize_float`.\n *\n * @since 0.1.0\n * @category number\n */\nexport const recognizeFloat: Parser<string> = /*#__PURE__*/ P.taken(Ascii.float)\n\n/**\n * nom's `hex_u32`.\n *\n * @since 0.1.0\n * @category number\n */\nexport const hexU32 = Ascii.hexUint\n\n/** @since 0.1.0 @category number */\nexport const beU8 = Binary.u8\n/** @since 0.1.0 @category number */\nexport const beI8 = Binary.i8\n/** @since 0.1.0 @category number */\nexport const leU8 = Binary.u8\n/** @since 0.1.0 @category number */\nexport const leI8 = Binary.i8\n/** @since 0.1.0 @category number */\nexport const beU16 = Binary.beU16\n/** @since 0.1.0 @category number */\nexport const leU16 = Binary.leU16\n/** @since 0.1.0 @category number */\nexport const beI16 = Binary.beI16\n/** @since 0.1.0 @category number */\nexport const leI16 = Binary.leI16\n/** @since 0.1.0 @category number */\nexport const beU24 = Binary.beU24\n/** @since 0.1.0 @category number */\nexport const leU24 = Binary.leU24\n/** @since 0.1.0 @category number */\nexport const beI24 = Binary.beI24\n/** @since 0.1.0 @category number */\nexport const leI24 = Binary.leI24\n/** @since 0.1.0 @category number */\nexport const beU32 = Binary.beU32\n/** @since 0.1.0 @category number */\nexport const leU32 = Binary.leU32\n/** @since 0.1.0 @category number */\nexport const beI32 = Binary.beI32\n/** @since 0.1.0 @category number */\nexport const leI32 = Binary.leI32\n/** @since 0.1.0 @category number */\nexport const beU64 = Binary.beU64\n/** @since 0.1.0 @category number */\nexport const leU64 = Binary.leU64\n/** @since 0.1.0 @category number */\nexport const beI64 = Binary.beI64\n/** @since 0.1.0 @category number */\nexport const leI64 = Binary.leI64\n/** @since 0.1.0 @category number */\nexport const beU128 = Binary.beU128\n/** @since 0.1.0 @category number */\nexport const leU128 = Binary.leU128\n/** @since 0.1.0 @category number */\nexport const beI128 = Binary.beI128\n/** @since 0.1.0 @category number */\nexport const leI128 = Binary.leI128\n/** @since 0.1.0 @category number */\nexport const beF32 = Binary.beF32\n/** @since 0.1.0 @category number */\nexport const leF32 = Binary.leF32\n/** @since 0.1.0 @category number */\nexport const beF64 = Binary.beF64\n/** @since 0.1.0 @category number */\nexport const leF64 = Binary.leF64\n\n// -----------------------------------------------------------------------------\n// multi\n// -----------------------------------------------------------------------------\n\n/**\n * Zero or more (nom's `many0`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const many0 = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<Array<A>, E, R, I> =>\n  P.repeat(parser)\n\n/**\n * One or more (nom's `many1`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const many1 = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<[A, ...Array<A>], E, R, I> =>\n  P.repeat(parser, { min: 1 })\n\n/**\n * Between `m` and `n` times (nom's `many_m_n`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const manyMN = <A, E, R, I extends Input>(\n  m: number,\n  n: number,\n  parser: Parser<A, E, R, I>\n): Parser<Array<A>, E, R, I> => P.repeat(parser, { min: m, max: n })\n\n/**\n * Exactly `count` times (nom's `count`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const count = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>, count: number): Parser<Array<A>, E, R, I> =>\n  P.repeat(parser, count)\n\n/**\n * Repeats `parser` until `end` succeeds (nom's `many_till`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const manyTill = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  parser: Parser<A, E, R, I>,\n  end: Parser<B, E2, R2, I2>\n): Parser<[Array<A>, B], E | E2, R | R2, I & I2> => P.repeatTill(parser, end)\n\n/**\n * Zero or more `parser` separated by `separator` (nom's `separated_list0`;\n * note the separator comes first).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const separatedList0 = <S, E2, R2, I2 extends Input, A, E, R, I extends Input>(\n  separator: Parser<S, E2, R2, I2>,\n  parser: Parser<A, E, R, I>\n): Parser<Array<A>, E | E2, R | R2, I & I2> => P.separated(parser, separator)\n\n/**\n * One or more `parser` separated by `separator` (nom's `separated_list1`;\n * note the separator comes first).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const separatedList1 = <S, E2, R2, I2 extends Input, A, E, R, I extends Input>(\n  separator: Parser<S, E2, R2, I2>,\n  parser: Parser<A, E, R, I>\n): Parser<[A, ...Array<A>], E | E2, R | R2, I & I2> => P.separated(parser, separator, { min: 1 })\n\n/**\n * Folds zero or more (nom's `fold_many0`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldMany0 = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f })\n\n/**\n * Folds one or more (nom's `fold_many1`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldMany1 = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f, range: { min: 1 } })\n\n/**\n * Folds between `m` and `n` times (nom's `fold_many_m_n`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldManyMN = <A, E, R, I extends Input, B>(\n  m: number,\n  n: number,\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f, range: { min: m, max: n } })\n\n/**\n * nom's `length_data`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthData = Binary.lengthTake\n\n/**\n * nom's `length_value`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthValue = Binary.lengthAndThen\n\n/**\n * nom's `length_count`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthCount = Binary.lengthRepeat\n\n// -----------------------------------------------------------------------------\n// sequence / branch\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `pair`.\n *\n * @since 0.1.0\n * @category sequence\n */\nexport const pair = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  first: Parser<A, E, R, I>,\n  second: Parser<B, E2, R2, I2>\n): Parser<[A, B], E | E2, R | R2, I & I2> => P.zip(first, second)\n\n/**\n * nom's tuples of parsers (`(a, b, c)`, formerly `tuple`).\n *\n * @since 0.1.0\n * @category sequence\n */\nexport const tuple = P.seq\n\n/** @since 0.1.0 @category sequence */\nexport const preceded = P.preceded\n/** @since 0.1.0 @category sequence */\nexport const terminated = P.terminated\n/** @since 0.1.0 @category sequence */\nexport const delimited = P.delimited\n/** @since 0.1.0 @category sequence */\nexport const separatedPair = P.separatedPair\n/** @since 0.1.0 @category branch */\nexport const alt = P.alt\n/** @since 0.1.0 @category branch */\nexport const permutation = P.permutation\n\n// -----------------------------------------------------------------------------\n// combinator\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `map`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const map = <A, E, R, I extends Input, B>(parser: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I> =>\n  P.map(parser, f)\n\n/**\n * nom's `map_res`: the function returns a `Result`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapRes = <A, E, R, I extends Input, B, E2>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Result.Result<B, E2>\n): Parser<B, E | E2, R, I> => P.tryMap(parser, f)\n\n/**\n * nom's `map_opt`: the function returns an `Option`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapOpt = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Option.Option<B>\n): Parser<B, E, R, I> => P.filterMap(parser, f)\n\n/**\n * nom's `map_parser`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapParser = <A extends Input, E, R, I extends Input, B, E2, R2>(\n  parser: Parser<A, E, R, I>,\n  applied: Parser<B, E2, R2, A>\n): Parser<B, E | E2, R | R2, I> => P.mapParser(parser, applied)\n\n/**\n * nom's `flat_map`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const flatMap = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Parser<B, E2, R2, I2>\n): Parser<B, E | E2, R | R2, I & I2> => P.flatMap(parser, f)\n\n/**\n * nom's `value` (note the value comes first).\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const value = <B, A, E, R, I extends Input>(val: B, parser: Parser<A, E, R, I>): Parser<B, E, R, I> =>\n  P.as(parser, val)\n\n/**\n * nom's `verify`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const verify = <A, E, R, I extends Input>(\n  parser: Parser<A, E, R, I>,\n  predicate: (a: A) => boolean\n): Parser<A, E, R, I> => P.filter(parser, predicate)\n\n/**\n * nom's `recognize`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const recognize = P.taken\n\n/**\n * nom's `consumed`: returns `[consumed, output]`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const consumed = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<[Slice<I>, A], E, R, I> =>\n  P.map(P.withTaken(parser), ([a, s]) => [s, a])\n\n/** @since 0.1.0 @category combinator */\nexport const opt = P.opt\n/** @since 0.1.0 @category combinator */\nexport const cond = P.cond\n/** @since 0.1.0 @category combinator */\nexport const peek = P.peek\n/** @since 0.1.0 @category combinator */\nexport const not = P.not\n/** @since 0.1.0 @category combinator */\nexport const eof = P.eof\n/** @since 0.1.0 @category combinator */\nexport const allConsuming = P.allConsuming\n/** @since 0.1.0 @category combinator */\nexport const complete = P.complete\n/** @since 0.1.0 @category combinator */\nexport const cut = P.cut\n/** @since 0.1.0 @category combinator */\nexport const success = P.succeed\n/**\n * nom's `fail()`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const fail = P.reject\n/** @since 0.1.0 @category combinator */\nexport const rest = Token.rest\n/** @since 0.1.0 @category combinator */\nexport const restLen = Token.restLen\n\n/**\n * nom's `context` (note the label comes first).\n *\n * @since 0.1.0\n * @category error\n */\nexport const context = <A, E, R, I extends Input>(label: string, parser: Parser<A, E, R, I>): Parser<A, E, R, I> =>\n  P.context(parser, label)\n"],"mappings":"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"}
+{"version":3,"file":"Nom.js","names":[],"sources":["../src/Nom.ts"],"sourcesContent":["/**\n * nom-flavoured names for effect-parse's parsers and combinators.\n *\n * effect-parse's main API follows winnow's naming (in camelCase). This module\n * offers the names, and argument orders, that nom users know, so grammars\n * can be ported with minimal changes:\n *\n * | nom | effect-parse |\n * |---|---|\n * | `tag(\"abc\")` | `Token.literal(\"abc\")` |\n * | `many0(p)` | `Parser.repeat(p)` |\n * | `separated_list1(sep, p)` | `Parser.separated(p, sep, { min: 1 })` |\n * | `map_res(p, f)` | `Parser.tryMap(p, f)` |\n * | `recognize(p)` | `Parser.taken(p)` |\n * | `value(v, p)` | `Parser.as(p, v)` |\n *\n * nom's `streaming` and `complete` variants are not separate functions here.\n * Whether input is partial is decided by the runner (`Parser.parsePartial`\n * vs `Parser.parse`).\n *\n * @example\n * ```ts\n * import { Result } from \"effect\"\n * import { Nom, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * const hexPrimary = Nom.mapRes(\n *   Nom.takeWhileMN(2, 2, (c: string) => /[0-9a-fA-F]/.test(c)),\n *   (s) => Result.succeed(parseInt(s, 16))\n * )\n * const hexColor = Nom.preceded(\n *   Nom.tag(\"#\"),\n *   Nom.tuple(hexPrimary, hexPrimary, hexPrimary)\n * )\n *\n * Parser.parse(hexColor, \"#2F14DF\") // Result.succeed([47, 20, 223])\n * ```\n *\n * @since 0.1.0\n */\nimport * as Option from \"effect/Option\"\nimport * as Result from \"effect/Result\"\nimport * as Ascii from \"./Ascii.js\"\nimport * as Binary from \"./Binary.js\"\nimport type { Input, Slice, Token as TokenOf } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as Token from \"./Token.js\"\nimport type { TokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// bytes / character\n// -----------------------------------------------------------------------------\n\n/**\n * Matches a literal (nom's `tag`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const tag = Token.literal\n\n/**\n * Matches a literal, ignoring ASCII case (nom's `tag_no_case`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const tagNoCase = Ascii.caseless\n\n/**\n * Matches a single character (nom's `char`).\n *\n * @since 0.1.0\n * @category character\n */\nexport const char = <const C extends string>(c: C): Parser<C> => Token.literal(c)\n\n/**\n * Matches any character (nom's `anychar`).\n *\n * @since 0.1.0\n * @category character\n */\nexport const anychar: Parser<string> = Token.any\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const oneOf = Token.oneOf\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const noneOf = Token.noneOf\n\n/**\n * @since 0.1.0\n * @category character\n */\nexport const satisfy = Token.satisfy\n\n/**\n * The longest non-empty run of tokens from a set (nom's `is_a`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const isA = <I extends Input = string>(set: TokenSet<I>): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  Token.takeWhile<I>(set, { min: 1 })\n\n/**\n * The longest non-empty run of tokens *not* from a set (nom's `is_not`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const isNot = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(set, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const take = Token.take\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhile = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  Token.takeWhile<I>(predicate as Token.TokenSet<I>)\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhile1 = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeWhileMN = <I extends Input = string>(\n  m: number,\n  n: number,\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: m, max: n })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeTill = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  Token.takeTill<I>(predicate as Token.TokenSet<I>)\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeTill1 = <I extends Input = string>(\n  predicate: (token: TokenOf<I>) => boolean\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  Token.takeTill<I>(predicate as Token.TokenSet<I>, { min: 1 })\n\n/**\n * @since 0.1.0\n * @category bytes\n */\nexport const takeUntil = Token.takeUntil\n\n/**\n * Recognizes an escaped string (nom's `escaped`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const escaped = Ascii.takeEscaped\n\n/**\n * Unescapes an escaped string (nom's `escaped_transform`).\n *\n * @since 0.1.0\n * @category bytes\n */\nexport const escapedTransform = Ascii.escaped\n\n/** @since 0.1.0 @category character */\nexport const alpha0 = Ascii.alpha0\n/** @since 0.1.0 @category character */\nexport const alpha1 = Ascii.alpha1\n/** @since 0.1.0 @category character */\nexport const digit0 = Ascii.digit0\n/** @since 0.1.0 @category character */\nexport const digit1 = Ascii.digit1\n/** @since 0.1.0 @category character */\nexport const hexDigit0 = Ascii.hexDigit0\n/** @since 0.1.0 @category character */\nexport const hexDigit1 = Ascii.hexDigit1\n/** @since 0.1.0 @category character */\nexport const octDigit0 = Ascii.octDigit0\n/** @since 0.1.0 @category character */\nexport const octDigit1 = Ascii.octDigit1\n/** @since 0.1.0 @category character */\nexport const alphanumeric0 = Ascii.alphanumeric0\n/** @since 0.1.0 @category character */\nexport const alphanumeric1 = Ascii.alphanumeric1\n/** @since 0.1.0 @category character */\nexport const space0 = Ascii.space0\n/** @since 0.1.0 @category character */\nexport const space1 = Ascii.space1\n/** @since 0.1.0 @category character */\nexport const multispace0 = Ascii.multispace0\n/** @since 0.1.0 @category character */\nexport const multispace1 = Ascii.multispace1\n/** @since 0.1.0 @category character */\nexport const lineEnding = Ascii.lineEnding\n/** @since 0.1.0 @category character */\nexport const newline = Ascii.newline\n/** @since 0.1.0 @category character */\nexport const tab = Ascii.tab\n/** @since 0.1.0 @category character */\nexport const crlf = Ascii.crlf\n/**\n * nom's `not_line_ending`.\n *\n * @since 0.1.0\n * @category character\n */\nexport const notLineEnding = Ascii.tillLineEnding\n/**\n * A decimal unsigned integer (nom's `character::complete::u64` and friends).\n *\n * @since 0.1.0\n * @category character\n */\nexport const u64 = Ascii.decUint\n/**\n * A decimal signed integer (nom's `character::complete::i64` and friends).\n *\n * @since 0.1.0\n * @category character\n */\nexport const i64 = Ascii.decInt\n\n// -----------------------------------------------------------------------------\n// number\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `double` (and `float`).\n *\n * @since 0.1.0\n * @category number\n */\nexport const double = Ascii.float\n\n/**\n * nom's `recognize_float`.\n *\n * @since 0.1.0\n * @category number\n */\nexport const recognizeFloat: Parser<string> = /*#__PURE__*/ P.taken(Ascii.float)\n\n/**\n * nom's `hex_u32`.\n *\n * @since 0.1.0\n * @category number\n */\nexport const hexU32 = Ascii.hexUint\n\n/** @since 0.1.0 @category number */\nexport const beU8 = Binary.u8\n/** @since 0.1.0 @category number */\nexport const beI8 = Binary.i8\n/** @since 0.1.0 @category number */\nexport const leU8 = Binary.u8\n/** @since 0.1.0 @category number */\nexport const leI8 = Binary.i8\n/** @since 0.1.0 @category number */\nexport const beU16 = Binary.beU16\n/** @since 0.1.0 @category number */\nexport const leU16 = Binary.leU16\n/** @since 0.1.0 @category number */\nexport const beI16 = Binary.beI16\n/** @since 0.1.0 @category number */\nexport const leI16 = Binary.leI16\n/** @since 0.1.0 @category number */\nexport const beU24 = Binary.beU24\n/** @since 0.1.0 @category number */\nexport const leU24 = Binary.leU24\n/** @since 0.1.0 @category number */\nexport const beI24 = Binary.beI24\n/** @since 0.1.0 @category number */\nexport const leI24 = Binary.leI24\n/** @since 0.1.0 @category number */\nexport const beU32 = Binary.beU32\n/** @since 0.1.0 @category number */\nexport const leU32 = Binary.leU32\n/** @since 0.1.0 @category number */\nexport const beI32 = Binary.beI32\n/** @since 0.1.0 @category number */\nexport const leI32 = Binary.leI32\n/** @since 0.1.0 @category number */\nexport const beU64 = Binary.beU64\n/** @since 0.1.0 @category number */\nexport const leU64 = Binary.leU64\n/** @since 0.1.0 @category number */\nexport const beI64 = Binary.beI64\n/** @since 0.1.0 @category number */\nexport const leI64 = Binary.leI64\n/** @since 0.1.0 @category number */\nexport const beU128 = Binary.beU128\n/** @since 0.1.0 @category number */\nexport const leU128 = Binary.leU128\n/** @since 0.1.0 @category number */\nexport const beI128 = Binary.beI128\n/** @since 0.1.0 @category number */\nexport const leI128 = Binary.leI128\n/** @since 0.1.0 @category number */\nexport const beF32 = Binary.beF32\n/** @since 0.1.0 @category number */\nexport const leF32 = Binary.leF32\n/** @since 0.1.0 @category number */\nexport const beF64 = Binary.beF64\n/** @since 0.1.0 @category number */\nexport const leF64 = Binary.leF64\n\n// -----------------------------------------------------------------------------\n// multi\n// -----------------------------------------------------------------------------\n\n/**\n * Zero or more (nom's `many0`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const many0 = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<Array<A>, E, R, I> =>\n  P.repeat(parser)\n\n/**\n * One or more (nom's `many1`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const many1 = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<[A, ...Array<A>], E, R, I> =>\n  P.repeat(parser, { min: 1 })\n\n/**\n * Between `m` and `n` times (nom's `many_m_n`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const manyMN = <A, E, R, I extends Input>(\n  m: number,\n  n: number,\n  parser: Parser<A, E, R, I>\n): Parser<Array<A>, E, R, I> => P.repeat(parser, { min: m, max: n })\n\n/**\n * Exactly `count` times (nom's `count`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const count = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>, count: number): Parser<Array<A>, E, R, I> =>\n  P.repeat(parser, count)\n\n/**\n * Repeats `parser` until `end` succeeds (nom's `many_till`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const manyTill = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  parser: Parser<A, E, R, I>,\n  end: Parser<B, E2, R2, I2>\n): Parser<[Array<A>, B], E | E2, R | R2, I & I2> => P.repeatTill(parser, end)\n\n/**\n * Zero or more `parser` separated by `separator` (nom's `separated_list0`;\n * note the separator comes first).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const separatedList0 = <S, E2, R2, I2 extends Input, A, E, R, I extends Input>(\n  separator: Parser<S, E2, R2, I2>,\n  parser: Parser<A, E, R, I>\n): Parser<Array<A>, E | E2, R | R2, I & I2> => P.separated(parser, separator)\n\n/**\n * One or more `parser` separated by `separator` (nom's `separated_list1`;\n * note the separator comes first).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const separatedList1 = <S, E2, R2, I2 extends Input, A, E, R, I extends Input>(\n  separator: Parser<S, E2, R2, I2>,\n  parser: Parser<A, E, R, I>\n): Parser<[A, ...Array<A>], E | E2, R | R2, I & I2> => P.separated(parser, separator, { min: 1 })\n\n/**\n * Folds zero or more (nom's `fold_many0`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldMany0 = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f })\n\n/**\n * Folds one or more (nom's `fold_many1`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldMany1 = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f, range: { min: 1 } })\n\n/**\n * Folds between `m` and `n` times (nom's `fold_many_m_n`).\n *\n * @since 0.1.0\n * @category multi\n */\nexport const foldManyMN = <A, E, R, I extends Input, B>(\n  m: number,\n  n: number,\n  parser: Parser<A, E, R, I>,\n  init: () => B,\n  f: (acc: B, a: A) => B\n): Parser<B, E, R, I> => P.fold(parser, { init, f, range: { min: m, max: n } })\n\n/**\n * nom's `length_data`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthData = Binary.lengthTake\n\n/**\n * nom's `length_value`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthValue = Binary.lengthAndThen\n\n/**\n * nom's `length_count`.\n *\n * @since 0.1.0\n * @category multi\n */\nexport const lengthCount = Binary.lengthRepeat\n\n// -----------------------------------------------------------------------------\n// sequence / branch\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `pair`.\n *\n * @since 0.1.0\n * @category sequence\n */\nexport const pair = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  first: Parser<A, E, R, I>,\n  second: Parser<B, E2, R2, I2>\n): Parser<[A, B], E | E2, R | R2, I & I2> => P.zip(first, second)\n\n/**\n * nom's tuples of parsers (`(a, b, c)`, formerly `tuple`).\n *\n * @since 0.1.0\n * @category sequence\n */\nexport const tuple = P.seq\n\n/** @since 0.1.0 @category sequence */\nexport const preceded = P.preceded\n/** @since 0.1.0 @category sequence */\nexport const terminated = P.terminated\n/** @since 0.1.0 @category sequence */\nexport const delimited = P.delimited\n/** @since 0.1.0 @category sequence */\nexport const separatedPair = P.separatedPair\n/** @since 0.1.0 @category branch */\nexport const alt = P.alt\n/** @since 0.1.0 @category branch */\nexport const permutation = P.permutation\n\n// -----------------------------------------------------------------------------\n// combinator\n// -----------------------------------------------------------------------------\n\n/**\n * nom's `map`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const map = <A, E, R, I extends Input, B>(parser: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I> =>\n  P.map(parser, f)\n\n/**\n * nom's `map_res`: the function returns a `Result`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapRes = <A, E, R, I extends Input, B, E2>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Result.Result<B, E2>\n): Parser<B, E | E2, R, I> => P.tryMap(parser, f)\n\n/**\n * nom's `map_opt`: the function returns an `Option`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapOpt = <A, E, R, I extends Input, B>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Option.Option<B>\n): Parser<B, E, R, I> => P.filterMap(parser, f)\n\n/**\n * nom's `map_parser`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const mapParser = <A extends Input, E, R, I extends Input, B, E2, R2>(\n  parser: Parser<A, E, R, I>,\n  applied: Parser<B, E2, R2, A>\n): Parser<B, E | E2, R | R2, I> => P.mapParser(parser, applied)\n\n/**\n * nom's `flat_map`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const flatMap = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  parser: Parser<A, E, R, I>,\n  f: (a: A) => Parser<B, E2, R2, I2>\n): Parser<B, E | E2, R | R2, I & I2> => P.flatMap(parser, f)\n\n/**\n * nom's `value` (note the value comes first).\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const value = <B, A, E, R, I extends Input>(val: B, parser: Parser<A, E, R, I>): Parser<B, E, R, I> =>\n  P.as(parser, val)\n\n/**\n * nom's `verify`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const verify = <A, E, R, I extends Input>(\n  parser: Parser<A, E, R, I>,\n  predicate: (a: A) => boolean\n): Parser<A, E, R, I> => P.filter(parser, predicate)\n\n/**\n * nom's `recognize`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const recognize = P.taken\n\n/**\n * nom's `consumed`: returns `[consumed, output]`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const consumed = <A, E, R, I extends Input>(parser: Parser<A, E, R, I>): Parser<[Slice<I>, A], E, R, I> =>\n  P.map(P.withTaken(parser), ([a, s]) => [s, a])\n\n/** @since 0.1.0 @category combinator */\nexport const opt = P.opt\n/** @since 0.1.0 @category combinator */\nexport const cond = P.cond\n/** @since 0.1.0 @category combinator */\nexport const peek = P.peek\n/** @since 0.1.0 @category combinator */\nexport const not = P.not\n/** @since 0.1.0 @category combinator */\nexport const eof = P.eof\n/** @since 0.1.0 @category combinator */\nexport const allConsuming = P.allConsuming\n/** @since 0.1.0 @category combinator */\nexport const complete = P.complete\n/** @since 0.1.0 @category combinator */\nexport const cut = P.cut\n/** @since 0.1.0 @category combinator */\nexport const success = P.succeed\n/**\n * nom's `fail()`.\n *\n * @since 0.1.0\n * @category combinator\n */\nexport const fail = P.reject\n/** @since 0.1.0 @category combinator */\nexport const rest = Token.rest\n/** @since 0.1.0 @category combinator */\nexport const restLen = Token.restLen\n\n/**\n * nom's `context` (note the label comes first).\n *\n * @since 0.1.0\n * @category error\n */\nexport const context = <A, E, R, I extends Input>(label: string, parser: Parser<A, E, R, I>): Parser<A, E, R, I> =>\n  P.context(parser, label)\n"],"mappings":"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"}

package/dist/ParseError.d.ts

@@ -82,7 +82,7 @@ export declare const isParseError: (u: unknown) => u is ParseError<unknown>;
  * @since 0.1.0
  * @category constructors
  */
-export declare const fromFailure: <E = never>(input: Input, failure: Failure, mode: ErrMode, encoding?: Encoding<any> | undefined) => ParseError<E>;
+export declare const fromFailure: <E = never>(input: Input, failure: Failure, mode: ErrMode, encoding?: Encoding<any>) => ParseError<E>;
 /**
  * The user supplied cause of an error, if any.
  *
@@ -109,7 +109,7 @@ export interface LineColumn {
  * @since 0.1.0
  * @category utils
  */
-export declare const lineColumn: (input: Input, offset: number, encoding?: Encoding<any> | undefined) => LineColumn;
+export declare const lineColumn: (input: Input, offset: number, encoding?: Encoding<any>) => LineColumn;
 /**
  * Formats a list of expectations: `a`, `a or b`, `a, b or c`.
  *

package/dist/ParseError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParseError.d.ts","names":[],"sources":["../src/ParseError.ts"],"mappings":";;;;;;;;;;;;;YAwCY;;;;;qBAuCC;;;;;;;;;;qBAQA,eAAe,iCACJ;;WAEX,OAAO;;WAEP;;WAEA,MAAM;;WAEN,MAAM;;WAEN,UAAU;;WAEV,SAAS;;WAET,OAAO;;WAEP;;;;;WAKA,WAAW,SAAS;;;;;YAMrB,gBAAgB;;;;;;;MAQtB,YAAY;;;;;;MASH;;;;EAOJ;;;;;;qBASE,eAAgB,eAAa,KAAK;;;;;;;qBAQlC,cAAe,WAC1B,OAAO,OACP,SAAS,SACT,MAAM,SACN,WAAW,8BACV,WAAW;;;;;;;qBAmBD,WAAY,GAAG,MAAM,WAAW,OAAK,OAAO,OAAO;;;;;;;iBAS/C;WACN;WACA;;;;;;;;;;;qBAYE,aAAc,OAAO,OAAO,gBAAgB,WAAW,8BAA4B;;;;;;;qBA6CnF,iBAAkB,UAAU;;qBA8B5B,eAAgB"}
+{"version":3,"file":"ParseError.d.ts","names":[],"sources":["../src/ParseError.ts"],"mappings":";;;;;;;;;;;;;YAwCY;;;;;qBAuCC;;;;;;;;;;qBAQA,eAAe,iCACJ;;WAEX,OAAO;;WAEP;;WAEA,MAAM;;WAEN,MAAM;;WAEN,UAAU;;WAEV,SAAS;;WAET,OAAO;;WAEP;;;;;WAKA,WAAW,SAAS;;;;;YAMrB,gBAAgB;;;;;;;MAQtB,YAAY;;;;;;MASH;;;;EAOJ;;;;;;qBASE,eAAgB,eAAa,KAAK;;;;;;;qBAQlC,cAAe,WAC1B,OAAO,OACP,SAAS,SACT,MAAM,SACN,WAAW,kBACV,WAAW;;;;;;;qBAsBD,WAAY,GAAG,MAAM,WAAW,OAAK,OAAO,OAAO;;;;;;;iBAS/C;WACN;WACA;;;;;;;;;;;qBAYE,aAAc,OAAO,OAAO,gBAAgB,WAAW,kBAAgB;;;;;;;qBA6CvE,iBAAkB,UAAU;;qBA8B5B,eAAgB"}

package/dist/ParseError.js

@@ -176,7 +176,7 @@ const describeFound = (input, offset, encoding) => {
 /** @internal */
 const inspectToken = (u) => {
 	if (Predicate.isString(u)) return JSON.stringify(u);
-	if (Predicate.isObjectOrArray(u)) return Result.getOrElse(Result.try(() => JSON.stringify(u)), () => String(u));
+	if (Predicate.isObjectOrArray(u)) return Result.getOrElse(Result.try(() => JSON.stringify(u)), () => Array.isArray(u) ? u.join(",") : Object.prototype.toString.call(u));
 	return String(u);
 };
 const causeMessage = (cause) => {