@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/dist/internal/compiler/closure.js

@@ -4,13 +4,14 @@ import { Fail } from "../../Input.js";
 import { floatScan, floatTexts, scanFloatBytes, scanFloatString, toFloat } from "../numbers.js";
 import { Key } from "../key.js";
 import * as Resume from "../resume.js";
-import { countTokens, indexOf } from "../tokens.js";
+import { countTokens, indexOf, indexOfAny } from "../tokens.js";
 import * as Option from "effect/Option";
-import { charOf, fastLimit, firstCodePoint, fold, utf16be, utf16le, validate } from "../text.js";
+import { charOf, fastLimit, firstCodePoint, fold, textIn, utf16be, utf16le, utf8, utf8Text, validate } from "../text.js";
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { nodeOf, scansFloat } from "../node.js";
+import { Defer, nodeOf, scansFloat } from "../node.js";
 import { buildsEntries, pairOf } from "./entries.js";
 import { FirstSets, planAlt } from "./first.js";
+import { SearchHead, StopCache, nextStop, stopChars } from "./search.js";
 import { TableSize, acceptTable, kindOfEncoding, textSet, tokenSet } from "./sets.js";
 // src/internal/compiler/closure.ts
 /**
@@ -110,6 +111,8 @@ var Compiler = class {
 	build(p, node, used) {
 		switch (node._tag) {
 			case "Opaque": return this.fallback(p, node, "not describable (Parser.make, gen, ...)");
+			case "Fixed": return p.step;
+			case "Combinator": return node.build(node.parsers.map((q) => this.compile(q, true)));
 			case "Succeed": {
 				const value = node.value;
 				return () => value;
@@ -130,10 +133,7 @@ var Compiler = class {
 					s.mode = BT;
 					return Fail;
 				}
-				if (s.partial) {
-					s.mode = INC;
-					return Fail;
-				}
+				if (s.partial) return s.incomplete(1);
 			};
 			case "Location": return (s) => s.pos;
 			case "RestLen": return (s) => s.end - s.pos;
@@ -144,9 +144,10 @@ var Compiler = class {
 			case "Take":
 			case "TakeWhile":
 			case "TakeUntil":
+			case "TakeUntilAny":
 			case "Rest":
 				if (!this.native(node.encoding)) return this.fallback(p, node, "token parser on array input");
-				return this.partialSafe(p, node.encoding === void 0 ? this.token(p, node, used) : this.text(p, node, node.encoding, used), Predicate.isTagged(node, "Literal") || Predicate.isTagged(node, "TakeUntil") ? node.literal.length * 4 : Margin);
+				return this.partialSafe(p, node.encoding === void 0 ? this.token(p, node, used) : this.text(p, node, node.encoding, used), marginOf(node));
 			case "TillLineEnding":
 			case "Identifier":
 			case "Bom": return this.fallback(p, node, "leaf parser without a compiled form");
@@ -159,7 +160,7 @@ var Compiler = class {
 					const step = this.float(node);
 					if (step !== void 0) return step;
 				}
-				if (node.f === fromEntries && !this.resumable && buildsEntries(node.self)) return this.entries(node.self);
+				if (node.f === fromEntries && buildsEntries(node.self)) return this.entries(node.self);
 				const c = this.compile(node.self, true);
 				const f = node.f;
 				return (s) => {
@@ -206,6 +207,28 @@ var Compiler = class {
 					return Fail;
 				};
 			}
+			case "FastPath": {
+				const c = this.compile(node.self, used);
+				const fast = node.fast;
+				return (s) => {
+					const start = s.pos;
+					const a = fast(s);
+					if (a !== Defer) return a;
+					s.pos = start;
+					return c(s);
+				};
+			}
+			case "MapOrFail": {
+				const c = this.compile(node.self, true);
+				const f = node.f;
+				return (s) => {
+					const a = c(s);
+					if (a === Fail) return Fail;
+					const b = f(a);
+					if (b === Fail) s.mode = BT;
+					return b;
+				};
+			}
 			case "Filter": {
 				const c = this.compile(node.self, true);
 				const predicate = node.predicate;
@@ -237,6 +260,16 @@ var Compiler = class {
 					return a === Fail ? Fail : [a, s.slice(start, s.pos)];
 				};
 			}
+			case "MapSpan": {
+				const c = this.compile(node.self, used);
+				if (!used) return c;
+				const f = node.f;
+				return (s) => {
+					const start = s.pos;
+					const a = c(s);
+					return a === Fail ? Fail : f(a, start, s.pos);
+				};
+			}
 			case "Span": {
 				const c = this.compile(node.self, false);
 				if (!used) return c;
@@ -271,6 +304,7 @@ var Compiler = class {
 			}
 			case "Context":
 			case "Expected":
+			case "Quiet":
 			case "MapError":
 			case "OrFail":
 			case "Trace":
@@ -336,6 +370,11 @@ var Compiler = class {
 					return out;
 				};
 			}
+			case "SeqWith": {
+				const steps = node.parsers.map((q) => this.compile(q, used));
+				if (!used) return this.chain(steps);
+				return this.seqWith(steps, node.f);
+			}
 			case "ZipWith": {
 				const c1 = this.compile(node.self, used);
 				const c2 = this.compile(node.that, used);
@@ -351,7 +390,22 @@ var Compiler = class {
 			case "Alt": return this.alt(node, used);
 			case "Dispatch": return this.dispatch(p, node, used);
 			case "Repeat":
-			case "Fold": return this.repeat(node, used);
+			case "Fold": {
+				const element = Predicate.isTagged(node, "Repeat") && !used ? nodeOf(node.self) : void 0;
+				if (element !== void 0 && Predicate.isTagged(element, "OneOf") && this.kind !== 2 && this.native(element.encoding)) {
+					const { encoding, negate, set } = element;
+					const run = {
+						_tag: "TakeWhile",
+						set,
+						negate,
+						encoding,
+						min: node.min,
+						max: node.max
+					};
+					return this.partialSafe(p, encoding === void 0 ? this.token(p, run, false) : this.text(p, run, encoding, false), Margin);
+				}
+				return this.repeat(node, used);
+			}
 			case "RepeatTill": return this.repeatTill(node);
 			case "Separated": return this.separated(node, used);
 			case "SeparatedFold": return this.separatedFold(node);
@@ -359,13 +413,47 @@ var Compiler = class {
 			case "Provide": return this.fallback(p, node, "services stay interpreted");
 		}
 	}
+	/** `seqWith`: up to three parsers without an array of values. */
+	seqWith(steps, f) {
+		const n = steps.length;
+		if (n === 0) return () => f();
+		const [c1, c2, c3] = steps;
+		if (n === 1) return (s) => {
+			const a = c1(s);
+			return a === Fail ? Fail : f(a);
+		};
+		if (n === 2) return (s) => {
+			const a = c1(s);
+			if (a === Fail) return Fail;
+			const b = c2(s);
+			return b === Fail ? Fail : f(a, b);
+		};
+		if (n === 3) return (s) => {
+			const a = c1(s);
+			if (a === Fail) return Fail;
+			const b = c2(s);
+			if (b === Fail) return Fail;
+			const c = c3(s);
+			return c === Fail ? Fail : f(a, b, c);
+		};
+		return (s) => {
+			const values = new Array(n);
+			for (let i = 0; i < n; i++) {
+				const a = steps[i](s);
+				if (a === Fail) return Fail;
+				values[i] = a;
+			}
+			return f(...values);
+		};
+	}
 	/** Runs steps in order, for their effect on the cursor only. */
 	chain(steps) {
 		const n = steps.length;
 		if (n === 0) return () => void 0;
 		if (n === 1) return steps[0];
 		if (n === 2) {
-			const [a, b] = steps;
+			const a = steps[0];
+			const b = steps[1];
 			return (s) => a(s) === Fail ? Fail : b(s);
 		}
 		return (s) => {
@@ -389,7 +477,8 @@ var Compiler = class {
 		};
 		if (Predicate.isNumber(output)) {
 			if (n === 2) {
-				const [a, b] = steps;
+				const a = steps[0];
+				const b = steps[1];
 				return output === 0 ? (s) => {
 					const x = a(s);
 					if (x === Fail) return Fail;
@@ -486,9 +575,9 @@ var Compiler = class {
 			this.note(p, node, "the parser returned by the function of cases runs interpreted");
 			return general;
 		}
-		let sel = nodeOf(node.selector);
-		const peek = Predicate.isTagged(sel, "Peek");
-		if (peek) sel = nodeOf(sel.self);
+		const top = nodeOf(node.selector);
+		const peek = Predicate.isTagged(top, "Peek");
+		const sel = peek ? nodeOf(top.self) : top;
 		if (!Predicate.isTagged(sel, "Any") || !this.native(sel.encoding)) return general;
 		const enc = sel.encoding;
 		const limit = enc === void 0 ? this.kind === 0 ? 55296 : TableSize : Math.min(fastLimit(enc), 55296);
@@ -581,42 +670,39 @@ var Compiler = class {
 	*/
 	entries(p) {
 		const node = nodeOf(p);
-		switch (node._tag) {
-			case "Mode": {
-				const c = this.entries(node.self);
-				const from = node.from;
-				const to = node.to;
-				return (s) => {
-					const a = c(s);
-					if (a === Fail && s.mode === from) s.mode = to;
-					return a;
-				};
-			}
-			case "Seq": {
-				const i = node.output;
-				const steps = node.parsers.map((q, j) => j === i ? this.entries(q) : this.compile(q, false));
-				return (s) => {
-					let out;
-					for (let j = 0; j < steps.length; j++) {
-						const a = steps[j](s);
-						if (a === Fail) return Fail;
-						if (j === i) out = a;
-					}
-					return out;
-				};
-			}
-			case "Repeat":
-			case "Separated": {
-				const pair = pairOf(node.self);
-				if (pair !== void 0) return this.entriesLoop(node, pair);
-				const c = this.compile(p, true);
-				return (s) => {
-					const a = c(s);
-					return a === Fail ? Fail : fromEntries(a);
-				};
-			}
-			default: return this.entries(node.self);
+		if (Predicate.isTagged(node, "Mode")) {
+			const c = this.entries(node.self);
+			const from = node.from;
+			const to = node.to;
+			return (s) => {
+				const a = c(s);
+				if (a === Fail && s.mode === from) s.mode = to;
+				return a;
+			};
+		}
+		if (Predicate.isTagged(node, "Seq")) {
+			const i = node.output;
+			const steps = node.parsers.map((q, j) => j === i ? this.entries(q) : this.compile(q, false));
+			return (s) => {
+				let out;
+				for (let j = 0; j < steps.length; j++) {
+					const a = steps[j](s);
+					if (a === Fail) return Fail;
+					if (j === i) out = a;
+				}
+				return out;
+			};
+		}
+		if (Predicate.isTagged(node, "Repeat") || Predicate.isTagged(node, "Separated")) {
+			const pair = pairOf(node.self);
+			if (pair !== void 0) return this.entriesLoop(node, pair);
+			const c = this.compile(p, true);
+			return (s) => {
+				const a = c(s);
+				return a === Fail ? Fail : fromEntries(a);
+			};
 		}
+		return this.entries(node.self);
 	}
 	entriesLoop(node, pair) {
 		const parts = pair.parsers.map((q, j) => this.compile(q, j === pair.key || j === pair.value));
@@ -635,9 +721,15 @@ var Compiler = class {
 		};
 		const { max, min } = node;
 		const checkLoop = max === Infinity;
+		const resumable = this.resumable;
+		const site = new Key();
 		if (Predicate.isTagged(node, "Repeat")) return (s) => {
-			const acc = new EntriesAcc();
-			for (let count = 0; count < max; count++) {
+			const at = s.pos;
+			const cp = resumable && s.resume !== void 0 ? resumeEntries(s, site, at) : void 0;
+			if (cp instanceof Resume.Done) return cp.value;
+			const resumed = cp !== void 0;
+			const acc = cp?.acc ?? new EntriesAcc();
+			for (let count = cp?.count ?? 0; count < max; count++) {
 				const start = s.pos;
 				let key;
 				let value;
@@ -651,50 +743,44 @@ var Compiler = class {
 					if (j === ki) key = a;
 					else if (j === vi) value = a;
 				}
-				if (!ok) {
-					if (s.mode !== BT || count < min) return Fail;
-					s.pos = start;
-					return acc.result();
-				}
+				if (!ok) return stopEntries(s, site, at, resumed, acc, count, start, min);
 				if (checkLoop && s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}
 				acc.add(key, value);
 			}
-			return acc.result();
+			return entriesDone(s, site, at, resumed, acc);
 		};
 		const sep = this.compile(node.separator, false);
 		return (s) => {
-			const acc = new EntriesAcc();
-			let count = 0;
-			if (max === 0) return acc.result();
-			let start = s.pos;
-			if (!entry(s, acc)) {
-				if (s.mode !== BT || min > 0) return Fail;
-				s.pos = start;
-				return acc.result();
-			}
-			count++;
-			while (count < max) {
-				start = s.pos;
-				if (sep(s) === Fail) {
-					if (s.mode !== BT || count < min) return Fail;
+			const at = s.pos;
+			const cp = resumable && s.resume !== void 0 ? resumeEntries(s, site, at) : void 0;
+			if (cp instanceof Resume.Done) return cp.value;
+			const resumed = cp !== void 0;
+			const acc = cp?.acc ?? new EntriesAcc();
+			let count = cp?.count ?? 0;
+			if (!resumed) {
+				if (max === 0) return acc.result();
+				const start = s.pos;
+				if (!entry(s, acc)) {
+					if (s.mode !== BT || min > 0) return Fail;
 					s.pos = start;
 					return acc.result();
 				}
+				count++;
+			}
+			while (count < max) {
+				const start = s.pos;
+				if (sep(s) === Fail) return stopEntries(s, site, at, resumed, acc, count, start, min);
 				if (checkLoop && s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}
-				if (!entry(s, acc)) {
-					if (s.mode !== BT || count < min) return Fail;
-					s.pos = start;
-					return acc.result();
-				}
+				if (!entry(s, acc)) return stopEntries(s, site, at, resumed, acc, count, start, min);
 				count++;
 			}
-			return acc.result();
+			return entriesDone(s, site, at, resumed, acc);
 		};
 	}
 	repeatTill(node) {
@@ -961,12 +1047,14 @@ var Compiler = class {
 				};
 			}
 			case "TakeWhile": return this.tokenTakeWhile(node, used);
-			case "TakeUntil": {
-				const { literal, max, min } = node;
+			case "TakeUntil":
+			case "TakeUntilAny": {
+				const { max, min } = node;
 				const bounded = min > 0 || max !== Infinity;
+				const search = Predicate.isTagged(node, "TakeUntil") ? (s, from) => indexOf(s, node.literal, from) : (s, from) => indexOfAny(s, node.literals, from);
 				return (s) => {
 					const start = s.pos;
-					const idx = indexOf(s, literal, start);
+					const idx = search(s, start);
 					if (idx < 0) return failAt(s, s.end);
 					if (bounded) {
 						const count = countTokens(s, start, idx);
@@ -987,7 +1075,7 @@ var Compiler = class {
 		const lit = node.literal;
 		const literalKind = Predicate.isString(lit) ? 0 : lit instanceof Uint8Array ? 1 : 2;
 		if (this.kind === 0) {
-			if (literalKind !== 0) return this.fallback(p, node, "byte or array literal on string input");
+			if (!Predicate.isString(lit)) return this.fallback(p, node, "byte or array literal on string input");
 			const str = lit;
 			const len = str.length;
 			if (node.caseless) {
@@ -1003,8 +1091,8 @@ var Compiler = class {
 			}
 			return stringLiteral(str, str);
 		}
-		if (literalKind === 2) return this.fallback(p, node, "array literal on byte input");
-		const bytes = literalKind === 0 ? new TextEncoder().encode(lit) : lit;
+		const bytes = Predicate.isString(lit) ? new TextEncoder().encode(lit) : lit instanceof Uint8Array ? lit : void 0;
+		if (bytes === void 0) return this.fallback(p, node, "array literal on byte input");
 		const len = bytes.length;
 		const sameKind = literalKind === 1 && !node.caseless;
 		const expect = node.caseless ? Array.from(bytes, lowerAscii) : Array.from(bytes);
@@ -1036,6 +1124,8 @@ var Compiler = class {
 			s.pos = i;
 			return used ? bytes.subarray(start, i) : void 0;
 		};
+		const stops = negate && min <= 1 && max === Infinity ? stopChars(set) : void 0;
+		if (stops !== void 0) return stopTakeTill(stops, min, used);
 		const test = set.test;
 		return (s) => {
 			const str = s.input;
@@ -1071,7 +1161,7 @@ var Compiler = class {
 		const { fast, unitAt, width: unitWidth } = unitReader(this.kind, enc);
 		const decode = enc.decode;
 		const width = enc.width;
-		const toText = enc.text;
+		const toText = enc === utf8 ? utf8Text : (s, start, end) => enc.text(s.input, start, end);
 		switch (node._tag) {
 			case "Any": return (s) => {
 				const pos = s.pos;
@@ -1112,7 +1202,7 @@ var Compiler = class {
 							if (fold(cp) !== folded[i]) return failAt(s, pos);
 						}
 						s.pos = pos;
-						return used ? toText(input, start, pos) : void 0;
+						return used ? toText(s, start, pos) : void 0;
 					};
 				}
 				const encoded = enc.encode(lit);
@@ -1177,7 +1267,7 @@ var Compiler = class {
 						}
 					}
 					s.pos = pos;
-					return used ? toText(input, start, pos) : void 0;
+					return used ? toText(s, start, pos) : void 0;
 				};
 			}
 			case "TakeWhile": {
@@ -1197,6 +1287,7 @@ var Compiler = class {
 				return this.kind === 0 ? takeWhileString(loop, enc) : takeWhileBytes(loop, enc);
 			}
 			case "TakeUntil":
+			case "TakeUntilAny":
 			case "Rest": return this.fallback(p, node, "Text parser without a compiled form");
 		}
 	}
@@ -1215,7 +1306,7 @@ var Compiler = class {
 			};
 		}
 		const { fast, unitAt, width } = unitReader(this.kind, enc);
-		const toText = enc.text;
+		const toText = enc === utf8 ? utf8Text : (s, start, end) => enc.text(s.input, start, end);
 		return (s) => {
 			const start = s.pos;
 			if (c(s) === Fail) return Fail;
@@ -1224,7 +1315,7 @@ var Compiler = class {
 			let i = start;
 			while (i < end && unitAt(input, i, end) < fast) i += width;
 			if (i < end && validate(enc, s, i, end) < 0) return fail(s);
-			return used ? toText(input, start, end) : void 0;
+			return used ? toText(s, start, end) : void 0;
 		};
 	}
 	/**
@@ -1295,7 +1386,7 @@ var Compiler = class {
 			return Fail;
 		};
 		if (raw) {
-			const slice = enc === void 0 ? (s, start) => s.slice(start, s.pos) : (s, start) => enc.text(s.input, start, s.pos);
+			const slice = enc === void 0 ? (s, start) => s.slice(start, s.pos) : (s, start) => textIn(enc, s, start, s.pos);
 			return (s) => {
 				const start = s.pos;
 				let resumed = false;
@@ -1326,7 +1417,10 @@ var Compiler = class {
 						if (escape(s) === Fail) return s.mode === INC ? incomplete(s, start, before) : Fail;
 					} else return resumed ? Resume.done(s, key, start, true, slice(s, start)) : slice(s, start);
 				}
-				if (s.partial) return incomplete(s, start, s.pos);
+				if (s.partial) {
+					s.incomplete(0);
+					return incomplete(s, start, s.pos);
+				}
 				return resumed ? Resume.done(s, key, start, true, slice(s, start)) : slice(s, start);
 			};
 		}
@@ -1371,14 +1465,23 @@ var Compiler = class {
 					out += b;
 				} else return resumed ? Resume.done(s, key, start, true, out) : out;
 			}
-			if (s.partial) return incomplete(s, start, {
-				out,
-				pos: s.pos
-			});
+			if (s.partial) {
+				s.incomplete(0);
+				return incomplete(s, start, {
+					out,
+					pos: s.pos
+				});
+			}
 			return resumed ? Resume.done(s, key, start, true, out) : out;
 		};
 	}
 };
+/** How far past the cursor a token parser may read: its literals' length in UTF-8 at most, or `Margin`. */
+const marginOf = (node) => {
+	if (Predicate.isTagged(node, "Literal") || Predicate.isTagged(node, "TakeUntil")) return node.literal.length * 4;
+	if (Predicate.isTagged(node, "TakeUntilAny")) return Math.max(0, ...node.literals.map((lit) => lit.length)) * 4;
+	return Margin;
+};
 const fail = (s) => {
 	s.mode = BT;
 	return Fail;
@@ -1506,7 +1609,62 @@ const stringLiteral = (str, value) => {
 		return fail(s);
 	};
 };
-/** A closure compiler for one input kind; it memoizes what it compiles. */
+/**
+* `Token.takeTill` on a string, of one to three stop characters that are
+* whole code points (see `search.ts`): every other unit, surrogates
+* included, is accepted, so the run ends at the first stop character, or
+* at the state's end.
+*/
+const stopTakeTill = (stops, min, used) => {
+	const head = stops.length === 1 ? SearchHead : 2 * SearchHead;
+	const c0 = stops[0];
+	const c1 = stops.length > 1 ? stops[1] : -1;
+	const c2 = stops.length > 2 ? stops[2] : -1;
+	const one = String.fromCharCode(c0);
+	const site = new StopCache(stops.map((u) => String.fromCharCode(u)));
+	return (s) => {
+		const str = s.input;
+		const start = s.pos;
+		const end = s.end;
+		const h = start + head < end ? start + head : end;
+		let i = start;
+		let c = -1;
+		while (i < h && (c = str.charCodeAt(i)) !== c0 && c !== c1 && c !== c2) i++;
+		if (i === h && i < end && (c = str.charCodeAt(i)) !== c0 && c !== c1 && c !== c2) {
+			if (stops.length === 1) {
+				const at = str.indexOf(one, i);
+				i = at < 0 || at > end ? end : at;
+			} else i = nextStop(site, s, i);
+		}
+		if (i - start < min) return failAt(s, i);
+		s.pos = i;
+		return used ? str.slice(start, i) : void 0;
+	};
+};
+/** Takes the checkpoint `entriesLoop` saved at `at`, restoring the position of a completed one. */
+const resumeEntries = (s, key, at) => {
+	const cp = Resume.take(s, key, at);
+	if (cp instanceof Resume.Done) s.pos = cp.pos;
+	else if (cp !== void 0) s.pos = cp.pos;
+	return cp;
+};
+/** The object `entriesLoop` built, recorded as done when the loop resumed. */
+const entriesDone = (s, key, at, resumed, acc) => resumed ? Resume.done(s, key, at, true, acc.result()) : acc.result();
+/**
+* Where `entriesLoop` stops at an entry (or separator) that failed at
+* `start`: a checkpoint when the input ran out, `Fail` unless the failure
+* backtracks after `min` entries, otherwise the object.
+*/
+const stopEntries = (s, site, at, resumed, acc, count, start, min) => {
+	if (s.mode === INC && s.resume !== void 0) Resume.save(s, site, at, {
+		acc,
+		count,
+		pos: start
+	});
+	if (s.mode !== BT || count < min) return Fail;
+	s.pos = start;
+	return entriesDone(s, site, at, resumed, acc);
+};
 /** The object of `Object.fromEntries`, built an entry at a time (see `internal/entries.ts`). */
 var EntriesAcc = class {
 	o = {};
@@ -1542,12 +1700,14 @@ const backend = { build: (p, kind, resumable) => Result.match(Result.try(() => c
 	onSuccess: ({ fallbacks, step }) => ({
 		backend: "closure",
 		step,
+		guarded: false,
 		fallbacks,
 		error: void 0
 	}),
 	onFailure: (error) => ({
-		backend: void 0,
+		backend: "interpreted",
 		step: void 0,
+		guarded: false,
 		fallbacks: [],
 		error
 	})