@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/dist/Syntax.js.map

@@ -1 +1 @@
-{"version":3,"file":"Syntax.js","names":[],"sources":["../src/Syntax.ts"],"sourcesContent":["/**\n * Concrete syntax trees and incremental parsing, in the spirit of\n * [Tree-sitter](https://tree-sitter.github.io).\n *\n * Mark the rules of a grammar that should appear in the tree with\n * {@link node} (and, optionally, {@link token} and {@link field}). Outside\n * this module the marks change nothing: `Parser.parse` returns the same\n * values, and compiled parsers compile them away. {@link parse} runs the\n * grammar and returns a {@link Tree}: a tree of {@link SyntaxNode}s with\n * spans, parents and siblings, to search by position (`descendantAt`) or walk\n * with a {@link TreeCursor}. Each node also carries the value its parser\n * returned.\n *\n * Like Tree-sitter, a syntax parse always produces a tree. Failures handled\n * by `Parser.resumeAfter` and `Parser.retryAfter` become `ERROR` nodes over\n * the input they skipped, and so does any input after a fatal failure.\n *\n * After an edit, {@link reparse} (or {@link replace}) parses the new input\n * reusing every node of the old tree whose input is unchanged: only the\n * nodes that enclose the edit, or looked at the edited input, are parsed\n * again, and each reused node is stepped over whole.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const ws = Ascii.multispace0\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const list = Syntax.node(\n *   Parser.delimited(\n *     Token.literal(\"[\"),\n *     Parser.separated(Parser.delimited(ws, number, ws), Token.literal(\",\")),\n *     Token.literal(\"]\")\n *   ),\n *   \"list\"\n * )\n *\n * const tree = Syntax.parse(list, \"[1, 2, 3]\")\n * String(tree.root) // \"(list (number) (number) (number))\"\n * tree.root.descendantAt(4)?.text // \"2\"\n *\n * const edited = Syntax.replace(tree, 4, 5, \"20\") // \"[1, 20, 3]\"\n * edited.root.namedChild(1)?.value // 20\n * edited.reused // 2: only \"20\" was parsed again\n * ```\n *\n * @since 0.2.0\n */\nimport * as Str from \"effect/String\"\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport { dual } from \"effect/Function\"\nimport * as Option from \"effect/Option\"\nimport type { Input, Slice, Source } from \"./Input.js\"\nimport { Fail, fromSource, State } from \"./Input.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport { nodeOf } from \"./internal/node.js\"\nimport { Key } from \"./internal/key.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport type { ErrorInfo, Green, Previous, Segment } from \"./internal/syntax.js\"\nimport { absolute, errorKind, SyntaxBuilder } from \"./internal/syntax.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { described, isParser } from \"./Parser.js\"\n\n// -----------------------------------------------------------------------------\n// Grammar annotations\n// -----------------------------------------------------------------------------\n\nconst syntaxNode = (self: Parser.Any, kind: string, named: boolean): Parser.Any => {\n  const step = self.step\n  // Identifies the nodes this parser builds, so a reparse can reuse them\n  const key = new Key()\n  return described<unknown, unknown, unknown, Input>(\n    (state) => {\n      const builder = state.syntax\n      return builder === undefined ? step(state) : builder.node(state, step, key, kind, named)\n    },\n    self.name,\n    { _tag: \"Syntax\", self, kind, named }\n  )\n}\n\n/**\n * Marks a parser as a rule of the syntax tree: in a {@link parse}, each\n * match becomes a named node of the given kind, spanning the input it\n * consumed, with the nodes built inside it as children and its output as\n * its `value`. Outside {@link parse}, the parser is unchanged.\n *\n * A match that consumes nothing adds no node (as in Tree-sitter, where rules\n * can't match the empty string).\n *\n * For {@link reparse} to reuse a node, its parser's output must depend only\n * on the input from where the node starts: not on services, on state kept\n * in closures, or on absolute offsets (`Parser.location`, `Parser.span`),\n * which are not updated when the node moves. Use the node's `start` and\n * `end` instead.\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const node: {\n  (kind: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind: string): Parser<A, E, R, I> =>\n    syntaxNode(self, kind, true) as Parser<A, E, R, I>\n)\n\n/**\n * Like {@link node}, but builds an *anonymous* node, Tree-sitter's name for\n * punctuation and keywords: anonymous nodes are left out of\n * `namedChildren` and of the tree's printed form. The kind defaults to the\n * literal for a `Token.literal` of a string, and to the parser's name\n * otherwise.\n *\n * @example\n * ```ts\n * import { Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const comma = Syntax.token(Token.literal(\",\")) // kind \",\"\n * ```\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const token: {\n  (kind?: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind?: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  (args) => isParser(args[0]),\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind?: string): Parser<A, E, R, I> =>\n    syntaxNode(self, kind ?? defaultTokenKind(self), false) as Parser<A, E, R, I>\n)\n\nconst defaultTokenKind = (self: Parser.Any): string => {\n  const n = nodeOf(self)\n  if (Predicate.isTagged(n, \"Literal\") && Predicate.isString(n.literal) && !n.caseless) return n.literal\n  return self.name ?? \"token\"\n}\n\n/**\n * Gives the nodes built by a parser a field name in their parent, like\n * Tree-sitter's `field(name, rule)`: find them with `childByField` and\n * `childrenByField`. Outside {@link parse}, the parser is unchanged.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const name = Syntax.node(Ascii.alpha1, \"name\")\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const pair = Syntax.node(\n *   Parser.separatedPair(Syntax.field(name, \"key\"), Token.literal(\"=\"), Syntax.field(number, \"value\")),\n *   \"pair\"\n * )\n * Syntax.parse(pair, \"x=1\").root.childByField(\"value\")?.value // 1\n * ```\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const field: {\n  (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> => {\n  const step = self.step\n  return described<A, E, R, I>(\n    (state) => {\n      const builder = state.syntax\n      return (builder === undefined ? step(state) : builder.field(state, step, name)) as A | typeof Fail\n    },\n    self.name,\n    { _tag: \"Syntax\", self, kind: undefined, named: false }\n  )\n})\n\n// -----------------------------------------------------------------------------\n// Trees\n// -----------------------------------------------------------------------------\n\n/**\n * The kind of the nodes that stand for input that could not be parsed.\n *\n * @since 0.2.0\n * @category models\n */\nexport const ERROR: \"ERROR\" = errorKind\n\n/**\n * An edit to an input, as Tree-sitter's `TSInputEdit`: the input\n * `[start, oldEnd)` was replaced by `[start, newEnd)`. Offsets are in the\n * input's units (UTF-16 code units for strings, bytes, elements).\n *\n * @since 0.2.0\n * @category models\n */\nexport interface Edit {\n  readonly start: number\n  readonly oldEnd: number\n  readonly newEnd: number\n}\n\n/**\n * Options for {@link parse}.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface ParseOptions {\n  /**\n   * The kind of the root node, when the grammar itself is not a\n   * {@link node}. Defaults to `\"document\"`.\n   */\n  readonly kind?: string | undefined\n  /**\n   * For {@link reparse}: how many input units custom parsers may read past\n   * the furthest position they move the cursor to or record a failure at,\n   * besides one token there. Defaults to 0, which is right for the built-in\n   * parsers, and for custom parsers (`Parser.make`) that only read past\n   * where they stop to see that the token there doesn't match.\n   *\n   * A node is reused only when the input its parse looked at is unchanged.\n   * Built-in parsers that read further, such as a literal that fails part\n   * way or `Token.takeUntil`, record how far they read.\n   */\n  readonly lookahead?: number | undefined\n}\n\n/**\n * Options for {@link parse} with a parser that requires services.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface ParseOptionsWithContext<R> extends ParseOptions {\n  readonly context: Context.Context<R>\n}\n\ninterface Config {\n  readonly kind: string\n  readonly inner: Parser.Any\n  readonly lookahead: number\n  readonly context: Context.Context<never> | undefined\n}\n\n/**\n * The result of a {@link parse}: a syntax tree over the whole input, the\n * grammar's output, and the errors met on the way.\n *\n * @since 0.2.0\n * @category models\n */\nexport class Tree<out A, out E = never, I extends Input = string> {\n  /** The root node. It always spans the whole input. */\n  readonly root: SyntaxNode<I>\n  private lines: Array<number> | undefined\n  private errorList: ReadonlyArray<ParseError.ParseError<E>> | undefined\n\n  /** @internal */\n  constructor(\n    /** The input the tree was parsed from. */\n    readonly input: I,\n    /** The grammar's output: `none` when the parse failed. */\n    readonly value: Option.Option<A>,\n    /** How many nodes were reused from the previous tree by {@link reparse}. */\n    readonly reused: number,\n    /** @internal */\n    readonly green: Green,\n    /** @internal */\n    readonly config: Config,\n    /** @internal */\n    readonly encoding: ParseError.ParseError<never>[\"encoding\"]\n  ) {\n    this.root = new SyntaxNode(this, green, 0, undefined, 0)\n  }\n\n  /**\n   * Every error of the parse, in input order: the failures recovered by\n   * `Parser.resumeAfter` and `Parser.retryAfter`, then the fatal one, if\n   * the parse failed. Each one belongs to an `ERROR` node.\n   */\n  get errors(): ReadonlyArray<ParseError.ParseError<E>> {\n    if (this.errorList === undefined) {\n      const out: Array<ParseError.ParseError<E>> = []\n      const visit = (green: Green, start: number) => {\n        if (!green.hasError) return\n        if (green.error !== undefined) out.push(this.toError(green.error, start))\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], start + green.offsets[i])\n      }\n      visit(this.green, 0)\n      this.errorList = out\n    }\n    return this.errorList\n  }\n\n  /** Whether the tree has any `ERROR` node. */\n  get hasErrors(): boolean {\n    return this.green.hasError\n  }\n\n  /** The smallest node containing `[start, end)` (see {@link SyntaxNode.descendantAt}). */\n  descendantAt(start: number, end?: number): SyntaxNode<I> {\n    return this.root.descendantAt(start, end)\n  }\n\n  /** A cursor at the root. */\n  walk(): TreeCursor<I> {\n    return new TreeCursor(this.root)\n  }\n\n  /**\n   * The 1-based line and column (in code points) of an offset, as in\n   * `ParseError`. Lines of a string input are indexed once, so lookups take\n   * logarithmic time.\n   */\n  lineColumn(offset: number): ParseError.LineColumn {\n    const input = this.input\n    if (!Predicate.isString(input)) return ParseError.lineColumn(input, offset, this.encoding)\n    let lines = this.lines\n    if (lines === undefined) {\n      lines = [0]\n      for (let i = input.indexOf(\"\\n\"); i >= 0; i = input.indexOf(\"\\n\", i + 1)) lines.push(i + 1)\n      this.lines = lines\n    }\n    const at = Math.max(0, Math.min(offset, input.length))\n    let lo = 0\n    let hi = lines.length - 1\n    while (lo < hi) {\n      const mid = (lo + hi + 1) >> 1\n      if (lines[mid] <= at) lo = mid\n      else hi = mid - 1\n    }\n    const lineStart = lines[lo]\n    return { line: lo + 1, column: ParseError.lineColumn(input.slice(lineStart, at), at - lineStart).column }\n  }\n\n  /** The root's S-expression (see {@link SyntaxNode.toString}). */\n  toString(): string {\n    return this.root.toString()\n  }\n\n  /** @internal */\n  toError(error: ErrorInfo, start: number): ParseError.ParseError<E> {\n    return ParseError.fromFailure<E>(this.input, absolute(error.failure, start), error.mode, this.encoding)\n  }\n}\n\n/**\n * A node of a syntax tree: its kind, span and value, and its place in the\n * tree. Nodes are views built on demand; two views of the same node are\n * different objects but have the same `start`, `end` and `kind`.\n *\n * @since 0.2.0\n * @category models\n */\nexport class SyntaxNode<I extends Input = string> {\n  private childList: ReadonlyArray<SyntaxNode<I>> | undefined\n\n  /** @internal */\n  constructor(\n    /** The tree this node belongs to. */\n    readonly tree: Tree<unknown, unknown, I>,\n    /** @internal */\n    readonly green: Green,\n    /** The offset where the node starts. */\n    readonly start: number,\n    /** The parent node; `undefined` for the root. */\n    readonly parent: SyntaxNode<I> | undefined,\n    /** The node's index among its parent's children. */\n    readonly index: number\n  ) {}\n\n  /** The node's kind: the name given to {@link node} or {@link token}, or `\"ERROR\"`. */\n  get kind(): string {\n    return this.green.kind\n  }\n\n  /** `false` for the anonymous nodes built by {@link token}. */\n  get named(): boolean {\n    return this.green.named\n  }\n\n  /** The field name given by {@link field}, if any. */\n  get field(): string | undefined {\n    return this.parent?.green.fields?.[this.index]\n  }\n\n  /** The offset where the node ends (exclusive). */\n  get end(): number {\n    return this.start + this.green.width\n  }\n\n  /** The number of input units the node spans. */\n  get length(): number {\n    return this.green.width\n  }\n\n  /** The output of the node's parser (`undefined` for `ERROR` nodes, and for a root that failed). */\n  get value(): unknown {\n    return this.green.value\n  }\n\n  /** The input the node spans. */\n  get text(): Slice<I> {\n    const input = this.tree.input as any\n    return input instanceof Uint8Array\n      ? (input.subarray(this.start, this.end) as any)\n      : input.slice(this.start, this.end)\n  }\n\n  /** Whether this is an `ERROR` node. */\n  get isError(): boolean {\n    return this.green.error !== undefined\n  }\n\n  /** Whether this node or a descendant is an `ERROR` node. */\n  get hasError(): boolean {\n    return this.green.hasError\n  }\n\n  /** For an `ERROR` node, the error it stands for. */\n  get error(): ParseError.ParseError<unknown> | undefined {\n    const error = this.green.error\n    return error === undefined ? undefined : this.tree.toError(error, this.start)\n  }\n\n  /** The child nodes, named and anonymous, in input order. */\n  get children(): ReadonlyArray<SyntaxNode<I>> {\n    if (this.childList === undefined) {\n      const green = this.green\n      const out = new Array<SyntaxNode<I>>(green.children.length)\n      for (let i = 0; i < out.length; i++) out[i] = this.makeChild(i)\n      this.childList = out\n    }\n    return this.childList\n  }\n\n  /** The number of children. */\n  get childCount(): number {\n    return this.green.children.length\n  }\n\n  /** The child at `index` (negative indices count from the end). */\n  child(index: number): SyntaxNode<I> | undefined {\n    const n = this.green.children.length\n    const i = index < 0 ? n + index : index\n    return i >= 0 && i < n ? this.children[i] : undefined\n  }\n\n  /** The named children. */\n  get namedChildren(): ReadonlyArray<SyntaxNode<I>> {\n    return this.children.filter((c) => c.named)\n  }\n\n  /** The named child at `index`. */\n  namedChild(index: number): SyntaxNode<I> | undefined {\n    return this.namedChildren[index]\n  }\n\n  /** The first child with the given field name. */\n  childByField(name: string): SyntaxNode<I> | undefined {\n    const fields = this.green.fields\n    if (fields === undefined) return undefined\n    const i = fields.indexOf(name)\n    return i < 0 ? undefined : this.children[i]\n  }\n\n  /** The children with the given field name. */\n  childrenByField(name: string): ReadonlyArray<SyntaxNode<I>> {\n    const fields = this.green.fields\n    if (fields === undefined) return []\n    return this.children.filter((_, i) => fields[i] === name)\n  }\n\n  /** The next sibling, named or anonymous. */\n  get nextSibling(): SyntaxNode<I> | undefined {\n    return this.parent?.children[this.index + 1]\n  }\n\n  /** The previous sibling, named or anonymous. */\n  get previousSibling(): SyntaxNode<I> | undefined {\n    return this.index > 0 ? this.parent?.children[this.index - 1] : undefined\n  }\n\n  /** The next named sibling. */\n  get nextNamedSibling(): SyntaxNode<I> | undefined {\n    const siblings = this.parent?.children\n    if (siblings === undefined) return undefined\n    for (let i = this.index + 1; i < siblings.length; i++) if (siblings[i].named) return siblings[i]\n    return undefined\n  }\n\n  /** The previous named sibling. */\n  get previousNamedSibling(): SyntaxNode<I> | undefined {\n    const siblings = this.parent?.children\n    if (siblings === undefined) return undefined\n    for (let i = this.index - 1; i >= 0; i--) if (siblings[i].named) return siblings[i]\n    return undefined\n  }\n\n  /**\n   * The index of the child containing the input unit at `offset`, or -1.\n   * Takes logarithmic time.\n   */\n  childIndexAt(offset: number): number {\n    const green = this.green\n    const offsets = green.offsets\n    const rel = offset - this.start\n    let lo = 0\n    let hi = offsets.length - 1\n    let found = -1\n    while (lo <= hi) {\n      const mid = (lo + hi) >> 1\n      if (offsets[mid] <= rel) {\n        found = mid\n        lo = mid + 1\n      } else {\n        hi = mid - 1\n      }\n    }\n    // Skip back over empty `ERROR` nodes at `offset`\n    while (found >= 0 && green.children[found].width === 0 && offsets[found] === rel) found--\n    return found >= 0 && rel < offsets[found] + green.children[found].width ? found : -1\n  }\n\n  /** The child containing the input unit at `offset`. */\n  childAt(offset: number): SyntaxNode<I> | undefined {\n    const i = this.childIndexAt(offset)\n    return i < 0 ? undefined : this.children[i]\n  }\n\n  /**\n   * The smallest node, this one or a descendant, that contains\n   * `[start, end)` (Tree-sitter's `descendant_for_byte_range`). With only\n   * `start`, the deepest node containing the input unit at `start`. Takes\n   * time proportional to the depth of the tree times the logarithm of the\n   * number of children.\n   */\n  descendantAt(start: number, end: number = start + 1): SyntaxNode<I> {\n    return descendantOf(this, start, end)\n  }\n\n  /** Like {@link descendantAt}, but only stops at named nodes. */\n  namedDescendantAt(start: number, end: number = start + 1): SyntaxNode<I> {\n    let node: SyntaxNode<I> = this.descendantAt(start, end)\n    // Every node below `this` has a parent, so the walk stops at `this` at the latest\n    while (!node.named && node !== this) node = node.parent ?? this\n    return node\n  }\n\n  /** This node and its descendants, in pre-order. */\n  *descendants(): Generator<SyntaxNode<I>, void, undefined> {\n    const cursor = this.walk()\n    while (true) {\n      yield cursor.node\n      if (cursor.gotoFirstChild()) continue\n      while (!cursor.gotoNextSibling()) {\n        if (!cursor.gotoParent()) return\n      }\n    }\n  }\n\n  /** The descendants of the given kind, in pre-order. */\n  *descendantsOfKind(kind: string): Generator<SyntaxNode<I>, void, undefined> {\n    for (const n of this.descendants()) if (n.kind === kind) yield n\n  }\n\n  /** A cursor at this node, which cannot move above it. */\n  walk(): TreeCursor<I> {\n    return new TreeCursor(this)\n  }\n\n  /**\n   * The node as an S-expression of its named descendants, with field\n   * names, as Tree-sitter prints it: `(pair key: (name) value: (number))`.\n   */\n  toString(): string {\n    let out = \"\"\n    const visit = (green: Green, field: string | undefined) => {\n      if (green.named || green === this.green) {\n        if (Str.isNonEmpty(out)) out += \" \"\n        if (field !== undefined) out += `${field}: `\n        out += `(${green.kind}`\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i])\n        out += \")\"\n      } else {\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i])\n      }\n    }\n    visit(this.green, this.field)\n    return out\n  }\n\n  toJSON(): unknown {\n    return { kind: this.kind, start: this.start, end: this.end }\n  }\n\n  private makeChild(i: number): SyntaxNode<I> {\n    const green = this.green\n    return new SyntaxNode(this.tree, green.children[i], this.start + green.offsets[i], this, i)\n  }\n}\n\n/** The smallest node, `root` or a descendant, that contains `[start, end)` (see `SyntaxNode.descendantAt`). */\nconst descendantOf = <I extends Input>(root: SyntaxNode<I>, start: number, end: number): SyntaxNode<I> => {\n  let node = root\n  while (true) {\n    const i = node.childIndexAt(start)\n    if (i < 0) return node\n    const child = node.children[i]\n    if (end > child.end) return node\n    node = child\n  }\n}\n\n/**\n * A cursor for walking a tree, as Tree-sitter's `TreeCursor`. It starts at\n * a node and cannot move above it.\n *\n * @since 0.2.0\n * @category models\n */\nexport class TreeCursor<I extends Input = string> {\n  private current: SyntaxNode<I>\n  private depth = 0\n\n  /** @internal */\n  constructor(node: SyntaxNode<I>) {\n    this.current = node\n  }\n\n  /** The node at the cursor. */\n  get node(): SyntaxNode<I> {\n    return this.current\n  }\n\n  /** The field name of the node at the cursor, if any. */\n  get field(): string | undefined {\n    return this.depth === 0 ? undefined : this.current.field\n  }\n\n  /** Moves to the first child; `false` if there is none. */\n  gotoFirstChild(): boolean {\n    return this.goto(this.current.child(0))\n  }\n\n  /** Moves to the last child; `false` if there is none. */\n  gotoLastChild(): boolean {\n    return this.goto(this.current.child(-1))\n  }\n\n  /** Moves to the child containing the input unit at `offset`; `false` if there is none. */\n  gotoFirstChildForOffset(offset: number): boolean {\n    return this.goto(this.current.childAt(offset))\n  }\n\n  /** Moves to the next sibling; `false` if there is none. */\n  gotoNextSibling(): boolean {\n    if (this.depth === 0) return false\n    const next = this.current.nextSibling\n    if (next === undefined) return false\n    this.current = next\n    return true\n  }\n\n  /** Moves to the previous sibling; `false` if there is none. */\n  gotoPreviousSibling(): boolean {\n    if (this.depth === 0) return false\n    const previous = this.current.previousSibling\n    if (previous === undefined) return false\n    this.current = previous\n    return true\n  }\n\n  /** Moves to the parent; `false` at the node the cursor started at. */\n  gotoParent(): boolean {\n    const parent = this.current.parent\n    if (this.depth === 0 || parent === undefined) return false\n    this.current = parent\n    this.depth--\n    return true\n  }\n\n  /** Moves to the deepest node containing the input unit at `offset`. */\n  gotoDescendantAt(offset: number): void {\n    while (this.gotoFirstChildForOffset(offset)) {\n      // descend\n    }\n  }\n\n  /** Starts again at `node`. */\n  reset(node: SyntaxNode<I>): void {\n    this.current = node\n    this.depth = 0\n  }\n\n  private goto(node: SyntaxNode<I> | undefined): boolean {\n    if (node === undefined) return false\n    this.current = node\n    this.depth++\n    return true\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Parsing\n// -----------------------------------------------------------------------------\n\nconst expectedEof = [\"end of input\"]\n\nconst run = <A, E, I extends Input>(config: Config, input: I, previous: Previous | undefined): Tree<A, E, I> => {\n  const state = new State<I>(input, { context: config.context })\n  const builder = new SyntaxBuilder(state, previous)\n  const a = Stack.run(config.inner.step, state)\n  // Text parsers record the encoding when they fail, which they may have done inside reused nodes\n  if (state.encoding === undefined && previous !== undefined) state.encoding = previous.encoding\n  let fatal: ErrorInfo | undefined\n  let value: Option.Option<A> = Option.none()\n  if (a === Fail) {\n    fatal = { failure: state.reportedFailure(), mode: state.mode }\n  } else if (state.pos < state.end) {\n    state.backtrack(\"Eof\", expectedEof)\n    fatal = { failure: state.reportedFailure(), mode: \"Backtrack\" }\n  } else {\n    value = Option.some(a as A)\n  }\n  const green = builder.finish(config.kind, Option.getOrUndefined(value), fatal, state.pos)\n  return new Tree<A, E, I>(input, value, builder.reused, green, config, state.encoding)\n}\n\n/**\n * Parses an input into a syntax {@link Tree}. The grammar's output is the\n * tree's `value`, and its {@link node}s are the tree's nodes. When the\n * grammar is itself a {@link node}, that node is the root; otherwise the\n * root is a node of kind `options.kind` (by default `\"document\"`).\n *\n * The parse never fails: recovered failures (see `Parser.resumeAfter`), a\n * fatal failure and unparsed input at the end all become `ERROR` nodes, and\n * are listed in `tree.errors`. The parse is interpreted, never compiled.\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const parse: {\n  <A, E, I extends Input>(\n    grammar: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): Tree<A, E, I>\n  <A, E, R, I extends Input>(\n    grammar: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): Tree<A, E, I>\n} = <A, E, R, I extends Input>(\n  grammar: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): Tree<A, E, I> => {\n  const n = nodeOf(grammar)\n  const isRoot = Predicate.isTagged(n, \"Syntax\") && n.kind !== undefined && n.named\n  const config: Config = {\n    kind: isRoot ? n.kind : (options?.kind ?? \"document\"),\n    inner: isRoot ? (n.self as Parser.Any) : grammar,\n    lookahead: options?.lookahead ?? 0,\n    context: options?.context as Context.Context<never> | undefined\n  }\n  return run(config, fromSource(input as Input) as I, undefined)\n}\n\n/**\n * Parses the new version of a tree's input, reusing the nodes of the tree\n * that the edits leave unchanged (Tree-sitter's `ts_tree_edit` followed by\n * `ts_parser_parse` with the old tree). The result is the tree a fresh\n * {@link parse} of `input` would build, but only the parts of the tree\n * around the edits are parsed again. `tree.reused` says how many nodes were\n * reused.\n *\n * `edits` describe how the old input became the new one, applied in order,\n * each in the coordinates of the input as the previous edits left it. When\n * they are omitted, the edit is found by comparing the inputs (their common\n * prefix and suffix), which takes time linear in their length but much less\n * than parsing.\n *\n * Errors in the new tree are those a fresh parse reports, except that an\n * error just after a reused node may list fewer expected alternatives.\n *\n * @example\n * ```ts\n * import { Ascii, Syntax } from \"@thomasfosterau/effect-parse\"\n *\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const tree = Syntax.parse(number, \"12\")\n * Syntax.reparse(tree, \"123\", [{ start: 2, oldEnd: 2, newEnd: 3 }]).root.value // 123\n * ```\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const reparse = <A, E, I extends Input>(\n  tree: Tree<A, E, I>,\n  input: NoInfer<Source<I>>,\n  edits?: Edit | ReadonlyArray<Edit>\n): Tree<A, E, I> => {\n  const next = fromSource(input as Input) as I\n  const list =\n    edits === undefined\n      ? diffList(tree.input, next)\n      : \"start\" in edits\n        ? [edits as Edit]\n        : (edits as ReadonlyArray<Edit>)\n  const previous: Previous = {\n    root: tree.green,\n    oldLength: tree.input.length,\n    newLength: next.length,\n    segments: segmentsOf(tree.input.length, next.length, list),\n    input: tree.input,\n    extra: tree.config.lookahead,\n    encoding: tree.encoding\n  }\n  return run(tree.config, next, previous)\n}\n\n/**\n * Replaces `[start, end)` of a tree's string input with `text` and parses\n * the result incrementally (see {@link reparse}).\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const replace = <A, E>(\n  tree: Tree<A, E, string>,\n  start: number,\n  end: number,\n  text: string\n): Tree<A, E, string> => {\n  const input = tree.input\n  if (start < 0 || end < start || end > input.length) {\n    throw new RangeError(`invalid range [${start}, ${end}) of an input of length ${input.length}`)\n  }\n  return reparse(tree, input.slice(0, start) + text + input.slice(end), {\n    start,\n    oldEnd: end,\n    newEnd: start + text.length\n  })\n}\n\n/**\n * Finds the edit that turns `before` into `after`: the part between their\n * longest common prefix and suffix. `undefined` when they are equal.\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const diff = <I extends Input>(before: I, after: I): Edit | undefined => {\n  const a = before as any\n  const b = after as any\n  const at = Predicate.isString(a) ? (s: string, i: number) => s.charCodeAt(i) : (s: any, i: number) => s[i]\n  const max = Math.min(a.length, b.length)\n  let prefix = 0\n  while (prefix < max && at(a, prefix) === at(b, prefix)) prefix++\n  if (prefix === a.length && prefix === b.length) return undefined\n  let suffix = 0\n  while (suffix < max - prefix && at(a, a.length - 1 - suffix) === at(b, b.length - 1 - suffix)) suffix++\n  return { start: prefix, oldEnd: a.length - suffix, newEnd: b.length - suffix }\n}\n\nconst diffList = (before: Input, after: Input): ReadonlyArray<Edit> => {\n  const edit = diff(before, after)\n  return edit === undefined ? [] : [edit]\n}\n\n/** The stretches of the new input copied unchanged from the old one. */\nconst segmentsOf = (oldLength: number, newLength: number, edits: ReadonlyArray<Edit>): Array<Segment> => {\n  let segments: Array<Segment> = oldLength > 0 ? [{ newStart: 0, oldStart: 0, length: oldLength }] : []\n  let length = oldLength\n  for (const { newEnd, oldEnd, start } of edits) {\n    if (!(start >= 0 && oldEnd >= start && oldEnd <= length && newEnd >= start)) {\n      throw new RangeError(\n        `invalid edit { start: ${start}, oldEnd: ${oldEnd}, newEnd: ${newEnd} } of an input of length ${length}`\n      )\n    }\n    const delta = newEnd - oldEnd\n    const out: Array<Segment> = []\n    for (const s of segments) {\n      const end = s.newStart + s.length\n      if (s.newStart < start) {\n        out.push({ newStart: s.newStart, oldStart: s.oldStart, length: Math.min(end, start) - s.newStart })\n      }\n      if (end > oldEnd) {\n        const from = Math.max(s.newStart, oldEnd)\n        out.push({ newStart: from + delta, oldStart: s.oldStart + (from - s.newStart), length: end - from })\n      }\n    }\n    segments = out\n    length += delta\n  }\n  if (length !== newLength) {\n    throw new RangeError(`the edits give an input of length ${length}, but the new input has length ${newLength}`)\n  }\n  return segments\n}\n"],"mappings":"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"}
+{"version":3,"file":"Syntax.js","names":[],"sources":["../src/Syntax.ts"],"sourcesContent":["/**\n * Concrete syntax trees and incremental parsing, in the spirit of\n * [Tree-sitter](https://tree-sitter.github.io).\n *\n * Mark the rules of a grammar that should appear in the tree with\n * {@link node} (and, optionally, {@link token} and {@link field}). Outside\n * this module the marks change nothing: `Parser.parse` returns the same\n * values, and compiled parsers compile them away. {@link parse} runs the\n * grammar and returns a {@link Tree}: a tree of {@link SyntaxNode}s with\n * spans, parents and siblings, to search by position (`descendantAt`) or walk\n * with a {@link TreeCursor}. Each node also carries the value its parser\n * returned.\n *\n * Like Tree-sitter, a syntax parse always produces a tree. Failures handled\n * by `Parser.resumeAfter` and `Parser.retryAfter` become `ERROR` nodes over\n * the input they skipped, and so does any input after a fatal failure.\n *\n * After an edit, {@link reparse} (or {@link replace}) parses the new input\n * reusing every node of the old tree whose input is unchanged: only the\n * nodes that enclose the edit, or looked at the edited input, are parsed\n * again, and each reused node is stepped over whole.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const ws = Ascii.multispace0\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const list = Syntax.node(\n *   Parser.delimited(\n *     Token.literal(\"[\"),\n *     Parser.separated(Parser.delimited(ws, number, ws), Token.literal(\",\")),\n *     Token.literal(\"]\")\n *   ),\n *   \"list\"\n * )\n *\n * const tree = Syntax.parse(list, \"[1, 2, 3]\")\n * String(tree.root) // \"(list (number) (number) (number))\"\n * tree.root.descendantAt(4)?.text // \"2\"\n *\n * const edited = Syntax.replace(tree, 4, 5, \"20\") // \"[1, 20, 3]\"\n * edited.root.namedChild(1)?.value // 20\n * edited.reused // 2: only \"20\" was parsed again\n * ```\n *\n * @since 0.2.0\n */\nimport * as Str from \"effect/String\"\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport { dual } from \"effect/Function\"\nimport * as Option from \"effect/Option\"\nimport type { Input, Slice, Source } from \"./Input.js\"\nimport { Fail, fromSource, State } from \"./Input.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport { nodeOf } from \"./internal/node.js\"\nimport { Key } from \"./internal/key.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport type { ErrorInfo, Green, Previous, Segment } from \"./internal/syntax.js\"\nimport { absolute, errorKind, SyntaxBuilder } from \"./internal/syntax.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { described, isParser } from \"./Parser.js\"\n\n// -----------------------------------------------------------------------------\n// Grammar annotations\n// -----------------------------------------------------------------------------\n\nconst syntaxNode = <A, E, R, I extends Input>(\n  self: Parser<A, E, R, I>,\n  kind: string,\n  named: boolean\n): Parser<A, E, R, I> => {\n  const step = self.step\n  // Identifies the nodes this parser builds, so a reparse can reuse them\n  const key = new Key()\n  return described<A, E, R, I>(\n    (state) => {\n      const builder = state.syntax\n      return builder === undefined ? step(state) : builder.node(state, step, key, kind, named)\n    },\n    self.name,\n    { _tag: \"Syntax\", self, kind, named }\n  )\n}\n\n/**\n * Marks a parser as a rule of the syntax tree: in a {@link parse}, each\n * match becomes a named node of the given kind, spanning the input it\n * consumed, with the nodes built inside it as children and its output as\n * its `value`. Outside {@link parse}, the parser is unchanged.\n *\n * A match that consumes nothing adds no node (as in Tree-sitter, where rules\n * can't match the empty string).\n *\n * For {@link reparse} to reuse a node, its parser's output must depend only\n * on the input from where the node starts: not on services, on state kept\n * in closures, or on absolute offsets (`Parser.location`, `Parser.span`),\n * which are not updated when the node moves. Use the node's `start` and\n * `end` instead.\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const node: {\n  (kind: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind: string): Parser<A, E, R, I> =>\n  syntaxNode(self, kind, true)\n)\n\n/**\n * Like {@link node}, but builds an *anonymous* node, Tree-sitter's name for\n * punctuation and keywords: anonymous nodes are left out of\n * `namedChildren` and of the tree's printed form. The kind defaults to the\n * literal for a `Token.literal` of a string, and to the parser's name\n * otherwise.\n *\n * @example\n * ```ts\n * import { Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const comma = Syntax.token(Token.literal(\",\")) // kind \",\"\n * ```\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const token: {\n  (kind?: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind?: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(\n  (args) => isParser(args[0]),\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, kind?: string): Parser<A, E, R, I> =>\n    syntaxNode(self, kind ?? defaultTokenKind(self), false)\n)\n\nconst defaultTokenKind = (self: Parser.Any): string => {\n  const n = nodeOf(self)\n  if (Predicate.isTagged(n, \"Literal\") && Predicate.isString(n.literal) && !n.caseless) return n.literal\n  return self.name ?? \"token\"\n}\n\n/**\n * Gives the nodes built by a parser a field name in their parent, like\n * Tree-sitter's `field(name, rule)`: find them with `childByField` and\n * `childrenByField`. Outside {@link parse}, the parser is unchanged.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Syntax, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const name = Syntax.node(Ascii.alpha1, \"name\")\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const pair = Syntax.node(\n *   Parser.separatedPair(Syntax.field(name, \"key\"), Token.literal(\"=\"), Syntax.field(number, \"value\")),\n *   \"pair\"\n * )\n * Syntax.parse(pair, \"x=1\").root.childByField(\"value\")?.value // 1\n * ```\n *\n * @since 0.2.0\n * @category annotations\n */\nexport const field: {\n  (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>\n  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>\n} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> => {\n  const step = self.step\n  return described<A, E, R, I>(\n    (state) => {\n      const builder = state.syntax\n      return builder === undefined ? step(state) : builder.field(state, step, name)\n    },\n    self.name,\n    { _tag: \"Syntax\", self, kind: undefined, named: false }\n  )\n})\n\n// -----------------------------------------------------------------------------\n// Trees\n// -----------------------------------------------------------------------------\n\n/**\n * The kind of the nodes that stand for input that could not be parsed.\n *\n * @since 0.2.0\n * @category models\n */\nexport const ERROR: \"ERROR\" = errorKind\n\n/**\n * An edit to an input, as Tree-sitter's `TSInputEdit`: the input\n * `[start, oldEnd)` was replaced by `[start, newEnd)`. Offsets are in the\n * input's units (UTF-16 code units for strings, bytes, elements).\n *\n * @since 0.2.0\n * @category models\n */\nexport interface Edit {\n  readonly start: number\n  readonly oldEnd: number\n  readonly newEnd: number\n}\n\n/**\n * Options for {@link parse}.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface ParseOptions {\n  /**\n   * The kind of the root node, when the grammar itself is not a\n   * {@link node}. Defaults to `\"document\"`.\n   */\n  readonly kind?: string | undefined\n  /**\n   * For {@link reparse}: how many input units custom parsers may read past\n   * the furthest position they move the cursor to or record a failure at,\n   * besides one token there. Defaults to 0, which is right for the built-in\n   * parsers, and for custom parsers (`Parser.make`) that only read past\n   * where they stop to see that the token there doesn't match.\n   *\n   * A node is reused only when the input its parse looked at is unchanged.\n   * Built-in parsers that read further, such as a literal that fails part\n   * way or `Token.takeUntil`, record how far they read.\n   */\n  readonly lookahead?: number | undefined\n}\n\n/**\n * Options for {@link parse} with a parser that requires services.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface ParseOptionsWithContext<R> extends ParseOptions {\n  readonly context: Context.Context<R>\n}\n\ninterface Config {\n  readonly kind: string\n  readonly inner: Parser.Any\n  readonly lookahead: number\n  readonly context: Context.Context<never> | undefined\n}\n\n/**\n * The result of a {@link parse}: a syntax tree over the whole input, the\n * grammar's output, and the errors met on the way.\n *\n * @since 0.2.0\n * @category models\n */\nexport class Tree<out A, out E = never, I extends Input = string> {\n  /** The root node. It always spans the whole input. */\n  readonly root: SyntaxNode<I>\n  private lines: Array<number> | undefined\n  private errorList: ReadonlyArray<ParseError.ParseError<E>> | undefined\n\n  /** @internal */\n  constructor(\n    /** The input the tree was parsed from. */\n    readonly input: I,\n    /** The grammar's output: `none` when the parse failed. */\n    readonly value: Option.Option<A>,\n    /** How many nodes were reused from the previous tree by {@link reparse}. */\n    readonly reused: number,\n    /** @internal */\n    readonly green: Green,\n    /** @internal */\n    readonly config: Config,\n    /** @internal */\n    readonly encoding: ParseError.ParseError<never>[\"encoding\"]\n  ) {\n    this.root = new SyntaxNode(this, green, 0, undefined, 0)\n  }\n\n  /**\n   * Every error of the parse, in input order: the failures recovered by\n   * `Parser.resumeAfter` and `Parser.retryAfter`, then the fatal one, if\n   * the parse failed. Each one belongs to an `ERROR` node.\n   */\n  get errors(): ReadonlyArray<ParseError.ParseError<E>> {\n    if (this.errorList === undefined) {\n      const out: Array<ParseError.ParseError<E>> = []\n      const visit = (green: Green, start: number) => {\n        if (!green.hasError) return\n        if (green.error !== undefined) out.push(this.toError(green.error, start))\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], start + green.offsets[i])\n      }\n      visit(this.green, 0)\n      this.errorList = out\n    }\n    return this.errorList\n  }\n\n  /** Whether the tree has any `ERROR` node. */\n  get hasErrors(): boolean {\n    return this.green.hasError\n  }\n\n  /** The smallest node containing `[start, end)` (see {@link SyntaxNode.descendantAt}). */\n  descendantAt(start: number, end?: number): SyntaxNode<I> {\n    return this.root.descendantAt(start, end)\n  }\n\n  /** A cursor at the root. */\n  walk(): TreeCursor<I> {\n    return new TreeCursor(this.root)\n  }\n\n  /**\n   * The 1-based line and column (in code points) of an offset, as in\n   * `ParseError`. Lines of a string input are indexed once, so lookups take\n   * logarithmic time.\n   */\n  lineColumn(offset: number): ParseError.LineColumn {\n    const input = this.input\n    if (!Predicate.isString(input)) return ParseError.lineColumn(input, offset, this.encoding)\n    let lines = this.lines\n    if (lines === undefined) {\n      lines = [0]\n      for (let i = input.indexOf(\"\\n\"); i >= 0; i = input.indexOf(\"\\n\", i + 1)) lines.push(i + 1)\n      this.lines = lines\n    }\n    const at = Math.max(0, Math.min(offset, input.length))\n    let lo = 0\n    let hi = lines.length - 1\n    while (lo < hi) {\n      const mid = (lo + hi + 1) >> 1\n      if (lines[mid] <= at) lo = mid\n      else hi = mid - 1\n    }\n    const lineStart = lines[lo]\n    return { line: lo + 1, column: ParseError.lineColumn(input.slice(lineStart, at), at - lineStart).column }\n  }\n\n  /** The root's S-expression (see {@link SyntaxNode.toString}). */\n  toString(): string {\n    return this.root.toString()\n  }\n\n  /** @internal */\n  toError(error: ErrorInfo, start: number): ParseError.ParseError<E> {\n    return ParseError.fromFailure<E>(this.input, absolute(error.failure, start), error.mode, this.encoding)\n  }\n}\n\n/**\n * What `JSON.stringify` writes for a {@link SyntaxNode}: its kind and span.\n *\n * @since 0.5.0\n * @category models\n */\nexport interface SyntaxNodeJson {\n  readonly kind: string\n  readonly start: number\n  readonly end: number\n}\n\n/**\n * A node of a syntax tree: its kind, span and value, and its place in the\n * tree. Nodes are views built on demand; two views of the same node are\n * different objects but have the same `start`, `end` and `kind`.\n *\n * @since 0.2.0\n * @category models\n */\nexport class SyntaxNode<I extends Input = string> {\n  private childList: ReadonlyArray<SyntaxNode<I>> | undefined\n\n  /** @internal */\n  constructor(\n    /** The tree this node belongs to. */\n    readonly tree: Tree<unknown, unknown, I>,\n    /** @internal */\n    readonly green: Green,\n    /** The offset where the node starts. */\n    readonly start: number,\n    /** The parent node; `undefined` for the root. */\n    readonly parent: SyntaxNode<I> | undefined,\n    /** The node's index among its parent's children. */\n    readonly index: number\n  ) {}\n\n  /** The node's kind: the name given to {@link node} or {@link token}, or `\"ERROR\"`. */\n  get kind(): string {\n    return this.green.kind\n  }\n\n  /** `false` for the anonymous nodes built by {@link token}. */\n  get named(): boolean {\n    return this.green.named\n  }\n\n  /** The field name given by {@link field}, if any. */\n  get field(): string | undefined {\n    return this.parent?.green.fields?.[this.index]\n  }\n\n  /** The offset where the node ends (exclusive). */\n  get end(): number {\n    return this.start + this.green.width\n  }\n\n  /** The number of input units the node spans. */\n  get length(): number {\n    return this.green.width\n  }\n\n  /** The output of the node's parser (`undefined` for `ERROR` nodes, and for a root that failed). */\n  get value(): unknown {\n    return this.green.value\n  }\n\n  /** The input the node spans. */\n  get text(): Slice<I> {\n    const input: Input = this.tree.input\n    // SAFETY: a `subarray` of a `Uint8Array`, or a `slice` of a string or array, has the input's own kind, `Slice<I>`\n    return (\n      input instanceof Uint8Array ? input.subarray(this.start, this.end) : input.slice(this.start, this.end)\n    ) as Slice<I>\n  }\n\n  /** Whether this is an `ERROR` node. */\n  get isError(): boolean {\n    return this.green.error !== undefined\n  }\n\n  /** Whether this node or a descendant is an `ERROR` node. */\n  get hasError(): boolean {\n    return this.green.hasError\n  }\n\n  /** For an `ERROR` node, the error it stands for. */\n  get error(): ParseError.ParseError<unknown> | undefined {\n    const error = this.green.error\n    return error === undefined ? undefined : this.tree.toError(error, this.start)\n  }\n\n  /** The child nodes, named and anonymous, in input order. */\n  get children(): ReadonlyArray<SyntaxNode<I>> {\n    if (this.childList === undefined) {\n      const green = this.green\n      const out = new Array<SyntaxNode<I>>(green.children.length)\n      for (let i = 0; i < out.length; i++) out[i] = this.makeChild(i)\n      this.childList = out\n    }\n    return this.childList\n  }\n\n  /** The number of children. */\n  get childCount(): number {\n    return this.green.children.length\n  }\n\n  /** The child at `index` (negative indices count from the end). */\n  child(index: number): SyntaxNode<I> | undefined {\n    const n = this.green.children.length\n    const i = index < 0 ? n + index : index\n    return i >= 0 && i < n ? this.children[i] : undefined\n  }\n\n  /** The named children. */\n  get namedChildren(): ReadonlyArray<SyntaxNode<I>> {\n    return this.children.filter((c) => c.named)\n  }\n\n  /** The named child at `index`. */\n  namedChild(index: number): SyntaxNode<I> | undefined {\n    return this.namedChildren[index]\n  }\n\n  /** The first child with the given field name. */\n  childByField(name: string): SyntaxNode<I> | undefined {\n    const fields = this.green.fields\n    if (fields === undefined) return undefined\n    const i = fields.indexOf(name)\n    return i < 0 ? undefined : this.children[i]\n  }\n\n  /** The children with the given field name. */\n  childrenByField(name: string): ReadonlyArray<SyntaxNode<I>> {\n    const fields = this.green.fields\n    if (fields === undefined) return []\n    return this.children.filter((_, i) => fields[i] === name)\n  }\n\n  /** The next sibling, named or anonymous. */\n  get nextSibling(): SyntaxNode<I> | undefined {\n    return this.parent?.children[this.index + 1]\n  }\n\n  /** The previous sibling, named or anonymous. */\n  get previousSibling(): SyntaxNode<I> | undefined {\n    return this.index > 0 ? this.parent?.children[this.index - 1] : undefined\n  }\n\n  /** The next named sibling. */\n  get nextNamedSibling(): SyntaxNode<I> | undefined {\n    const siblings = this.parent?.children\n    if (siblings === undefined) return undefined\n    for (let i = this.index + 1; i < siblings.length; i++) if (siblings[i].named) return siblings[i]\n    return undefined\n  }\n\n  /** The previous named sibling. */\n  get previousNamedSibling(): SyntaxNode<I> | undefined {\n    const siblings = this.parent?.children\n    if (siblings === undefined) return undefined\n    for (let i = this.index - 1; i >= 0; i--) if (siblings[i].named) return siblings[i]\n    return undefined\n  }\n\n  /**\n   * The index of the child containing the input unit at `offset`, or -1.\n   * Takes logarithmic time.\n   */\n  childIndexAt(offset: number): number {\n    const green = this.green\n    const offsets = green.offsets\n    const rel = offset - this.start\n    let lo = 0\n    let hi = offsets.length - 1\n    let found = -1\n    while (lo <= hi) {\n      const mid = (lo + hi) >> 1\n      if (offsets[mid] <= rel) {\n        found = mid\n        lo = mid + 1\n      } else {\n        hi = mid - 1\n      }\n    }\n    // Skip back over empty `ERROR` nodes at `offset`\n    while (found >= 0 && green.children[found].width === 0 && offsets[found] === rel) found--\n    return found >= 0 && rel < offsets[found] + green.children[found].width ? found : -1\n  }\n\n  /** The child containing the input unit at `offset`. */\n  childAt(offset: number): SyntaxNode<I> | undefined {\n    const i = this.childIndexAt(offset)\n    return i < 0 ? undefined : this.children[i]\n  }\n\n  /**\n   * The smallest node, this one or a descendant, that contains\n   * `[start, end)` (Tree-sitter's `descendant_for_byte_range`). With only\n   * `start`, the deepest node containing the input unit at `start`. Takes\n   * time proportional to the depth of the tree times the logarithm of the\n   * number of children.\n   */\n  descendantAt(start: number, end: number = start + 1): SyntaxNode<I> {\n    return descendantOf(this, start, end)\n  }\n\n  /** Like {@link descendantAt}, but only stops at named nodes. */\n  namedDescendantAt(start: number, end: number = start + 1): SyntaxNode<I> {\n    let node: SyntaxNode<I> = this.descendantAt(start, end)\n    // Every node below `this` has a parent, so the walk stops at `this` at the latest\n    while (!node.named && node !== this) node = node.parent ?? this\n    return node\n  }\n\n  /** This node and its descendants, in pre-order. */\n  *descendants(): Generator<SyntaxNode<I>, void, undefined> {\n    const cursor = this.walk()\n    while (true) {\n      yield cursor.node\n      if (cursor.gotoFirstChild()) continue\n      while (!cursor.gotoNextSibling()) {\n        if (!cursor.gotoParent()) return\n      }\n    }\n  }\n\n  /** The descendants of the given kind, in pre-order. */\n  *descendantsOfKind(kind: string): Generator<SyntaxNode<I>, void, undefined> {\n    for (const n of this.descendants()) if (n.kind === kind) yield n\n  }\n\n  /** A cursor at this node, which cannot move above it. */\n  walk(): TreeCursor<I> {\n    return new TreeCursor(this)\n  }\n\n  /**\n   * The node as an S-expression of its named descendants, with field\n   * names, as Tree-sitter prints it: `(pair key: (name) value: (number))`.\n   */\n  toString(): string {\n    let out = \"\"\n    const visit = (green: Green, field: string | undefined) => {\n      if (green.named || green === this.green) {\n        if (Str.isNonEmpty(out)) out += \" \"\n        if (field !== undefined) out += `${field}: `\n        out += `(${green.kind}`\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i])\n        out += \")\"\n      } else {\n        for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i])\n      }\n    }\n    visit(this.green, this.field)\n    return out\n  }\n\n  toJSON(): SyntaxNodeJson {\n    return { kind: this.kind, start: this.start, end: this.end }\n  }\n\n  private makeChild(i: number): SyntaxNode<I> {\n    const green = this.green\n    return new SyntaxNode(this.tree, green.children[i], this.start + green.offsets[i], this, i)\n  }\n}\n\n/** The smallest node, `root` or a descendant, that contains `[start, end)` (see `SyntaxNode.descendantAt`). */\nconst descendantOf = <I extends Input>(root: SyntaxNode<I>, start: number, end: number): SyntaxNode<I> => {\n  let node = root\n  while (true) {\n    const i = node.childIndexAt(start)\n    if (i < 0) return node\n    const child = node.children[i]\n    if (end > child.end) return node\n    node = child\n  }\n}\n\n/**\n * A cursor for walking a tree, as Tree-sitter's `TreeCursor`. It starts at\n * a node and cannot move above it.\n *\n * @since 0.2.0\n * @category models\n */\nexport class TreeCursor<I extends Input = string> {\n  private current: SyntaxNode<I>\n  private depth = 0\n\n  /** @internal */\n  constructor(node: SyntaxNode<I>) {\n    this.current = node\n  }\n\n  /** The node at the cursor. */\n  get node(): SyntaxNode<I> {\n    return this.current\n  }\n\n  /** The field name of the node at the cursor, if any. */\n  get field(): string | undefined {\n    return this.depth === 0 ? undefined : this.current.field\n  }\n\n  /** Moves to the first child; `false` if there is none. */\n  gotoFirstChild(): boolean {\n    return this.goto(this.current.child(0))\n  }\n\n  /** Moves to the last child; `false` if there is none. */\n  gotoLastChild(): boolean {\n    return this.goto(this.current.child(-1))\n  }\n\n  /** Moves to the child containing the input unit at `offset`; `false` if there is none. */\n  gotoFirstChildForOffset(offset: number): boolean {\n    return this.goto(this.current.childAt(offset))\n  }\n\n  /** Moves to the next sibling; `false` if there is none. */\n  gotoNextSibling(): boolean {\n    if (this.depth === 0) return false\n    const next = this.current.nextSibling\n    if (next === undefined) return false\n    this.current = next\n    return true\n  }\n\n  /** Moves to the previous sibling; `false` if there is none. */\n  gotoPreviousSibling(): boolean {\n    if (this.depth === 0) return false\n    const previous = this.current.previousSibling\n    if (previous === undefined) return false\n    this.current = previous\n    return true\n  }\n\n  /** Moves to the parent; `false` at the node the cursor started at. */\n  gotoParent(): boolean {\n    const parent = this.current.parent\n    if (this.depth === 0 || parent === undefined) return false\n    this.current = parent\n    this.depth--\n    return true\n  }\n\n  /** Moves to the deepest node containing the input unit at `offset`. */\n  gotoDescendantAt(offset: number): void {\n    while (this.gotoFirstChildForOffset(offset)) {\n      // descend\n    }\n  }\n\n  /** Starts again at `node`. */\n  reset(node: SyntaxNode<I>): void {\n    this.current = node\n    this.depth = 0\n  }\n\n  private goto(node: SyntaxNode<I> | undefined): boolean {\n    if (node === undefined) return false\n    this.current = node\n    this.depth++\n    return true\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Parsing\n// -----------------------------------------------------------------------------\n\nconst expectedEof = [\"end of input\"]\n\nconst run = <A, E, I extends Input>(config: Config, input: I, previous: Previous | undefined): Tree<A, E, I> => {\n  const state = new State<I>(input, { context: config.context })\n  const builder = new SyntaxBuilder(state, previous)\n  const a = Stack.run(config.inner.step, state)\n  // Text parsers record the encoding when they fail, which they may have done inside reused nodes\n  if (state.encoding === undefined && previous !== undefined) state.encoding = previous.encoding\n  let fatal: ErrorInfo | undefined\n  let value: Option.Option<A> = Option.none()\n  if (a === Fail) {\n    fatal = { failure: state.reportedFailure(), mode: state.mode }\n  } else if (state.pos < state.end) {\n    state.backtrack(\"Eof\", expectedEof)\n    fatal = { failure: state.reportedFailure(), mode: \"Backtrack\" }\n  } else {\n    // SAFETY: `config.inner` is the `Parser<A, ...>` given to `parse` or the parser its root `node` wraps, which returns\n    // the same `A` (a `reparse` reuses the tree's config)\n    value = Option.some(a as A)\n  }\n  const green = builder.finish(config.kind, Option.getOrUndefined(value), fatal, state.pos)\n  return new Tree<A, E, I>(input, value, builder.reused, green, config, state.encoding)\n}\n\n/**\n * The overloads of {@link parse}.\n *\n * @since 0.5.0\n * @category parsing\n */\nexport interface ParseFn {\n  <A, E, I extends Input>(\n    grammar: Parser<A, E, never, I>,\n    input: NoInfer<Source<I>>,\n    options?: ParseOptions\n  ): Tree<A, E, I>\n  <A, E, R, I extends Input>(\n    grammar: Parser<A, E, R, I>,\n    input: NoInfer<Source<I>>,\n    options: ParseOptionsWithContext<R>\n  ): Tree<A, E, I>\n}\n\n/**\n * Parses an input into a syntax {@link Tree}. The grammar's output is the\n * tree's `value`, and its {@link node}s are the tree's nodes. When the\n * grammar is itself a {@link node}, that node is the root; otherwise the\n * root is a node of kind `options.kind` (by default `\"document\"`).\n *\n * The parse never fails: recovered failures (see `Parser.resumeAfter`), a\n * fatal failure and unparsed input at the end all become `ERROR` nodes, and\n * are listed in `tree.errors`. The parse is interpreted, never compiled.\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const parse: ParseFn = <A, E, R, I extends Input>(\n  grammar: Parser<A, E, R, I>,\n  input: I | Source<I>,\n  options?: ParseOptions & { readonly context?: Context.Context<R> }\n): Tree<A, E, I> => {\n  const n = nodeOf(grammar)\n  const isRoot = Predicate.isTagged(n, \"Syntax\") && n.kind !== undefined && n.named\n  const config: Config = {\n    kind: isRoot ? n.kind : (options?.kind ?? \"document\"),\n    // SAFETY: a `Syntax` node's `self` is the parser that `node` wrapped, a parser built by this library\n    inner: isRoot ? (n.self as Parser.Any) : grammar,\n    lookahead: options?.lookahead ?? 0,\n    context: options?.context\n  }\n  return run(config, fromSource<I>(input), undefined)\n}\n\n/**\n * Parses the new version of a tree's input, reusing the nodes of the tree\n * that the edits leave unchanged (Tree-sitter's `ts_tree_edit` followed by\n * `ts_parser_parse` with the old tree). The result is the tree a fresh\n * {@link parse} of `input` would build, but only the parts of the tree\n * around the edits are parsed again. `tree.reused` says how many nodes were\n * reused.\n *\n * `edits` describe how the old input became the new one, applied in order,\n * each in the coordinates of the input as the previous edits left it. When\n * they are omitted, the edit is found by comparing the inputs (their common\n * prefix and suffix), which takes time linear in their length but much less\n * than parsing.\n *\n * Errors in the new tree are those a fresh parse reports, except that an\n * error just after a reused node may list fewer expected alternatives.\n *\n * @example\n * ```ts\n * import { Ascii, Syntax } from \"@thomasfosterau/effect-parse\"\n *\n * const number = Syntax.node(Ascii.decInt, \"number\")\n * const tree = Syntax.parse(number, \"12\")\n * Syntax.reparse(tree, \"123\", [{ start: 2, oldEnd: 2, newEnd: 3 }]).root.value // 123\n * ```\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const reparse = <A, E, I extends Input>(\n  tree: Tree<A, E, I>,\n  input: NoInfer<Source<I>>,\n  edits?: Edit | ReadonlyArray<Edit>\n): Tree<A, E, I> => {\n  const next = fromSource<I>(input)\n  const list = edits === undefined ? diffList(tree.input, next) : \"start\" in edits ? [edits] : edits\n  const previous: Previous = {\n    root: tree.green,\n    oldLength: tree.input.length,\n    newLength: next.length,\n    segments: segmentsOf(tree.input.length, next.length, list),\n    input: tree.input,\n    extra: tree.config.lookahead,\n    encoding: tree.encoding\n  }\n  return run(tree.config, next, previous)\n}\n\n/**\n * Replaces `[start, end)` of a tree's string input with `text` and parses\n * the result incrementally (see {@link reparse}).\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const replace = <A, E>(\n  tree: Tree<A, E, string>,\n  start: number,\n  end: number,\n  text: string\n): Tree<A, E, string> => {\n  const input = tree.input\n  if (start < 0 || end < start || end > input.length) {\n    throw new RangeError(`invalid range [${start}, ${end}) of an input of length ${input.length}`)\n  }\n  return reparse(tree, input.slice(0, start) + text + input.slice(end), {\n    start,\n    oldEnd: end,\n    newEnd: start + text.length\n  })\n}\n\n/**\n * Finds the edit that turns `before` into `after`: the part between their\n * longest common prefix and suffix. `undefined` when they are equal.\n *\n * @since 0.2.0\n * @category parsing\n */\nexport const diff = <I extends Input>(before: I, after: I): Edit | undefined => {\n  const a: Input = before\n  const b: Input = after\n  // SAFETY: the string reader is chosen only when `a` is a string, and `b` has the same type `I`\n  const at = Predicate.isString(a)\n    ? (s: Input, i: number) => (s as string).charCodeAt(i)\n    : (s: Input, i: number) => s[i]\n  const max = Math.min(a.length, b.length)\n  let prefix = 0\n  while (prefix < max && at(a, prefix) === at(b, prefix)) prefix++\n  if (prefix === a.length && prefix === b.length) return undefined\n  let suffix = 0\n  while (suffix < max - prefix && at(a, a.length - 1 - suffix) === at(b, b.length - 1 - suffix)) suffix++\n  return { start: prefix, oldEnd: a.length - suffix, newEnd: b.length - suffix }\n}\n\nconst diffList = (before: Input, after: Input): ReadonlyArray<Edit> => {\n  const edit = diff(before, after)\n  return edit === undefined ? [] : [edit]\n}\n\n/** The stretches of the new input copied unchanged from the old one. */\nconst segmentsOf = (oldLength: number, newLength: number, edits: ReadonlyArray<Edit>): Array<Segment> => {\n  let segments: Array<Segment> = oldLength > 0 ? [{ newStart: 0, oldStart: 0, length: oldLength }] : []\n  let length = oldLength\n  for (const { newEnd, oldEnd, start } of edits) {\n    if (!(start >= 0 && oldEnd >= start && oldEnd <= length && newEnd >= start)) {\n      throw new RangeError(\n        `invalid edit { start: ${start}, oldEnd: ${oldEnd}, newEnd: ${newEnd} } of an input of length ${length}`\n      )\n    }\n    const delta = newEnd - oldEnd\n    const out: Array<Segment> = []\n    for (const s of segments) {\n      const end = s.newStart + s.length\n      if (s.newStart < start) {\n        out.push({ newStart: s.newStart, oldStart: s.oldStart, length: Math.min(end, start) - s.newStart })\n      }\n      if (end > oldEnd) {\n        const from = Math.max(s.newStart, oldEnd)\n        out.push({ newStart: from + delta, oldStart: s.oldStart + (from - s.newStart), length: end - from })\n      }\n    }\n    segments = out\n    length += delta\n  }\n  if (length !== newLength) {\n    throw new RangeError(`the edits give an input of length ${length}, but the new input has length ${newLength}`)\n  }\n  return segments\n}\n"],"mappings":"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"}

