@thomasfosterau/effect-parse 0.4.1 → 0.5.0

package/dist/internal/tokens.js

@@ -2,7 +2,7 @@ import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { charOf, firstCodePoint } from "./text.js";
 // src/internal/tokens.ts
-const isRange = (u) => Predicate.isObjectOrArray(u) && u._tag === "TokenRange";
+const isRange = (u) => Predicate.isObjectOrArray(u) && Predicate.isTagged(u, "TokenRange");
 const toCode = (u) => Predicate.isNumber(u) ? u : firstCodePoint(u);
 /** @internal */
 const describeChar = (s) => JSON.stringify(s);
@@ -89,8 +89,9 @@ const PredicateRanges = /*#__PURE__*/ Symbol.for("effect-parse/PredicateRanges")
 */
 const codePointPredicate = (name, f, ranges) => {
 	Object.defineProperty(f, "name", { value: name });
-	f[CodePointPredicate] = true;
-	if (ranges !== void 0) f[PredicateRanges] = ranges;
+	const marked = f;
+	marked[CodePointPredicate] = true;
+	if (ranges !== void 0) marked[PredicateRanges] = ranges;
 	return f;
 };
 /**
@@ -202,10 +203,29 @@ const nextIf = (state, m, negate) => {
 		}
 	}
 };
+/** The one record {@link scan} fills; see there. */
+var ScanResult = class {
+	offset = 0;
+	count = 0;
+	hitEnd = false;
+};
+const scanned = /*#__PURE__*/ new ScanResult();
+/** Fills {@link scanned} and returns it. */
+const scannedAt = (offset, count, hitEnd) => {
+	scanned.offset = offset;
+	scanned.count = count;
+	scanned.hitEnd = hitEnd;
+	return scanned;
+};
 /**
 * Scans forward while tokens satisfy the matcher (xor `negate`), up to `max`
 * tokens. Returns the offset reached, the number of tokens matched, and
 * whether the end of input was hit before `max` tokens.
+*
+* The result is one shared record, overwritten by the next scan: read it
+* before running anything else. Allocating one per call cost the
+* interpreter a record per token, since `scan` (shared by every `takeWhile`)
+* is too polymorphic for V8 to inline and remove it.
 */
 const scan = (state, m, negate, max) => {
 	let i = state.pos;
@@ -216,70 +236,42 @@ const scan = (state, m, negate, max) => {
 			const s = state.input;
 			const test = m.forString.code;
 			while (count < max) {
-				if (i >= end) return {
-					offset: i,
-					count,
-					hitEnd: true
-				};
+				if (i >= end) return scannedAt(i, count, true);
 				const c = s.charCodeAt(i);
 				if (c < 55296 || c > 56319) {
 					if (test(c) === negate) break;
 					i++;
 				} else {
-					if (splitSurrogate(state, i)) return {
-						offset: i,
-						count,
-						hitEnd: true
-					};
+					if (splitSurrogate(state, i)) return scannedAt(i, count, true);
 					const cp = codePointAt(s, i);
 					if (test(cp) === negate) break;
 					i += cp > 65535 ? 2 : 1;
 				}
 				count++;
 			}
-			return {
-				offset: i,
-				count,
-				hitEnd: false
-			};
+			return scannedAt(i, count, false);
 		}
 		case 1: {
 			const bytes = state.input;
 			const test = m.forCode.code;
 			while (count < max) {
-				if (i >= end) return {
-					offset: i,
-					count,
-					hitEnd: true
-				};
+				if (i >= end) return scannedAt(i, count, true);
 				if (test(bytes[i]) === negate) break;
 				i++;
 				count++;
 			}
-			return {
-				offset: i,
-				count,
-				hitEnd: false
-			};
+			return scannedAt(i, count, false);
 		}
 		default: {
 			const arr = state.input;
 			const test = m.forCode.token;
 			while (count < max) {
-				if (i >= end) return {
-					offset: i,
-					count,
-					hitEnd: true
-				};
+				if (i >= end) return scannedAt(i, count, true);
 				if (test(arr[i]) === negate) break;
 				i++;
 				count++;
 			}
-			return {
-				offset: i,
-				count,
-				hitEnd: false
-			};
+			return scannedAt(i, count, false);
 		}
 	}
 };
@@ -318,6 +310,34 @@ const countTokens = (state, start, end) => {
 	}
 	return count;
 };
+/**
+* The first index at or after `from` of any of `needles` within
+* `[from, state.end)`, or -1. The state remembers, under `needles`, where
+* each one next occurs (`[from, at]` at `2 * i`), so successive searches
+* forwards over one input search each needle once per occurrence rather
+* than once per call (as `nextStop` does for `takeTill`).
+*/
+const indexOfAny = (state, needles, from) => {
+	const searches = state.searches ??= /* @__PURE__ */ new Map();
+	let memo = searches.get(needles);
+	if (memo === void 0) {
+		memo = needles.flatMap(() => [-1, -1]);
+		searches.set(needles, memo);
+	}
+	let best = -1;
+	for (let i = 0; i < needles.length; i++) {
+		const known = memo[2 * i] ?? -1;
+		let at = memo[2 * i + 1] ?? -1;
+		const needle = needles[i] ?? "";
+		if (known < 0 || from < known || at >= 0 && (at < from || at > state.end - needle.length)) {
+			at = indexOf(state, needle, from);
+			memo[2 * i] = from;
+			memo[2 * i + 1] = at;
+		}
+		if (at >= 0 && (best < 0 || at < best)) best = at;
+	}
+	return best;
+};
 /** Finds `needle` within `[from, state.end)`; returns -1 if absent. */
 const indexOf = (state, needle, from) => {
 	const last = state.end - needle.length;
@@ -397,6 +417,6 @@ const match = (state, lit, caseless) => {
 	}
 };
 const lowerAscii = (c) => c >= 65 && c <= 90 ? c + 32 : c;
-export { End, NoMatch, PredicateRanges, advance, codePointPredicate, compile, compileAny, countTokens, describeChar, describeLiteral, indexOf, matchLiteral, nextIf, scan, splitSurrogate };
+export { End, NoMatch, PredicateRanges, advance, codePointPredicate, compile, compileAny, countTokens, describeChar, describeLiteral, indexOf, indexOfAny, matchLiteral, nextIf, scan, splitSurrogate };
 
 //# sourceMappingURL=tokens.js.map

