@thomasfosterau/effect-parse 0.4.1 → 0.6.0

package/dist/internal/compiler/first.js

@@ -1,7 +1,7 @@
 import * as Predicate from "effect/Predicate";
+import { nodeOf } from "../node.js";
 import { fastLimit, isEmptyUnits } from "../text.js";
 import * as Arr from "effect/Array";
-import { nodeOf } from "../node.js";
 import { TableSize, kindOfEncoding, reachesAbove, textSet, tokenSet } from "./sets.js";
 // src/internal/compiler/first.ts
 /**
@@ -157,13 +157,17 @@ var FirstSets = class {
 			case "Tap":
 			case "TryMap":
 			case "FilterMap":
+			case "MapOrFail":
 			case "Filter":
 			case "Taken":
 			case "WithTaken":
 			case "Span":
 			case "WithSpan":
+			case "MapSpan":
 			case "Context":
 			case "Expected":
+			case "Quiet":
+			case "FastPath":
 			case "MapError":
 			case "OrFail":
 			case "Peek":
@@ -181,13 +185,15 @@ var FirstSets = class {
 				const f = this.of(node.self);
 				return node.from === "Backtrack" ? f.mode === Unknown ? f : unknown : f;
 			}
+			case "Not":
 			case "Opt":
 			case "OrElseSucceed": {
 				const f = this.of(node.self);
 				return f.mode === Unknown ? f : withMode(f, Optional);
 			}
 			case "Seq":
-			case "Struct": return this.sequence(node.parsers);
+			case "Struct":
+			case "SeqWith": return this.sequence(node.parsers);
 			case "ZipWith": return this.sequence([node.self, node.that]);
 			case "Alt": {
 				if (Arr.isReadonlyArrayEmpty(node.parsers)) return failing;
@@ -210,6 +216,7 @@ var FirstSets = class {
 				return node.min === 0 ? withMode(f, Optional) : f;
 			}
 			case "Suspend": return this.of(node.resolve());
+			case "Fixed": return kind !== 1 ? unknown : node.size === 0 ? emptyOptional : anyUnit;
 			default: return unknown;
 		}
 	}

package/dist/internal/compiler/first.js.map

@@ -1 +1 @@
-{"version":3,"file":"first.js","names":[],"sources":["../../../src/internal/compiler/first.ts"],"sourcesContent":["/**\n * First sets: which input units can start a match of a parser.\n *\n * A first set has a mode:\n *\n * - `Strict`: when the next unit is not in `units` (or the input has\n *   ended), the parser fails with `Backtrack`.\n * - `Optional`: in that case, the parser either fails with `Backtrack` or\n *   succeeds without consuming input.\n * - `Unknown`: no guarantee.\n *\n * Units are UTF-16 code units for strings and bytes for byte inputs; units\n * from `TableSize` up are summarized by `high`. Array inputs have no units.\n *\n * Skipping a parser that is certain to fail also skips the callbacks it\n * would have run before failing, which is why callbacks must be pure.\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"../../Encoding.js\"\nimport type { Node, ParserLike } from \"../node.js\"\nimport { nodeOf } from \"../node.js\"\nimport { fastLimit, isEmptyUnits } from \"../text.js\"\nimport type { CharSet } from \"./sets.js\"\nimport { kindOfEncoding, reachesAbove, TableSize, textSet, tokenSet } from \"./sets.js\"\n\nexport const Strict = 0\nconst Optional = 1\nconst Unknown = 2\n\nexport interface First {\n  readonly mode: 0 | 1 | 2\n  readonly units: Uint8Array\n  readonly high: boolean\n}\n\nconst none = /*#__PURE__*/ new Uint8Array(TableSize)\nconst all = /*#__PURE__*/ new Uint8Array(TableSize).fill(1)\n\nconst unknown: First = { mode: Unknown, units: all, high: true }\nconst emptyOptional: First = { mode: Optional, units: none, high: false }\nconst failing: First = { mode: Strict, units: none, high: false }\nconst anyUnit: First = { mode: Strict, units: all, high: true }\n\nconst union = (a: First, b: First, mode: 0 | 1 | 2): First => {\n  const units = new Uint8Array(TableSize)\n  for (let i = 0; i < TableSize; i++) units[i] = a.units[i] | b.units[i]\n  return { mode, units, high: a.high || b.high }\n}\n\nconst withMode = (f: First, mode: 0 | 1 | 2): First => (f.mode === mode ? f : { ...f, mode })\n\nconst lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)\nconst upperAscii = (c: number): number => (c >= 97 && c <= 122 ? c - 32 : c)\n\nconst ofUnits = (codes: ReadonlyArray<number>, mode: 0 | 1 | 2 = Strict): First => {\n  const units = new Uint8Array(TableSize)\n  let high = false\n  for (const c of codes) {\n    if (c < TableSize) units[c] = 1\n    else high = true\n  }\n  return { mode, units, high }\n}\n\nexport class FirstSets {\n  private readonly memo = new Map<ParserLike, First | undefined>()\n  constructor(readonly kind: 0 | 1 | 2) {}\n\n  of(p: ParserLike): First {\n    if (this.kind === 2) return unknown\n    if (this.memo.has(p)) return this.memo.get(p) ?? unknown // in progress: a cycle\n    this.memo.set(p, undefined)\n    const f = this.compute(nodeOf(p))\n    this.memo.set(p, f)\n    return f\n  }\n\n  /** Units of the code points of a set, as an encoding (or `Token`) reads them. */\n  private setUnits(set: CharSet, enc: Encoding<any> | undefined, mode: 0 | 1): First | undefined {\n    if (enc === undefined || kindOfEncoding(enc) === 0) {\n      if (this.kind === 1) return { mode, units: set.table, high: false }\n      return { mode, units: set.table, high: reachesAbove(set, TableSize) }\n    }\n    if (enc.unit !== 1) return undefined\n    const fast = fastLimit(enc)\n    if (fast === 0) return undefined\n    const units = set.table.slice()\n    // Multi-unit sequences start with a unit at or above `fast`\n    if (fast < TableSize) units.fill(reachesAbove(set, fast) ? 1 : 0, fast)\n    return { mode, units, high: false }\n  }\n\n  private compute(node: Node): First {\n    const kind = this.kind as 0 | 1\n    switch (node._tag) {\n      case \"Succeed\":\n      case \"Sync\":\n      case \"Location\":\n      case \"RestLen\":\n      case \"Eof\":\n        return emptyOptional\n      case \"Fail\":\n        return node.mode === \"Backtrack\" ? failing : unknown\n      case \"Any\":\n        return node.encoding !== undefined && kindOfEncoding(node.encoding) !== kind ? unknown : anyUnit\n      case \"Take\":\n        return node.count === 0 ? emptyOptional : anyUnit\n      case \"Literal\": {\n        const lit = node.literal\n        if (node.encoding !== undefined) {\n          if (kindOfEncoding(node.encoding) !== kind) return unknown\n          if (node.caseless) return isEmptyUnits(lit) ? unknown : anyUnit\n          const encoded = node.encoding.encode(lit as string)\n          if (isEmptyUnits(encoded)) return emptyOptional\n          return ofUnits([Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]])\n        }\n        if (isEmptyUnits(lit)) return emptyOptional\n        let first: number\n        if (Predicate.isString(lit)) {\n          first = kind === 0 ? lit.charCodeAt(0) : new TextEncoder().encode(lit)[0]\n        } else if (lit instanceof Uint8Array && kind === 1) {\n          first = lit[0]\n        } else {\n          return unknown\n        }\n        return ofUnits(node.caseless ? [first, lowerAscii(first), upperAscii(first)] : [first])\n      }\n      case \"OneOf\":\n      case \"TakeWhile\": {\n        if (node.encoding !== undefined && kindOfEncoding(node.encoding) !== kind) return unknown\n        const min = Predicate.isTagged(node, \"OneOf\") ? 1 : node.min\n        if (Predicate.isTagged(node, \"TakeWhile\") && node.max === 0) return emptyOptional\n        const mode = min > 0 ? Strict : Optional\n        if (node.negate) return mode === Strict ? anyUnit : withMode(anyUnit, Optional)\n        const set = node.encoding === undefined ? tokenSet(node.set, kind) : textSet(node.set)\n        return this.setUnits(set, node.encoding, mode) ?? (mode === Strict ? anyUnit : unknown)\n      }\n      case \"Map\":\n      case \"As\":\n      case \"Tap\":\n      case \"TryMap\":\n      case \"FilterMap\":\n      case \"Filter\":\n      case \"Taken\":\n      case \"WithTaken\":\n      case \"Span\":\n      case \"WithSpan\":\n      case \"Context\":\n      case \"Expected\":\n      case \"MapError\":\n      case \"OrFail\":\n      case \"Peek\":\n      case \"Trace\":\n      case \"Syntax\":\n      case \"ResumeAfter\":\n      case \"RetryAfter\":\n        return this.of(node.self)\n      case \"FlatMap\":\n      case \"SeparatedFold\":\n      case \"Dispatch\": {\n        const f = this.of(Predicate.isTagged(node, \"Dispatch\") ? node.selector : node.self)\n        return f.mode === Strict ? f : unknown\n      }\n      case \"Mode\": {\n        const f = this.of(node.self)\n        return node.from === \"Backtrack\" ? (f.mode === Unknown ? f : unknown) : f\n      }\n      case \"Opt\":\n      case \"OrElseSucceed\": {\n        const f = this.of(node.self)\n        return f.mode === Unknown ? f : withMode(f, Optional)\n      }\n      case \"Seq\":\n      case \"Struct\":\n        return this.sequence(node.parsers)\n      case \"ZipWith\":\n        return this.sequence([node.self, node.that])\n      case \"Alt\": {\n        if (Arr.isReadonlyArrayEmpty(node.parsers)) return failing\n        let acc: First | undefined\n        let mode: 0 | 1 | 2 = Strict\n        for (const p of node.parsers) {\n          const f = this.of(p)\n          if (f.mode === Unknown) return unknown\n          if (f.mode === Optional) mode = Optional\n          acc = acc === undefined ? f : union(acc, f, mode)\n        }\n        return acc === undefined ? failing : withMode(acc, mode)\n      }\n      case \"Repeat\":\n      case \"Fold\":\n      case \"Separated\": {\n        if (node.max === 0) return emptyOptional\n        const f = this.of(node.self)\n        if (f.mode !== Strict) return unknown\n        return node.min === 0 ? withMode(f, Optional) : f\n      }\n      case \"Suspend\":\n        return this.of(node.resolve())\n      default:\n        return unknown\n    }\n  }\n\n  private sequence(parsers: ReadonlyArray<ParserLike>): First {\n    let acc: First | undefined\n    for (const p of parsers) {\n      const f = this.of(p)\n      if (f.mode === Unknown) return unknown\n      acc = acc === undefined ? f : union(acc, f, f.mode)\n      if (f.mode === Strict) return acc\n    }\n    return acc ?? emptyOptional\n  }\n}\n\n/**\n * For an `Alt`: the branches worth trying for each next unit, each next\n * high unit, and at the end of the input, or `undefined` when pruning\n * would never skip a branch.\n */\nexport interface AltPlan {\n  /** Indexed by unit: indexes into `lists`. */\n  readonly byUnit: Uint8Array\n  readonly high: number\n  readonly end: number\n  readonly lists: ReadonlyArray<ReadonlyArray<number>>\n}\n\nexport const planAlt = (firsts: ReadonlyArray<First>): AltPlan | undefined => {\n  const n = firsts.length\n  if (n < 2 || n > 64) return undefined\n  const lists: Array<ReadonlyArray<number>> = []\n  const index = new Map<string, number>()\n  const listOf = (keep: (f: First) => boolean): number => {\n    const list: Array<number> = []\n    for (let i = 0; i < n; i++) if (keep(firsts[i])) list.push(i)\n    const key = list.join(\",\")\n    let k = index.get(key)\n    if (k === undefined) {\n      k = lists.length\n      lists.push(list)\n      index.set(key, k)\n    }\n    return k\n  }\n  const byUnit = new Uint8Array(TableSize)\n  for (let u = 0; u < TableSize; u++) byUnit[u] = listOf((f) => f.mode !== Strict || f.units[u] === 1)\n  const high = listOf((f) => f.mode !== Strict || f.high)\n  const end = listOf((f) => f.mode !== Strict)\n  if (lists.length === 1 && lists[0].length === n) return undefined\n  if (lists.length > 255) return undefined\n  return { byUnit, high, end, lists }\n}\n"],"mappings":"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"}
+{"version":3,"file":"first.js","names":[],"sources":["../../../src/internal/compiler/first.ts"],"sourcesContent":["/**\n * First sets: which input units can start a match of a parser.\n *\n * A first set has a mode:\n *\n * - `Strict`: when the next unit is not in `units` (or the input has\n *   ended), the parser fails with `Backtrack`.\n * - `Optional`: in that case, the parser either fails with `Backtrack` or\n *   succeeds without consuming input.\n * - `Unknown`: no guarantee.\n *\n * Units are UTF-16 code units for strings and bytes for byte inputs; units\n * from `TableSize` up are summarized by `high`. Array inputs have no units.\n *\n * Skipping a parser that is certain to fail also skips the callbacks it\n * would have run before failing, which is why callbacks must be pure.\n */\nimport * as Arr from \"effect/Array\"\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"../../Encoding.js\"\nimport type { Node, ParserLike } from \"../node.js\"\nimport { nodeOf } from \"../node.js\"\nimport { fastLimit, isEmptyUnits } from \"../text.js\"\nimport type { CharSet } from \"./sets.js\"\nimport { kindOfEncoding, reachesAbove, TableSize, textSet, tokenSet } from \"./sets.js\"\n\nexport const Strict = 0\nconst Optional = 1\nconst Unknown = 2\n\nexport interface First {\n  readonly mode: 0 | 1 | 2\n  readonly units: Uint8Array\n  readonly high: boolean\n}\n\nconst none = /*#__PURE__*/ new Uint8Array(TableSize)\nconst all = /*#__PURE__*/ new Uint8Array(TableSize).fill(1)\n\nconst unknown: First = { mode: Unknown, units: all, high: true }\nconst emptyOptional: First = { mode: Optional, units: none, high: false }\nconst failing: First = { mode: Strict, units: none, high: false }\nconst anyUnit: First = { mode: Strict, units: all, high: true }\n\nconst union = (a: First, b: First, mode: 0 | 1 | 2): First => {\n  const units = new Uint8Array(TableSize)\n  for (let i = 0; i < TableSize; i++) units[i] = a.units[i] | b.units[i]\n  return { mode, units, high: a.high || b.high }\n}\n\nconst withMode = (f: First, mode: 0 | 1 | 2): First => (f.mode === mode ? f : { ...f, mode })\n\nconst lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)\nconst upperAscii = (c: number): number => (c >= 97 && c <= 122 ? c - 32 : c)\n\nconst ofUnits = (codes: ReadonlyArray<number>, mode: 0 | 1 | 2 = Strict): First => {\n  const units = new Uint8Array(TableSize)\n  let high = false\n  for (const c of codes) {\n    if (c < TableSize) units[c] = 1\n    else high = true\n  }\n  return { mode, units, high }\n}\n\nexport class FirstSets {\n  private readonly memo = new Map<ParserLike, First | undefined>()\n  constructor(readonly kind: 0 | 1 | 2) {}\n\n  of(p: ParserLike): First {\n    if (this.kind === 2) return unknown\n    if (this.memo.has(p)) return this.memo.get(p) ?? unknown // in progress: a cycle\n    this.memo.set(p, undefined)\n    const f = this.compute(nodeOf(p))\n    this.memo.set(p, f)\n    return f\n  }\n\n  /** Units of the code points of a set, as an encoding (or `Token`) reads them. */\n  private setUnits(set: CharSet, enc: Encoding<any> | undefined, mode: 0 | 1): First | undefined {\n    if (enc === undefined || kindOfEncoding(enc) === 0) {\n      if (this.kind === 1) return { mode, units: set.table, high: false }\n      return { mode, units: set.table, high: reachesAbove(set, TableSize) }\n    }\n    if (enc.unit !== 1) return undefined\n    const fast = fastLimit(enc)\n    if (fast === 0) return undefined\n    const units = set.table.slice()\n    // Multi-unit sequences start with a unit at or above `fast`\n    if (fast < TableSize) units.fill(reachesAbove(set, fast) ? 1 : 0, fast)\n    return { mode, units, high: false }\n  }\n\n  private compute(node: Node): First {\n    // SAFETY: `compute` is only called from `of`, which returns before it when `kind` is 2\n    const kind = this.kind as 0 | 1\n    switch (node._tag) {\n      case \"Succeed\":\n      case \"Sync\":\n      case \"Location\":\n      case \"RestLen\":\n      case \"Eof\":\n        return emptyOptional\n      case \"Fail\":\n        return node.mode === \"Backtrack\" ? failing : unknown\n      case \"Any\":\n        return node.encoding !== undefined && kindOfEncoding(node.encoding) !== kind ? unknown : anyUnit\n      case \"Take\":\n        return node.count === 0 ? emptyOptional : anyUnit\n      case \"Literal\": {\n        const lit = node.literal\n        if (node.encoding !== undefined) {\n          if (kindOfEncoding(node.encoding) !== kind) return unknown\n          if (node.caseless) return isEmptyUnits(lit) ? unknown : anyUnit\n          // SAFETY: a `Literal` with an encoding is a `Text` literal, which records the string it encodes\n          const encoded = node.encoding.encode(lit as string)\n          if (isEmptyUnits(encoded)) return emptyOptional\n          return ofUnits([Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]])\n        }\n        if (isEmptyUnits(lit)) return emptyOptional\n        let first: number\n        if (Predicate.isString(lit)) {\n          first = kind === 0 ? lit.charCodeAt(0) : new TextEncoder().encode(lit)[0]\n        } else if (lit instanceof Uint8Array && kind === 1) {\n          first = lit[0]\n        } else {\n          return unknown\n        }\n        return ofUnits(node.caseless ? [first, lowerAscii(first), upperAscii(first)] : [first])\n      }\n      case \"OneOf\":\n      case \"TakeWhile\": {\n        if (node.encoding !== undefined && kindOfEncoding(node.encoding) !== kind) return unknown\n        const min = Predicate.isTagged(node, \"OneOf\") ? 1 : node.min\n        if (Predicate.isTagged(node, \"TakeWhile\") && node.max === 0) return emptyOptional\n        const mode = min > 0 ? Strict : Optional\n        if (node.negate) return mode === Strict ? anyUnit : withMode(anyUnit, Optional)\n        const set = node.encoding === undefined ? tokenSet(node.set, kind) : textSet(node.set)\n        return this.setUnits(set, node.encoding, mode) ?? (mode === Strict ? anyUnit : unknown)\n      }\n      case \"Map\":\n      case \"As\":\n      case \"Tap\":\n      case \"TryMap\":\n      case \"FilterMap\":\n      case \"MapOrFail\":\n      case \"Filter\":\n      case \"Taken\":\n      case \"WithTaken\":\n      case \"Span\":\n      case \"WithSpan\":\n      case \"MapSpan\":\n      case \"Context\":\n      case \"Expected\":\n      case \"Quiet\":\n      // A fast path accepts what its grammar accepts (`Parser.withFastPath`)\n      case \"FastPath\":\n      case \"MapError\":\n      case \"OrFail\":\n      case \"Peek\":\n      case \"Trace\":\n      case \"Syntax\":\n      case \"ResumeAfter\":\n      case \"RetryAfter\":\n        return this.of(node.self)\n      case \"FlatMap\":\n      case \"SeparatedFold\":\n      case \"Dispatch\": {\n        const f = this.of(Predicate.isTagged(node, \"Dispatch\") ? node.selector : node.self)\n        return f.mode === Strict ? f : unknown\n      }\n      case \"Mode\": {\n        const f = this.of(node.self)\n        return node.from === \"Backtrack\" ? (f.mode === Unknown ? f : unknown) : f\n      }\n      // `not(p)` consumes nothing. Where `p`'s first set rules a unit out, `p`\n      // backtracks there, so `not(p)` succeeds without consuming: Optional\n      // over `p`'s units. On a unit in that set it may also fail, Cut\n      // included, which Optional leaves open. So `seq(not(p), q)` starts\n      // with `p`'s units and `q`'s, and an `alt` can skip it on any other (#84)\n      case \"Not\":\n      case \"Opt\":\n      case \"OrElseSucceed\": {\n        const f = this.of(node.self)\n        return f.mode === Unknown ? f : withMode(f, Optional)\n      }\n      case \"Seq\":\n      case \"Struct\":\n      case \"SeqWith\":\n        return this.sequence(node.parsers)\n      case \"ZipWith\":\n        return this.sequence([node.self, node.that])\n      case \"Alt\": {\n        if (Arr.isReadonlyArrayEmpty(node.parsers)) return failing\n        let acc: First | undefined\n        let mode: 0 | 1 | 2 = Strict\n        for (const p of node.parsers) {\n          const f = this.of(p)\n          if (f.mode === Unknown) return unknown\n          if (f.mode === Optional) mode = Optional\n          acc = acc === undefined ? f : union(acc, f, mode)\n        }\n        return acc === undefined ? failing : withMode(acc, mode)\n      }\n      case \"Repeat\":\n      case \"Fold\":\n      case \"Separated\": {\n        if (node.max === 0) return emptyOptional\n        const f = this.of(node.self)\n        if (f.mode !== Strict) return unknown\n        return node.min === 0 ? withMode(f, Optional) : f\n      }\n      case \"Suspend\":\n        return this.of(node.resolve())\n      case \"Fixed\":\n        return kind !== 1 ? unknown : node.size === 0 ? emptyOptional : anyUnit\n      default:\n        return unknown\n    }\n  }\n\n  private sequence(parsers: ReadonlyArray<ParserLike>): First {\n    let acc: First | undefined\n    for (const p of parsers) {\n      const f = this.of(p)\n      if (f.mode === Unknown) return unknown\n      acc = acc === undefined ? f : union(acc, f, f.mode)\n      if (f.mode === Strict) return acc\n    }\n    return acc ?? emptyOptional\n  }\n}\n\n/**\n * For an `Alt`: the branches worth trying for each next unit, each next\n * high unit, and at the end of the input, or `undefined` when pruning\n * would never skip a branch.\n */\nexport interface AltPlan {\n  /** Indexed by unit: indexes into `lists`. */\n  readonly byUnit: Uint8Array\n  readonly high: number\n  readonly end: number\n  readonly lists: ReadonlyArray<ReadonlyArray<number>>\n}\n\nexport const planAlt = (firsts: ReadonlyArray<First>): AltPlan | undefined => {\n  const n = firsts.length\n  if (n < 2 || n > 64) return undefined\n  const lists: Array<ReadonlyArray<number>> = []\n  const index = new Map<string, number>()\n  const listOf = (keep: (f: First) => boolean): number => {\n    const list: Array<number> = []\n    for (let i = 0; i < n; i++) if (keep(firsts[i])) list.push(i)\n    const key = list.join(\",\")\n    let k = index.get(key)\n    if (k === undefined) {\n      k = lists.length\n      lists.push(list)\n      index.set(key, k)\n    }\n    return k\n  }\n  const byUnit = new Uint8Array(TableSize)\n  for (let u = 0; u < TableSize; u++) byUnit[u] = listOf((f) => f.mode !== Strict || f.units[u] === 1)\n  const high = listOf((f) => f.mode !== Strict || f.high)\n  const end = listOf((f) => f.mode !== Strict)\n  if (lists.length === 1 && lists[0].length === n) return undefined\n  if (lists.length > 255) return undefined\n  return { byUnit, high, end, lists }\n}\n"],"mappings":"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"}

package/dist/internal/compiler/graph.d.ts

@@ -0,0 +1,39 @@
+import { Node, ParserLike } from "../node.js";
+/** Whether a node is a token or a constant, always generated inline. */
+export declare const isLeaf: (node: Node) => boolean;
+/**
+ * How many times each parser reachable from `root` is used: one for every
+ * place a parent mentions it. A parser used twice is generated once, as a
+ * rule the two places call (unless it is small, see {@link isSmall}).
+ *
+ * Uses are counted, not distinct parents: `seq(p, p)` uses `p` twice. When
+ * only parents were counted, such a `p` was inlined at both places, and a
+ * grammar that does it at every level (`p = seq(p, p)`, twenty times over)
+ * compiled to 2^20 copies: 160 MB of source from twenty lines (#122).
+ */
+export declare const countRefs: (root: ParserLike) => WeakMap<ParserLike, number>;
+/**
+ * The most parsers a code-generating compiler inlines for one root. Sharing
+ * is what keeps generated code proportional to the grammar; a grammar that
+ * is itself enormous (a tree of distinct parsers built by a loop, a derived
+ * schema) would still take minutes and gigabytes to generate, so past this
+ * many the compiler gives up and the next one down takes over (the JIT for
+ * WebAssembly, the closure compiler for the JIT), which costs a closure per
+ * parser instead of source text. The largest grammars in this repository
+ * and the libraries built on it inline a few thousand.
+ */
+export declare const MaxInlined = 100000;
+/** Counts a parser a compiler is about to inline, failing the compilation past {@link MaxInlined}. */
+export declare const countInlined: (inlined: number) => number;
+/** Whether a parser is small enough to inline wherever it is used. */
+export declare const isSmall: (p: ParserLike) => boolean;
+/** The node a `dispatch` selects on, and whether it is looked at with `peek`. */
+export declare const selectorOf: (selector: ParserLike) => {
+  readonly node: Node;
+  readonly peek: boolean;
+};
+/** ASCII lower case. */
+export declare const lowerAscii: (c: number) => number;
+/** Whether a code is an ASCII letter. */
+export declare const isLetter: (c: number) => boolean;
+//# sourceMappingURL=graph.d.ts.map

package/dist/internal/compiler/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","names":[],"sources":["../../../src/internal/compiler/graph.ts"],"mappings":";;qBAUa,SAAU,MAAM;;;;;;;;;;;qBAqBhB,YAAa,MAAM,eAAa,QAAQ;;;;;;;;;;;qBAyBxC;;qBAGA,eAAgB;;qBAUhB,UAAW,GAAG;;qBAiBd,aAAc,UAAU;WAAwB,MAAM;WAAe;;;qBAMrE,aAAc;;qBAGd,WAAY"}

package/dist/internal/compiler/graph.js

@@ -0,0 +1,78 @@
+import * as Predicate from "effect/Predicate";
+import { children, nodeOf } from "../node.js";
+// src/internal/compiler/graph.ts
+/**
+* The shape of a grammar, as the code-generating compilers (the JIT and the
+* WebAssembly compiler) see it: which parsers are leaves, which are shared
+* and which are small enough to inline everywhere.
+*/
+/** Whether a node is a token or a constant, always generated inline. */
+const isLeaf = (node) => Predicate.isTagged(node, "Succeed") || Predicate.isTagged(node, "Fail") || Predicate.isTagged(node, "Eof") || Predicate.isTagged(node, "Location") || Predicate.isTagged(node, "RestLen") || Predicate.isTagged(node, "Any") || Predicate.isTagged(node, "Literal") || Predicate.isTagged(node, "OneOf") || Predicate.isTagged(node, "TakeWhile");
+/**
+* How many times each parser reachable from `root` is used: one for every
+* place a parent mentions it. A parser used twice is generated once, as a
+* rule the two places call (unless it is small, see {@link isSmall}).
+*
+* Uses are counted, not distinct parents: `seq(p, p)` uses `p` twice. When
+* only parents were counted, such a `p` was inlined at both places, and a
+* grammar that does it at every level (`p = seq(p, p)`, twenty times over)
+* compiled to 2^20 copies: 160 MB of source from twenty lines (#122).
+*/
+const countRefs = (root) => {
+	const refs = /* @__PURE__ */ new WeakMap();
+	const seen = /* @__PURE__ */ new WeakSet();
+	const stack = [root];
+	for (let p = stack.pop(); p !== void 0; p = stack.pop()) {
+		if (seen.has(p)) continue;
+		seen.add(p);
+		for (const c of children(nodeOf(p))) {
+			refs.set(c, (refs.get(c) ?? 0) + 1);
+			stack.push(c);
+		}
+	}
+	return refs;
+};
+/**
+* The most parsers a code-generating compiler inlines for one root. Sharing
+* is what keeps generated code proportional to the grammar; a grammar that
+* is itself enormous (a tree of distinct parsers built by a loop, a derived
+* schema) would still take minutes and gigabytes to generate, so past this
+* many the compiler gives up and the next one down takes over (the JIT for
+* WebAssembly, the closure compiler for the JIT), which costs a closure per
+* parser instead of source text. The largest grammars in this repository
+* and the libraries built on it inline a few thousand.
+*/
+const MaxInlined = 1e5;
+/** Counts a parser a compiler is about to inline, failing the compilation past {@link MaxInlined}. */
+const countInlined = (inlined) => {
+	if (inlined >= 1e5) throw new RangeError(`effect-parse: the grammar is too large to generate code for (over ${MaxInlined} parsers inlined)`);
+	return inlined + 1;
+};
+/** Whether a parser is small enough to inline wherever it is used. */
+const isSmall = (p) => {
+	let budget = 6;
+	const visit = (q) => {
+		const node = nodeOf(q);
+		if (--budget < 0 || Predicate.isTagged(node, "Suspend") || Predicate.isTagged(node, "Escaped") || Predicate.isTagged(node, "Dispatch")) return false;
+		return children(node).every(visit);
+	};
+	return visit(p);
+};
+/** The node a `dispatch` selects on, and whether it is looked at with `peek`. */
+const selectorOf = (selector) => {
+	const node = nodeOf(selector);
+	return Predicate.isTagged(node, "Peek") ? {
+		node: nodeOf(node.self),
+		peek: true
+	} : {
+		node,
+		peek: false
+	};
+};
+/** ASCII lower case. */
+const lowerAscii = (c) => c >= 65 && c <= 90 ? c + 32 : c;
+/** Whether a code is an ASCII letter. */
+const isLetter = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122;
+export { MaxInlined, countInlined, countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf };
+
+//# sourceMappingURL=graph.js.map

package/dist/internal/compiler/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","names":[],"sources":["../../../src/internal/compiler/graph.ts"],"sourcesContent":["/**\n * The shape of a grammar, as the code-generating compilers (the JIT and the\n * WebAssembly compiler) see it: which parsers are leaves, which are shared\n * and which are small enough to inline everywhere.\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Node, ParserLike } from \"../node.js\"\nimport { children, nodeOf } from \"../node.js\"\n\n/** Whether a node is a token or a constant, always generated inline. */\nexport const isLeaf = (node: Node): boolean =>\n  Predicate.isTagged(node, \"Succeed\") ||\n  Predicate.isTagged(node, \"Fail\") ||\n  Predicate.isTagged(node, \"Eof\") ||\n  Predicate.isTagged(node, \"Location\") ||\n  Predicate.isTagged(node, \"RestLen\") ||\n  Predicate.isTagged(node, \"Any\") ||\n  Predicate.isTagged(node, \"Literal\") ||\n  Predicate.isTagged(node, \"OneOf\") ||\n  Predicate.isTagged(node, \"TakeWhile\")\n\n/**\n * How many times each parser reachable from `root` is used: one for every\n * place a parent mentions it. A parser used twice is generated once, as a\n * rule the two places call (unless it is small, see {@link isSmall}).\n *\n * Uses are counted, not distinct parents: `seq(p, p)` uses `p` twice. When\n * only parents were counted, such a `p` was inlined at both places, and a\n * grammar that does it at every level (`p = seq(p, p)`, twenty times over)\n * compiled to 2^20 copies: 160 MB of source from twenty lines (#122).\n */\nexport const countRefs = (root: ParserLike): WeakMap<ParserLike, number> => {\n  const refs = new WeakMap<ParserLike, number>()\n  const seen = new WeakSet<ParserLike>()\n  const stack = [root]\n  for (let p = stack.pop(); p !== undefined; p = stack.pop()) {\n    if (seen.has(p)) continue\n    seen.add(p)\n    for (const c of children(nodeOf(p))) {\n      refs.set(c, (refs.get(c) ?? 0) + 1)\n      stack.push(c)\n    }\n  }\n  return refs\n}\n\n/**\n * The most parsers a code-generating compiler inlines for one root. Sharing\n * is what keeps generated code proportional to the grammar; a grammar that\n * is itself enormous (a tree of distinct parsers built by a loop, a derived\n * schema) would still take minutes and gigabytes to generate, so past this\n * many the compiler gives up and the next one down takes over (the JIT for\n * WebAssembly, the closure compiler for the JIT), which costs a closure per\n * parser instead of source text. The largest grammars in this repository\n * and the libraries built on it inline a few thousand.\n */\nexport const MaxInlined = 100_000\n\n/** Counts a parser a compiler is about to inline, failing the compilation past {@link MaxInlined}. */\nexport const countInlined = (inlined: number): number => {\n  if (inlined >= MaxInlined) {\n    throw new RangeError(\n      `effect-parse: the grammar is too large to generate code for (over ${MaxInlined} parsers inlined)`\n    )\n  }\n  return inlined + 1\n}\n\n/** Whether a parser is small enough to inline wherever it is used. */\nexport const isSmall = (p: ParserLike): boolean => {\n  let budget = 6\n  const visit = (q: ParserLike): boolean => {\n    const node = nodeOf(q)\n    if (\n      --budget < 0 ||\n      Predicate.isTagged(node, \"Suspend\") ||\n      Predicate.isTagged(node, \"Escaped\") ||\n      Predicate.isTagged(node, \"Dispatch\")\n    )\n      return false\n    return children(node).every(visit)\n  }\n  return visit(p)\n}\n\n/** The node a `dispatch` selects on, and whether it is looked at with `peek`. */\nexport const selectorOf = (selector: ParserLike): { readonly node: Node; readonly peek: boolean } => {\n  const node = nodeOf(selector)\n  return Predicate.isTagged(node, \"Peek\") ? { node: nodeOf(node.self), peek: true } : { node, peek: false }\n}\n\n/** ASCII lower case. */\nexport const lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)\n\n/** Whether a code is an ASCII letter. */\nexport const isLetter = (c: number): boolean => (c >= 65 && c <= 90) || (c >= 97 && c <= 122)\n"],"mappings":";;;;;;;;;AAUA,MAAa,UAAU,SACrB,UAAU,SAAS,MAAM,SAAS,KAClC,UAAU,SAAS,MAAM,MAAM,KAC/B,UAAU,SAAS,MAAM,KAAK,KAC9B,UAAU,SAAS,MAAM,UAAU,KACnC,UAAU,SAAS,MAAM,SAAS,KAClC,UAAU,SAAS,MAAM,KAAK,KAC9B,UAAU,SAAS,MAAM,SAAS,KAClC,UAAU,SAAS,MAAM,OAAO,KAChC,UAAU,SAAS,MAAM,WAAW;;;;;;;;;;;AAYtC,MAAa,aAAa,SAAkD;CAC1E,MAAM,uBAAO,IAAI,QAA4B;CAC7C,MAAM,uBAAO,IAAI,QAAoB;CACrC,MAAM,QAAQ,CAAC,IAAI;CACnB,KAAK,IAAI,IAAI,MAAM,IAAI,GAAG,MAAM,KAAA,GAAW,IAAI,MAAM,IAAI,GAAG;EAC1D,IAAI,KAAK,IAAI,CAAC,GAAG;EACjB,KAAK,IAAI,CAAC;EACV,KAAK,MAAM,KAAK,SAAS,OAAO,CAAC,CAAC,GAAG;GACnC,KAAK,IAAI,IAAI,KAAK,IAAI,CAAC,KAAK,KAAK,CAAC;GAClC,MAAM,KAAK,CAAC;EACd;CACF;CACA,OAAO;AACT;;;;;;;;;;;AAYA,MAAa,aAAa;;AAG1B,MAAa,gBAAgB,YAA4B;CACvD,IAAI,WAAA,KACF,MAAM,IAAI,WACR,qEAAqE,WAAW,kBAClF;CAEF,OAAO,UAAU;AACnB;;AAGA,MAAa,WAAW,MAA2B;CACjD,IAAI,SAAS;CACb,MAAM,SAAS,MAA2B;EACxC,MAAM,OAAO,OAAO,CAAC;EACrB,IACE,EAAE,SAAS,KACX,UAAU,SAAS,MAAM,SAAS,KAClC,UAAU,SAAS,MAAM,SAAS,KAClC,UAAU,SAAS,MAAM,UAAU,GAEnC,OAAO;EACT,OAAO,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK;CACnC;CACA,OAAO,MAAM,CAAC;AAChB;;AAGA,MAAa,cAAc,aAA0E;CACnG,MAAM,OAAO,OAAO,QAAQ;CAC5B,OAAO,UAAU,SAAS,MAAM,MAAM,IAAI;EAAE,MAAM,OAAO,KAAK,IAAI;EAAG,MAAM;CAAK,IAAI;EAAE;EAAM,MAAM;CAAM;AAC1G;;AAGA,MAAa,cAAc,MAAuB,KAAK,MAAM,KAAK,KAAK,IAAI,KAAK;;AAGhF,MAAa,YAAY,MAAwB,KAAK,MAAM,KAAK,MAAQ,KAAK,MAAM,KAAK"}

package/dist/internal/compiler/jit.d.ts

@@ -1,4 +1,9 @@
 import { Backend } from "./registry.js";
+/**
+ * Whether `new Function` works here (it doesn't under a Content Security
+ * Policy). Checked once, and again if `globalThis.Function` is replaced.
+ */
+export declare const jitSupported: () => boolean;
 /**
  * The JIT as a backend: generated code where `new Function` is allowed,
  * otherwise (or if generating fails) the closure compiler.

package/dist/internal/compiler/jit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jit.d.ts","names":[],"sources":["../../../src/internal/compiler/jit.ts"],"mappings":";;;;;qBAgxCa,SAAS"}
+{"version":3,"file":"jit.d.ts","names":[],"sources":["../../../src/internal/compiler/jit.ts"],"mappings":";;;;;qBAmGa;;;;;qBAk0CA,SAAS"}