package/dist/Text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Text.d.ts","names":[],"sources":["../src/Text.ts"],"mappings":";;;;;;;;;;YAgEY,iBAAiB;;;;;;;;;;;;;;;;;qBAsChB,WAAY,iBAAe;;;;;;;;qBAS3B,cAAc;;;;;;;qBAQd,UAAU;;;;;;;qBAQV,aAAa;;;;;;;qBAQb,aAAa;;;;;;;;qBASb,gBAAgB;;;;;;;;qBAShB,WAAW;;;;;;;qBAQX,gBAAgB;;;;;;;;qBAShB,cAAc;;;;;;;;qBASd,SAAS;;;;;;;;qBAYT,WAAW;;;;;;;;qBASX,cAAc;;;;;;;qBAQd,eAAe;;;;;;;qBAQf,WAAW;;;;;;;;;;;;iBAiBP,YAAY,mBAAmB;;WAErC,UAAU,SAAS;;WAKnB,KAAK,6BAA6B;;;;;WAKlC,gBAAgB,kBAAkB,SAAS,MAAM,OAAO,iBAAiB;;;;;;WAMzE,WAAW,oBAAoB,6BAA6B;;WAE5D,QAAQ,KAAK,mBAAmB,6BAA6B;;WAE7D,SAAS,KAAK,mBAAmB,6BAA6B;;WAE9D,KAAK,8BAA8B;;WAKnC,OAAO,kBAAkB,6BAA6B;;WAEtD,YAAY,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAEhF,WAAW,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAE/E,YAAY,iBAAiB,QAAQ,UAAU,6BAA6B;;WAE5E,MAAM,6BAA6B;;;;;WAKnC,QAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,OAAO,eAAe,GAAG,GAAG;;WAKnE,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,eAAe,6BAA6B;;WAE5C,eAAe,6BAA6B;;WAE5C,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,aAAa,6BAA6B;;WAE1C,aAAa,6BAA6B;;;;;WAK1C,YAAY,6BAA6B;;WAKzC,SAAS,2BAA2B;;WAEpC,MAAM,6BAA6B;;WAEnC,KAAK,2BAA2B;;WAEhC,YAAY,oCAAoC;;WAEhD,gBAAgB,6BAA6B;;WAK7C,SAAS,8BAA8B;;WAEvC,QAAQ,8BAA8B;;WAEtC,YAAY,6BAA6B;;WAEzC,WAAW,6BAA6B;;WAExC,SAAS,8BAA8B;;WAEvC,OAAO,6BAA6B;;;;;WAQpC,cAAc,GAAG,GAAG,GAAG,GAAG,IAAI,IACrC,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,iBACA,WAAW,OAAO,GAAG,IAAI,IAAI,OAC1B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;WAK3B,UAAU,GAAG,GAAG,IAAI,IAC3B,QAAQ,eAAe,GAAG,GAAG,IAC7B,iBACA,QAAQ,eAAe,IAAI,IAAI,OAC5B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;qBAyCzB,OAAQ,mBAAmB,YAAY,UAAU,SAAS,OAAK,YAAY;;;;;;;qBAuZ3E,QAAQ;;;;;;;;;;;;;;;;qBAiBR,MAAM,YAAY;;;;;;;qBAQlB,SAAS,YAAY;;;;;;;qBAQrB,SAAS,YAAY;;;;;;;qBAQrB,QAAQ,YAAY"}
+{"version":3,"file":"Text.d.ts","names":[],"sources":["../src/Text.ts"],"mappings":";;;;;;;;;;YAgEY,iBAAiB;;;;;;;;;;;;;;;;;qBAsChB,WAAY,iBAAe;;;;;;;;qBAS3B,cAAc;;;;;;;qBAQd,UAAU;;;;;;;qBAQV,aAAa;;;;;;;qBAQb,aAAa;;;;;;;;qBASb,gBAAgB;;;;;;;;qBAShB,WAAW;;;;;;;qBAQX,gBAAgB;;;;;;;;qBAShB,cAAc;;;;;;;;qBASd,SAAS;;;;;;;;qBAYT,WAAW;;;;;;;;qBASX,cAAc;;;;;;;qBAQd,eAAe;;;;;;;qBAQf,WAAW;;;;;;;;;;;;iBAiBP,YAAY,mBAAmB;;WAErC,UAAU,SAAS;;WAKnB,KAAK,6BAA6B;;;;;WAKlC,gBAAgB,kBAAkB,SAAS,MAAM,OAAO,iBAAiB;;;;;;WAMzE,WAAW,oBAAoB,6BAA6B;;WAE5D,QAAQ,KAAK,mBAAmB,6BAA6B;;WAE7D,SAAS,KAAK,mBAAmB,6BAA6B;;WAE9D,KAAK,8BAA8B;;WAKnC,OAAO,kBAAkB,6BAA6B;;WAEtD,YAAY,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAEhF,WAAW,KAAK,gBAAgB,QAAQ,UAAU,6BAA6B;;WAE/E,YAAY,iBAAiB,QAAQ,UAAU,6BAA6B;;WAE5E,MAAM,6BAA6B;;;;;WAKnC,QAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,OAAO,eAAe,GAAG,GAAG;;WAKnE,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,eAAe,6BAA6B;;WAE5C,eAAe,6BAA6B;;WAE5C,QAAQ,6BAA6B;;WAErC,QAAQ,6BAA6B;;WAErC,aAAa,6BAA6B;;WAE1C,aAAa,6BAA6B;;;;;WAK1C,YAAY,6BAA6B;;WAKzC,SAAS,2BAA2B;;WAEpC,MAAM,6BAA6B;;WAEnC,KAAK,2BAA2B;;WAEhC,YAAY,oCAAoC;;WAEhD,gBAAgB,6BAA6B;;WAK7C,SAAS,8BAA8B;;WAEvC,QAAQ,8BAA8B;;WAEtC,YAAY,6BAA6B;;WAEzC,WAAW,6BAA6B;;WAExC,SAAS,8BAA8B;;WAEvC,OAAO,6BAA6B;;;;;WAQpC,cAAc,GAAG,GAAG,GAAG,GAAG,IAAI,IACrC,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,iBACA,WAAW,OAAO,GAAG,IAAI,IAAI,OAC1B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;WAK3B,UAAU,GAAG,GAAG,IAAI,IAC3B,QAAQ,eAAe,GAAG,GAAG,IAC7B,iBACA,QAAQ,eAAe,IAAI,IAAI,OAC5B,eAAe,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;qBAyCzB,OAAQ,mBAAmB,YAAY,UAAU,SAAS,OAAK,YAAY;;;;;;;qBAwZ3E,QAAQ;;;;;;;;;;;;;;;;qBAiBR,MAAM,YAAY;;;;;;;qBAQlB,SAAS,YAAY;;;;;;;qBAQrB,SAAS,YAAY;;;;;;;qBAQrB,QAAQ,YAAY"}

