@thomasfosterau/effect-parse 0.2.0 → 0.4.0

package/dist/internal/compiler/closure.js

@@ -1,16 +1,18 @@
 import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
 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 * as Option from "effect/Option";
-import { charOf, fastLimit, firstCodePoint, fold, validate } from "../text.js";
+import { charOf, fastLimit, firstCodePoint, fold, utf16be, utf16le, validate } from "../text.js";
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { nodeOf } from "../node.js";
+import { nodeOf, scansFloat } from "../node.js";
 import { buildsEntries, pairOf } from "./entries.js";
 import { FirstSets, planAlt } from "./first.js";
-import { TableSize, kindOfEncoding, textSet, tokenSet } from "./sets.js";
-//#region src/internal/compiler/closure.ts
+import { TableSize, acceptTable, kindOfEncoding, textSet, tokenSet } from "./sets.js";
+// src/internal/compiler/closure.ts
 /**
 * The closure compiler: turns a parser's description into specialized
 * closures with the step signature. Compiled steps return a value, or
@@ -33,8 +35,6 @@ const INC = "Incomplete";
 */
 const Margin = 4;
 const lowerAscii = (c) => c >= 65 && c <= 90 ? c + 32 : c;
-const isSuccess = (r) => r._tag === "Success";
-const isSome = (o) => o._tag === "Some";
 var Compiler = class {
 	kind;
 	resumable;
@@ -146,7 +146,7 @@ var Compiler = class {
 			case "TakeUntil":
 			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), node._tag === "Literal" || node._tag === "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), Predicate.isTagged(node, "Literal") || Predicate.isTagged(node, "TakeUntil") ? node.literal.length * 4 : Margin);
 			case "TillLineEnding":
 			case "Identifier":
 			case "Bom": return this.fallback(p, node, "leaf parser without a compiled form");
@@ -189,7 +189,7 @@ var Compiler = class {
 					const a = c(s);
 					if (a === Fail) return Fail;
 					const r = f(a);
-					if (isSuccess(r)) return r.success;
+					if (Result.isSuccess(r)) return r.success;
 					s.mode = BT;
 					return Fail;
 				};
@@ -201,7 +201,7 @@ var Compiler = class {
 					const a = c(s);
 					if (a === Fail) return Fail;
 					const o = f(a);
-					if (isSome(o)) return o.value;
+					if (Option.isSome(o)) return o.value;
 					s.mode = BT;
 					return Fail;
 				};
@@ -287,8 +287,8 @@ var Compiler = class {
 			case "Opt":
 			case "OrElseSucceed": {
 				const c = this.compile(node.self, used);
-				const orElse = !used ? void 0 : node._tag === "Opt" ? Option.none : node.value;
-				const some = used && node._tag === "Opt";
+				const orElse = !used ? void 0 : Predicate.isTagged(node, "Opt") ? Option.none : node.value;
+				const some = used && Predicate.isTagged(node, "Opt");
 				return (s) => {
 					const start = s.pos;
 					const a = c(s);
@@ -487,9 +487,9 @@ var Compiler = class {
 			return general;
 		}
 		let sel = nodeOf(node.selector);
-		const peek = sel._tag === "Peek";
+		const peek = Predicate.isTagged(sel, "Peek");
 		if (peek) sel = nodeOf(sel.self);
-		if (sel._tag !== "Any" || !this.native(sel.encoding)) return general;
+		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);
 		const size = Math.min(limit, TableSize);
@@ -522,11 +522,11 @@ var Compiler = class {
 	repeat(node, used) {
 		const { max, min } = node;
 		const checkLoop = max === Infinity;
-		const isFold = node._tag === "Fold";
+		const isFold = Predicate.isTagged(node, "Fold");
 		const cond = isFold ? node.while : void 0;
 		const c = this.compile(node.self, used);
 		const resumable = this.resumable;
-		const key = {};
+		const key = new Key();
 		const tracked = used || cond !== void 0;
 		const init = !tracked ? () => void 0 : isFold ? node.init : () => [];
 		const add = !tracked ? (acc) => acc : isFold ? node.f : (acc, a) => {
@@ -635,7 +635,7 @@ var Compiler = class {
 		};
 		const { max, min } = node;
 		const checkLoop = max === Infinity;
-		if (node._tag === "Repeat") return (s) => {
+		if (Predicate.isTagged(node, "Repeat")) return (s) => {
 			const acc = new EntriesAcc();
 			for (let count = 0; count < max; count++) {
 				const start = s.pos;
@@ -728,7 +728,7 @@ var Compiler = class {
 		const c = this.compile(node.self, used);
 		const sep = this.compile(node.separator, false);
 		const resumable = this.resumable;
-		const key = {};
+		const key = new Key();
 		return (s) => {
 			const entry = s.pos;
 			let acc;
@@ -798,7 +798,7 @@ var Compiler = class {
 		const sep = this.compile(node.separator, true);
 		const op = node.op;
 		const resumable = this.resumable;
-		const key = {};
+		const key = new Key();
 		if (!node.right) return (s) => {
 			const entry = s.pos;
 			let acc;
@@ -1068,20 +1068,18 @@ var Compiler = class {
 		};
 	}
 	text(p, node, enc, used) {
-		const kind = this.kind;
-		const fast = fastLimit(enc);
+		const { fast, unitAt, width: unitWidth } = unitReader(this.kind, enc);
 		const decode = enc.decode;
 		const width = enc.width;
 		const toText = enc.text;
-		const unitAt = kind === 0 ? (input, i) => input.charCodeAt(i) : (input, i) => input[i];
 		switch (node._tag) {
 			case "Any": return (s) => {
 				const pos = s.pos;
 				const end = s.end;
 				if (pos >= end) return fail(s);
-				const c = unitAt(s.input, pos);
+				const c = unitAt(s.input, pos, end);
 				if (c < fast) {
-					s.pos = pos + 1;
+					s.pos = pos + unitWidth;
 					return used ? charOf(c) : void 0;
 				}
 				const cp = decode(s.input, pos, end);
@@ -1101,11 +1099,11 @@ var Compiler = class {
 						let pos = start;
 						for (let i = 0; i < n; i++) {
 							if (pos >= end) return failAt(s, pos);
-							const c = unitAt(input, pos);
+							const c = unitAt(input, pos, end);
 							let cp;
 							if (c < fast) {
 								cp = c;
-								pos++;
+								pos += unitWidth;
 							} else {
 								cp = decode(input, pos, end);
 								if (cp < 0) return failAt(s, pos);
@@ -1150,15 +1148,15 @@ var Compiler = class {
 					const pos = s.pos;
 					const end = s.end;
 					if (pos >= end) return fail(s);
-					const c = unitAt(s.input, pos);
+					const c = unitAt(s.input, pos, end);
 					if (c < fast && c < TableSize) {
 						if (accept[c] === 0) return fail(s);
-						s.pos = pos + 1;
+						s.pos = pos + unitWidth;
 						return used ? charOf(c) : void 0;
 					}
 					const cp = c < fast ? c : decode(s.input, pos, end);
 					if (cp < 0 || test(cp) === negate) return fail(s);
-					s.pos = pos + (c < fast ? 1 : width(cp));
+					s.pos = pos + (c < fast ? unitWidth : width(cp));
 					return used ? charOf(cp) : void 0;
 				};
 			}
@@ -1171,7 +1169,7 @@ var Compiler = class {
 					let pos = start;
 					for (let got = 0; got < count; got++) {
 						if (pos >= end) return failAt(s, pos);
-						if (unitAt(input, pos) < fast) pos++;
+						if (unitAt(input, pos, end) < fast) pos += unitWidth;
 						else {
 							const cp = decode(input, pos, end);
 							if (cp < 0) return failAt(s, pos);
@@ -1185,34 +1183,18 @@ var Compiler = class {
 			case "TakeWhile": {
 				const { max, min, negate } = node;
 				const set = textSet(node.set);
-				const accept = acceptTable(set, negate);
-				const test = set.test;
-				const small = Math.min(fast, TableSize);
-				return (s) => {
-					const input = s.input;
-					const start = s.pos;
-					const end = s.end;
-					let i = start;
-					let count = 0;
-					while (count < max && i < end) {
-						const c = unitAt(input, i);
-						if (c < small) {
-							if (accept[c] === 0) break;
-							i++;
-						} else if (c < fast) {
-							if (test(c) === negate) break;
-							i++;
-						} else {
-							const cp = decode(input, i, end);
-							if (cp < 0 || test(cp) === negate) break;
-							i += width(cp);
-						}
-						count++;
-					}
-					if (count < min) return failAt(s, i);
-					s.pos = i;
-					return used ? toText(input, start, i) : void 0;
+				const loop = {
+					max,
+					min,
+					negate,
+					accept: acceptTable(set, negate),
+					test: set.test,
+					small: Math.min(fast, TableSize),
+					fast,
+					used
 				};
+				if (unitWidth === 2) return takeWhileUtf16(loop, enc === utf16le ? 0 : 1, enc);
+				return this.kind === 0 ? takeWhileString(loop, enc) : takeWhileBytes(loop, enc);
 			}
 			case "TakeUntil":
 			case "Rest": return this.fallback(p, node, "Text parser without a compiled form");
@@ -1232,16 +1214,15 @@ var Compiler = class {
 				return c(s) === Fail ? Fail : s.slice(start, s.pos);
 			};
 		}
-		const fast = fastLimit(enc);
+		const { fast, unitAt, width } = unitReader(this.kind, enc);
 		const toText = enc.text;
-		const unitAt = this.kind === 0 ? (input, i) => input.charCodeAt(i) : (input, i) => input[i];
 		return (s) => {
 			const start = s.pos;
 			if (c(s) === Fail) return Fail;
 			const end = s.pos;
 			const input = s.input;
 			let i = start;
-			while (i < end && unitAt(input, i) < fast) i++;
+			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;
 		};
@@ -1253,11 +1234,7 @@ var Compiler = class {
 	*/
 	float(node) {
 		if (!floatTexts.has(node.self) || this.kind === 2) return void 0;
-		let taken = nodeOf(node.self);
-		while (taken._tag === "Expected") taken = nodeOf(taken.self);
-		if (taken._tag !== "Taken") return void 0;
-		const enc = taken.encoding;
-		if (enc !== void 0 && !(this.native(enc) && enc.unit === 1 && enc.asciiCompatible)) return void 0;
+		if (!scansFloat(node.self, (enc) => this.native(enc))) return void 0;
 		const c = this.compile(node.self, true);
 		const scan = this.kind === 0 ? scanFloatString : scanFloatBytes;
 		const resumable = this.resumable;
@@ -1293,7 +1270,16 @@ var Compiler = class {
 			}
 			return false;
 		};
-		else control = (s) => {
+		else if (ctrl < unitReader(kind, enc).fast) {
+			const { unitAt, width } = unitReader(kind, enc);
+			control = (s) => {
+				if (s.pos < s.end && unitAt(s.input, s.pos, s.end) === ctrl) {
+					s.pos += width;
+					return true;
+				}
+				return false;
+			};
+		} else control = (s) => {
 			if (s.pos >= s.end) return false;
 			const cp = enc.decode(s.input, s.pos, s.end);
 			if (cp !== ctrl) return false;
@@ -1301,7 +1287,7 @@ var Compiler = class {
 			return true;
 		};
 		const resumable = this.resumable;
-		const key = {};
+		const key = new Key();
 		/** Fails as incomplete, keeping a checkpoint in a streaming parse. */
 		const incomplete = (s, start, checkpoint) => {
 			if (s.resume !== void 0) Resume.save(s, key, start, checkpoint);
@@ -1397,18 +1383,105 @@ const fail = (s) => {
 	s.mode = BT;
 	return Fail;
 };
-/** Fails, leaving the cursor at `pos`: how far a token parser read (see `partialSafe`). */
+const takeWhileString = (loop, enc) => {
+	const { accept, fast, max, min, negate, small, test, used } = loop;
+	const { decode, text, width } = enc;
+	return (s) => {
+		const input = s.input;
+		const start = s.pos;
+		const end = s.end;
+		let i = start;
+		let count = 0;
+		while (count < max && i < end) {
+			const c = input.charCodeAt(i);
+			if (c < small) {
+				if (accept[c] === 0) break;
+				i++;
+			} else if (c < fast) {
+				if (test(c) === negate) break;
+				i++;
+			} else {
+				const cp = decode(input, i, end);
+				if (cp < 0 || test(cp) === negate) break;
+				i += width(cp);
+			}
+			count++;
+		}
+		if (count < min) return failAt(s, i);
+		s.pos = i;
+		return used ? text(input, start, i) : void 0;
+	};
+};
+const takeWhileBytes = (loop, enc) => {
+	const { accept, max, min, negate, small, test, used } = loop;
+	const { decode, text, width } = enc;
+	return (s) => {
+		const input = s.input;
+		const start = s.pos;
+		const end = s.end;
+		let i = start;
+		let count = 0;
+		while (count < max && i < end) {
+			const c = input[i];
+			if (c < small) {
+				if (accept[c] === 0) break;
+				i++;
+			} else {
+				const cp = decode(input, i, end);
+				if (cp < 0 || test(cp) === negate) break;
+				i += width(cp);
+			}
+			count++;
+		}
+		if (count < min) return failAt(s, i);
+		s.pos = i;
+		return used ? text(input, start, i) : void 0;
+	};
+};
+/** For UTF-16 bytes; `lo` is the offset of a unit's low byte (0 for little endian). */
+const takeWhileUtf16 = (loop, lo, enc) => {
+	const { accept, fast, max, min, negate, small, test, used } = loop;
+	const { decode, text, width } = enc;
+	const hi = 1 - lo;
+	return (s) => {
+		const input = s.input;
+		const start = s.pos;
+		const end = s.end;
+		let i = start;
+		let count = 0;
+		while (count < max && i < end) {
+			const c = i + 1 < end ? input[i + lo] | input[i + hi] << 8 : 65535;
+			if (c < fast ? c < small ? accept[c] === 0 : test(c) === negate : false) break;
+			if (c < fast) i += 2;
+			else {
+				const cp = decode(input, i, end);
+				if (cp < 0 || test(cp) === negate) break;
+				i += width(cp);
+			}
+			count++;
+		}
+		if (count < min) return failAt(s, i);
+		s.pos = i;
+		return used ? text(input, start, i) : void 0;
+	};
+};
+const unitReader = (kind, enc) => {
+	if (kind === 1 && (enc === utf16le || enc === utf16be)) return {
+		width: 2,
+		fast: 55296,
+		unitAt: enc === utf16le ? (input, i, end) => i + 1 < end ? input[i] | input[i + 1] << 8 : 65535 : (input, i, end) => i + 1 < end ? input[i] << 8 | input[i + 1] : 65535
+	};
+	return {
+		width: 1,
+		fast: fastLimit(enc),
+		unitAt: kind === 0 ? (input, i, _end) => input.charCodeAt(i) : (input, i, _end) => input[i]
+	};
+};
 const failAt = (s, pos) => {
 	s.pos = pos;
 	s.mode = BT;
 	return Fail;
 };
-/** 1 where a small code is accepted (taking `negate` into account). */
-const acceptTable = (set, negate) => {
-	const t = new Uint8Array(TableSize);
-	for (let c = 0; c < TableSize; c++) t[c] = set.table[c] === 1 !== negate ? 1 : 0;
-	return t;
-};
 /** A literal matched against a string input, returning `value`. */
 const stringLiteral = (str, value) => {
 	const len = str.length;
@@ -1465,25 +1538,20 @@ const compileClosure = (root, kind, resumable = false) => {
 	};
 };
 /** The closure compiler as a backend. */
-const backend = { build: (p, kind, resumable) => {
-	try {
-		const { fallbacks, step } = compileClosure(p, kind, resumable);
-		return {
-			backend: "closure",
-			step,
-			fallbacks,
-			error: void 0
-		};
-	} catch (error) {
-		return {
-			backend: void 0,
-			step: void 0,
-			fallbacks: [],
-			error
-		};
-	}
-} };
-//#endregion
+const backend = { build: (p, kind, resumable) => Result.match(Result.try(() => compileClosure(p, kind, resumable)), {
+	onSuccess: ({ fallbacks, step }) => ({
+		backend: "closure",
+		step,
+		fallbacks,
+		error: void 0
+	}),
+	onFailure: (error) => ({
+		backend: void 0,
+		step: void 0,
+		fallbacks: [],
+		error
+	})
+}) };
 export { backend, createClosureCompiler };
 
 //# sourceMappingURL=closure.js.map