@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/internal/tokens.js

@@ -1,400 +1,406 @@
-const isRange = (u) => typeof u === "object" && u !== null && u._tag === "TokenRange";
-const toCode = (u) => typeof u === "number" ? u : u.codePointAt(0);
+import * as Predicate from "effect/Predicate";
+import { charOf, firstCodePoint } from "./text.js";
+//#region src/internal/tokens.ts
+const isRange = (u) => Predicate.isObjectOrArray(u) && u._tag === "TokenRange";
+const toCode = (u) => Predicate.isNumber(u) ? u : firstCodePoint(u);
 /** @internal */
-export const describeChar = (s) => JSON.stringify(s);
+const describeChar = (s) => JSON.stringify(s);
 const describeSet = (u) => {
-    if (typeof u === "string") {
-        const chars = Array.from(u);
-        return chars.length === 1 ? describeChar(u) : `one of ${JSON.stringify(u)}`;
-    }
-    if (typeof u === "number")
-        return `0x${u.toString(16).padStart(2, "0")}`;
-    if (typeof u === "function")
-        return u.name ? u.name : "a matching token";
-    if (u instanceof Uint8Array)
-        return `one of ${describeBytes(u)}`;
-    if (isRange(u))
-        return `${describeSet(u.from)}..=${describeSet(u.to)}`;
-    if (Array.isArray(u))
-        return u.map(describeSet).join(" or ");
-    return JSON.stringify(u);
+	if (Predicate.isString(u)) return Array.from(u).length === 1 ? describeChar(u) : `one of ${JSON.stringify(u)}`;
+	if (Predicate.isNumber(u)) return `0x${u.toString(16).padStart(2, "0")}`;
+	if (Predicate.isFunction(u)) return u.name ? u.name : "a matching token";
+	if (u instanceof Uint8Array) return `one of ${describeBytes(u)}`;
+	if (isRange(u)) return `${describeSet(u.from)}..=${describeSet(u.to)}`;
+	if (Array.isArray(u)) return u.map(describeSet).join(" or ");
+	return JSON.stringify(u);
 };
 /** Renders bytes as a Rust-style byte string literal: b"GET\r\n". */