package/dist/Text.js

@@ -213,7 +213,7 @@ const make = (encoding) => {
 	const textOf = (state, start, end, kind, expected) => {
 		const count = internal.validate(enc, state, start, end);
 		if (count < 0) return backtrack(state, kind, expected, -1 - count);
-		return enc.text(state.input, start, end);
+		return internal.textIn(enc, state, start, end);
 	};
 	const takeWhileText = (test, r, negate, name, expected, kind, hint, set = test) => {
 		const [min, max] = normalize(r);
@@ -228,7 +228,7 @@ const make = (encoding) => {
 			if (count < min) return backtrack(state, kind, expected, offset);
 			if (hint && count < max) state.setHint(offset, expected);
 			state.pos = offset;
-			return enc.text(state.input, start, offset);
+			return internal.textIn(enc, state, start, offset);
 		}, name, {
 			_tag: "TakeWhile",
 			set,
@@ -299,7 +299,7 @@ const make = (encoding) => {
 				pos += internal.width;
 			}
 			state.pos = pos;
-			return enc.text(state.input, start, pos);
+			return internal.textIn(enc, state, start, pos);
 		}, expected[0], {
 			_tag: "Literal",
 			literal: lit,
@@ -340,7 +340,7 @@ const make = (encoding) => {
 				pos += internal.width;
 			}
 			state.pos = pos;
-			return enc.text(state.input, start, pos);
+			return internal.textIn(enc, state, start, pos);
 		}, "take", {
 			_tag: "Take",
 			count,
@@ -367,7 +367,7 @@ const make = (encoding) => {
 			if (count < min) return backtrack(state, "TakeUntil", expected, idx);
 			if (count > max) return backtrack(state, "TakeUntil", expected);
 			state.pos = idx;
-			return enc.text(state.input, start, idx);
+			return internal.textIn(enc, state, start, idx);
 		}, "takeUntil", {
 			_tag: "TakeUntil",
 			literal: lit,
@@ -385,7 +385,7 @@ const make = (encoding) => {
 		if (internal.scanStop === internal.Truncated) return state.incomplete(1, expectedAny);
 		if (internal.scanStop === internal.Invalid) return backtrack(state, "Token", expectedAny, offset);
 		state.pos = offset;
-		return enc.text(state.input, start, offset);
+		return internal.textIn(enc, state, start, offset);
 	}, "rest", {
 		_tag: "Rest",
 		encoding: enc
@@ -415,7 +415,7 @@ const make = (encoding) => {
 		const stop = internal.scanStop;
 		if (state.partial && (stop === internal.End || stop === internal.Truncated)) return state.incomplete(1, expectedIdentifier);
 		state.pos = internal.scanOffset;
-		return enc.text(state.input, start, state.pos);
+		return internal.textIn(enc, state, start, state.pos);
 	}, "identifier", {
 		_tag: "Identifier",
 		encoding: enc
@@ -451,7 +451,7 @@ const make = (encoding) => {
 			if (after !== 10) return backtrack(state, "LineEnding", expectedLineEnding, offset);
 		}
 		state.pos = offset;
-		return enc.text(state.input, start, offset);
+		return internal.textIn(enc, state, start, offset);
 	}, "tillLineEnding", {
 		_tag: "TillLineEnding",
 		encoding: enc
@@ -513,7 +513,7 @@ const make = (encoding) => {
 		decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith("+") ? s.slice(1) : s))),
 		hexUint: hexDigits.pipe(P.tryMap((s) => overflow(parseInt(s, 16))), P.named("hexUint")),
 		float: floatText$1.pipe(P.map(toFloat$1), P.named("float")),
-		takeEscaped: (normal, control, escapable) => takeEscapedImpl(normal, matchControl(control), escapable, (state, start) => enc.text(state.input, start, state.pos), internal.firstCodePoint(control), enc),
+		takeEscaped: (normal, control, escapable) => takeEscapedImpl(normal, matchControl(control), escapable, (state, start) => internal.textIn(enc, state, start, state.pos), internal.firstCodePoint(control), enc),
 		escaped: (normal, control, escape) => escapedImpl(normal, matchControl(control), escape, internal.firstCodePoint(control), enc)
 	};
 };

package/dist/Text.js.map

@@ -1 +1 @@
-{"version":3,"file":"Text.js","names":["floatText","markFloatText","toFloat"],"sources":["../src/Text.ts"],"sourcesContent":["/**\n * Unicode text parsers, generic over the input's encoding.\n *\n * `Text.make(encoding)` builds one set of parsers ({@link TextParsers}) for\n * an {@link Encoding.Encoding}, and ready-made sets are provided for\n * JavaScript strings and the common byte encodings:\n *\n * | Parsers | Input | Offsets |\n * |---|---|---|\n * | `Text.string` | `string` | UTF-16 code units |\n * | `Text.utf8` | `Uint8Array` of UTF-8 | bytes |\n * | `Text.utf16le`, `Text.utf16be` | `Uint8Array` of UTF-16 | bytes |\n * | `Text.latin1` | `Uint8Array` of ISO-8859-1 | bytes |\n *\n * Every set has the same members, and every parser returns `string`s, so a\n * grammar written against `TextParsers<I>` parses all of them:\n *\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greeting = <I extends string | Uint8Array>(T: Text.TextParsers<I>) =>\n *   Parser.preceded(T.literal(\"¡hola \"), T.identifier)\n *\n * Parser.parse(greeting(Text.string), \"¡hola mundo\")                           // \"mundo\"\n * Parser.parse(greeting(Text.utf8), new TextEncoder().encode(\"¡hola Zoë\"))    // \"Zoë\"\n * ```\n *\n * Tokens are Unicode code points, and character classes follow Unicode\n * properties: `alpha1` matches `\"Ωμέγα\"`, `space1` matches a no-break space.\n * Use the `Ascii` module for the ASCII-only classes.\n *\n * Decoding is strict. Malformed input (invalid UTF-8, unpaired surrogates)\n * never matches, and error messages point at it. On partial input, a\n * character split across chunks reports `Incomplete`, so byte streams can be\n * parsed as text without decoding them first.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"./Encoding.js\"\nimport * as Encodings from \"./Encoding.js\"\nimport type { Input, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport { escapedImpl, overflow, takeEscapedImpl, toFloat } from \"./Ascii.js\"\nimport { codePointPredicate, compile, indexOf, matchLiteral } from \"./internal/tokens.js\"\nimport { floatText as markFloatText } from \"./internal/numbers.js\"\nimport * as internal from \"./internal/text.js\"\nimport type { Node } from \"./internal/node.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport type { StringTokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Unicode predicates\n// -----------------------------------------------------------------------------\n\n/**\n * A predicate over characters. It accepts a one-character string or a code\n * point.\n *\n * @since 0.1.0\n * @category models\n */\nexport type CharPredicate = (char: string | number) => boolean\n\nconst toCodePoint = (c: string | number): number => (Predicate.isNumber(c) ? c : (c.codePointAt(0) ?? -1))\n\nconst makePredicate = (name: string, re: RegExp): CharPredicate => {\n  // Results for the Basic Multilingual Plane are cached: a table lookup is\n  // much faster than a regular expression test.\n  let ascii: Uint8Array | undefined\n  let bmp: Uint8Array | undefined\n  return codePointPredicate(name, (c: string | number): boolean => {\n    const x = toCodePoint(c)\n    if (x < 0) return false\n    let table: Uint8Array\n    if (x < 128) table = ascii ??= new Uint8Array(128)\n    else if (x < 0x10000) table = bmp ??= new Uint8Array(0x10000)\n    else return re.test(String.fromCodePoint(x))\n    let v = table[x]\n    if (v === 0) table[x] = v = re.test(String.fromCharCode(x)) ? 2 : 1\n    return v === 2\n  })\n}\n\n/**\n * A predicate testing a Unicode property, using the syntax of regular\n * expression property escapes (`\\p{...}`): a general category (`\"Lu\"`,\n * `\"Letter\"`), a binary property (`\"Emoji\"`, `\"Dash\"`) or a script\n * (`\"Script=Greek\"`).\n *\n * @example\n * ```ts\n * import { Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greek = Text.string.takeWhile(Text.property(\"Script=Greek\"), { min: 1 })\n * ```\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const property = (name: string): CharPredicate => makePredicate(name, new RegExp(`^\\\\p{${name}}$`, \"u\"))\n\n/**\n * Letters and other alphabetic characters (the Unicode `Alphabetic`\n * property, Rust's `char::is_alphabetic`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphabetic: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphabetic\", /^\\p{Alphabetic}$/u)\n\n/**\n * Letters (general category `L`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLetter: CharPredicate = /*#__PURE__*/ makePredicate(\"isLetter\", /^\\p{L}$/u)\n\n/**\n * Uppercase characters (the Unicode `Uppercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isUppercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isUppercase\", /^\\p{Uppercase}$/u)\n\n/**\n * Lowercase characters (the Unicode `Lowercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLowercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isLowercase\", /^\\p{Lowercase}$/u)\n\n/**\n * Decimal digits of any script (general category `Nd`): `0`–`9`, `٠`–`٩`,\n * `०`–`९`, ...\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDecimalDigit: CharPredicate = /*#__PURE__*/ makePredicate(\"isDecimalDigit\", /^\\p{Nd}$/u)\n\n/**\n * Numeric characters (general category `N`), including `½` and `Ⅻ` (Rust's\n * `char::is_numeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isNumeric\", /^\\p{N}$/u)\n\n/**\n * Alphabetic or numeric characters (Rust's `char::is_alphanumeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphanumeric\", /^[\\p{Alphabetic}\\p{N}]$/u)\n\n/**\n * Whitespace, including line breaks (the Unicode `White_Space` property,\n * Rust's `char::is_whitespace`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWhitespace: CharPredicate = /*#__PURE__*/ makePredicate(\"isWhitespace\", /^\\p{White_Space}$/u)\n\n/**\n * Whitespace that does not break lines: `White_Space` except `\\n`, `\\v`,\n * `\\f`, `\\r`, U+0085, U+2028 and U+2029. Includes tabs and no-break spaces.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: CharPredicate = /*#__PURE__*/ makePredicate(\n  \"isSpace\",\n  /^(?![\\n\\v\\f\\r\\u0085\\u2028\\u2029])\\p{White_Space}$/u\n)\n\n/**\n * Characters that can start an identifier (the Unicode `ID_Start` property,\n * see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdStart: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdStart\", /^\\p{ID_Start}$/u)\n\n/**\n * Characters that can continue an identifier (the Unicode `ID_Continue`\n * property, see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdContinue: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdContinue\", /^\\p{ID_Continue}$/u)\n\n/**\n * Punctuation (general category `P`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isPunctuation: CharPredicate = /*#__PURE__*/ makePredicate(\"isPunctuation\", /^\\p{P}$/u)\n\n/**\n * Control characters (general category `Cc`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isControl: CharPredicate = /*#__PURE__*/ makePredicate(\"isControl\", /^\\p{Cc}$/u)\n\n// -----------------------------------------------------------------------------\n// Parsers\n// -----------------------------------------------------------------------------\n\n/**\n * The text parsers for one encoding. Build a set with {@link make}, or use\n * {@link string}, {@link utf8}, {@link utf16le}, {@link utf16be} or\n * {@link latin1}.\n *\n * Every parser returns text as a `string`, whatever the input. To keep a\n * slice of a byte input as bytes instead, use `Parser.taken`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TextParsers<I extends string | Uint8Array> {\n  /** The encoding these parsers read. */\n  readonly encoding: Encoding<I>\n\n  // Tokens\n\n  /** Any single character (code point). */\n  readonly any: Parser<string, never, never, I>\n  /**\n   * A literal string, returned as written. On byte inputs it is matched in\n   * its encoded form.\n   */\n  readonly literal: <const L extends string>(literal: L) => Parser<L, never, never, I>\n  /**\n   * A literal string, ignoring case (by simple Unicode case folding, so\n   * `\"straße\"` matches `\"STRAßE\"` but not `\"STRASSE\"`). Returns the input as\n   * written.\n   */\n  readonly caseless: (literal: string) => Parser<string, never, never, I>\n  /** One character belonging to a set (the characters of a string, a range, a predicate, or an array of these). */\n  readonly oneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** One character *not* belonging to a set. */\n  readonly noneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** An optional byte order mark, U+FEFF. Returns whether one was present. */\n  readonly bom: Parser<boolean, never, never, I>\n\n  // Slices\n\n  /** Exactly `count` characters. */\n  readonly take: (count: number) => Parser<string, never, never, I>\n  /** The longest run of characters belonging to a set, with a count in `range` (default: any). */\n  readonly takeWhile: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** The longest run of characters *not* belonging to a set, with a count in `range`. */\n  readonly takeTill: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** Characters up to (not including) the first occurrence of a literal. */\n  readonly takeUntil: (literal: string, range?: Range) => Parser<string, never, never, I>\n  /** The rest of the input. */\n  readonly rest: Parser<string, never, never, I>\n  /**\n   * Runs a parser and returns the text it consumed (`Parser.taken`, decoded\n   * to a `string`).\n   */\n  readonly taken: <A, E, R>(self: Parser<A, E, R, I>) => Parser<string, E, R, I>\n\n  // Character classes\n\n  /** Zero or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha0: Parser<string, never, never, I>\n  /** One or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha1: Parser<string, never, never, I>\n  /** Zero or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit0: Parser<string, never, never, I>\n  /** One or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit1: Parser<string, never, never, I>\n  /** Zero or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric0: Parser<string, never, never, I>\n  /** One or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric1: Parser<string, never, never, I>\n  /** Zero or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space0: Parser<string, never, never, I>\n  /** One or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space1: Parser<string, never, never, I>\n  /** Zero or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace0: Parser<string, never, never, I>\n  /** One or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace1: Parser<string, never, never, I>\n  /**\n   * An identifier: an {@link isIdStart} character or `_`, then any\n   * {@link isIdContinue} characters (UAX #31 default identifiers).\n   */\n  readonly identifier: Parser<string, never, never, I>\n\n  // Line endings\n\n  /** `\\n` */\n  readonly newline: Parser<\"\\n\", never, never, I>\n  /** `\\r\\n` */\n  readonly crlf: Parser<\"\\r\\n\", never, never, I>\n  /** `\\t` */\n  readonly tab: Parser<\"\\t\", never, never, I>\n  /** `\\n` or `\\r\\n`. */\n  readonly lineEnding: Parser<\"\\n\" | \"\\r\\n\", never, never, I>\n  /** Everything up to (not including) a line ending. A `\\r` not followed by `\\n` is an error. */\n  readonly tillLineEnding: Parser<string, never, never, I>\n\n  // Numbers (ASCII digits, as in most languages)\n\n  /** An unsigned decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decUint: Parser<number, string, never, I>\n  /** A signed decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decInt: Parser<number, string, never, I>\n  /** An unsigned decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigUint: Parser<bigint, never, never, I>\n  /** A signed decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigInt: Parser<bigint, never, never, I>\n  /** A hexadecimal unsigned integer, without prefix. Fails if it is not a safe integer. */\n  readonly hexUint: Parser<number, string, never, I>\n  /** A floating point number, as accepted by `Ascii.float`. */\n  readonly float: Parser<number, never, never, I>\n\n  // Escapes\n\n  /**\n   * Recognizes text containing escape sequences, returning it raw (see\n   * `Ascii.takeEscaped`). `control` is the escape character.\n   */\n  readonly takeEscaped: <A, E, R, B, E2, R2>(\n    normal: Parser<A, E, R, I>,\n    control: string,\n    escapable: Parser<B, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n  /**\n   * Parses text containing escape sequences, returning it unescaped (see\n   * `Ascii.escaped`). `control` is the escape character.\n   */\n  readonly escaped: <E, R, E2, R2>(\n    normal: Parser<string, E, R, I>,\n    control: string,\n    escape: Parser<string, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  if (r === undefined) return [0, Infinity]\n  if (Predicate.isNumber(r)) return [r, r]\n  return [r.min ?? 0, r.max ?? Infinity]\n}\n\nconst isAsciiDigit = /*#__PURE__*/ codePointPredicate(\"isAsciiDigit\", (c: number): boolean => c >= 48 && c <= 57, [\n  [48, 57]\n])\nconst isAsciiHexDigit = /*#__PURE__*/ codePointPredicate(\n  \"isAsciiHexDigit\",\n  (c: number): boolean => (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102),\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\nconst isLineBreak = (c: number): boolean => c === 10 || c === 13\n\nconst expectedAny = [\"any character\"]\nconst expectedLineEnding = [\"line ending\"]\nconst expectedIdentifier = [\"identifier\"]\n\n/**\n * Builds the text parsers for an encoding.\n *\n * @example\n * ```ts\n * import { Encoding, Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const T = Text.make(Encoding.latin1)\n * Parser.parse(T.alpha1, new Uint8Array([0x63, 0x61, 0x66, 0xe9])) // \"café\"\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <I extends string | Uint8Array>(encoding: Encoding<I>): TextParsers<I> => {\n  const enc = encoding as Encoding<any>\n  const fast = internal.fastLimit(enc)\n\n  // Each parser records its encoding on byte input (`state.encoding`), so\n  // that errors can show the input as text.\n  const backtrack = (state: State<any>, kind: ErrorKind, expected: ReadonlyArray<string>, offset = state.pos): Fail =>\n    state.backtrack(kind, expected, offset)\n\n  /** The text `[start, end)` after checking it is well formed, or `Fail`. */\n  const textOf = (\n    state: State<any>,\n    start: number,\n    end: number,\n    kind: ErrorKind,\n    expected: ReadonlyArray<string>\n  ): string | Fail => {\n    const count = internal.validate(enc, state, start, end)\n    if (count < 0) return backtrack(state, kind, expected, -1 - count)\n    return enc.text(state.input, start, end)\n  }\n\n  const takeWhileText = (\n    test: (cp: number) => boolean,\n    r: Range | undefined,\n    negate: boolean,\n    name: string,\n    expected: ReadonlyArray<string>,\n    kind: ErrorKind,\n    hint: boolean,\n    set: unknown = test\n  ): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        internal.scan(enc, state, test, negate, max, state.pos, fast)\n        const offset = internal.scanOffset\n        const count = internal.scanCount\n        const stop = internal.scanStop\n        if (state.partial && (stop === internal.End || stop === internal.Truncated))\n          return state.incomplete(1, expected)\n        if (count < min) return backtrack(state, kind, expected, offset)\n        // More matching characters would have been accepted where we stopped\n        if (hint && count < max) state.setHint(offset, expected)\n        state.pos = offset\n        return enc.text(state.input, start, offset)\n      },\n      name,\n      { _tag: \"TakeWhile\", set, negate, min, max, encoding: enc }\n    )\n  }\n\n  const any: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"Token\", expectedAny)\n      state.pos += internal.width\n      return internal.charOf(cp)\n    },\n    \"any\",\n    { _tag: \"Any\", encoding: enc }\n  )\n\n  const literal = <const L extends string>(lit: L): Parser<L, never, never, I> => {\n    const encoded = enc.encode(lit)\n    const len = encoded.length\n    const expected = [JSON.stringify(lit)]\n    const node: Node = { _tag: \"Literal\", literal: lit, caseless: false, encoding: enc }\n    if (len === 1) {\n      // Single unit literals (punctuation, mostly) are compared directly\n      const unit = Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]\n      return P.described<L, never, never, I>(\n        (state: State<any>) => {\n          const pos = state.pos\n          if (state.inputKind === 1) state.encoding = enc\n          if (pos >= state.end) return state.eoi(\"Literal\", expected, 1)\n          const input = state.input\n          if ((state.inputKind === 0 ? (input as string).charCodeAt(pos) : (input as Uint8Array)[pos]) !== unit) {\n            return backtrack(state, \"Literal\", expected)\n          }\n          state.pos = pos + 1\n          return lit\n        },\n        expected[0],\n        node\n      )\n    }\n    return P.described<L, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const r = matchLiteral(state, encoded, false)\n        if (r === -1) return backtrack(state, \"Literal\", expected)\n        if (r === -2) {\n          if (state.partial) return state.incomplete(len - (state.end - state.pos), expected)\n          return backtrack(state, \"Literal\", expected)\n        }\n        state.pos += len\n        return lit\n      },\n      expected[0],\n      node\n    )\n  }\n\n  const caseless = (lit: string): Parser<string, never, never, I> => {\n    const folded = Array.from(lit, (c) => internal.fold(internal.firstCodePoint(c)))\n    const expected = [`${JSON.stringify(lit)} (case insensitive)`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let i = 0; i < folded.length; i++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End || cp === internal.Truncated) {\n            return state.partial ? state.incomplete(1, expected) : backtrack(state, \"Literal\", expected)\n          }\n          if (cp < 0 || internal.fold(cp) !== folded[i]) {\n            state.syntax?.read(pos + Math.max(internal.width, 1))\n            return backtrack(state, \"Literal\", expected)\n          }\n          pos += internal.width\n        }\n        state.pos = pos\n        return enc.text(state.input, start, pos)\n      },\n      expected[0],\n      { _tag: \"Literal\", literal: lit, caseless: true, encoding: enc }\n    )\n  }\n\n  const oneOfImpl = (set: StringTokenSet, negate: boolean): Parser<string, never, never, I> => {\n    const m = compile(set, \"string\")\n    const test = m.code\n    const expected = [negate ? `anything but ${m.description}` : m.description]\n    const kind: ErrorKind = negate ? \"NoneOf\" : \"OneOf\"\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const cp = internal.next(enc, state)\n        if (cp < 0) return internal.failAt(state, cp, kind, expected)\n        const w = internal.width\n        if (test(cp) === negate) return state.backtrack(kind, expected)\n        state.pos += w\n        return internal.charOf(cp)\n      },\n      expected[0],\n      { _tag: \"OneOf\", set, negate, encoding: enc }\n    )\n  }\n\n  const take = (count: number): Parser<string, never, never, I> => {\n    const expected = [count === 1 ? \"1 character\" : `${count} characters`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let got = 0; got < count; got++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End) return state.eoi(\"Take\", expected, count - got)\n          if (cp < 0) return internal.failAt(state, cp, \"Take\", expected, pos)\n          pos += internal.width\n        }\n        state.pos = pos\n        return enc.text(state.input, start, pos)\n      },\n      \"take\",\n      { _tag: \"Take\", count, encoding: enc }\n    )\n  }\n\n  const takeUntil = (lit: string, r?: Range): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    const needle = enc.encode(lit)\n    const unit = enc.unit\n    const expected = [JSON.stringify(lit)]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let idx = indexOf(state, needle as Input, start)\n        // Multi-unit encodings: only accept matches on a character boundary\n        while (unit > 1 && idx >= 0 && (idx - start) % unit !== 0) idx = indexOf(state, needle as Input, idx + 1)\n        if (idx < 0) {\n          if (state.partial) return state.incomplete(0, expected)\n          return backtrack(state, \"TakeUntil\", expected, state.end)\n        }\n        // The literal was read but is not consumed\n        state.syntax?.read(idx + needle.length)\n        const count = internal.validate(enc, state, start, idx)\n        if (count < 0) return backtrack(state, \"TakeUntil\", expected, -1 - count)\n        // As in winnow, the first occurrence must lie within the range\n        if (count < min) return backtrack(state, \"TakeUntil\", expected, idx)\n        if (count > max) return backtrack(state, \"TakeUntil\", expected)\n        state.pos = idx\n        return enc.text(state.input, start, idx)\n      },\n      \"takeUntil\",\n      { _tag: \"TakeUntil\", literal: lit, min, max, encoding: enc }\n    )\n  }\n\n  const always = () => true\n  const rest: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, always, false, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      if (internal.scanStop === internal.Truncated) return state.incomplete(1, expectedAny)\n      if (internal.scanStop === internal.Invalid) return backtrack(state, \"Token\", expectedAny, offset)\n      state.pos = offset\n      return enc.text(state.input, start, offset)\n    },\n    \"rest\",\n    { _tag: \"Rest\", encoding: enc }\n  )\n\n  const taken = <A, E, R>(self: Parser<A, E, R, I>): Parser<string, E, R, I> => {\n    const step = self.step\n    return P.described<string, E, R, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        if (step(state) === Fail) return Fail\n        return textOf(state, start, state.pos, \"Slice\", expectedAny)\n      },\n      self.name,\n      { _tag: \"Taken\", self, encoding: enc }\n    )\n  }\n\n  const cls = (test: CharPredicate, min: 0 | 1, description: string, kind: ErrorKind, hint = true) =>\n    takeWhileText(test as any, { min }, false, `${kind.toLowerCase()}${min}`, [description], kind, hint)\n\n  const identifierStart = (cp: number) => cp === 95 || isIdStart(cp)\n  const identifier: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"TakeWhile\", expectedIdentifier)\n      if (!identifierStart(cp)) return state.backtrack(\"TakeWhile\", expectedIdentifier)\n      internal.scan(enc, state, isIdContinue as any, false, Infinity, start + internal.width, fast)\n      const stop = internal.scanStop\n      if (state.partial && (stop === internal.End || stop === internal.Truncated)) {\n        return state.incomplete(1, expectedIdentifier)\n      }\n      state.pos = internal.scanOffset\n      return enc.text(state.input, start, state.pos)\n    },\n    \"identifier\",\n    { _tag: \"Identifier\", encoding: enc }\n  )\n\n  // Decoded rather than matched as a literal, as not every encoding can encode it\n  const bom: Parser<boolean, never, never, I> = P.described<boolean, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp === 0xfeff) {\n        state.pos += internal.width\n        return true\n      }\n      if (cp === internal.Truncated || (cp === internal.End && state.partial)) {\n        return state.incomplete(1, [\"byte order mark\"])\n      }\n      return false\n    },\n    \"bom\",\n    { _tag: \"Bom\", encoding: enc }\n  )\n\n  const newline = literal(\"\\n\")\n  const crlf = literal(\"\\r\\n\")\n\n  const tillLineEnding: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, isLineBreak, true, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      const stop = internal.scanStop\n      if (stop === internal.Truncated || (stop === internal.End && state.partial)) {\n        return state.incomplete(1, expectedLineEnding)\n      }\n      if (stop === internal.Invalid) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      if (stop === 0 && internal.next(enc, state, offset) === 13) {\n        const cr = internal.width\n        // The line feed after it is read, not consumed\n        state.syntax?.read(offset + 2 * cr)\n        const after = internal.next(enc, state, offset + cr)\n        if (after === internal.End && state.partial) return state.incomplete(1, expectedLineEnding)\n        if (after !== 10) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      }\n      state.pos = offset\n      return enc.text(state.input, start, offset)\n    },\n    \"tillLineEnding\",\n    { _tag: \"TillLineEnding\", encoding: enc }\n  )\n\n  const asciiDigits = takeWhileText(isAsciiDigit, { min: 1 }, false, \"digit1\", [\"digit\"], \"Digit\", true)\n  const hexDigits = takeWhileText(\n    isAsciiHexDigit,\n    { min: 1 },\n    false,\n    \"hexDigit1\",\n    [\"hexadecimal digit\"],\n    \"HexDigit\",\n    true\n  )\n  const sign = P.opt(oneOfImpl(\"+-\", false))\n  const signed = taken(P.seq(sign, asciiDigits))\n\n  const exponent = P.opt(P.seq(oneOfImpl(\"eE\", false), sign, asciiDigits))\n  const unsignedFloat = P.alt(\n    P.seq(caseless(\"inf\"), P.opt(caseless(\"inity\"))),\n    P.seq(literal(\".\"), asciiDigits, exponent),\n    P.seq(asciiDigits, P.opt(P.seq(literal(\".\"), P.opt(asciiDigits))), exponent)\n  )\n  const floatText = markFloatText(taken(P.alt(caseless(\"nan\"), P.seq(sign, unsignedFloat))).pipe(P.expected(\"number\")))\n\n  const matchControl = (control: string) => {\n    const ctrl = control.codePointAt(0)\n    return (state: State<any>): boolean => {\n      if (internal.next(enc, state) !== ctrl) return false\n      state.pos += internal.width\n      return true\n    }\n  }\n\n  return {\n    encoding,\n    any,\n    literal,\n    caseless,\n    oneOf: (set) => oneOfImpl(set, false),\n    noneOf: (set) => oneOfImpl(set, true),\n    bom,\n    take,\n    takeWhile: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, false, \"takeWhile\", [m.description], \"TakeWhile\", false, set)\n    },\n    takeTill: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, true, \"takeTill\", [`anything but ${m.description}`], \"TakeWhile\", false, set)\n    },\n    takeUntil,\n    rest,\n    taken,\n    alpha0: cls(isAlphabetic, 0, \"letter\", \"Alpha\"),\n    alpha1: cls(isAlphabetic, 1, \"letter\", \"Alpha\"),\n    digit0: cls(isDecimalDigit, 0, \"digit\", \"Digit\"),\n    digit1: cls(isDecimalDigit, 1, \"digit\", \"Digit\"),\n    alphanumeric0: cls(isAlphanumeric, 0, \"letter or digit\", \"AlphaNumeric\"),\n    alphanumeric1: cls(isAlphanumeric, 1, \"letter or digit\", \"AlphaNumeric\"),\n    space0: cls(isSpace, 0, \"space\", \"Space\", false),\n    space1: cls(isSpace, 1, \"space\", \"Space\", false),\n    multispace0: cls(isWhitespace, 0, \"whitespace\", \"MultiSpace\", false),\n    multispace1: cls(isWhitespace, 1, \"whitespace\", \"MultiSpace\", false),\n    identifier,\n    newline,\n    crlf,\n    tab: literal(\"\\t\"),\n    lineEnding: P.alt(newline, crlf).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint: asciiDigits.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decUint\")\n    ),\n    decInt: signed.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decInt\")\n    ),\n    decBigUint: asciiDigits.pipe(P.map((s) => BigInt(s))),\n    decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith(\"+\") ? s.slice(1) : s))),\n    hexUint: hexDigits.pipe(\n      P.tryMap((s) => overflow(parseInt(s, 16))),\n      P.named(\"hexUint\")\n    ),\n    float: floatText.pipe(P.map(toFloat), P.named(\"float\")),\n    takeEscaped: (normal, control, escapable) =>\n      takeEscapedImpl(\n        normal,\n        matchControl(control),\n        escapable,\n        (state, start) => enc.text(state.input, start, state.pos),\n        internal.firstCodePoint(control),\n        enc\n      ),\n    escaped: (normal, control, escape) =>\n      escapedImpl(normal, matchControl(control), escape, internal.firstCodePoint(control), enc)\n  }\n}\n\n/**\n * Text parsers for JavaScript strings.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const string: TextParsers<string> = /*#__PURE__*/ make(Encodings.string)\n\n/**\n * Text parsers for UTF-8 encoded bytes.\n *\n * @example\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const bytes = new TextEncoder().encode(\"naïve café\")\n * Parser.parse(Parser.separatedPair(Text.utf8.alpha1, Text.utf8.space1, Text.utf8.alpha1), bytes)\n * // Result.succeed([\"naïve\", \"café\"])\n * ```\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf8: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf8)\n\n/**\n * Text parsers for UTF-16 little endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16le: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16le)\n\n/**\n * Text parsers for UTF-16 big endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16be: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16be)\n\n/**\n * Text parsers for ISO-8859-1 (Latin-1) bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const latin1: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.latin1)\n"],"mappings":"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"}
+{"version":3,"file":"Text.js","names":["floatText","markFloatText","toFloat"],"sources":["../src/Text.ts"],"sourcesContent":["/**\n * Unicode text parsers, generic over the input's encoding.\n *\n * `Text.make(encoding)` builds one set of parsers ({@link TextParsers}) for\n * an {@link Encoding.Encoding}, and ready-made sets are provided for\n * JavaScript strings and the common byte encodings:\n *\n * | Parsers | Input | Offsets |\n * |---|---|---|\n * | `Text.string` | `string` | UTF-16 code units |\n * | `Text.utf8` | `Uint8Array` of UTF-8 | bytes |\n * | `Text.utf16le`, `Text.utf16be` | `Uint8Array` of UTF-16 | bytes |\n * | `Text.latin1` | `Uint8Array` of ISO-8859-1 | bytes |\n *\n * Every set has the same members, and every parser returns `string`s, so a\n * grammar written against `TextParsers<I>` parses all of them:\n *\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greeting = <I extends string | Uint8Array>(T: Text.TextParsers<I>) =>\n *   Parser.preceded(T.literal(\"¡hola \"), T.identifier)\n *\n * Parser.parse(greeting(Text.string), \"¡hola mundo\")                           // \"mundo\"\n * Parser.parse(greeting(Text.utf8), new TextEncoder().encode(\"¡hola Zoë\"))    // \"Zoë\"\n * ```\n *\n * Tokens are Unicode code points, and character classes follow Unicode\n * properties: `alpha1` matches `\"Ωμέγα\"`, `space1` matches a no-break space.\n * Use the `Ascii` module for the ASCII-only classes.\n *\n * Decoding is strict. Malformed input (invalid UTF-8, unpaired surrogates)\n * never matches, and error messages point at it. On partial input, a\n * character split across chunks reports `Incomplete`, so byte streams can be\n * parsed as text without decoding them first.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"./Encoding.js\"\nimport * as Encodings from \"./Encoding.js\"\nimport type { State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport { escapedImpl, overflow, takeEscapedImpl, toFloat } from \"./Ascii.js\"\nimport { codePointPredicate, compile, indexOf, matchLiteral } from \"./internal/tokens.js\"\nimport { floatText as markFloatText } from \"./internal/numbers.js\"\nimport * as internal from \"./internal/text.js\"\nimport type { Node } from \"./internal/node.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport type { StringTokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Unicode predicates\n// -----------------------------------------------------------------------------\n\n/**\n * A predicate over characters. It accepts a one-character string or a code\n * point.\n *\n * @since 0.1.0\n * @category models\n */\nexport type CharPredicate = (char: string | number) => boolean\n\nconst toCodePoint = (c: string | number): number => (Predicate.isNumber(c) ? c : (c.codePointAt(0) ?? -1))\n\nconst makePredicate = (name: string, re: RegExp): CharPredicate => {\n  // Results for the Basic Multilingual Plane are cached: a table lookup is\n  // much faster than a regular expression test.\n  let ascii: Uint8Array | undefined\n  let bmp: Uint8Array | undefined\n  return codePointPredicate(name, (c: string | number): boolean => {\n    const x = toCodePoint(c)\n    if (x < 0) return false\n    let table: Uint8Array\n    if (x < 128) table = ascii ??= new Uint8Array(128)\n    else if (x < 0x10000) table = bmp ??= new Uint8Array(0x10000)\n    else return re.test(String.fromCodePoint(x))\n    let v = table[x]\n    if (v === 0) table[x] = v = re.test(String.fromCharCode(x)) ? 2 : 1\n    return v === 2\n  })\n}\n\n/**\n * A predicate testing a Unicode property, using the syntax of regular\n * expression property escapes (`\\p{...}`): a general category (`\"Lu\"`,\n * `\"Letter\"`), a binary property (`\"Emoji\"`, `\"Dash\"`) or a script\n * (`\"Script=Greek\"`).\n *\n * @example\n * ```ts\n * import { Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greek = Text.string.takeWhile(Text.property(\"Script=Greek\"), { min: 1 })\n * ```\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const property = (name: string): CharPredicate => makePredicate(name, new RegExp(`^\\\\p{${name}}$`, \"u\"))\n\n/**\n * Letters and other alphabetic characters (the Unicode `Alphabetic`\n * property, Rust's `char::is_alphabetic`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphabetic: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphabetic\", /^\\p{Alphabetic}$/u)\n\n/**\n * Letters (general category `L`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLetter: CharPredicate = /*#__PURE__*/ makePredicate(\"isLetter\", /^\\p{L}$/u)\n\n/**\n * Uppercase characters (the Unicode `Uppercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isUppercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isUppercase\", /^\\p{Uppercase}$/u)\n\n/**\n * Lowercase characters (the Unicode `Lowercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLowercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isLowercase\", /^\\p{Lowercase}$/u)\n\n/**\n * Decimal digits of any script (general category `Nd`): `0`–`9`, `٠`–`٩`,\n * `०`–`९`, ...\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDecimalDigit: CharPredicate = /*#__PURE__*/ makePredicate(\"isDecimalDigit\", /^\\p{Nd}$/u)\n\n/**\n * Numeric characters (general category `N`), including `½` and `Ⅻ` (Rust's\n * `char::is_numeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isNumeric\", /^\\p{N}$/u)\n\n/**\n * Alphabetic or numeric characters (Rust's `char::is_alphanumeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphanumeric\", /^[\\p{Alphabetic}\\p{N}]$/u)\n\n/**\n * Whitespace, including line breaks (the Unicode `White_Space` property,\n * Rust's `char::is_whitespace`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWhitespace: CharPredicate = /*#__PURE__*/ makePredicate(\"isWhitespace\", /^\\p{White_Space}$/u)\n\n/**\n * Whitespace that does not break lines: `White_Space` except `\\n`, `\\v`,\n * `\\f`, `\\r`, U+0085, U+2028 and U+2029. Includes tabs and no-break spaces.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: CharPredicate = /*#__PURE__*/ makePredicate(\n  \"isSpace\",\n  /^(?![\\n\\v\\f\\r\\u0085\\u2028\\u2029])\\p{White_Space}$/u\n)\n\n/**\n * Characters that can start an identifier (the Unicode `ID_Start` property,\n * see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdStart: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdStart\", /^\\p{ID_Start}$/u)\n\n/**\n * Characters that can continue an identifier (the Unicode `ID_Continue`\n * property, see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdContinue: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdContinue\", /^\\p{ID_Continue}$/u)\n\n/**\n * Punctuation (general category `P`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isPunctuation: CharPredicate = /*#__PURE__*/ makePredicate(\"isPunctuation\", /^\\p{P}$/u)\n\n/**\n * Control characters (general category `Cc`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isControl: CharPredicate = /*#__PURE__*/ makePredicate(\"isControl\", /^\\p{Cc}$/u)\n\n// -----------------------------------------------------------------------------\n// Parsers\n// -----------------------------------------------------------------------------\n\n/**\n * The text parsers for one encoding. Build a set with {@link make}, or use\n * {@link string}, {@link utf8}, {@link utf16le}, {@link utf16be} or\n * {@link latin1}.\n *\n * Every parser returns text as a `string`, whatever the input. To keep a\n * slice of a byte input as bytes instead, use `Parser.taken`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TextParsers<I extends string | Uint8Array> {\n  /** The encoding these parsers read. */\n  readonly encoding: Encoding<I>\n\n  // Tokens\n\n  /** Any single character (code point). */\n  readonly any: Parser<string, never, never, I>\n  /**\n   * A literal string, returned as written. On byte inputs it is matched in\n   * its encoded form.\n   */\n  readonly literal: <const L extends string>(literal: L) => Parser<L, never, never, I>\n  /**\n   * A literal string, ignoring case (by simple Unicode case folding, so\n   * `\"straße\"` matches `\"STRAßE\"` but not `\"STRASSE\"`). Returns the input as\n   * written.\n   */\n  readonly caseless: (literal: string) => Parser<string, never, never, I>\n  /** One character belonging to a set (the characters of a string, a range, a predicate, or an array of these). */\n  readonly oneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** One character *not* belonging to a set. */\n  readonly noneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** An optional byte order mark, U+FEFF. Returns whether one was present. */\n  readonly bom: Parser<boolean, never, never, I>\n\n  // Slices\n\n  /** Exactly `count` characters. */\n  readonly take: (count: number) => Parser<string, never, never, I>\n  /** The longest run of characters belonging to a set, with a count in `range` (default: any). */\n  readonly takeWhile: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** The longest run of characters *not* belonging to a set, with a count in `range`. */\n  readonly takeTill: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** Characters up to (not including) the first occurrence of a literal. */\n  readonly takeUntil: (literal: string, range?: Range) => Parser<string, never, never, I>\n  /** The rest of the input. */\n  readonly rest: Parser<string, never, never, I>\n  /**\n   * Runs a parser and returns the text it consumed (`Parser.taken`, decoded\n   * to a `string`).\n   */\n  readonly taken: <A, E, R>(self: Parser<A, E, R, I>) => Parser<string, E, R, I>\n\n  // Character classes\n\n  /** Zero or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha0: Parser<string, never, never, I>\n  /** One or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha1: Parser<string, never, never, I>\n  /** Zero or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit0: Parser<string, never, never, I>\n  /** One or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit1: Parser<string, never, never, I>\n  /** Zero or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric0: Parser<string, never, never, I>\n  /** One or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric1: Parser<string, never, never, I>\n  /** Zero or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space0: Parser<string, never, never, I>\n  /** One or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space1: Parser<string, never, never, I>\n  /** Zero or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace0: Parser<string, never, never, I>\n  /** One or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace1: Parser<string, never, never, I>\n  /**\n   * An identifier: an {@link isIdStart} character or `_`, then any\n   * {@link isIdContinue} characters (UAX #31 default identifiers).\n   */\n  readonly identifier: Parser<string, never, never, I>\n\n  // Line endings\n\n  /** `\\n` */\n  readonly newline: Parser<\"\\n\", never, never, I>\n  /** `\\r\\n` */\n  readonly crlf: Parser<\"\\r\\n\", never, never, I>\n  /** `\\t` */\n  readonly tab: Parser<\"\\t\", never, never, I>\n  /** `\\n` or `\\r\\n`. */\n  readonly lineEnding: Parser<\"\\n\" | \"\\r\\n\", never, never, I>\n  /** Everything up to (not including) a line ending. A `\\r` not followed by `\\n` is an error. */\n  readonly tillLineEnding: Parser<string, never, never, I>\n\n  // Numbers (ASCII digits, as in most languages)\n\n  /** An unsigned decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decUint: Parser<number, string, never, I>\n  /** A signed decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decInt: Parser<number, string, never, I>\n  /** An unsigned decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigUint: Parser<bigint, never, never, I>\n  /** A signed decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigInt: Parser<bigint, never, never, I>\n  /** A hexadecimal unsigned integer, without prefix. Fails if it is not a safe integer. */\n  readonly hexUint: Parser<number, string, never, I>\n  /** A floating point number, as accepted by `Ascii.float`. */\n  readonly float: Parser<number, never, never, I>\n\n  // Escapes\n\n  /**\n   * Recognizes text containing escape sequences, returning it raw (see\n   * `Ascii.takeEscaped`). `control` is the escape character.\n   */\n  readonly takeEscaped: <A, E, R, B, E2, R2>(\n    normal: Parser<A, E, R, I>,\n    control: string,\n    escapable: Parser<B, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n  /**\n   * Parses text containing escape sequences, returning it unescaped (see\n   * `Ascii.escaped`). `control` is the escape character.\n   */\n  readonly escaped: <E, R, E2, R2>(\n    normal: Parser<string, E, R, I>,\n    control: string,\n    escape: Parser<string, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  if (r === undefined) return [0, Infinity]\n  if (Predicate.isNumber(r)) return [r, r]\n  return [r.min ?? 0, r.max ?? Infinity]\n}\n\nconst isAsciiDigit = /*#__PURE__*/ codePointPredicate(\"isAsciiDigit\", (c: number): boolean => c >= 48 && c <= 57, [\n  [48, 57]\n])\nconst isAsciiHexDigit = /*#__PURE__*/ codePointPredicate(\n  \"isAsciiHexDigit\",\n  (c: number): boolean => (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102),\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\nconst isLineBreak = (c: number): boolean => c === 10 || c === 13\n\nconst expectedAny = [\"any character\"]\nconst expectedLineEnding = [\"line ending\"]\nconst expectedIdentifier = [\"identifier\"]\n\n/**\n * Builds the text parsers for an encoding.\n *\n * @example\n * ```ts\n * import { Encoding, Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const T = Text.make(Encoding.latin1)\n * Parser.parse(T.alpha1, new Uint8Array([0x63, 0x61, 0x66, 0xe9])) // \"café\"\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <I extends string | Uint8Array>(encoding: Encoding<I>): TextParsers<I> => {\n  const enc = encoding\n  const fast = internal.fastLimit(enc)\n\n  // Each parser records its encoding on byte input (`state.encoding`), so\n  // that errors can show the input as text.\n  const backtrack = (state: State<any>, kind: ErrorKind, expected: ReadonlyArray<string>, offset = state.pos): Fail =>\n    state.backtrack(kind, expected, offset)\n\n  /** The text `[start, end)` after checking it is well formed, or `Fail`. */\n  const textOf = (\n    state: State<any>,\n    start: number,\n    end: number,\n    kind: ErrorKind,\n    expected: ReadonlyArray<string>\n  ): string | Fail => {\n    const count = internal.validate(enc, state, start, end)\n    if (count < 0) return backtrack(state, kind, expected, -1 - count)\n    return internal.textIn(enc, state, start, end)\n  }\n\n  const takeWhileText = (\n    test: (cp: number) => boolean,\n    r: Range | undefined,\n    negate: boolean,\n    name: string,\n    expected: ReadonlyArray<string>,\n    kind: ErrorKind,\n    hint: boolean,\n    set: unknown = test\n  ): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        internal.scan(enc, state, test, negate, max, state.pos, fast)\n        const offset = internal.scanOffset\n        const count = internal.scanCount\n        const stop = internal.scanStop\n        if (state.partial && (stop === internal.End || stop === internal.Truncated))\n          return state.incomplete(1, expected)\n        if (count < min) return backtrack(state, kind, expected, offset)\n        // More matching characters would have been accepted where we stopped\n        if (hint && count < max) state.setHint(offset, expected)\n        state.pos = offset\n        return internal.textIn(enc, state, start, offset)\n      },\n      name,\n      { _tag: \"TakeWhile\", set, negate, min, max, encoding: enc }\n    )\n  }\n\n  const any: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"Token\", expectedAny)\n      state.pos += internal.width\n      return internal.charOf(cp)\n    },\n    \"any\",\n    { _tag: \"Any\", encoding: enc }\n  )\n\n  const literal = <const L extends string>(lit: L): Parser<L, never, never, I> => {\n    const encoded = enc.encode(lit)\n    const len = encoded.length\n    const expected = [JSON.stringify(lit)]\n    const node: Node = { _tag: \"Literal\", literal: lit, caseless: false, encoding: enc }\n    if (len === 1) {\n      // Single unit literals (punctuation, mostly) are compared directly\n      const unit = Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]\n      return P.described<L, never, never, I>(\n        (state: State<any>) => {\n          const pos = state.pos\n          if (state.inputKind === 1) state.encoding = enc\n          if (pos >= state.end) return state.eoi(\"Literal\", expected, 1)\n          const input = state.input\n          // SAFETY: a `Text` parser runs on strings or `Uint8Array`s, and `inputKind` 0 is set only for a string\n          if ((state.inputKind === 0 ? (input as string).charCodeAt(pos) : (input as Uint8Array)[pos]) !== unit) {\n            return backtrack(state, \"Literal\", expected)\n          }\n          state.pos = pos + 1\n          return lit\n        },\n        expected[0],\n        node\n      )\n    }\n    return P.described<L, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const r = matchLiteral(state, encoded, false)\n        if (r === -1) return backtrack(state, \"Literal\", expected)\n        if (r === -2) {\n          if (state.partial) return state.incomplete(len - (state.end - state.pos), expected)\n          return backtrack(state, \"Literal\", expected)\n        }\n        state.pos += len\n        return lit\n      },\n      expected[0],\n      node\n    )\n  }\n\n  const caseless = (lit: string): Parser<string, never, never, I> => {\n    const folded = Array.from(lit, (c) => internal.fold(internal.firstCodePoint(c)))\n    const expected = [`${JSON.stringify(lit)} (case insensitive)`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let i = 0; i < folded.length; i++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End || cp === internal.Truncated) {\n            return state.partial ? state.incomplete(1, expected) : backtrack(state, \"Literal\", expected)\n          }\n          if (cp < 0 || internal.fold(cp) !== folded[i]) {\n            state.syntax?.read(pos + Math.max(internal.width, 1))\n            return backtrack(state, \"Literal\", expected)\n          }\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      expected[0],\n      { _tag: \"Literal\", literal: lit, caseless: true, encoding: enc }\n    )\n  }\n\n  const oneOfImpl = (set: StringTokenSet, negate: boolean): Parser<string, never, never, I> => {\n    const m = compile(set, \"string\")\n    const test = m.code\n    const expected = [negate ? `anything but ${m.description}` : m.description]\n    const kind: ErrorKind = negate ? \"NoneOf\" : \"OneOf\"\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const cp = internal.next(enc, state)\n        if (cp < 0) return internal.failAt(state, cp, kind, expected)\n        const w = internal.width\n        if (test(cp) === negate) return state.backtrack(kind, expected)\n        state.pos += w\n        return internal.charOf(cp)\n      },\n      expected[0],\n      { _tag: \"OneOf\", set, negate, encoding: enc }\n    )\n  }\n\n  const take = (count: number): Parser<string, never, never, I> => {\n    const expected = [count === 1 ? \"1 character\" : `${count} characters`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let got = 0; got < count; got++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End) return state.eoi(\"Take\", expected, count - got)\n          if (cp < 0) return internal.failAt(state, cp, \"Take\", expected, pos)\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      \"take\",\n      { _tag: \"Take\", count, encoding: enc }\n    )\n  }\n\n  const takeUntil = (lit: string, r?: Range): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    const needle = enc.encode(lit)\n    const unit = enc.unit\n    const expected = [JSON.stringify(lit)]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let idx = indexOf(state, needle, start)\n        // Multi-unit encodings: only accept matches on a character boundary\n        while (unit > 1 && idx >= 0 && (idx - start) % unit !== 0) idx = indexOf(state, needle, idx + 1)\n        if (idx < 0) {\n          if (state.partial) return state.incomplete(0, expected)\n          return backtrack(state, \"TakeUntil\", expected, state.end)\n        }\n        // The literal was read but is not consumed\n        state.syntax?.read(idx + needle.length)\n        const count = internal.validate(enc, state, start, idx)\n        if (count < 0) return backtrack(state, \"TakeUntil\", expected, -1 - count)\n        // As in winnow, the first occurrence must lie within the range\n        if (count < min) return backtrack(state, \"TakeUntil\", expected, idx)\n        if (count > max) return backtrack(state, \"TakeUntil\", expected)\n        state.pos = idx\n        return internal.textIn(enc, state, start, idx)\n      },\n      \"takeUntil\",\n      { _tag: \"TakeUntil\", literal: lit, min, max, encoding: enc }\n    )\n  }\n\n  const always = () => true\n  const rest: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, always, false, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      if (internal.scanStop === internal.Truncated) return state.incomplete(1, expectedAny)\n      if (internal.scanStop === internal.Invalid) return backtrack(state, \"Token\", expectedAny, offset)\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"rest\",\n    { _tag: \"Rest\", encoding: enc }\n  )\n\n  const taken = <A, E, R>(self: Parser<A, E, R, I>): Parser<string, E, R, I> => {\n    const step = self.step\n    return P.described<string, E, R, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        if (step(state) === Fail) return Fail\n        return textOf(state, start, state.pos, \"Slice\", expectedAny)\n      },\n      self.name,\n      { _tag: \"Taken\", self, encoding: enc }\n    )\n  }\n\n  const cls = (test: CharPredicate, min: 0 | 1, description: string, kind: ErrorKind, hint = true) =>\n    takeWhileText(test, { min }, false, `${kind.toLowerCase()}${min}`, [description], kind, hint)\n\n  const identifierStart = (cp: number) => cp === 95 || isIdStart(cp)\n  const identifier: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"TakeWhile\", expectedIdentifier)\n      if (!identifierStart(cp)) return state.backtrack(\"TakeWhile\", expectedIdentifier)\n      internal.scan(enc, state, isIdContinue, false, Infinity, start + internal.width, fast)\n      const stop = internal.scanStop\n      if (state.partial && (stop === internal.End || stop === internal.Truncated)) {\n        return state.incomplete(1, expectedIdentifier)\n      }\n      state.pos = internal.scanOffset\n      return internal.textIn(enc, state, start, state.pos)\n    },\n    \"identifier\",\n    { _tag: \"Identifier\", encoding: enc }\n  )\n\n  // Decoded rather than matched as a literal, as not every encoding can encode it\n  const bom: Parser<boolean, never, never, I> = P.described<boolean, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp === 0xfeff) {\n        state.pos += internal.width\n        return true\n      }\n      if (cp === internal.Truncated || (cp === internal.End && state.partial)) {\n        return state.incomplete(1, [\"byte order mark\"])\n      }\n      return false\n    },\n    \"bom\",\n    { _tag: \"Bom\", encoding: enc }\n  )\n\n  const newline = literal(\"\\n\")\n  const crlf = literal(\"\\r\\n\")\n\n  const tillLineEnding: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, isLineBreak, true, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      const stop = internal.scanStop\n      if (stop === internal.Truncated || (stop === internal.End && state.partial)) {\n        return state.incomplete(1, expectedLineEnding)\n      }\n      if (stop === internal.Invalid) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      if (stop === 0 && internal.next(enc, state, offset) === 13) {\n        const cr = internal.width\n        // The line feed after it is read, not consumed\n        state.syntax?.read(offset + 2 * cr)\n        const after = internal.next(enc, state, offset + cr)\n        if (after === internal.End && state.partial) return state.incomplete(1, expectedLineEnding)\n        if (after !== 10) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      }\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"tillLineEnding\",\n    { _tag: \"TillLineEnding\", encoding: enc }\n  )\n\n  const asciiDigits = takeWhileText(isAsciiDigit, { min: 1 }, false, \"digit1\", [\"digit\"], \"Digit\", true)\n  const hexDigits = takeWhileText(\n    isAsciiHexDigit,\n    { min: 1 },\n    false,\n    \"hexDigit1\",\n    [\"hexadecimal digit\"],\n    \"HexDigit\",\n    true\n  )\n  const sign = P.opt(oneOfImpl(\"+-\", false))\n  const signed = taken(P.seq(sign, asciiDigits))\n\n  const exponent = P.opt(P.seq(oneOfImpl(\"eE\", false), sign, asciiDigits))\n  const unsignedFloat = P.alt(\n    P.seq(caseless(\"inf\"), P.opt(caseless(\"inity\"))),\n    P.seq(literal(\".\"), asciiDigits, exponent),\n    P.seq(asciiDigits, P.opt(P.seq(literal(\".\"), P.opt(asciiDigits))), exponent)\n  )\n  const floatText = markFloatText(taken(P.alt(caseless(\"nan\"), P.seq(sign, unsignedFloat))).pipe(P.expected(\"number\")))\n\n  const matchControl = (control: string) => {\n    const ctrl = control.codePointAt(0)\n    return (state: State<any>): boolean => {\n      if (internal.next(enc, state) !== ctrl) return false\n      state.pos += internal.width\n      return true\n    }\n  }\n\n  return {\n    encoding,\n    any,\n    literal,\n    caseless,\n    oneOf: (set) => oneOfImpl(set, false),\n    noneOf: (set) => oneOfImpl(set, true),\n    bom,\n    take,\n    takeWhile: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, false, \"takeWhile\", [m.description], \"TakeWhile\", false, set)\n    },\n    takeTill: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, true, \"takeTill\", [`anything but ${m.description}`], \"TakeWhile\", false, set)\n    },\n    takeUntil,\n    rest,\n    taken,\n    alpha0: cls(isAlphabetic, 0, \"letter\", \"Alpha\"),\n    alpha1: cls(isAlphabetic, 1, \"letter\", \"Alpha\"),\n    digit0: cls(isDecimalDigit, 0, \"digit\", \"Digit\"),\n    digit1: cls(isDecimalDigit, 1, \"digit\", \"Digit\"),\n    alphanumeric0: cls(isAlphanumeric, 0, \"letter or digit\", \"AlphaNumeric\"),\n    alphanumeric1: cls(isAlphanumeric, 1, \"letter or digit\", \"AlphaNumeric\"),\n    space0: cls(isSpace, 0, \"space\", \"Space\", false),\n    space1: cls(isSpace, 1, \"space\", \"Space\", false),\n    multispace0: cls(isWhitespace, 0, \"whitespace\", \"MultiSpace\", false),\n    multispace1: cls(isWhitespace, 1, \"whitespace\", \"MultiSpace\", false),\n    identifier,\n    newline,\n    crlf,\n    tab: literal(\"\\t\"),\n    lineEnding: P.alt(newline, crlf).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint: asciiDigits.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decUint\")\n    ),\n    decInt: signed.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decInt\")\n    ),\n    decBigUint: asciiDigits.pipe(P.map((s) => BigInt(s))),\n    decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith(\"+\") ? s.slice(1) : s))),\n    hexUint: hexDigits.pipe(\n      P.tryMap((s) => overflow(parseInt(s, 16))),\n      P.named(\"hexUint\")\n    ),\n    float: floatText.pipe(P.map(toFloat), P.named(\"float\")),\n    takeEscaped: (normal, control, escapable) =>\n      takeEscapedImpl(\n        normal,\n        matchControl(control),\n        escapable,\n        (state, start) => internal.textIn(enc, state, start, state.pos),\n        internal.firstCodePoint(control),\n        enc\n      ),\n    escaped: (normal, control, escape) =>\n      escapedImpl(normal, matchControl(control), escape, internal.firstCodePoint(control), enc)\n  }\n}\n\n/**\n * Text parsers for JavaScript strings.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const string: TextParsers<string> = /*#__PURE__*/ make(Encodings.string)\n\n/**\n * Text parsers for UTF-8 encoded bytes.\n *\n * @example\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const bytes = new TextEncoder().encode(\"naïve café\")\n * Parser.parse(Parser.separatedPair(Text.utf8.alpha1, Text.utf8.space1, Text.utf8.alpha1), bytes)\n * // Result.succeed([\"naïve\", \"café\"])\n * ```\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf8: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf8)\n\n/**\n * Text parsers for UTF-16 little endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16le: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16le)\n\n/**\n * Text parsers for UTF-16 big endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16be: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16be)\n\n/**\n * Text parsers for ISO-8859-1 (Latin-1) bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const latin1: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.latin1)\n"],"mappings":"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"}