@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/Bits.js

@@ -1,144 +1,142 @@
 import { Fail, Failure } from "./Input.js";
 import { make } from "./Parser.js";
+//#region src/Bits.ts
 const scale = (f, factor) => new Failure(factor < 1 ? Math.floor(f.offset * factor) : f.offset * factor, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, factor < 1 ? Math.ceil(f.needed * factor) : f.needed * factor);
 /**
- * Runs `step` with offsets measured in different units (bits vs bytes),
- * converting failure offsets back to the outer units afterwards.
- */
+* Runs `step` with offsets measured in different units (bits vs bytes),
+* converting failure offsets back to the outer units afterwards.
+*/
 const inUnits = (state, factor, step) => {
-    const end = state.end;
-    const deepest = state.deepest;
-    state.deepest = undefined;
-    state.pos = factor > 1 ? state.pos * factor : Math.ceil(state.pos * factor);
-    state.end = end * factor;
-    const a = step(state);
-    state.end = end;
-    const inner = state.deepest;
-    state.deepest = deepest;
-    if (a === Fail) {
-        state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor;
-        const f = state.failure;
-        state.failure = scale(f, 1 / factor);
-        if (inner !== undefined) {
-            const d = inner === f ? state.failure : scale(inner, 1 / factor);
-            if (deepest === undefined || d.offset >= deepest.offset)
-                state.deepest = d;
-        }
-        return Fail;
-    }
-    state.pos = factor > 1 ? Math.ceil(state.pos / factor) : state.pos / factor;
-    if (inner !== undefined) {
-        const d = scale(inner, 1 / factor);
-        if (deepest === undefined || d.offset >= deepest.offset)
-            state.deepest = d;
-    }
-    return a;
+	const end = state.end;
+	const deepest = state.deepest;
+	state.deepest = void 0;
+	state.pos = factor > 1 ? state.pos * factor : Math.ceil(state.pos * factor);
+	state.end = end * factor;
+	const a = step(state);
+	state.end = end;
+	const inner = state.deepest;
+	state.deepest = deepest;
+	if (a === Fail) {
+		state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor;
+		const f = state.failure;
+		state.failure = scale(f, 1 / factor);
+		if (state.mode === "Cut") state.deepest = void 0;
+		if (inner !== void 0) {
+			const d = inner === f ? state.failure : scale(inner, 1 / factor);
+			if (state.deepest === void 0 || d.offset >= state.deepest.offset) state.deepest = d;
+		}
+		return Fail;
+	}
+	state.pos = factor > 1 ? Math.ceil(state.pos / factor) : state.pos / factor;
+	if (inner !== void 0) {
+		const d = scale(inner, 1 / factor);
+		if (deepest === void 0 || d.offset >= deepest.offset) state.deepest = d;
+	}
+	return a;
 };
 /**
- * Runs a bit-level parser on byte input (winnow's and nom's `bits`). After
- * success, the input advances to the next byte boundary.
- *
- * @since 0.1.0
- * @category combinators
- */
-export const bits = (self) => {
-    const step = self.step;
-    return make((state) => inUnits(state, 8, step), "bits");
+* Runs a bit-level parser on byte input (winnow's and nom's `bits`). After
+* success, the input advances to the next byte boundary.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const bits = (self) => {
+	const step = self.step;
+	return make((state) => inUnits(state, 8, step), "bits");
 };
 /**
- * Runs a byte-level parser from within a bit-level parser (winnow's and
- * nom's `bytes`). The partly consumed byte, if any, is skipped first.
- *
- * @since 0.1.0
- * @category combinators
- */
-export const bytes = (self) => {
-    const step = self.step;
-    return make((state) => inUnits(state, 1 / 8, step), "bytes");
+* Runs a byte-level parser from within a bit-level parser (winnow's and
+* nom's `bytes`). The partly consumed byte, if any, is skipped first.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const bytes = (self) => {
+	const step = self.step;
+	return make((state) => inUnits(state, 1 / 8, step), "bytes");
 };
 const readBits = (state, count) => {
-    const input = state.input;
-    let pos = state.pos;
-    let value = 0;
-    for (let i = 0; i < count; i++) {
-        const byte = input[pos >>> 3];
-        value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1);
-        pos++;
-    }
-    state.pos = pos;
-    return value;
+	const input = state.input;
+	let pos = state.pos;
+	let value = 0;
+	for (let i = 0; i < count; i++) {
+		const byte = input[pos >>> 3];
+		value = value * 2 + (byte >>> 7 - (pos & 7) & 1);
+		pos++;
+	}
+	state.pos = pos;
+	return value;
 };
 /**
- * Takes `count` bits (at most 53) as an unsigned number (winnow's and nom's
- * bit-level `take`).
- *
- * @since 0.1.0
- * @category parsers
- */
-export const take = (count) => {
-    if (count > 53)
-        throw new RangeError("Bits.take: use Bits.takeBig for more than 53 bits");
-    const expected = [`${count} bits`];
-    return make((state) => {
-        const avail = state.end - state.pos;
-        if (avail < count)
-            return state.eoi("Bits", expected, count - avail);
-        return readBits(state, count);
-    }, "take");
+* Takes `count` bits (at most 53) as an unsigned number (winnow's and nom's
+* bit-level `take`).
+*
+* @since 0.1.0
+* @category parsers
+*/
+const take = (count) => {
+	if (count > 53) throw new RangeError("Bits.take: use Bits.takeBig for more than 53 bits");
+	const expected = [`${count} bits`];
+	return make((state) => {
+		const avail = state.end - state.pos;
+		if (avail < count) return state.eoi("Bits", expected, count - avail);
+		return readBits(state, count);
+	}, "take");
 };
 /**
- * Takes `count` bits as an unsigned `bigint`.
- *
- * @since 0.1.0
- * @category parsers
- */
-export const takeBig = (count) => {
-    const expected = [`${count} bits`];
-    return make((state) => {
-        const avail = state.end - state.pos;
-        if (avail < count)
-            return state.eoi("Bits", expected, count - avail);
-        let value = 0n;
-        let remaining = count;
-        while (remaining > 0) {
-            const n = Math.min(remaining, 32);
-            value = (value << BigInt(n)) | BigInt(readBits(state, n));
-            remaining -= n;
-        }
-        return value;
-    }, "takeBig");
+* Takes `count` bits as an unsigned `bigint`.
+*
+* @since 0.1.0
+* @category parsers
+*/
+const takeBig = (count) => {
+	const expected = [`${count} bits`];
+	return make((state) => {
+		const avail = state.end - state.pos;
+		if (avail < count) return state.eoi("Bits", expected, count - avail);
+		let value = 0n;
+		let remaining = count;
+		while (remaining > 0) {
+			const n = Math.min(remaining, 32);
+			value = value << BigInt(n) | BigInt(readBits(state, n));
+			remaining -= n;
+		}
+		return value;
+	}, "takeBig");
 };
 /**
- * Matches `count` bits equal to `pattern` (winnow's `pattern`, nom's bit
- * `tag`).
- *
- * @since 0.1.0
- * @category parsers
- */
-export const pattern = (pattern, count) => {
-    const expected = [`bit pattern ${pattern.toString(2).padStart(count, "0")}`];
-    return make((state) => {
-        const start = state.pos;
-        const avail = state.end - start;
-        if (avail < count)
-            return state.eoi("Bits", expected, count - avail);
-        const value = readBits(state, count);
-        if (value !== pattern) {
-            state.pos = start;
-            return state.backtrack("Bits", expected);
-        }
-        return value;
-    }, "pattern");
+* Matches `count` bits equal to `pattern` (winnow's `pattern`, nom's bit
+* `tag`).
+*
+* @since 0.1.0
+* @category parsers
+*/
+const pattern = (pattern, count) => {
+	const expected = [`bit pattern ${pattern.toString(2).padStart(count, "0")}`];
+	return make((state) => {
+		const start = state.pos;
+		const avail = state.end - start;
+		if (avail < count) return state.eoi("Bits", expected, count - avail);
+		const value = readBits(state, count);
+		if (value !== pattern) {
+			state.pos = start;
+			return state.backtrack("Bits", expected);
+		}
+		return value;
+	}, "pattern");
 };
 /**
- * Takes one bit as a boolean (winnow's and nom's `bool`).
- *
- * @since 0.1.0
- * @category parsers
- */
-export const bool = make((state) => {
-    if (state.pos >= state.end)
-        return state.eoi("Bits", ["1 bit"], 1);
-    return readBits(state, 1) === 1;
+* Takes one bit as a boolean (winnow's and nom's `bool`).
+*
+* @since 0.1.0
+* @category parsers
+*/
+const bool = /*#__PURE__*/ make((state) => {
+	if (state.pos >= state.end) return state.eoi("Bits", ["1 bit"], 1);
+	return readBits(state, 1) === 1;
 }, "bool");
+//#endregion
+export { bits, bool, bytes, pattern, take, takeBig };
+
 //# sourceMappingURL=Bits.js.map

package/dist/Bits.js.map

@@ -1 +1 @@
-{"version":3,"file":"Bits.js","sourceRoot":"","sources":["../src/Bits.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Bits.js","names":[],"sources":["../src/Bits.ts"],"sourcesContent":["/**\n * Bit-level parsing (winnow's `binary::bits`, nom's `bits` module).\n *\n * Bit parsers run inside {@link bits}, which switches a byte parser into\n * bit mode. Bits are read most-significant first. When `bits` finishes, any\n * remaining bits of a partly consumed byte are skipped.\n *\n * Inside `bits`, offsets count bits, so the general combinators (`alt`,\n * `repeat`, `opt`, ...) backtrack at bit granularity.\n *\n * @example\n * ```ts\n * import { Binary, Bits, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // An IPv4 header starts with a 4-bit version and a 4-bit header length\n * const versionAndLength = Bits.bits(Parser.seq(Bits.take(4), Bits.take(4)))\n *\n * Parser.parse(versionAndLength, new Uint8Array([0x45])) // Result.succeed([4, 5])\n * ```\n *\n * @since 0.1.0\n */\nimport type { State } from \"./Input.js\"\nimport { Fail, Failure } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { make } from \"./Parser.js\"\n\ndeclare const BitInputBrand: unique symbol\n\n/**\n * The input type of bit-level parsers. A `Parser<A, E, R, BitInput>` can\n * only be run inside {@link bits}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BitInput extends ReadonlyArray<never> {\n  readonly [BitInputBrand]: true\n}\n\nconst scale = (f: Failure, factor: number): Failure =>\n  new Failure(\n    factor < 1 ? Math.floor(f.offset * factor) : f.offset * factor,\n    f.kind,\n    f.expected,\n    f.context,\n    f.hasCause,\n    f.cause,\n    f.message,\n    factor < 1 ? Math.ceil(f.needed * factor) : f.needed * factor\n  )\n\n/**\n * Runs `step` with offsets measured in different units (bits vs bytes),\n * converting failure offsets back to the outer units afterwards.\n */\nconst inUnits = <A>(state: State<any>, factor: number, step: (state: State<any>) => A | Fail): A | Fail => {\n  const end = state.end\n  const deepest = state.deepest\n  state.deepest = undefined\n  state.pos = factor > 1 ? state.pos * factor : Math.ceil(state.pos * factor)\n  state.end = end * factor\n  const a = step(state)\n  state.end = end\n  const inner = state.deepest\n  state.deepest = deepest\n  if (a === Fail) {\n    state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor\n    const f = state.failure\n    state.failure = scale(f, 1 / factor)\n    // A committed failure keeps only the failures recorded after the commit\n    // (see `Parser.cut`), so none from before these units\n    if (state.mode === \"Cut\") state.deepest = undefined\n    if (inner !== undefined) {\n      const d = inner === f ? state.failure : scale(inner, 1 / factor)\n      if (state.deepest === undefined || d.offset >= state.deepest.offset) state.deepest = d\n    }\n    return Fail\n  }\n  state.pos = factor > 1 ? Math.ceil(state.pos / factor) : state.pos / factor\n  if (inner !== undefined) {\n    const d = scale(inner, 1 / factor)\n    if (deepest === undefined || d.offset >= deepest.offset) state.deepest = d\n  }\n  return a\n}\n\n/**\n * Runs a bit-level parser on byte input (winnow's and nom's `bits`). After\n * success, the input advances to the next byte boundary.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bits = <A, E, R>(self: Parser<A, E, R, BitInput>): Parser<A, E, R, Uint8Array> => {\n  const step = self.step as unknown as (state: State<any>) => A | Fail\n  return make((state) => inUnits(state, 8, step), \"bits\")\n}\n\n/**\n * Runs a byte-level parser from within a bit-level parser (winnow's and\n * nom's `bytes`). The partly consumed byte, if any, is skipped first.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bytes = <A, E, R>(self: Parser<A, E, R, Uint8Array>): Parser<A, E, R, BitInput> => {\n  const step = self.step as (state: State<any>) => A | Fail\n  return make((state: State<any>) => inUnits(state, 1 / 8, step), \"bytes\")\n}\n\nconst readBits = (state: State<any>, count: number): number => {\n  const input = state.input as Uint8Array\n  let pos = state.pos\n  let value = 0\n  for (let i = 0; i < count; i++) {\n    const byte = input[pos >>> 3]\n    value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1)\n    pos++\n  }\n  state.pos = pos\n  return value\n}\n\n/**\n * Takes `count` bits (at most 53) as an unsigned number (winnow's and nom's\n * bit-level `take`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const take = (count: number): Parser<number, never, never, BitInput> => {\n  if (count > 53) throw new RangeError(\"Bits.take: use Bits.takeBig for more than 53 bits\")\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    return readBits(state, count)\n  }, \"take\")\n}\n\n/**\n * Takes `count` bits as an unsigned `bigint`.\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const takeBig = (count: number): Parser<bigint, never, never, BitInput> => {\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    let value = 0n\n    let remaining = count\n    while (remaining > 0) {\n      const n = Math.min(remaining, 32)\n      value = (value << BigInt(n)) | BigInt(readBits(state, n))\n      remaining -= n\n    }\n    return value\n  }, \"takeBig\")\n}\n\n/**\n * Matches `count` bits equal to `pattern` (winnow's `pattern`, nom's bit\n * `tag`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const pattern = (pattern: number, count: number): Parser<number, never, never, BitInput> => {\n  const expected = [`bit pattern ${pattern.toString(2).padStart(count, \"0\")}`]\n  return make((state: State<any>) => {\n    const start = state.pos\n    const avail = state.end - start\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    const value = readBits(state, count)\n    if (value !== pattern) {\n      state.pos = start\n      return state.backtrack(\"Bits\", expected)\n    }\n    return value\n  }, \"pattern\")\n}\n\n/**\n * Takes one bit as a boolean (winnow's and nom's `bool`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const bool: Parser<boolean, never, never, BitInput> = /*#__PURE__*/ make((state: State<any>) => {\n  if (state.pos >= state.end) return state.eoi(\"Bits\", [\"1 bit\"], 1)\n  return readBits(state, 1) === 1\n}, \"bool\")\n"],"mappings":"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"}

package/dist/Compiler.d.ts

@@ -0,0 +1,39 @@
+import { Input } from "./Input.js";
+import { Parser } from "./Parser.js";
+//#region src/Compiler.d.ts
+/**
+ * Compiles a parser with the JIT: generated code where `new Function` is
+ * allowed, otherwise specialized closures (see {@link closure}). Returns the
+ * same parser.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const list = Compiler.jit(Parser.separated(Ascii.decInt, Token.literal(",")))
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+ * ```
+ *
+ * @since 0.2.0
+ * @category compilation
+ */
+export declare const jit: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>;
+/**
+ * Compiles a parser into specialized closures. Returns the same parser.
+ * Nothing is generated, so it works under a Content Security Policy, and a
+ * bundle that compiles only with `closure` contains no `new Function`.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const list = Compiler.closure(Parser.separated(Ascii.decInt, Token.literal(",")))
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+ * ```
+ *
+ * @since 0.2.0
+ * @category compilation
+ */
+export declare const closure: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>;
+//#endregion
+//# sourceMappingURL=Compiler.d.ts.map

package/dist/Compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compiler.d.ts","names":[],"sources":["../src/Compiler.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAyEa,MAAO,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG;;;;;;;;;;;;;;;;;qBAqB5E,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG"}

package/dist/Compiler.js

@@ -0,0 +1,48 @@
+import { backend } from "./internal/compiler/closure.js";
+import { backend as backend$1 } from "./internal/compiler/jit.js";
+import { register } from "./internal/compiler/registry.js";
+//#region src/Compiler.ts
+/**
+* Compiles a parser with the JIT: generated code where `new Function` is
+* allowed, otherwise specialized closures (see {@link closure}). Returns the
+* same parser.
+*
+* @example
+* ```ts
+* import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const list = Compiler.jit(Parser.separated(Ascii.decInt, Token.literal(",")))
+* Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+* ```
+*
+* @since 0.2.0
+* @category compilation
+*/
+const jit = (self) => {
+	register(self, backend$1);
+	return self;
+};
+/**
+* Compiles a parser into specialized closures. Returns the same parser.
+* Nothing is generated, so it works under a Content Security Policy, and a
+* bundle that compiles only with `closure` contains no `new Function`.
+*
+* @example
+* ```ts
+* import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* const list = Compiler.closure(Parser.separated(Ascii.decInt, Token.literal(",")))
+* Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+* ```
+*
+* @since 0.2.0
+* @category compilation
+*/
+const closure = (self) => {
+	register(self, backend);
+	return self;
+};
+//#endregion
+export { closure, jit };
+
+//# sourceMappingURL=Compiler.js.map

package/dist/Compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compiler.js","names":["jitBackend","closureBackend"],"sources":["../src/Compiler.ts"],"sourcesContent":["/**\n * Compiles parsers into fused, specialized code. Grammars are written as\n * usual; compiling the root of a grammar only makes `Parser.parse`,\n * `Parser.parseSync`, `Parser.parsePeek`, `Parser.parsePartial` and\n * `Parser.parseEffect` faster, from any `offset`.\n *\n * There are two compilers, one function each, so a program bundles only the\n * one it uses, and a program that compiles nothing bundles neither:\n *\n * - {@link jit} generates code with `new Function` where it is allowed, and\n *   otherwise uses the closure compiler. It is the fastest.\n * - {@link closure} builds specialized closures only. It never generates\n *   code, and a bundle that uses only it contains no `new Function`, so it\n *   is the choice under a Content Security Policy, where even probing for\n *   `new Function` is reported as a violation.\n *\n * ```ts\n * import { Ascii, Compiler, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * export const list = Compiler.jit(\n *   Parser.separated(Ascii.decInt, Token.literal(\",\"))\n * )\n * Parser.parse(list, \"1,2,3\") // Result.succeed([1, 2, 3]), compiled\n * ```\n *\n * Both return the same parser, so they also work in a pipe:\n * `p.pipe(Compiler.closure)`. The code is built lazily on the first run, for\n * each kind of input (string, bytes or array), and cached with the parser.\n * Compiling a parser again, with either function, replaces its compiled\n * form.\n *\n * **Results and errors are unchanged.** Compiled code records no\n * diagnostics. When it fails, the parser runs again, interpreted, from the\n * same offset, so every `ParseError` (offset, expected, context, cause and\n * message) is exactly the one the interpreter reports.\n *\n * **Callbacks should be pure.** On an input that fails, the callbacks given\n * to `map`, `filter`, `tryMap`, `tap`, `fold`, ... may run twice, once\n * compiled and once interpreted. Callbacks whose results are discarded\n * (a `map` inside `taken` or `preceded`, for example) may not run at all,\n * nor those of a branch that is certain to fail, and token-set predicates\n * may be called once per character code and cached.\n *\n * `Parser.parsePartial` and `ParserStream.parseAll` run a build that\n * handles partial input. `ParserStream.parseMany`, `Parser.parseRecoverable`\n * and runs with the `trace` option are always interpreted. Parsers that\n * can't be described, such as `Parser.make` and `Parser.gen`, run\n * interpreted inside compiled code.\n *\n * @since 0.2.0\n */\nimport type { Input } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { backend as closureBackend } from \"./internal/compiler/closure.js\"\nimport { backend as jitBackend } from \"./internal/compiler/jit.js\"\nimport { register } from \"./internal/compiler/registry.js\"\n\n/**\n * Compiles a parser with the JIT: generated code where `new Function` is\n * allowed, otherwise specialized closures (see {@link closure}). Returns the\n * same parser.\n *\n * @example\n * ```ts\n * import { Ascii, Compiler, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const list = Compiler.jit(Parser.separated(Ascii.decInt, Token.literal(\",\")))\n * Parser.parse(list, \"1,2,3\") // Result.succeed([1, 2, 3])\n * ```\n *\n * @since 0.2.0\n * @category compilation\n */\nexport const jit = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {\n  register(self, jitBackend)\n  return self\n}\n\n/**\n * Compiles a parser into specialized closures. Returns the same parser.\n * Nothing is generated, so it works under a Content Security Policy, and a\n * bundle that compiles only with `closure` contains no `new Function`.\n *\n * @example\n * ```ts\n * import { Ascii, Compiler, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const list = Compiler.closure(Parser.separated(Ascii.decInt, Token.literal(\",\")))\n * Parser.parse(list, \"1,2,3\") // Result.succeed([1, 2, 3])\n * ```\n *\n * @since 0.2.0\n * @category compilation\n */\nexport const closure = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {\n  register(self, closureBackend)\n  return self\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyEA,MAAa,OAAiC,SAAiD;CAC7F,SAAS,MAAMA,SAAU;CACzB,OAAO;AACT;;;;;;;;;;;;;;;;;AAkBA,MAAa,WAAqC,SAAiD;CACjG,SAAS,MAAMC,OAAc;CAC7B,OAAO;AACT"}

package/dist/Encoding.d.ts

@@ -1,23 +1,5 @@
-/**
- * Text encodings for the `Text` module.
- *
- * An {@link Encoding} tells the `Text` parsers how to read Unicode code
- * points out of an input. JavaScript strings are read natively, without any
- * conversion. Byte inputs are decoded as they are parsed, so offsets stay
- * byte offsets, slices that are kept as bytes (`Parser.taken`) are
- * zero-copy views, and partial input that ends in the middle of a character
- * reports `Incomplete`.
- *
- * ```ts
- * import { Encoding, Text } from "@thomasfosterau/effect-parse"
- *
- * Text.utf8.encoding === Encoding.utf8
- * Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own
- * ```
- *
- * @since 0.1.0
- */
 import * as Option from "effect/Option";
+//#region src/Encoding.d.ts
 /**
  * A text encoding: how to read Unicode code points out of an input. The
  * `Text` module is generic over encodings, so one grammar can parse
@@ -30,33 +12,33 @@ import * as Option from "effect/Option";
  * @category models
  */
 export interface Encoding<I extends string | Uint8Array = string | Uint8Array> {
-    /** The name of the encoding, e.g. `"UTF-8"`. Used in error messages. */
-    readonly name: string;
-    /**
-     * The size of a code unit, in input units: 1 for strings, UTF-8 and
-     * Latin-1, 2 for UTF-16 bytes. Code points start at multiples of it.
-     */
-    readonly unit: number;
-    /**
-     * Whether every input unit below `0x80` encodes the ASCII character with
-     * that value, and is never part of a longer sequence. Enables fast paths.
-     */
-    readonly asciiCompatible: boolean;
-    /**
-     * Decodes the code point starting at `offset` (with `offset < end`).
-     * Returns the code point, `-1` if the input is malformed there, or `-2` if
-     * the input ends inside a sequence (more input could complete it).
-     */
-    readonly decode: (input: I, offset: number, end: number) => number;
-    /** The number of input units that encode a code point. */
-    readonly width: (codePoint: number) => number;
-    /** Encodes a string. Throws if the string can't be represented. */
-    readonly encode: (text: string) => I;
-    /**
-     * Decodes the units `[start, end)` to a string. The parsers only call it
-     * on ranges they have checked are well formed.
-     */
-    readonly text: (input: I, start: number, end: number) => string;
+  /** The name of the encoding, e.g. `"UTF-8"`. Used in error messages. */
+  readonly name: string;
+  /**
+   * The size of a code unit, in input units: 1 for strings, UTF-8 and
+   * Latin-1, 2 for UTF-16 bytes. Code points start at multiples of it.
+   */
+  readonly unit: number;
+  /**
+   * Whether every input unit below `0x80` encodes the ASCII character with
+   * that value, and is never part of a longer sequence. Enables fast paths.
+   */
+  readonly asciiCompatible: boolean;
+  /**
+   * Decodes the code point starting at `offset` (with `offset < end`).
+   * Returns the code point, `-1` if the input is malformed there, or `-2` if
+   * the input ends inside a sequence (more input could complete it).
+   */
+  readonly decode: (input: I, offset: number, end: number) => number;
+  /** The number of input units that encode a code point. */
+  readonly width: (codePoint: number) => number;
+  /** Encodes a string. Throws if the string can't be represented. */
+  readonly encode: (text: string) => I;
+  /**
+   * Decodes the units `[start, end)` to a string. The parsers only call it
+   * on ranges they have checked are well formed.
+   */
+  readonly text: (input: I, start: number, end: number) => string;
 }
 /**
  * JavaScript strings, read as UTF-16 code units. Offsets are code-unit
@@ -113,4 +95,5 @@ export declare const latin1: Encoding<Uint8Array>;
  * @category utils
  */
 export declare const sniff: (bytes: Uint8Array) => Option.Option<Encoding<Uint8Array>>;
+//#endregion
 //# sourceMappingURL=Encoding.d.ts.map

package/dist/Encoding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Encoding.d.ts","sourceRoot":"","sources":["../src/Encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU;IAC3E,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IAClE,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IAC7C,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAA;IACpC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAChE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAmB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAiB,CAAA;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAoB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAoB,CAAA;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAmB,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,UAAW,UAAU,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAK3E,CAAA"}
+{"version":3,"file":"Encoding.d.ts","names":[],"sources":["../src/Encoding.ts"],"mappings":";;;;;;;;;;;;;iBAiCiB,SAAS,mBAAmB,sBAAsB;;WAExD;;;;;WAKA;;;;;WAKA;;;;;;WAMA,SAAS,OAAO,GAAG,gBAAgB;;WAEnC,QAAQ;;WAER,SAAS,iBAAiB;;;;;WAK1B,OAAO,OAAO,GAAG,eAAe;;;;;;;;;;qBAW9B,QAAQ;;;;;;;;qBASR,MAAM,SAAS;;;;;;;qBAQf,SAAS,SAAS;;;;;;;qBAQlB,SAAS,SAAS;;;;;;;;qBASlB,QAAQ,SAAS;;;;;;;;;;;;;;;;qBAiBjB,QAAS,OAAO,eAAa,OAAO,OAAO,SAAS"}