-export const describeBytes = (bytes) => {
-    let out = "b\"";
-    for (const b of bytes) {
-        if (b === 0x22)
-            out += "\\\"";
-        else if (b === 0x5c)
-            out += "\\\\";
-        else if (b === 0x0a)
-            out += "\\n";
-        else if (b === 0x0d)
-            out += "\\r";
-        else if (b === 0x09)
-            out += "\\t";
-        else if (b >= 0x20 && b < 0x7f)
-            out += String.fromCharCode(b);
-        else
-            out += `\\x${b.toString(16).padStart(2, "0")}`;
-    }
-    return out + "\"";
+const describeBytes = (bytes) => {
+	let out = "b\"";
+	for (const b of bytes) if (b === 34) out += "\\\"";
+	else if (b === 92) out += "\\\\";
+	else if (b === 10) out += "\\n";
+	else if (b === 13) out += "\\r";
+	else if (b === 9) out += "\\t";
+	else if (b >= 32 && b < 127) out += String.fromCharCode(b);
+	else out += `\\x${b.toString(16).padStart(2, "0")}`;
+	return out + "\"";
 };
 const compileCode = (u) => {
-    if (typeof u === "string") {
-        const codes = Array.from(u, (c) => c.codePointAt(0));
-        if (codes.length === 1) {
-            const c = codes[0];
-            return (x) => x === c;
-        }
-        return bitmap(codes);
-    }
-    if (typeof u === "number")
-        return (x) => x === u;
-    if (typeof u === "function")
-        return u;
-    if (u instanceof Uint8Array)
-        return bitmap(Array.from(u));
-    if (isRange(u)) {
-        const from = toCode(u.from);
-        const to = toCode(u.to);
-        return (x) => x >= from && x <= to;
-    }
-    if (Array.isArray(u)) {
-        const tests = u.map(compileCode);
-        if (tests.length === 1)
-            return tests[0];
-        return (x) => {
-            for (let i = 0; i < tests.length; i++)
-                if (tests[i](x))
-                    return true;
-            return false;
-        };
-    }
-    throw new TypeError(`invalid token set: ${String(u)}`);
+	if (Predicate.isString(u)) {
+		const codes = Array.from(u, firstCodePoint);
+		if (codes.length === 1) {
+			const c = codes[0];
+			return (x) => x === c;
+		}
+		return bitmap(codes);
+	}
+	if (Predicate.isNumber(u)) return (x) => x === u;
+	if (Predicate.isFunction(u)) return u;
+	if (u instanceof Uint8Array) return bitmap(Array.from(u));
+	if (isRange(u)) {
+		const from = toCode(u.from);
+		const to = toCode(u.to);
+		return (x) => x >= from && x <= to;
+	}
+	if (Array.isArray(u)) {
+		const tests = u.map(compileCode);
+		if (tests.length === 1) return tests[0];
+		return (x) => {
+			for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true;
+			return false;
+		};
+	}
+	throw new TypeError(`invalid token set: ${String(u)}`);
 };
 const bitmap = (codes) => {
-    const ascii = new Uint8Array(256);
-    let other;
-    for (const c of codes) {
-        if (c < 256)
-            ascii[c] = 1;
-        else
-            (other ??= new Set()).add(c);
-    }
-    if (other === undefined)
-        return (x) => x < 256 && ascii[x] === 1;
-    const set = other;
-    return (x) => x < 256 ? ascii[x] === 1 : set.has(x);
+	const ascii = /* @__PURE__ */ new Uint8Array(256);
+	let other;
+	for (const c of codes) if (c < 256) ascii[c] = 1;
+	else (other ??= /* @__PURE__ */ new Set()).add(c);
+	if (other === void 0) return (x) => x < 256 && ascii[x] === 1;
+	const set = other;
+	return (x) => x < 256 ? ascii[x] === 1 : set.has(x);
 };
 const compileToken = (u) => {
-    if (typeof u === "function")
-        return u;
-    if (Array.isArray(u)) {
-        const set = new Set(u);
-        return (t) => set.has(t);
-    }
-    return (t) => t === u;
+	if (Predicate.isFunction(u)) return u;
+	if (Array.isArray(u)) {
+		const set = new Set(u);
+		return (t) => set.has(t);
+	}
+	return (t) => t === u;
 };
 /**
- * Marks a predicate over characters that also accepts a code point (a
- * number), so string inputs can call it without allocating a string per
- * character.
- */
-export const CodePointPredicate = Symbol.for("effect-parse/CodePointPredicate");
+* Marks a predicate over characters that also accepts a code point (a
+* number), so string inputs can call it without allocating a string per
+* character.
+*/
+const CodePointPredicate = /*#__PURE__*/ Symbol.for("effect-parse/CodePointPredicate");
 /**
- * The code points accepted by a predicate, as sorted, disjoint, inclusive
- * ranges, when they are known. The compiler turns such predicates into
- * comparisons or tables.
- */
-export const PredicateRanges = Symbol.for("effect-parse/PredicateRanges");
+* The code points accepted by a predicate, as sorted, disjoint, inclusive
+* ranges, when they are known. The compiler turns such predicates into
+* comparisons or tables.
+*/
+const PredicateRanges = /*#__PURE__*/ Symbol.for("effect-parse/PredicateRanges");
 /**
- * Marks `f` as a {@link CodePointPredicate} named `name` (used in error
- * messages), optionally recording the code point ranges it accepts.
- */
-export const codePointPredicate = (name, f, ranges) => {
-    Object.defineProperty(f, "name", { value: name });
-    f[CodePointPredicate] = true;
-    if (ranges !== undefined)
-        f[PredicateRanges] = ranges;
-    return f;
+* Marks `f` as a {@link CodePointPredicate} named `name` (used in error
+* messages), optionally recording the code point ranges it accepts.
+*/
+const codePointPredicate = (name, f, ranges) => {
+	Object.defineProperty(f, "name", { value: name });
+	f[CodePointPredicate] = true;
+	if (ranges !== void 0) f[PredicateRanges] = ranges;
+	return f;
 };
 /**
- * Compiles a token set. Predicates for string inputs receive the token as a
- * string, so they are wrapped here.
- */
-export const compile = (set, kind = "code") => {
-    const description = describeSet(set);
-    let code;
-    if (typeof set === "function" && kind === "string" && !(CodePointPredicate in set)) {
-        const pred = set;
-        code = (x) => pred(String.fromCodePoint(x));
-    }
-    else {
-        code = compileCodeSafe(set, kind);
-    }
-    return { code, token: compileToken(set), description };
+* Compiles a token set. Predicates for string inputs receive the token as a
+* string, so they are wrapped here; `charOf` avoids `String.fromCodePoint`,
+* which is several times slower, for the Basic Multilingual Plane.
+*/
+const compile = (set, kind = "code") => {
+	const description = describeSet(set);
+	let code;
+	if (Predicate.isFunction(set) && kind === "string" && !(CodePointPredicate in set)) {
+		const pred = set;
+		code = (x) => pred(charOf(x));
+	} else code = compileCodeSafe(set, kind);
+	return {
+		code,
+		token: compileToken(set),
+		description
+	};
 };
 const compileCodeSafe = (set, kind) => {
-    if (Array.isArray(set) && kind === "string") {
-        // Predicates nested in arrays also take strings
-        const tests = set.map((s) => compile(s, kind).code);
-        return (x) => {
-            for (let i = 0; i < tests.length; i++)
-                if (tests[i](x))
-                    return true;
-            return false;
-        };
-    }
-    try {
-        return compileCode(set);
-    }
-    catch {
-        return () => false;
-    }
+	if (Array.isArray(set) && kind === "string") {
+		const tests = set.map((s) => compile(s, kind).code);
+		return (x) => {
+			for (let i = 0; i < tests.length; i++) if (tests[i](x)) return true;
+			return false;
+		};
+	}
+	try {
+		return compileCode(set);
+	} catch {
+		return () => false;
+	}
 };
-export const compileAny = (set) => {
-    const forCode = compile(set, "code");
-    const needsString = typeof set === "function" || Array.isArray(set);
-    return {
-        forString: needsString ? compile(set, "string") : forCode,
-        forCode,
-        description: forCode.description
-    };
+/**
+* A small cache keyed by value, for the parts of a parser that are costly to
+* build and depend only on a string (compiled sets, descriptions). Parsers
+* built inside `Parser.gen` bodies are rebuilt on every run, usually from the
+* same few strings. Dynamic strings could grow it without bound, so it is
+* cleared when full.
+*/
+const cached = (cache, key, build) => {
+	let a = cache.get(key);
+	if (a === void 0) {
+		if (cache.size >= 1024) cache.clear();
+		a = build(key);
+		cache.set(key, a);
+	}
+	return a;
+};
+const literalDescriptions = /*#__PURE__*/ new Map();
+/** Describes a literal for error messages: `"abc"`, `b"abc"` or `["a", 1]`. */
+const describeLiteral = (lit) => Predicate.isString(lit) ? cached(literalDescriptions, lit, describeChar) : lit instanceof Uint8Array ? describeBytes(lit) : `[${lit.map((t) => JSON.stringify(t)).join(", ")}]`;
+const stringMatchers = /*#__PURE__*/ new Map();
+const compileAny = (set) => Predicate.isString(set) ? cached(stringMatchers, set, compileAnyImpl) : compileAnyImpl(set);
+const compileAnyImpl = (set) => {
+	const forCode = compile(set, "code");
+	return {
+		forString: Predicate.isFunction(set) || Array.isArray(set) ? compile(set, "string") : forCode,
+		forCode,
+		description: forCode.description
+	};
 };
 /**
- * Whether the string token at `i` is a high surrogate at the very end of a
- * partial input, i.e. the first half of a code point whose second half has
- * not arrived yet.
- */
-export const splitSurrogate = (state, i) => {
-    if (!state.partial || i !== state.end - 1)
-        return false;
-    const c = state.input.charCodeAt(i);
-    return c >= 0xd800 && c <= 0xdbff;
+* Whether the string token at `i` is a high surrogate at the very end of a
+* partial input, i.e. the first half of a code point whose second half has
+* not arrived yet.
+*/
+const splitSurrogate = (state, i) => {
+	if (!state.partial || i !== state.end - 1) return false;
+	const c = state.input.charCodeAt(i);
+	return c >= 55296 && c <= 56319;
 };
 /** Reads the code point at `i` of a string. */
-export const codePointAt = (s, i) => {
-    const c = s.charCodeAt(i);
-    if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
-        const d = s.charCodeAt(i + 1);
-        if (d >= 0xdc00 && d <= 0xdfff)
-            return ((c - 0xd800) << 10) + (d - 0xdc00) + 0x10000;
-    }
-    return c;
+const codePointAt = (s, i) => {
+	const c = s.charCodeAt(i);
+	if (c >= 55296 && c <= 56319 && i + 1 < s.length) {
+		const d = s.charCodeAt(i + 1);
+		if (d >= 56320 && d <= 57343) return (c - 55296 << 10) + (d - 56320) + 65536;
+	}
+	return c;
 };
 /**
- * Tests the token at the current position. Returns the token (as the input's
- * token type) and advances, or returns `NoMatch`/`End`.
- */
-export const NoMatch = Symbol("NoMatch");
-export const End = Symbol("End");
-export const nextIf = (state, m, negate) => {
-    const pos = state.pos;
-    if (pos >= state.end)
-        return End;
-    switch (state.inputKind) {
-        case 0: {
-            const s = state.input;
-            if (splitSurrogate(state, pos))
-                return End;
-            const cp = codePointAt(s, pos);
-            if (m.forString.code(cp) === negate)
-                return NoMatch;
-            const len = cp > 0xffff ? 2 : 1;
-            state.pos = pos + len;
-            return len === 1 ? s[pos] : s.slice(pos, pos + 2);
-        }
-        case 1: {
-            const b = state.input[pos];
-            if (m.forCode.code(b) === negate)
-                return NoMatch;
-            state.pos = pos + 1;
-            return b;
-        }
-        default: {
-            const t = state.input[pos];
-            if (m.forCode.token(t) === negate)
-                return NoMatch;
-            state.pos = pos + 1;
-            return t;
-        }
-    }
+* Tests the token at the current position. Returns the token (as the input's
+* token type) and advances, or returns `NoMatch`/`End`.
+*/
+const NoMatch = /*#__PURE__*/ Symbol("NoMatch");
+const End = /*#__PURE__*/ Symbol("End");
+const nextIf = (state, m, negate) => {
+	const pos = state.pos;
+	if (pos >= state.end) return End;
+	switch (state.inputKind) {
+		case 0: {
+			const s = state.input;
+			if (splitSurrogate(state, pos)) return End;
+			const cp = codePointAt(s, pos);
+			if (m.forString.code(cp) === negate) return NoMatch;
+			const len = cp > 65535 ? 2 : 1;
+			state.pos = pos + len;
+			return len === 1 ? s[pos] : s.slice(pos, pos + 2);
+		}
+		case 1: {
+			const b = state.input[pos];
+			if (m.forCode.code(b) === negate) return NoMatch;
+			state.pos = pos + 1;
+			return b;
+		}
+		default: {
+			const t = state.input[pos];
+			if (m.forCode.token(t) === negate) return NoMatch;
+			state.pos = pos + 1;
+			return t;
+		}
+	}
 };
 /**
- * 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.
- */
-export const scan = (state, m, negate, max) => {
-    let i = state.pos;
-    const end = state.end;
-    let count = 0;
-    switch (state.inputKind) {
-        case 0: {
-            const s = state.input;
-            const test = m.forString.code;
-            while (count < max) {
-                if (i >= end)
-                    return { offset: i, count, hitEnd: true };
-                const c = s.charCodeAt(i);
-                if (c < 0xd800 || c > 0xdbff) {
-                    if (test(c) === negate)
-                        break;
-                    i++;
-                }
-                else {
-                    if (splitSurrogate(state, i))
-                        return { offset: i, count, hitEnd: true };
-                    const cp = codePointAt(s, i);
-                    if (test(cp) === negate)
-                        break;
-                    i += cp > 0xffff ? 2 : 1;
-                }
-                count++;
-            }
-            return { offset: i, count, hitEnd: 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 (test(bytes[i]) === negate)
-                    break;
-                i++;
-                count++;
-            }
-            return { offset: i, count, hitEnd: false };
-        }
-        default: {
-            const arr = state.input;
-            const test = m.forCode.token;
-            while (count < max) {
-                if (i >= end)
-                    return { offset: i, count, hitEnd: true };
-                if (test(arr[i]) === negate)
-                    break;
-                i++;
-                count++;
-            }
-            return { offset: i, count, hitEnd: false };
-        }
-    }
+* 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.
+*/
+const scan = (state, m, negate, max) => {
+	let i = state.pos;
+	const end = state.end;
+	let count = 0;
+	switch (state.inputKind) {
+		case 0: {
+			const s = state.input;
+			const test = m.forString.code;
+			while (count < max) {
+				if (i >= end) return {
+					offset: i,
+					count,
+					hitEnd: 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
+					};
+					const cp = codePointAt(s, i);
+					if (test(cp) === negate) break;
+					i += cp > 65535 ? 2 : 1;
+				}
+				count++;
+			}
+			return {
+				offset: i,
+				count,
+				hitEnd: 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 (test(bytes[i]) === negate) break;
+				i++;
+				count++;
+			}
+			return {
+				offset: i,
+				count,
+				hitEnd: false
+			};
+		}
+		default: {
+			const arr = state.input;
+			const test = m.forCode.token;
+			while (count < max) {
+				if (i >= end) return {
+					offset: i,
+					count,
+					hitEnd: true
+				};
+				if (test(arr[i]) === negate) break;
+				i++;
+				count++;
+			}
+			return {
+				offset: i,
+				count,
+				hitEnd: false
+			};
+		}
+	}
 };
 /** Advances `n` tokens from `start`, returning the offset reached and the count. */
-export const advance = (state, start, n) => {
-    if (state.inputKind !== 0) {
-        const offset = Math.min(state.end, start + n);
-        return { offset, count: offset - start };
-    }
-    const s = state.input;
-    let i = start;
-    let count = 0;
-    while (count < n && i < state.end) {
-        if (splitSurrogate(state, i))
-            break;
-        const c = s.charCodeAt(i);
-        i += c >= 0xd800 && c <= 0xdbff && i + 1 < s.length && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00 ? 2 : 1;
-        count++;
-    }
-    return { offset: i, count };
+const advance = (state, start, n) => {
+	if (state.inputKind !== 0) {
+		const offset = Math.min(state.end, start + n);
+		return {
+			offset,
+			count: offset - start
+		};
+	}
+	const s = state.input;
+	let i = start;
+	let count = 0;
+	while (count < n && i < state.end) {
+		if (splitSurrogate(state, i)) break;
+		const c = s.charCodeAt(i);
+		i += c >= 55296 && c <= 56319 && i + 1 < s.length && (s.charCodeAt(i + 1) & 64512) === 56320 ? 2 : 1;
+		count++;
+	}
+	return {
+		offset: i,
+		count
+	};
 };
 /** Counts tokens between two offsets. */
-export const countTokens = (state, start, end) => {
-    if (state.inputKind !== 0)
-        return end - start;
-    const s = state.input;
-    let count = 0;
-    for (let i = start; i < end; i++) {
-        const c = s.charCodeAt(i);
-        if (c >= 0xd800 && c <= 0xdbff && i + 1 < end && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00)
-            i++;
-        count++;
-    }
-    return count;
+const countTokens = (state, start, end) => {
+	if (state.inputKind !== 0) return end - start;
+	const s = state.input;
+	let count = 0;
+	for (let i = start; i < end; i++) {
+		const c = s.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < end && (s.charCodeAt(i + 1) & 64512) === 56320) i++;
+		count++;
+	}
+	return count;
 };
-/** Finds `needle` in the input at or after `from`; returns -1 if absent. */
-export const indexOf = (state, needle, from) => {
-    switch (state.inputKind) {
-        case 0:
-            return state.input.indexOf(needle, from);
-        case 1: {
-            const hay = state.input;
-            const n = needle;
-            if (n.length === 0)
-                return from <= hay.length ? from : -1;
-            const first = n[0];
-            let i = hay.indexOf(first, from);
-            while (i !== -1 && i + n.length <= hay.length) {
-                let j = 1;
-                while (j < n.length && hay[i + j] === n[j])
-                    j++;
-                if (j === n.length)
-                    return i;
-                i = hay.indexOf(first, i + 1);
-            }
-            return -1;
-        }
-        default: {
-            const hay = state.input;
-            const n = needle;
-            outer: for (let i = from; i + n.length <= hay.length; i++) {
-                for (let j = 0; j < n.length; j++)
-                    if (hay[i + j] !== n[j])
-                        continue outer;
-                return i;
-            }
-            return -1;
-        }
-    }
+/** Finds `needle` within `[from, state.end)`; returns -1 if absent. */
+const indexOf = (state, needle, from) => {
+	const last = state.end - needle.length;
+	if (from > last) return -1;
+	switch (state.inputKind) {
+		case 0: {
+			const i = state.input.indexOf(needle, from);
+			return i <= last ? i : -1;
+		}
+		case 1: {
+			const hay = state.input;
+			const n = needle;
+			if (n.length === 0) return from;
+			const first = n[0];
+			let i = hay.indexOf(first, from);
+			while (i !== -1 && i <= last) {
+				let j = 1;
+				while (j < n.length && hay[i + j] === n[j]) j++;
+				if (j === n.length) return i;
+				i = hay.indexOf(first, i + 1);
+			}
+			return -1;
+		}
+		default: {
+			const hay = state.input;
+			const n = needle;
+			outer: for (let i = from; i <= last; i++) {
+				for (let j = 0; j < n.length; j++) if (hay[i + j] !== n[j]) continue outer;
+				return i;
+			}
+			return -1;
+		}
+	}
 };
 /**
- * Compares the input at the current position with a literal. Returns the
- * number of matching units if the literal matches completely (its length),
- * -1 on mismatch, or -2 when the input ends while matching a prefix.
- */
-export const matchLiteral = (state, lit, caseless) => {
-    const pos = state.pos;
-    const len = lit.length;
-    const avail = state.end - pos;
-    const n = Math.min(len, avail);
-    switch (state.inputKind) {
-        case 0: {
-            const s = state.input;
-            const l = lit;
-            if (!caseless) {
-                if (avail >= len)
-                    return s.startsWith(l, pos) ? len : -1;
-                return l.startsWith(s.slice(pos)) ? -2 : -1;
-            }
-            for (let i = 0; i < n; i++) {
-                if (lowerAscii(s.charCodeAt(pos + i)) !== lowerAscii(l.charCodeAt(i)))
-                    return -1;
-            }
-            return n === len ? len : -2;
-        }
-        case 1: {
-            const b = state.input;
-            const l = lit;
-            for (let i = 0; i < n; i++) {
-                const x = b[pos + i];
-                const y = l[i];
-                if (caseless ? lowerAscii(x) !== lowerAscii(y) : x !== y)
-                    return -1;
-            }
-            return n === len ? len : -2;
-        }
-        default: {
-            const a = state.input;
-            const l = lit;
-            for (let i = 0; i < n; i++)
-                if (a[pos + i] !== l[i])
-                    return -1;
-            return n === len ? len : -2;
-        }
-    }
+* Compares the input at the current position with a literal. Returns the
+* number of matching units if the literal matches completely (its length),
+* -1 on mismatch, or -2 when the input ends while matching a prefix.
+*/
+const matchLiteral = (state, lit, caseless) => {
+	const r = match(state, lit, caseless);
+	if (r < 0 && state.syntax !== void 0) state.syntax.read(state.pos + Math.min(lit.length, state.end - state.pos));
+	return r;
+};
+const match = (state, lit, caseless) => {
+	const pos = state.pos;
+	const len = lit.length;
+	const avail = state.end - pos;
+	const n = Math.min(len, avail);
+	switch (state.inputKind) {
+		case 0: {
+			const s = state.input;
+			const l = lit;
+			if (!caseless) {
+				if (avail >= len) return s.startsWith(l, pos) ? len : -1;
+				return l.startsWith(s.slice(pos)) ? -2 : -1;
+			}
+			for (let i = 0; i < n; i++) if (lowerAscii(s.charCodeAt(pos + i)) !== lowerAscii(l.charCodeAt(i))) return -1;
+			return n === len ? len : -2;
+		}
+		case 1: {
+			const b = state.input;
+			const l = lit;
+			for (let i = 0; i < n; i++) {
+				const x = b[pos + i];
+				const y = l[i];
+				if (caseless ? lowerAscii(x) !== lowerAscii(y) : x !== y) return -1;
+			}
+			return n === len ? len : -2;
+		}
+		default: {
+			const a = state.input;
+			const l = lit;
+			for (let i = 0; i < n; i++) if (a[pos + i] !== l[i]) return -1;
+			return n === len ? len : -2;
+		}
+	}
 };
 const lowerAscii = (c) => c >= 65 && c <= 90 ? c + 32 : c;
+//#endregion
+export { End, NoMatch, PredicateRanges, advance, codePointPredicate, compile, compileAny, countTokens, describeChar, describeLiteral, indexOf, matchLiteral, nextIf, scan, splitSurrogate };
+
 //# sourceMappingURL=tokens.js.map