package/dist/internal/tokens.js.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.js","names":[],"sources":["../../src/internal/tokens.ts"],"sourcesContent":["// fallow-ignore-file duplicate-export -- `End` and `scan` here are the token-set versions of the text\n// helpers in ./text.ts; both are internal modules, imported by path, never re-exported from one barrel.\nimport * as Predicate from \"effect/Predicate\"\nimport * as Result from \"effect/Result\"\nimport type { Input, State } from \"../Input.js\"\nimport { charOf, firstCodePoint } from \"./text.js\"\n\n/** A compiled token set. */\nexport interface Matcher {\n  /** Tests a code point (string input) or a byte (Uint8Array input). */\n  readonly code: (code: number) => boolean\n  /** Tests an element of an array input. */\n  readonly token: (token: unknown) => boolean\n  /** Human readable description, used in error messages. */\n  readonly description: string\n}\n\n/** @internal */\nexport interface TokenRangeLike {\n  readonly _tag: \"TokenRange\"\n  readonly from: string | number\n  readonly to: string | number\n}\n\nconst isRange = (u: unknown): u is TokenRangeLike => Predicate.isObjectOrArray(u) && (u as any)._tag === \"TokenRange\"\n\nconst toCode = (u: string | number): number => (Predicate.isNumber(u) ? u : firstCodePoint(u))\n\n/** @internal */\nexport const describeChar = (s: string): string => JSON.stringify(s)\n\nconst describeSet = (u: unknown): string => {\n  if (Predicate.isString(u)) {\n    const chars = Array.from(u)\n    return chars.length === 1 ? describeChar(u) : `one of ${JSON.stringify(u)}`\n  }\n  if (Predicate.isNumber(u)) return `0x${u.toString(16).padStart(2, \"0\")}`\n  if (Predicate.isFunction(u)) return u.name ? u.name : \"a matching token\"\n  if (u instanceof Uint8Array) return `one of ${describeBytes(u)}`\n  if (isRange(u)) return `${describeSet(u.from)}..=${describeSet(u.to)}`\n  if (Array.isArray(u)) return u.map(describeSet).join(\" or \")\n  return JSON.stringify(u)\n}\n\n/** Renders bytes as a Rust-style byte string literal: b\"GET\\r\\n\". */\nconst describeBytes = (bytes: Uint8Array): string => {\n  let out = 'b\"'\n  for (const b of bytes) {\n    if (b === 0x22) out += '\\\\\"'\n    else if (b === 0x5c) out += \"\\\\\\\\\"\n    else if (b === 0x0a) out += \"\\\\n\"\n    else if (b === 0x0d) out += \"\\\\r\"\n    else if (b === 0x09) out += \"\\\\t\"\n    else if (b >= 0x20 && b < 0x7f) out += String.fromCharCode(b)\n    else out += `\\\\x${b.toString(16).padStart(2, \"0\")}`\n  }\n  return out + '\"'\n}\n\nconst compileCode = (u: unknown): ((code: number) => boolean) => {\n  if (Predicate.isString(u)) {\n    const codes = Array.from(u, firstCodePoint)\n    if (codes.length === 1) {\n      const c = codes[0]\n      return (x) => x === c\n    }\n    return bitmap(codes)\n  }\n  if (Predicate.isNumber(u)) return (x) => x === u\n  if (Predicate.isFunction(u)) return u as (code: number) => boolean\n  if (u instanceof Uint8Array) return bitmap(Array.from(u))\n  if (isRange(u)) {\n    const from = toCode(u.from)\n    const to = toCode(u.to)\n    return (x) => x >= from && x <= to\n  }\n  if (Array.isArray(u)) {\n    const tests = u.map(compileCode)\n    if (tests.length === 1) return tests[0]\n    return (x) => {\n      for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true\n      return false\n    }\n  }\n  throw new TypeError(`invalid token set: ${String(u)}`)\n}\n\nconst bitmap = (codes: ReadonlyArray<number>): ((code: number) => boolean) => {\n  const ascii = new Uint8Array(256)\n  let other: Set<number> | undefined\n  for (const c of codes) {\n    if (c < 256) ascii[c] = 1\n    else (other ??= new Set()).add(c)\n  }\n  if (other === undefined) return (x) => x < 256 && ascii[x] === 1\n  const set = other\n  return (x) => (x < 256 ? ascii[x] === 1 : set.has(x))\n}\n\nconst compileToken = (u: unknown): ((token: unknown) => boolean) => {\n  if (Predicate.isFunction(u)) return u as (token: unknown) => boolean\n  if (Array.isArray(u)) {\n    const set = new Set(u)\n    return (t) => set.has(t)\n  }\n  return (t) => t === u\n}\n\n/**\n * Marks a predicate over characters that also accepts a code point (a\n * number), so string inputs can call it without allocating a string per\n * character.\n */\nconst CodePointPredicate: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/CodePointPredicate\")\n\n/**\n * The code points accepted by a predicate, as sorted, disjoint, inclusive\n * ranges, when they are known. The compiler turns such predicates into\n * comparisons or tables.\n */\nexport const PredicateRanges: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/PredicateRanges\")\n\n/**\n * Marks `f` as a {@link CodePointPredicate} named `name` (used in error\n * messages), optionally recording the code point ranges it accepts.\n */\nexport const codePointPredicate = <F extends (c: never) => boolean>(\n  name: string,\n  f: F,\n  ranges?: ReadonlyArray<readonly [number, number]>\n): F => {\n  Object.defineProperty(f, \"name\", { value: name })\n  ;(f as any)[CodePointPredicate] = true\n  if (ranges !== undefined) (f as any)[PredicateRanges] = ranges\n  return f\n}\n\n/**\n * Compiles a token set. Predicates for string inputs receive the token as a\n * string, so they are wrapped here; `charOf` avoids `String.fromCodePoint`,\n * which is several times slower, for the Basic Multilingual Plane.\n */\nexport const compile = (set: unknown, kind: \"string\" | \"code\" = \"code\"): Matcher => {\n  const description = describeSet(set)\n  let code: (code: number) => boolean\n  if (Predicate.isFunction(set) && kind === \"string\" && !(CodePointPredicate in set)) {\n    const pred = set as (c: string) => boolean\n    code = (x) => pred(charOf(x))\n  } else {\n    code = compileCodeSafe(set, kind)\n  }\n  return { code, token: compileToken(set), description }\n}\n\nconst compileCodeSafe = (set: unknown, kind: \"string\" | \"code\"): ((code: number) => boolean) => {\n  if (Array.isArray(set) && kind === \"string\") {\n    // Predicates nested in arrays also take strings\n    const tests = set.map((s) => compile(s, kind).code)\n    return (x) => {\n      for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true\n      return false\n    }\n  }\n  return Result.getOrElse(\n    Result.try(() => compileCode(set)),\n    (): ((code: number) => boolean) => () => false\n  )\n}\n\n/**\n * A matcher that works for every input kind. String predicates receive the\n * token as a string, byte predicates receive numbers.\n */\nexport interface AnyMatcher {\n  readonly forString: Matcher\n  readonly forCode: Matcher\n  readonly description: string\n}\n\n/**\n * A small cache keyed by value, for the parts of a parser that are costly to\n * build and depend only on a string (compiled sets, descriptions). Parsers\n * built inside `Parser.gen` bodies are rebuilt on every run, usually from the\n * same few strings. Dynamic strings could grow it without bound, so it is\n * cleared when full.\n */\nconst cached = <A>(cache: Map<string, A>, key: string, build: (key: string) => A): A => {\n  let a = cache.get(key)\n  if (a === undefined) {\n    if (cache.size >= 1024) cache.clear()\n    a = build(key)\n    cache.set(key, a)\n  }\n  return a\n}\n\nconst literalDescriptions = /*#__PURE__*/ new Map<string, string>()\n\n/** Describes a literal for error messages: `\"abc\"`, `b\"abc\"` or `[\"a\", 1]`. */\nexport const describeLiteral = (lit: Input): string =>\n  Predicate.isString(lit)\n    ? cached(literalDescriptions, lit, describeChar)\n    : lit instanceof Uint8Array\n      ? describeBytes(lit)\n      : `[${lit.map((t) => JSON.stringify(t)).join(\", \")}]`\n\nconst stringMatchers = /*#__PURE__*/ new Map<string, AnyMatcher>()\n\nexport const compileAny = (set: unknown): AnyMatcher =>\n  // Matchers for strings are pure functions of the string, so they're shared\n  Predicate.isString(set) ? cached(stringMatchers, set, compileAnyImpl) : compileAnyImpl(set)\n\nconst compileAnyImpl = (set: unknown): AnyMatcher => {\n  const forCode = compile(set, \"code\")\n  const needsString = Predicate.isFunction(set) || Array.isArray(set)\n  return {\n    forString: needsString ? compile(set, \"string\") : forCode,\n    forCode,\n    description: forCode.description\n  }\n}\n\n/**\n * Whether the string token at `i` is a high surrogate at the very end of a\n * partial input, i.e. the first half of a code point whose second half has\n * not arrived yet.\n */\nexport const splitSurrogate = (state: State<Input>, i: number): boolean => {\n  if (!state.partial || i !== state.end - 1) return false\n  const c = (state.input as string).charCodeAt(i)\n  return c >= 0xd800 && c <= 0xdbff\n}\n\n/** Reads the code point at `i` of a string. */\nconst codePointAt = (s: string, i: number): number => {\n  const c = s.charCodeAt(i)\n  if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {\n    const d = s.charCodeAt(i + 1)\n    if (d >= 0xdc00 && d <= 0xdfff) return ((c - 0xd800) << 10) + (d - 0xdc00) + 0x10000\n  }\n  return c\n}\n\n/**\n * Tests the token at the current position. Returns the token (as the input's\n * token type) and advances, or returns `NoMatch`/`End`.\n */\nexport const NoMatch: unique symbol = /*#__PURE__*/ Symbol(\"NoMatch\")\nexport const End: unique symbol = /*#__PURE__*/ Symbol(\"End\")\n\nexport const nextIf = (state: State<Input>, m: AnyMatcher, negate: boolean): unknown => {\n  const pos = state.pos\n  if (pos >= state.end) return End\n  switch (state.inputKind) {\n    case 0: {\n      const s = state.input as string\n      if (splitSurrogate(state, pos)) return End\n      const cp = codePointAt(s, pos)\n      if (m.forString.code(cp) === negate) return NoMatch\n      const len = cp > 0xffff ? 2 : 1\n      state.pos = pos + len\n      return len === 1 ? s[pos] : s.slice(pos, pos + 2)\n    }\n    case 1: {\n      const b = (state.input as Uint8Array)[pos]\n      if (m.forCode.code(b) === negate) return NoMatch\n      state.pos = pos + 1\n      return b\n    }\n    default: {\n      const t = (state.input as ReadonlyArray<unknown>)[pos]\n      if (m.forCode.token(t) === negate) return NoMatch\n      state.pos = pos + 1\n      return t\n    }\n  }\n}\n\n/** How far a {@link scan} got. */\nexport interface Scanned extends Advanced {\n  /** Whether the end of input was hit before `max` tokens. */\n  readonly hitEnd: boolean\n}\n\n/**\n * Scans forward while tokens satisfy the matcher (xor `negate`), up to `max`\n * tokens. Returns the offset reached, the number of tokens matched, and\n * whether the end of input was hit before `max` tokens.\n */\nexport const scan = (state: State<Input>, m: AnyMatcher, negate: boolean, max: number): Scanned => {\n  let i = state.pos\n  const end = state.end\n  let count = 0\n  switch (state.inputKind) {\n    case 0: {\n      const s = state.input as string\n      const test = m.forString.code\n      while (count < max) {\n        if (i >= end) return { offset: i, count, hitEnd: true }\n        const c = s.charCodeAt(i)\n        if (c < 0xd800 || c > 0xdbff) {\n          if (test(c) === negate) break\n          i++\n        } else {\n          if (splitSurrogate(state, i)) return { offset: i, count, hitEnd: true }\n          const cp = codePointAt(s, i)\n          if (test(cp) === negate) break\n          i += cp > 0xffff ? 2 : 1\n        }\n        count++\n      }\n      return { offset: i, count, hitEnd: false }\n    }\n    case 1: {\n      const bytes = state.input as Uint8Array\n      const test = m.forCode.code\n      while (count < max) {\n        if (i >= end) return { offset: i, count, hitEnd: true }\n        if (test(bytes[i]) === negate) break\n        i++\n        count++\n      }\n      return { offset: i, count, hitEnd: false }\n    }\n    default: {\n      const arr = state.input as ReadonlyArray<unknown>\n      const test = m.forCode.token\n      while (count < max) {\n        if (i >= end) return { offset: i, count, hitEnd: true }\n        if (test(arr[i]) === negate) break\n        i++\n        count++\n      }\n      return { offset: i, count, hitEnd: false }\n    }\n  }\n}\n\n/** The offset reached and the number of tokens passed. */\nexport interface Advanced {\n  readonly offset: number\n  readonly count: number\n}\n\n/** Advances `n` tokens from `start`, returning the offset reached and the count. */\nexport const advance = (state: State<Input>, start: number, n: number): Advanced => {\n  if (state.inputKind !== 0) {\n    const offset = Math.min(state.end, start + n)\n    return { offset, count: offset - start }\n  }\n  const s = state.input as string\n  let i = start\n  let count = 0\n  while (count < n && i < state.end) {\n    if (splitSurrogate(state, i)) break\n    const c = s.charCodeAt(i)\n    i += c >= 0xd800 && c <= 0xdbff && i + 1 < s.length && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00 ? 2 : 1\n    count++\n  }\n  return { offset: i, count }\n}\n\n/** Counts tokens between two offsets. */\nexport const countTokens = (state: State<Input>, start: number, end: number): number => {\n  if (state.inputKind !== 0) return end - start\n  const s = state.input as string\n  let count = 0\n  for (let i = start; i < end; i++) {\n    const c = s.charCodeAt(i)\n    if (c >= 0xd800 && c <= 0xdbff && i + 1 < end && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00) i++\n    count++\n  }\n  return count\n}\n\n/** Finds `needle` within `[from, state.end)`; returns -1 if absent. */\nexport const indexOf = (state: State<Input>, needle: Input, from: number): number => {\n  // The whole needle must lie before `state.end`, which may narrow the input\n  const last = state.end - needle.length\n  if (from > last) return -1\n  switch (state.inputKind) {\n    case 0: {\n      const i = (state.input as string).indexOf(needle as string, from)\n      return i <= last ? i : -1\n    }\n    case 1: {\n      const hay = state.input as Uint8Array\n      const n = needle as Uint8Array\n      if (n.byteLength === 0) return from\n      const first = n[0]\n      let i = hay.indexOf(first, from)\n      while (i !== -1 && i <= last) {\n        let j = 1\n        while (j < n.length && hay[i + j] === n[j]) j++\n        if (j === n.length) return i\n        i = hay.indexOf(first, i + 1)\n      }\n      return -1\n    }\n    default: {\n      const hay = state.input as ReadonlyArray<unknown>\n      const n = needle as ReadonlyArray<unknown>\n      outer: for (let i = from; i <= last; i++) {\n        for (let j = 0; j < n.length; j++) if (hay[i + j] !== n[j]) continue outer\n        return i\n      }\n      return -1\n    }\n  }\n}\n\n/**\n * Compares the input at the current position with a literal. Returns the\n * number of matching units if the literal matches completely (its length),\n * -1 on mismatch, or -2 when the input ends while matching a prefix.\n */\nexport const matchLiteral = (state: State<Input>, lit: Input, caseless: boolean): number => {\n  const r = match(state, lit, caseless)\n  // A failed match may have read up to its length past where it fails (see `Syntax`)\n  if (r < 0 && state.syntax !== undefined) state.syntax.read(state.pos + Math.min(lit.length, state.end - state.pos))\n  return r\n}\n\nconst match = (state: State<Input>, lit: Input, caseless: boolean): number => {\n  const pos = state.pos\n  const len = lit.length\n  const avail = state.end - pos\n  const n = Math.min(len, avail)\n  switch (state.inputKind) {\n    case 0: {\n      const s = state.input as string\n      const l = lit as string\n      if (!caseless) {\n        if (avail >= len) return s.startsWith(l, pos) ? len : -1\n        return l.startsWith(s.slice(pos)) ? -2 : -1\n      }\n      for (let i = 0; i < n; i++) {\n        if (lowerAscii(s.charCodeAt(pos + i)) !== lowerAscii(l.charCodeAt(i))) return -1\n      }\n      return n === len ? len : -2\n    }\n    case 1: {\n      const b = state.input as Uint8Array\n      const l = lit as Uint8Array\n      for (let i = 0; i < n; i++) {\n        const x = b[pos + i]\n        const y = l[i]\n        if (caseless ? lowerAscii(x) !== lowerAscii(y) : x !== y) return -1\n      }\n      return n === len ? len : -2\n    }\n    default: {\n      const a = state.input as ReadonlyArray<unknown>\n      const l = lit as ReadonlyArray<unknown>\n      for (let i = 0; i < n; i++) if (a[pos + i] !== l[i]) return -1\n      return n === len ? len : -2\n    }\n  }\n}\n\nconst lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)\n"],"mappings":";;;;AAwBA,MAAM,WAAW,MAAoC,UAAU,gBAAgB,CAAC,KAAM,EAAU,SAAS;AAEzG,MAAM,UAAU,MAAgC,UAAU,SAAS,CAAC,IAAI,IAAI,eAAe,CAAC;;AAG5F,MAAa,gBAAgB,MAAsB,KAAK,UAAU,CAAC;AAEnE,MAAM,eAAe,MAAuB;CAC1C,IAAI,UAAU,SAAS,CAAC,GAEtB,OADc,MAAM,KAAK,CACd,CAAC,CAAC,WAAW,IAAI,aAAa,CAAC,IAAI,UAAU,KAAK,UAAU,CAAC;CAE1E,IAAI,UAAU,SAAS,CAAC,GAAG,OAAO,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CACrE,IAAI,UAAU,WAAW,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO;CACtD,IAAI,aAAa,YAAY,OAAO,UAAU,cAAc,CAAC;CAC7D,IAAI,QAAQ,CAAC,GAAG,OAAO,GAAG,YAAY,EAAE,IAAI,EAAE,KAAK,YAAY,EAAE,EAAE;CACnE,IAAI,MAAM,QAAQ,CAAC,GAAG,OAAO,EAAE,IAAI,WAAW,CAAC,CAAC,KAAK,MAAM;CAC3D,OAAO,KAAK,UAAU,CAAC;AACzB;;AAGA,MAAM,iBAAiB,UAA8B;CACnD,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,OACd,IAAI,MAAM,IAAM,OAAO;MAClB,IAAI,MAAM,IAAM,OAAO;MACvB,IAAI,MAAM,IAAM,OAAO;MACvB,IAAI,MAAM,IAAM,OAAO;MACvB,IAAI,MAAM,GAAM,OAAO;MACvB,IAAI,KAAK,MAAQ,IAAI,KAAM,OAAO,OAAO,aAAa,CAAC;MACvD,OAAO,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAElD,OAAO,MAAM;AACf;AAEA,MAAM,eAAe,MAA4C;CAC/D,IAAI,UAAU,SAAS,CAAC,GAAG;EACzB,MAAM,QAAQ,MAAM,KAAK,GAAG,cAAc;EAC1C,IAAI,MAAM,WAAW,GAAG;GACtB,MAAM,IAAI,MAAM;GAChB,QAAQ,MAAM,MAAM;EACtB;EACA,OAAO,OAAO,KAAK;CACrB;CACA,IAAI,UAAU,SAAS,CAAC,GAAG,QAAQ,MAAM,MAAM;CAC/C,IAAI,UAAU,WAAW,CAAC,GAAG,OAAO;CACpC,IAAI,aAAa,YAAY,OAAO,OAAO,MAAM,KAAK,CAAC,CAAC;CACxD,IAAI,QAAQ,CAAC,GAAG;EACd,MAAM,OAAO,OAAO,EAAE,IAAI;EAC1B,MAAM,KAAK,OAAO,EAAE,EAAE;EACtB,QAAQ,MAAM,KAAK,QAAQ,KAAK;CAClC;CACA,IAAI,MAAM,QAAQ,CAAC,GAAG;EACpB,MAAM,QAAQ,EAAE,IAAI,WAAW;EAC/B,IAAI,MAAM,WAAW,GAAG,OAAO,MAAM;EACrC,QAAQ,MAAM;GACZ,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,EAAE,CAAC,CAAC,GAAG,OAAO;GAC/D,OAAO;EACT;CACF;CACA,MAAM,IAAI,UAAU,sBAAsB,OAAO,CAAC,GAAG;AACvD;AAEA,MAAM,UAAU,UAA8D;CAC5E,MAAM,wBAAQ,IAAI,WAAW,GAAG;CAChC,IAAI;CACJ,KAAK,MAAM,KAAK,OACd,IAAI,IAAI,KAAK,MAAM,KAAK;MACnB,CAAC,0BAAU,IAAI,IAAI,EAAA,CAAG,IAAI,CAAC;CAElC,IAAI,UAAU,KAAA,GAAW,QAAQ,MAAM,IAAI,OAAO,MAAM,OAAO;CAC/D,MAAM,MAAM;CACZ,QAAQ,MAAO,IAAI,MAAM,MAAM,OAAO,IAAI,IAAI,IAAI,CAAC;AACrD;AAEA,MAAM,gBAAgB,MAA8C;CAClE,IAAI,UAAU,WAAW,CAAC,GAAG,OAAO;CACpC,IAAI,MAAM,QAAQ,CAAC,GAAG;EACpB,MAAM,MAAM,IAAI,IAAI,CAAC;EACrB,QAAQ,MAAM,IAAI,IAAI,CAAC;CACzB;CACA,QAAQ,MAAM,MAAM;AACtB;;;;;;AAOA,MAAM,qBAAkD,qBAAO,IAAI,iCAAiC;;;;;;AAOpG,MAAa,kBAA+C,qBAAO,IAAI,8BAA8B;;;;;AAMrG,MAAa,sBACX,MACA,GACA,WACM;CACN,OAAO,eAAe,GAAG,QAAQ,EAAE,OAAO,KAAK,CAAC;CAC/C,EAAW,sBAAsB;CAClC,IAAI,WAAW,KAAA,GAAW,EAAW,mBAAmB;CACxD,OAAO;AACT;;;;;;AAOA,MAAa,WAAW,KAAc,OAA0B,WAAoB;CAClF,MAAM,cAAc,YAAY,GAAG;CACnC,IAAI;CACJ,IAAI,UAAU,WAAW,GAAG,KAAK,SAAS,YAAY,EAAE,sBAAsB,MAAM;EAClF,MAAM,OAAO;EACb,QAAQ,MAAM,KAAK,OAAO,CAAC,CAAC;CAC9B,OACE,OAAO,gBAAgB,KAAK,IAAI;CAElC,OAAO;EAAE;EAAM,OAAO,aAAa,GAAG;EAAG;CAAY;AACvD;AAEA,MAAM,mBAAmB,KAAc,SAAyD;CAC9F,IAAI,MAAM,QAAQ,GAAG,KAAK,SAAS,UAAU;EAE3C,MAAM,QAAQ,IAAI,KAAK,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,IAAI;EAClD,QAAQ,MAAM;GACZ,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,EAAE,CAAC,CAAC,GAAG,OAAO;GAC/D,OAAO;EACT;CACF;CACA,OAAO,OAAO,UACZ,OAAO,UAAU,YAAY,GAAG,CAAC,eACQ,KAC3C;AACF;;;;;;;;AAmBA,MAAM,UAAa,OAAuB,KAAa,UAAiC;CACtF,IAAI,IAAI,MAAM,IAAI,GAAG;CACrB,IAAI,MAAM,KAAA,GAAW;EACnB,IAAI,MAAM,QAAQ,MAAM,MAAM,MAAM;EACpC,IAAI,MAAM,GAAG;EACb,MAAM,IAAI,KAAK,CAAC;CAClB;CACA,OAAO;AACT;AAEA,MAAM,oCAAoC,IAAI,IAAoB;;AAGlE,MAAa,mBAAmB,QAC9B,UAAU,SAAS,GAAG,IAClB,OAAO,qBAAqB,KAAK,YAAY,IAC7C,eAAe,aACb,cAAc,GAAG,IACjB,IAAI,IAAI,KAAK,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;AAEzD,MAAM,+BAA+B,IAAI,IAAwB;AAEjE,MAAa,cAAc,QAEzB,UAAU,SAAS,GAAG,IAAI,OAAO,gBAAgB,KAAK,cAAc,IAAI,eAAe,GAAG;AAE5F,MAAM,kBAAkB,QAA6B;CACnD,MAAM,UAAU,QAAQ,KAAK,MAAM;CAEnC,OAAO;EACL,WAFkB,UAAU,WAAW,GAAG,KAAK,MAAM,QAAQ,GAAG,IAEvC,QAAQ,KAAK,QAAQ,IAAI;EAClD;EACA,aAAa,QAAQ;CACvB;AACF;;;;;;AAOA,MAAa,kBAAkB,OAAqB,MAAuB;CACzE,IAAI,CAAC,MAAM,WAAW,MAAM,MAAM,MAAM,GAAG,OAAO;CAClD,MAAM,IAAK,MAAM,MAAiB,WAAW,CAAC;CAC9C,OAAO,KAAK,SAAU,KAAK;AAC7B;;AAGA,MAAM,eAAe,GAAW,MAAsB;CACpD,MAAM,IAAI,EAAE,WAAW,CAAC;CACxB,IAAI,KAAK,SAAU,KAAK,SAAU,IAAI,IAAI,EAAE,QAAQ;EAClD,MAAM,IAAI,EAAE,WAAW,IAAI,CAAC;EAC5B,IAAI,KAAK,SAAU,KAAK,OAAQ,QAAS,IAAI,SAAW,OAAO,IAAI,SAAU;CAC/E;CACA,OAAO;AACT;;;;;AAMA,MAAa,UAAuC,qBAAO,SAAS;AACpE,MAAa,MAAmC,qBAAO,KAAK;AAE5D,MAAa,UAAU,OAAqB,GAAe,WAA6B;CACtF,MAAM,MAAM,MAAM;CAClB,IAAI,OAAO,MAAM,KAAK,OAAO;CAC7B,QAAQ,MAAM,WAAd;EACE,KAAK,GAAG;GACN,MAAM,IAAI,MAAM;GAChB,IAAI,eAAe,OAAO,GAAG,GAAG,OAAO;GACvC,MAAM,KAAK,YAAY,GAAG,GAAG;GAC7B,IAAI,EAAE,UAAU,KAAK,EAAE,MAAM,QAAQ,OAAO;GAC5C,MAAM,MAAM,KAAK,QAAS,IAAI;GAC9B,MAAM,MAAM,MAAM;GAClB,OAAO,QAAQ,IAAI,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;EAClD;EACA,KAAK,GAAG;GACN,MAAM,IAAK,MAAM,MAAqB;GACtC,IAAI,EAAE,QAAQ,KAAK,CAAC,MAAM,QAAQ,OAAO;GACzC,MAAM,MAAM,MAAM;GAClB,OAAO;EACT;EACA,SAAS;GACP,MAAM,IAAK,MAAM,MAAiC;GAClD,IAAI,EAAE,QAAQ,MAAM,CAAC,MAAM,QAAQ,OAAO;GAC1C,MAAM,MAAM,MAAM;GAClB,OAAO;EACT;CACF;AACF;;;;;;AAaA,MAAa,QAAQ,OAAqB,GAAe,QAAiB,QAAyB;CACjG,IAAI,IAAI,MAAM;CACd,MAAM,MAAM,MAAM;CAClB,IAAI,QAAQ;CACZ,QAAQ,MAAM,WAAd;EACE,KAAK,GAAG;GACN,MAAM,IAAI,MAAM;GAChB,MAAM,OAAO,EAAE,UAAU;GACzB,OAAO,QAAQ,KAAK;IAClB,IAAI,KAAK,KAAK,OAAO;KAAE,QAAQ;KAAG;KAAO,QAAQ;IAAK;IACtD,MAAM,IAAI,EAAE,WAAW,CAAC;IACxB,IAAI,IAAI,SAAU,IAAI,OAAQ;KAC5B,IAAI,KAAK,CAAC,MAAM,QAAQ;KACxB;IACF,OAAO;KACL,IAAI,eAAe,OAAO,CAAC,GAAG,OAAO;MAAE,QAAQ;MAAG;MAAO,QAAQ;KAAK;KACtE,MAAM,KAAK,YAAY,GAAG,CAAC;KAC3B,IAAI,KAAK,EAAE,MAAM,QAAQ;KACzB,KAAK,KAAK,QAAS,IAAI;IACzB;IACA;GACF;GACA,OAAO;IAAE,QAAQ;IAAG;IAAO,QAAQ;GAAM;EAC3C;EACA,KAAK,GAAG;GACN,MAAM,QAAQ,MAAM;GACpB,MAAM,OAAO,EAAE,QAAQ;GACvB,OAAO,QAAQ,KAAK;IAClB,IAAI,KAAK,KAAK,OAAO;KAAE,QAAQ;KAAG;KAAO,QAAQ;IAAK;IACtD,IAAI,KAAK,MAAM,EAAE,MAAM,QAAQ;IAC/B;IACA;GACF;GACA,OAAO;IAAE,QAAQ;IAAG;IAAO,QAAQ;GAAM;EAC3C;EACA,SAAS;GACP,MAAM,MAAM,MAAM;GAClB,MAAM,OAAO,EAAE,QAAQ;GACvB,OAAO,QAAQ,KAAK;IAClB,IAAI,KAAK,KAAK,OAAO;KAAE,QAAQ;KAAG;KAAO,QAAQ;IAAK;IACtD,IAAI,KAAK,IAAI,EAAE,MAAM,QAAQ;IAC7B;IACA;GACF;GACA,OAAO;IAAE,QAAQ;IAAG;IAAO,QAAQ;GAAM;EAC3C;CACF;AACF;;AASA,MAAa,WAAW,OAAqB,OAAe,MAAwB;CAClF,IAAI,MAAM,cAAc,GAAG;EACzB,MAAM,SAAS,KAAK,IAAI,MAAM,KAAK,QAAQ,CAAC;EAC5C,OAAO;GAAE;GAAQ,OAAO,SAAS;EAAM;CACzC;CACA,MAAM,IAAI,MAAM;CAChB,IAAI,IAAI;CACR,IAAI,QAAQ;CACZ,OAAO,QAAQ,KAAK,IAAI,MAAM,KAAK;EACjC,IAAI,eAAe,OAAO,CAAC,GAAG;EAC9B,MAAM,IAAI,EAAE,WAAW,CAAC;EACxB,KAAK,KAAK,SAAU,KAAK,SAAU,IAAI,IAAI,EAAE,WAAW,EAAE,WAAW,IAAI,CAAC,IAAI,WAAY,QAAS,IAAI;EACvG;CACF;CACA,OAAO;EAAE,QAAQ;EAAG;CAAM;AAC5B;;AAGA,MAAa,eAAe,OAAqB,OAAe,QAAwB;CACtF,IAAI,MAAM,cAAc,GAAG,OAAO,MAAM;CACxC,MAAM,IAAI,MAAM;CAChB,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,KAAK;EAChC,MAAM,IAAI,EAAE,WAAW,CAAC;EACxB,IAAI,KAAK,SAAU,KAAK,SAAU,IAAI,IAAI,QAAQ,EAAE,WAAW,IAAI,CAAC,IAAI,WAAY,OAAQ;EAC5F;CACF;CACA,OAAO;AACT;;AAGA,MAAa,WAAW,OAAqB,QAAe,SAAyB;CAEnF,MAAM,OAAO,MAAM,MAAM,OAAO;CAChC,IAAI,OAAO,MAAM,OAAO;CACxB,QAAQ,MAAM,WAAd;EACE,KAAK,GAAG;GACN,MAAM,IAAK,MAAM,MAAiB,QAAQ,QAAkB,IAAI;GAChE,OAAO,KAAK,OAAO,IAAI;EACzB;EACA,KAAK,GAAG;GACN,MAAM,MAAM,MAAM;GAClB,MAAM,IAAI;GACV,IAAI,EAAE,eAAe,GAAG,OAAO;GAC/B,MAAM,QAAQ,EAAE;GAChB,IAAI,IAAI,IAAI,QAAQ,OAAO,IAAI;GAC/B,OAAO,MAAM,MAAM,KAAK,MAAM;IAC5B,IAAI,IAAI;IACR,OAAO,IAAI,EAAE,UAAU,IAAI,IAAI,OAAO,EAAE,IAAI;IAC5C,IAAI,MAAM,EAAE,QAAQ,OAAO;IAC3B,IAAI,IAAI,QAAQ,OAAO,IAAI,CAAC;GAC9B;GACA,OAAO;EACT;EACA,SAAS;GACP,MAAM,MAAM,MAAM;GAClB,MAAM,IAAI;GACV,OAAO,KAAK,IAAI,IAAI,MAAM,KAAK,MAAM,KAAK;IACxC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,IAAI,IAAI,OAAO,EAAE,IAAI,SAAS;IACrE,OAAO;GACT;GACA,OAAO;EACT;CACF;AACF;;;;;;AAOA,MAAa,gBAAgB,OAAqB,KAAY,aAA8B;CAC1F,MAAM,IAAI,MAAM,OAAO,KAAK,QAAQ;CAEpC,IAAI,IAAI,KAAK,MAAM,WAAW,KAAA,GAAW,MAAM,OAAO,KAAK,MAAM,MAAM,KAAK,IAAI,IAAI,QAAQ,MAAM,MAAM,MAAM,GAAG,CAAC;CAClH,OAAO;AACT;AAEA,MAAM,SAAS,OAAqB,KAAY,aAA8B;CAC5E,MAAM,MAAM,MAAM;CAClB,MAAM,MAAM,IAAI;CAChB,MAAM,QAAQ,MAAM,MAAM;CAC1B,MAAM,IAAI,KAAK,IAAI,KAAK,KAAK;CAC7B,QAAQ,MAAM,WAAd;EACE,KAAK,GAAG;GACN,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI;GACV,IAAI,CAAC,UAAU;IACb,IAAI,SAAS,KAAK,OAAO,EAAE,WAAW,GAAG,GAAG,IAAI,MAAM;IACtD,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC,IAAI,KAAK;GAC3C;GACA,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,IAAI,WAAW,EAAE,WAAW,MAAM,CAAC,CAAC,MAAM,WAAW,EAAE,WAAW,CAAC,CAAC,GAAG,OAAO;GAEhF,OAAO,MAAM,MAAM,MAAM;EAC3B;EACA,KAAK,GAAG;GACN,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;IAC1B,MAAM,IAAI,EAAE,MAAM;IAClB,MAAM,IAAI,EAAE;IACZ,IAAI,WAAW,WAAW,CAAC,MAAM,WAAW,CAAC,IAAI,MAAM,GAAG,OAAO;GACnE;GACA,OAAO,MAAM,MAAM,MAAM;EAC3B;EACA,SAAS;GACP,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,EAAE,MAAM,OAAO,EAAE,IAAI,OAAO;GAC5D,OAAO,MAAM,MAAM,MAAM;EAC3B;CACF;AACF;AAEA,MAAM,cAAc,MAAuB,KAAK,MAAM,KAAK,KAAK,IAAI,KAAK"}
+{"version":3,"file":"tokens.js","names":[],"sources":["../../src/internal/tokens.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\"\nimport * as Result from \"effect/Result\"\nimport type { Input, State } from \"../Input.js\"\nimport { charOf, firstCodePoint } from \"./text.js\"\n\n/** A compiled token set. */\nexport interface Matcher {\n  /** Tests a code point (string input) or a byte (Uint8Array input). */\n  readonly code: (code: number) => boolean\n  /** Tests an element of an array input. */\n  readonly token: (token: unknown) => boolean\n  /** Human readable description, used in error messages. */\n  readonly description: string\n}\n\n/** @internal */\nexport interface TokenRangeLike {\n  readonly _tag: \"TokenRange\"\n  readonly from: string | number\n  readonly to: string | number\n}\n\nconst isRange = (u: unknown): u is TokenRangeLike => Predicate.isObjectOrArray(u) && Predicate.isTagged(u, \"TokenRange\")\n\nconst toCode = (u: string | number): number => (Predicate.isNumber(u) ? u : firstCodePoint(u))\n\n/** @internal */\nexport const describeChar = (s: string): string => JSON.stringify(s)\n\nconst describeSet = (u: unknown): string => {\n  if (Predicate.isString(u)) {\n    const chars = Array.from(u)\n    return chars.length === 1 ? describeChar(u) : `one of ${JSON.stringify(u)}`\n  }\n  if (Predicate.isNumber(u)) return `0x${u.toString(16).padStart(2, \"0\")}`\n  if (Predicate.isFunction(u)) return u.name ? u.name : \"a matching token\"\n  if (u instanceof Uint8Array) return `one of ${describeBytes(u)}`\n  if (isRange(u)) return `${describeSet(u.from)}..=${describeSet(u.to)}`\n  if (Array.isArray(u)) return u.map(describeSet).join(\" or \")\n  return JSON.stringify(u)\n}\n\n/** Renders bytes as a Rust-style byte string literal: b\"GET\\r\\n\". */\nconst describeBytes = (bytes: Uint8Array): string => {\n  let out = 'b\"'\n  for (const b of bytes) {\n    if (b === 0x22) out += '\\\\\"'\n    else if (b === 0x5c) out += \"\\\\\\\\\"\n    else if (b === 0x0a) out += \"\\\\n\"\n    else if (b === 0x0d) out += \"\\\\r\"\n    else if (b === 0x09) out += \"\\\\t\"\n    else if (b >= 0x20 && b < 0x7f) out += String.fromCharCode(b)\n    else out += `\\\\x${b.toString(16).padStart(2, \"0\")}`\n  }\n  return out + '\"'\n}\n\nconst compileCode = (u: unknown): ((code: number) => boolean) => {\n  if (Predicate.isString(u)) {\n    const codes = Array.from(u, firstCodePoint)\n    if (codes.length === 1) {\n      const c = codes[0]\n      return (x) => x === c\n    }\n    return bitmap(codes)\n  }\n  if (Predicate.isNumber(u)) return (x) => x === u\n  if (Predicate.isFunction(u)) {\n    // SAFETY: a predicate compiled for codes is a byte, code point or `codePoints` predicate (`compile` wraps string predicates first)\n    return u as (code: number) => boolean\n  }\n  if (u instanceof Uint8Array) return bitmap(Array.from(u))\n  if (isRange(u)) {\n    const from = toCode(u.from)\n    const to = toCode(u.to)\n    return (x) => x >= from && x <= to\n  }\n  if (Array.isArray(u)) {\n    const tests = u.map(compileCode)\n    if (tests.length === 1) return tests[0]\n    return (x) => {\n      for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true\n      return false\n    }\n  }\n  throw new TypeError(`invalid token set: ${String(u)}`)\n}\n\nconst bitmap = (codes: ReadonlyArray<number>): ((code: number) => boolean) => {\n  const ascii = new Uint8Array(256)\n  let other: Set<number> | undefined\n  for (const c of codes) {\n    if (c < 256) ascii[c] = 1\n    else (other ??= new Set()).add(c)\n  }\n  if (other === undefined) return (x) => x < 256 && ascii[x] === 1\n  const set = other\n  return (x) => (x < 256 ? ascii[x] === 1 : set.has(x))\n}\n\nconst compileToken = (u: unknown): ((token: unknown) => boolean) => {\n  if (Predicate.isFunction(u)) {\n    // SAFETY: a predicate in an array input's token set takes the array's elements, the tokens tested here\n    return u as (token: unknown) => boolean\n  }\n  if (Array.isArray(u)) {\n    const set = new Set(u)\n    return (t) => set.has(t)\n  }\n  return (t) => t === u\n}\n\n/**\n * Marks a predicate over characters that also accepts a code point (a\n * number), so string inputs can call it without allocating a string per\n * character.\n */\nconst CodePointPredicate: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/CodePointPredicate\")\n\n/**\n * The code points accepted by a predicate, as sorted, disjoint, inclusive\n * ranges, when they are known. The compiler turns such predicates into\n * comparisons or tables.\n */\nexport const PredicateRanges: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/PredicateRanges\")\n\n/**\n * Marks `f` as a {@link CodePointPredicate} named `name` (used in error\n * messages), optionally recording the code point ranges it accepts.\n */\nexport const codePointPredicate = <F extends (c: never) => boolean>(\n  name: string,\n  f: F,\n  ranges?: ReadonlyArray<readonly [number, number]>\n): F => {\n  Object.defineProperty(f, \"name\", { value: name })\n  // SAFETY: `f` is a function object, which takes new properties; the intersection only names the two markers set here\n  const marked = f as F & {\n    [CodePointPredicate]?: true\n    [PredicateRanges]?: ReadonlyArray<readonly [number, number]>\n  }\n  marked[CodePointPredicate] = true\n  if (ranges !== undefined) marked[PredicateRanges] = ranges\n  return f\n}\n\n/**\n * Compiles a token set. Predicates for string inputs receive the token as a\n * string, so they are wrapped here; `charOf` avoids `String.fromCodePoint`,\n * which is several times slower, for the Basic Multilingual Plane.\n */\nexport const compile = (set: unknown, kind: \"string\" | \"code\" = \"code\"): Matcher => {\n  const description = describeSet(set)\n  let code: (code: number) => boolean\n  if (Predicate.isFunction(set) && kind === \"string\" && !(CodePointPredicate in set)) {\n    // SAFETY: an unmarked predicate in a string token set takes each character as a string (`StringTokenSet`)\n    const pred = set as (c: string) => boolean\n    code = (x) => pred(charOf(x))\n  } else {\n    code = compileCodeSafe(set, kind)\n  }\n  return { code, token: compileToken(set), description }\n}\n\nconst compileCodeSafe = (set: unknown, kind: \"string\" | \"code\"): ((code: number) => boolean) => {\n  if (Array.isArray(set) && kind === \"string\") {\n    // Predicates nested in arrays also take strings\n    const tests = set.map((s) => compile(s, kind).code)\n    return (x) => {\n      for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true\n      return false\n    }\n  }\n  return Result.getOrElse(\n    Result.try(() => compileCode(set)),\n    (): ((code: number) => boolean) => () => false\n  )\n}\n\n/**\n * A matcher that works for every input kind. String predicates receive the\n * token as a string, byte predicates receive numbers.\n */\nexport interface AnyMatcher {\n  readonly forString: Matcher\n  readonly forCode: Matcher\n  readonly description: string\n}\n\n/**\n * A small cache keyed by value, for the parts of a parser that are costly to\n * build and depend only on a string (compiled sets, descriptions). Parsers\n * built inside `Parser.gen` bodies are rebuilt on every run, usually from the\n * same few strings. Dynamic strings could grow it without bound, so it is\n * cleared when full.\n */\nconst cached = <A>(cache: Map<string, A>, key: string, build: (key: string) => A): A => {\n  let a = cache.get(key)\n  if (a === undefined) {\n    if (cache.size >= 1024) cache.clear()\n    a = build(key)\n    cache.set(key, a)\n  }\n  return a\n}\n\nconst literalDescriptions = /*#__PURE__*/ new Map<string, string>()\n\n/** Describes a literal for error messages: `\"abc\"`, `b\"abc\"` or `[\"a\", 1]`. */\nexport const describeLiteral = (lit: Input): string =>\n  Predicate.isString(lit)\n    ? cached(literalDescriptions, lit, describeChar)\n    : lit instanceof Uint8Array\n      ? describeBytes(lit)\n      : `[${lit.map((t) => JSON.stringify(t)).join(\", \")}]`\n\nconst stringMatchers = /*#__PURE__*/ new Map<string, AnyMatcher>()\n\nexport const compileAny = (set: unknown): AnyMatcher =>\n  // Matchers for strings are pure functions of the string, so they're shared\n  Predicate.isString(set) ? cached(stringMatchers, set, compileAnyImpl) : compileAnyImpl(set)\n\nconst compileAnyImpl = (set: unknown): AnyMatcher => {\n  const forCode = compile(set, \"code\")\n  const needsString = Predicate.isFunction(set) || Array.isArray(set)\n  return {\n    forString: needsString ? compile(set, \"string\") : forCode,\n    forCode,\n    description: forCode.description\n  }\n}\n\n/**\n * Whether the string token at `i` is a high surrogate at the very end of a\n * partial input, i.e. the first half of a code point whose second half has\n * not arrived yet.\n */\nexport const splitSurrogate = (state: State<Input>, i: number): boolean => {\n  if (!state.partial || i !== state.end - 1) return false\n  // SAFETY: called only on string input (the `inputKind === 0` paths of `nextIf`, `scan`, `advance` and `Token.any`)\n  const c = (state.input as string).charCodeAt(i)\n  return c >= 0xd800 && c <= 0xdbff\n}\n\n/** Reads the code point at `i` of a string. */\nconst codePointAt = (s: string, i: number): number => {\n  const c = s.charCodeAt(i)\n  if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {\n    const d = s.charCodeAt(i + 1)\n    if (d >= 0xdc00 && d <= 0xdfff) return ((c - 0xd800) << 10) + (d - 0xdc00) + 0x10000\n  }\n  return c\n}\n\n/**\n * Tests the token at the current position. Returns the token (as the input's\n * token type) and advances, or returns `NoMatch`/`End`.\n */\nexport const NoMatch: unique symbol = /*#__PURE__*/ Symbol(\"NoMatch\")\nexport const End: unique symbol = /*#__PURE__*/ Symbol(\"End\")\n\nexport const nextIf = (state: State<Input>, m: AnyMatcher, negate: boolean): unknown => {\n  const pos = state.pos\n  if (pos >= state.end) return End\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input\n      const s = state.input as string\n      if (splitSurrogate(state, pos)) return End\n      const cp = codePointAt(s, pos)\n      if (m.forString.code(cp) === negate) return NoMatch\n      const len = cp > 0xffff ? 2 : 1\n      state.pos = pos + len\n      return len === 1 ? s[pos] : s.slice(pos, pos + 2)\n    }\n    case 1: {\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      const b = (state.input as Uint8Array)[pos]\n      if (m.forCode.code(b) === negate) return NoMatch\n      state.pos = pos + 1\n      return b\n    }\n    default: {\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      const t = (state.input as ReadonlyArray<unknown>)[pos]\n      if (m.forCode.token(t) === negate) return NoMatch\n      state.pos = pos + 1\n      return t\n    }\n  }\n}\n\n/** How far a {@link scan} got. */\nexport interface Scanned extends Advanced {\n  /** Whether the end of input was hit before `max` tokens. */\n  readonly hitEnd: boolean\n}\n\n/** The one record {@link scan} fills; see there. */\nclass ScanResult implements Scanned {\n  offset = 0\n  count = 0\n  hitEnd = false\n}\n\nconst scanned = /*#__PURE__*/ new ScanResult()\n\n/** Fills {@link scanned} and returns it. */\nconst scannedAt = (offset: number, count: number, hitEnd: boolean): Scanned => {\n  scanned.offset = offset\n  scanned.count = count\n  scanned.hitEnd = hitEnd\n  return scanned\n}\n\n/**\n * Scans forward while tokens satisfy the matcher (xor `negate`), up to `max`\n * tokens. Returns the offset reached, the number of tokens matched, and\n * whether the end of input was hit before `max` tokens.\n *\n * The result is one shared record, overwritten by the next scan: read it\n * before running anything else. Allocating one per call cost the\n * interpreter a record per token, since `scan` (shared by every `takeWhile`)\n * is too polymorphic for V8 to inline and remove it.\n */\nexport const scan = (state: State<Input>, m: AnyMatcher, negate: boolean, max: number): Scanned => {\n  let i = state.pos\n  const end = state.end\n  let count = 0\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input\n      const s = state.input as string\n      const test = m.forString.code\n      while (count < max) {\n        if (i >= end) return scannedAt(i, count, true)\n        const c = s.charCodeAt(i)\n        if (c < 0xd800 || c > 0xdbff) {\n          if (test(c) === negate) break\n          i++\n        } else {\n          if (splitSurrogate(state, i)) return scannedAt(i, count, true)\n          const cp = codePointAt(s, i)\n          if (test(cp) === negate) break\n          i += cp > 0xffff ? 2 : 1\n        }\n        count++\n      }\n      return scannedAt(i, count, false)\n    }\n    case 1: {\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      const bytes = state.input as Uint8Array\n      const test = m.forCode.code\n      while (count < max) {\n        if (i >= end) return scannedAt(i, count, true)\n        if (test(bytes[i]) === negate) break\n        i++\n        count++\n      }\n      return scannedAt(i, count, false)\n    }\n    default: {\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      const arr = state.input as ReadonlyArray<unknown>\n      const test = m.forCode.token\n      while (count < max) {\n        if (i >= end) return scannedAt(i, count, true)\n        if (test(arr[i]) === negate) break\n        i++\n        count++\n      }\n      return scannedAt(i, count, false)\n    }\n  }\n}\n\n/** The offset reached and the number of tokens passed. */\nexport interface Advanced {\n  readonly offset: number\n  readonly count: number\n}\n\n/** Advances `n` tokens from `start`, returning the offset reached and the count. */\nexport const advance = (state: State<Input>, start: number, n: number): Advanced => {\n  if (state.inputKind !== 0) {\n    const offset = Math.min(state.end, start + n)\n    return { offset, count: offset - start }\n  }\n  // SAFETY: the other input kinds returned above, and `inputKind` 0 is set only for a string input\n  const s = state.input as string\n  let i = start\n  let count = 0\n  while (count < n && i < state.end) {\n    if (splitSurrogate(state, i)) break\n    const c = s.charCodeAt(i)\n    i += c >= 0xd800 && c <= 0xdbff && i + 1 < s.length && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00 ? 2 : 1\n    count++\n  }\n  return { offset: i, count }\n}\n\n/** Counts tokens between two offsets. */\nexport const countTokens = (state: State<Input>, start: number, end: number): number => {\n  if (state.inputKind !== 0) return end - start\n  // SAFETY: the other input kinds returned above, and `inputKind` 0 is set only for a string input\n  const s = state.input as string\n  let count = 0\n  for (let i = start; i < end; i++) {\n    const c = s.charCodeAt(i)\n    if (c >= 0xd800 && c <= 0xdbff && i + 1 < end && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00) i++\n    count++\n  }\n  return count\n}\n\n/**\n * The first index at or after `from` of any of `needles` within\n * `[from, state.end)`, or -1. The state remembers, under `needles`, where\n * each one next occurs (`[from, at]` at `2 * i`), so successive searches\n * forwards over one input search each needle once per occurrence rather\n * than once per call (as `nextStop` does for `takeTill`).\n */\nexport const indexOfAny = (state: State<Input>, needles: ReadonlyArray<Input>, from: number): number => {\n  const searches = (state.searches ??= new Map())\n  let memo = searches.get(needles)\n  if (memo === undefined) {\n    memo = needles.flatMap(() => [-1, -1])\n    searches.set(needles, memo)\n  }\n  let best = -1\n  for (let i = 0; i < needles.length; i++) {\n    const known = memo[2 * i] ?? -1\n    let at = memo[2 * i + 1] ?? -1\n    const needle = needles[i] ?? \"\"\n    // Searched again when the input's end moved before a remembered occurrence\n    if (known < 0 || from < known || (at >= 0 && (at < from || at > state.end - needle.length))) {\n      at = indexOf(state, needle, from)\n      memo[2 * i] = from\n      memo[2 * i + 1] = at\n    }\n    if (at >= 0 && (best < 0 || at < best)) best = at\n  }\n  return best\n}\n\n/** Finds `needle` within `[from, state.end)`; returns -1 if absent. */\nexport const indexOf = (state: State<Input>, needle: Input, from: number): number => {\n  // The whole needle must lie before `state.end`, which may narrow the input\n  const last = state.end - needle.length\n  if (from > last) return -1\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input, and the callers' types give the needle the input's kind\n      const i = (state.input as string).indexOf(needle as string, from)\n      return i <= last ? i : -1\n    }\n    case 1: {\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      const hay = state.input as Uint8Array\n      // SAFETY: the callers' types give the needle the input's kind (`Text` encodes it for byte input)\n      const n = needle as Uint8Array\n      if (n.byteLength === 0) return from\n      const first = n[0]\n      let i = hay.indexOf(first, from)\n      while (i !== -1 && i <= last) {\n        let j = 1\n        while (j < n.length && hay[i + j] === n[j]) j++\n        if (j === n.length) return i\n        i = hay.indexOf(first, i + 1)\n      }\n      return -1\n    }\n    default: {\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      const hay = state.input as ReadonlyArray<unknown>\n      // SAFETY: the callers' types give the needle the input's kind, an array of the same element type\n      const n = needle as ReadonlyArray<unknown>\n      outer: for (let i = from; i <= last; i++) {\n        for (let j = 0; j < n.length; j++) if (hay[i + j] !== n[j]) continue outer\n        return i\n      }\n      return -1\n    }\n  }\n}\n\n/**\n * Compares the input at the current position with a literal. Returns the\n * number of matching units if the literal matches completely (its length),\n * -1 on mismatch, or -2 when the input ends while matching a prefix.\n */\nexport const matchLiteral = (state: State<Input>, lit: Input, caseless: boolean): number => {\n  const r = match(state, lit, caseless)\n  // A failed match may have read up to its length past where it fails (see `Syntax`)\n  if (r < 0 && state.syntax !== undefined) state.syntax.read(state.pos + Math.min(lit.length, state.end - state.pos))\n  return r\n}\n\nconst match = (state: State<Input>, lit: Input, caseless: boolean): number => {\n  const pos = state.pos\n  const len = lit.length\n  const avail = state.end - pos\n  const n = Math.min(len, avail)\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input\n      const s = state.input as string\n      // SAFETY: the callers' types give the literal the input's kind (`Token.literal` encodes a string literal for byte input)\n      const l = lit as string\n      if (!caseless) {\n        if (avail >= len) return s.startsWith(l, pos) ? len : -1\n        return l.startsWith(s.slice(pos)) ? -2 : -1\n      }\n      for (let i = 0; i < n; i++) {\n        if (lowerAscii(s.charCodeAt(pos + i)) !== lowerAscii(l.charCodeAt(i))) return -1\n      }\n      return n === len ? len : -2\n    }\n    case 1: {\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      const b = state.input as Uint8Array\n      // SAFETY: the callers' types give the literal the input's kind (`Token.literal` and `Text` encode string literals for byte input)\n      const l = lit as Uint8Array\n      for (let i = 0; i < n; i++) {\n        const x = b[pos + i]\n        const y = l[i]\n        if (caseless ? lowerAscii(x) !== lowerAscii(y) : x !== y) return -1\n      }\n      return n === len ? len : -2\n    }\n    default: {\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      const a = state.input as ReadonlyArray<unknown>\n      // SAFETY: the callers' types give the literal the input's kind, an array of the same element type\n      const l = lit as ReadonlyArray<unknown>\n      for (let i = 0; i < n; i++) if (a[pos + i] !== l[i]) return -1\n      return n === len ? len : -2\n    }\n  }\n}\n\nconst lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package",
   "name": "@thomasfosterau/effect-parse",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Parser combinators for Effect, ported from Rust's nom and winnow: text, bytes, bits and token streams, streaming input, compiled parsers and Schema integration",
   "keywords": [
     "effect",
@@ -102,13 +102,14 @@
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.3",
     "@effect/language-service": "^0.87.5",
+    "@effect/platform-node-shared": "4.1.1",
     "@effect/tsgo": "0.63.0",
-    "@enfect/oxlint": "^0.9.0",
+    "@enfect/oxlint": "^0.10.0",
     "@types/node": "^26.6.5",
     "@typescript/native": "npm:typescript@7.0.2",
     "@vitest/coverage-istanbul": "5.0.5",
-    "effect": "4.1.0",
-    "fallow": "3.37.0",
+    "effect": "4.1.1",
+    "fallow": "3.40.0",
     "rolldown": "^1.2.14",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",

package/src/Ascii.ts

@@ -183,8 +183,13 @@ const alnumSet = [/*#__PURE__*/ range("a", "z"), /*#__PURE__*/ range("A", "Z"),
 const spaceSet = " \t"
 const multispaceSet = " \t\r\n"
 
-const cls = (set: unknown, min: 0 | 1, description: string, kind: ErrorKind, hint = true): Parser<string> =>
-  takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)
+const cls = (
+  set: Token.StringTokenSet,
+  min: 0 | 1,
+  description: string,
+  kind: ErrorKind,
+  hint = true
+): Parser<string> => takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)
 
 // -----------------------------------------------------------------------------
 // Character classes
@@ -359,6 +364,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
     const isString = state.inputKind === 0
     let i = start
     while (i < state.end) {
+      // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string
       const c = isString ? (input as string).charCodeAt(i) : (input as Uint8Array)[i]
       if (c === 10) break
       if (c === 13) {
@@ -368,6 +374,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
           if (state.partial) return state.incomplete(1, expectedLineEnding)
           return state.backtrack("LineEnding", expectedLineEnding, i)
         }
+        // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string
         const d = isString ? (input as string).charCodeAt(i + 1) : (input as Uint8Array)[i + 1]
         if (d === 10) break
         return state.backtrack("LineEnding", expectedLineEnding, i)
@@ -376,6 +383,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
     }
     if (i >= state.end && state.partial) return state.incomplete(1, expectedLineEnding)
     state.pos = i
+    // SAFETY: on string input, the input type of a `Parser<string>`, the slice is a string (`bytes` retypes it for bytes)
     return state.slice(start, i) as string
   },
   "tillLineEnding",
@@ -471,7 +479,7 @@ const unsignedFloat = /*#__PURE__*/ P.alt(
 const floatText = /*#__PURE__*/ numbers.floatText(
   /*#__PURE__*/ P.taken(
     /*#__PURE__*/ P.alt(/*#__PURE__*/ literalImpl("nan", true), /*#__PURE__*/ P.seq(sign, unsignedFloat))
-  ).pipe(/*#__PURE__*/ P.expected("number")) as Parser<string>
+  ).pipe(/*#__PURE__*/ P.expected("number"))
 )
 
 /** @internal */
@@ -501,6 +509,17 @@ export const float: Parser<number> = /*#__PURE__*/ floatText.pipe(
 // Literals
 // -----------------------------------------------------------------------------
 
+/**
+ * The overloads of {@link caseless}.
+ *
+ * @since 0.5.0
+ * @category literals
+ */
+export interface CaselessFn {
+  (literal: string): Parser<string>
+  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>
+}
+
 /**
  * Matches a literal ignoring ASCII case (winnow's `Caseless`, nom's
  * `tag_no_case`). Returns the input as written.
@@ -508,10 +527,7 @@ export const float: Parser<number> = /*#__PURE__*/ floatText.pipe(
  * @since 0.1.0
  * @category literals
  */
-export const caseless: {
-  (literal: string): Parser<string>
-  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>
-} = (lit: string | Uint8Array): any => literalImpl(lit, true)
+export const caseless: CaselessFn = (lit: string | Uint8Array): any => literalImpl(lit, true)
 
 // -----------------------------------------------------------------------------
 // Escapes
@@ -522,6 +538,7 @@ const controlCode = (c: string | number): number => (Predicate.isNumber(c) ? c :
 const atControl = (state: State<Input>, control: number): boolean => {
   if (state.pos >= state.end) return false
   const input = state.input
+  // SAFETY: escapes are read from strings or `Uint8Array`s, and `inputKind` 0 is set only for a string
   const c = state.inputKind === 0 ? (input as string).charCodeAt(state.pos) : (input as Uint8Array)[state.pos]
   return c === control
 }
@@ -559,6 +576,7 @@ export const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Inpu
       return true
     },
     escapable,
+    // SAFETY: the parser runs on input of type `I & I2`, and `State.slice` returns that input's own slice type
     (state, start) => state.slice(start, state.pos) as Slice<I & I2>,
     ctrl,
     undefined
@@ -593,9 +611,11 @@ export const takeEscapedImpl = <A, E, R, I extends Input, B, E2, R2, I2 extends
       const start = state.pos
       let resumed = false
       if (state.resume !== undefined) {
+        // SAFETY: under its own `key`, this parser saves only a resume offset (`suspendAt`) or a `Done`
         const checkpoint = Resume.take(state, key, start) as number | Resume.Done | undefined
         if (checkpoint instanceof Resume.Done) {
           state.pos = checkpoint.pos
+          // SAFETY: a `Done` saved under this parser's `key` holds the `S` it returned
           return checkpoint.value as S
         }
         if (checkpoint !== undefined) {
@@ -701,9 +721,11 @@ export const escapedImpl = <E, R, I extends Input, E2, R2, I2 extends Input>(
       let out = ""
       let resumed = false
       if (state.resume !== undefined) {
+        // SAFETY: under its own `key`, this parser saves only an `EscapedCheckpoint` (`suspendAt`) or a `Done`
         const checkpoint = Resume.take(state, key, start) as EscapedCheckpoint | Resume.Done | undefined
         if (checkpoint instanceof Resume.Done) {
           state.pos = checkpoint.pos
+          // SAFETY: a `Done` saved under this parser's `key` holds the string it returned
           return checkpoint.value as string
         }
         if (checkpoint !== undefined) {
@@ -754,6 +776,14 @@ type Bytes<P> =
     ? Parser<A extends string ? Uint8Array : A, E, R, Uint8Array>
     : never
 
+/**
+ * Gives a value the type of another view of the same parsers (see
+ * {@link bytes}).
+ */
+const retype = <T>(value: unknown): T =>
+  // SAFETY: callers pass the byte views' parsers, which are the string parsers themselves (below)
+  value as T
+
 /**
  * The parsers of this module, typed for `Uint8Array` input. Slices are
  * returned as `Uint8Array`s.
@@ -803,7 +833,7 @@ export const bytes: {
   const lit = (s: string) => Token.literal(new TextEncoder().encode(s))
   const crlfB = lit("\r\n")
   const newlineB = lit("\n")
-  return {
+  const views = {
     alpha0,
     alpha1,
     digit0,
@@ -829,5 +859,8 @@ export const bytes: {
     decBigInt,
     hexUint,
     float
-  } as any
+  }
+  // SAFETY: the string parsers run on byte input unchanged (their slices of a `Uint8Array` are `Uint8Array`s),
+  // so only their declared input and slice types differ from the byte views'
+  return retype<typeof bytes>(views)
 })()