@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/dist/ParserSchema.js

@@ -1,56 +1,685 @@
-/**
- * Building Effect `Schema`s from parsers.
- *
- * A parser over strings becomes a schema that decodes a `string` into the
- * parser's output. Parse errors become schema issues carrying the rendered
- * `ParseError` message. Encoding needs a printer, supplied as `encode`;
- * without one, encoding is forbidden.
- *
- * @example
- * ```ts
- * import { Schema } from "effect"
- * import { Ascii, Parser, ParserSchema, Token } from "@thomasfosterau/effect-parse"
- *
- * const Version = ParserSchema.make(
- *   Parser.struct({
- *     major: Ascii.decUint,
- *     minor: Parser.preceded(Token.literal("."), Ascii.decUint)
- *   }),
- *   { encode: ({ major, minor }) => `${major}.${minor}` }
- * )
- *
- * Schema.decodeUnknownSync(Version)("1.2") // { major: 1, minor: 2 }
- * Schema.encodeSync(Version)({ major: 3, minor: 4 }) // "3.4"
- * ```
- *
- * @since 0.1.0
- */
-import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
+import * as P from "./Parser.js";
+import { describeLiteral } from "./internal/tokens.js";
+import * as Token from "./Token.js";
+import * as Option from "effect/Option";
+import * as Ascii from "./Ascii.js";
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as Arr from "effect/Array";
+import * as Match from "effect/Match";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Order from "effect/Order";
+import * as Record from "effect/Record";
 import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-import * as P from "./Parser.js";
+//#region src/ParserSchema.ts
+/**
+* Effect `Schema`s and parsers, in both directions.
+*
+* {@link make} turns a parser over strings into a schema that decodes a
+* `string` into the parser's output. Parse errors become schema issues
+* carrying the rendered `ParseError` message. Encoding needs a printer,
+* supplied as `encode`; without one, encoding is forbidden.
+*
+* {@link toParser} goes the other way: it derives a parser from a schema,
+* guided by annotations ({@link annotate}) that say how each part is
+* written. {@link toPrinter} derives the printer that writes that text, and
+* {@link fromSchema} wraps both as a schema.
+*
+* @example
+* ```ts
+* import { Schema } from "effect"
+* import { Ascii, Parser, ParserSchema, Token } from "@thomasfosterau/effect-parse"
+*
+* const Version = ParserSchema.make(
+*   Parser.struct({
+*     major: Ascii.decUint,
+*     minor: Parser.preceded(Token.literal("."), Ascii.decUint)
+*   }),
+*   { encode: ({ major, minor }) => `${major}.${minor}` }
+* )
+*
+* Schema.decodeUnknownSync(Version)("1.2") // { major: 1, minor: 2 }
+* Schema.encodeSync(Version)({ major: 3, minor: 4 }) // "3.4"
+* ```
+*
+* @since 0.1.0
+*/
+/**
+* The key of the annotation that says how a schema is written as text
+* ({@link Annotation}), namespaced to this package so it cannot collide with
+* another library's. {@link annotate} sets it.
+*
+* @since 0.3.0
+* @category annotations
+*/
+const annotationKey = "@thomasfosterau/effect-parse/ParserSchema";
+const encodeWith = (encode) => (value) => Result.succeed(encode(value));
+const decodeWith = (target, parser, encode) => Schema.String.pipe(Schema.decodeTo(target, SchemaTransformation.transformEffect({
+	decode: (input, parseOptions) => {
+		const result = P.parse(parser, input);
+		return Result.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(new SchemaIssue.InvalidValue({ message: result.failure.message }, input, parseOptions));
+	},
+	encode: (value, parseOptions) => {
+		if (encode === void 0) return Effect.fail(new SchemaIssue.Forbidden({ message: "Encoding is not supported" }, value, parseOptions));
+		const result = encode(value);
+		return Result.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(result.failure);
+	}
+})));
+/**
+* Creates a schema that decodes a string with `parser`, which must consume
+* the whole string.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (parser, options) => decodeWith(Schema.declare((_u) => true, options?.description !== void 0 ? { description: options.description } : void 0), parser, options?.encode === void 0 ? void 0 : encodeWith(options.encode));
+/**
+* Annotates a schema with how it is written as text, for {@link toParser}
+* and {@link toPrinter}. The same as
+* `schema.annotate({ [ParserSchema.annotationKey]: annotation })`, except
+* that the parser's output must have the schema's type.
+*
+* @example
+* ```ts
+* import { Schema } from "effect"
+* import { ParserSchema } from "@thomasfosterau/effect-parse"
+*
+* const Point = Schema.Struct({ x: Schema.Int, y: Schema.Int }).pipe(
+*   ParserSchema.annotate({ prefix: "(", separator: ",", suffix: ")" })
+* )
+* ```
+*
+* @since 0.3.0
+* @category annotations
+*/
+const annotate = /*#__PURE__*/ dual(2, (self, annotation) => self.annotate({ [annotationKey]: annotation }));
+/**
+* Derives a parser from a schema. The parser reads the text the schema's
+* annotations ({@link Grammar}) describe and returns a value of the schema's
+* type, which the schema's checks and transformations have already
+* validated; their failures become parse errors whose `cause` is the
+* `SchemaError`.
+*
+* Without an annotation, a schema is parsed as follows:
+*
+* - `String`: one or more characters up to the next separator, key
+*   separator, suffix or literal around it (to the end of the input at the
+*   top level).
+* - `Number`: a decimal number (`Ascii.float`), or a decimal integer when
+*   the schema checks `isInt` (as `Schema.Int` does). `BigInt`: a decimal
+*   integer. `Boolean`: `true` or `false`. `Null`: `null`. `Undefined` and
+*   `Void`: nothing.
+* - `Literal`, `Enum` and `TemplateLiteral`: their text.
+* - `Struct` and `Tuple`: their fields or elements in order, between
+*   separators; an optional one may be left out along with its separator.
+*   `Array`: elements between separators.
+* - `Record`, and `Struct` with a `keySeparator`: `key`, key separator,
+*   value entries in any order, between separators.
+* - `Union`: the first member that parses, in order (literals longest
+*   first). `suspend`: recursion.
+* - A transformation (a `Class`, `NumberFromString`, ...): its encoded side,
+*   decoded by the schema. A grammar on it with a separator applies to the
+*   encoded side.
+*
+* A parser that fails where the schema starts reports the schema's
+* `identifier` annotation (or its `expected` annotation, unless that belongs
+* to a check) as what it expected. Other declarations, `Unknown`, `Any`,
+* symbols and `object` need a parser in their annotation; without one,
+* `toParser` throws. Transformations must decode synchronously.
+*
+* @example
+* ```ts
+* import { Schema } from "effect"
+* import { Parser, ParserSchema } from "@thomasfosterau/effect-parse"
+*
+* const Version = Schema.Struct({ major: Schema.Int, minor: Schema.Int }).pipe(
+*   ParserSchema.annotate({ separator: "." })
+* )
+*
+* Parser.parse(ParserSchema.toParser(Version), "1.2") // Result.succeed({ major: 1, minor: 2 })
+* ```
+*
+* @since 0.3.0
+* @category derivation
+*/
+const toParser = (schema) => {
+	const ast = schema.ast;
+	const parser = derive(ast, initial());
+	return grammarOf(ast).whitespace === true ? P.delimited(Ascii.multispace0, parser, Ascii.multispace0) : parser;
+};
+/**
+* Derives a printer from a schema: it writes a value of the schema's type as
+* the text {@link toParser} reads, following the same annotations, with no
+* optional whitespace. Transformations encode the value first, and a
+* {@link Grammar.print} replaces the derived printer.
+*
+* The printer fails with a `SchemaError` when the value is not of the
+* schema's type, or cannot be written so that it reads back: a string that
+* is empty or contains a character that would end it (a separator, a
+* suffix), or a part annotated with a parser but no `print`. Where the
+* grammar is ambiguous (an optional field followed by a field of the same
+* type), the text can still read back as a different value;
+* {@link fromSchema} checks that it doesn't.
+*
+* @example
+* ```ts
+* import { Schema } from "effect"
+* import { ParserSchema } from "@thomasfosterau/effect-parse"
+*
+* const Version = Schema.Struct({ major: Schema.Int, minor: Schema.Int }).pipe(
+*   ParserSchema.annotate({ separator: "." })
+* )
+*
+* ParserSchema.toPrinter(Version)({ major: 1, minor: 2 }) // Result.succeed("1.2")
+* ```
+*
+* @since 0.3.0
+* @category derivation
+*/
+const toPrinter = (schema) => {
+	const validate = typeDecoder(schema.ast);
+	const print = printerOf(schema.ast, initial());
+	return (value) => {
+		const valid = validate(value);
+		if (Result.isFailure(valid)) return Result.fail(valid.failure);
+		const out = [];
+		const issue = print(valid.success, out);
+		return issue === void 0 ? Result.succeed(out.join("")) : Result.fail(schemaError(issue));
+	};
+};
 /**
- * Creates a schema that decodes a string with `parser`, which must consume
- * the whole string.
- *
- * @since 0.1.0
- * @category constructors
- */
-export const make = (parser, options) => {
-    const target = Schema.declare((_u) => true, options?.description !== undefined ? { description: options.description } : undefined);
-    const encode = options?.encode;
-    return Schema.String.pipe(Schema.decodeTo(target, SchemaTransformation.transformEffect({
-        decode: (input, parseOptions) => {
-            const result = P.parse(parser, input);
-            return Result.isSuccess(result)
-                ? Effect.succeed(result.success)
-                : Effect.fail(new SchemaIssue.InvalidValue({ message: result.failure.message }, input, parseOptions));
-        },
-        encode: (value, parseOptions) => encode !== undefined
-            ? Effect.succeed(encode(value))
-            : Effect.fail(new SchemaIssue.Forbidden({ message: "Encoding is not supported" }, value, parseOptions))
-    })));
+* Creates a schema that decodes a string with the parser {@link toParser}
+* derives from `schema`, into `schema`'s type, and encodes with the printer
+* {@link toPrinter} derives, or with `encode` when given. A derived printer's
+* text is parsed back, and encoding fails unless it gives a value equivalent
+* to the one encoded, so decoding what was encoded always gives it back.
+*
+* @example
+* ```ts
+* import { Schema } from "effect"
+* import { ParserSchema } from "@thomasfosterau/effect-parse"
+*
+* const Pair = ParserSchema.fromSchema(
+*   Schema.Tuple([Schema.String, Schema.Number]).pipe(ParserSchema.annotate({ separator: "=" }))
+* )
+*
+* Schema.decodeUnknownSync(Pair)("width=10") // ["width", 10]
+* Schema.encodeSync(Pair)(["height", 2]) // "height=2"
+* ```
+*
+* @since 0.3.0
+* @category constructors
+*/
+const fromSchema = (schema, options) => {
+	const parser = toParser(schema);
+	const encode = options?.encode;
+	return decodeWith(Schema.toType(schema), parser, encode === void 0 ? roundTrip(schema, parser) : encodeWith(encode));
+};
+/** Prints with the derived printer, then checks that the text reads back as the value. */
+const roundTrip = (schema, parser) => {
+	const print = toPrinter(schema);
+	const equivalent = Schema.toEquivalence(Schema.toType(schema));
+	return (value) => Result.flatMap(Result.mapError(print(value), (error) => error.issue), (text) => {
+		const back = P.parse(parser, text);
+		return Result.isSuccess(back) && equivalent(back.success, value) ? Result.succeed(text) : Result.fail(new SchemaIssue.InvalidValue({ message: `The value is written ${describeLiteral(text)}, which does not read back as the value` }));
+	});
+};
+const initial = () => ({
+	stop: "",
+	whitespace: false,
+	inherit: void 0,
+	path: [],
+	recursions: []
+});
+/** The annotation `key` on `ast`, from its last check back to the node, as `Schema.resolveAnnotations` resolves it. */
+const lookup = (ast, key) => {
+	const checks = ast.checks;
+	if (checks !== void 0) for (let i = checks.length - 1; i >= 0; i--) {
+		const value = checks[i].annotations?.[key];
+		if (value !== void 0) return value;
+	}
+	return ast.annotations?.[key];
+};
+const grammarOf = (ast) => {
+	const value = lookup(ast, annotationKey);
+	if (value === void 0) return {};
+	return P.isParser(value) ? { parser: value } : value;
+};
+const isAnnotated = (ast) => lookup(ast, annotationKey) !== void 0;
+const withStop = (ctx, text) => {
+	if (text === void 0 || text === "" || ctx.stop.includes(text[0])) return ctx;
+	return {
+		...ctx,
+		stop: Arr.sort([...ctx.stop, text[0]], Order.String).join("")
+	};
+};
+const at = (ctx, key) => ({
+	...ctx,
+	inherit: void 0,
+	path: [...ctx.path, key]
+});
+const where = (ctx) => `[${ctx.path.map(String).join(", ")}]`;
+const unsupported = (ast, ctx, what) => {
+	throw new TypeError(`ParserSchema: cannot derive a ${what} for ${ast._tag} at ${where(ctx)}; annotate it`);
+};
+/** The node's grammar, with what its transformation passed down, and the context inside it. */
+const resolve = (ast, ctx) => {
+	const own = grammarOf(ast);
+	const inherit = ctx.inherit;
+	const grammar = inherit === void 0 ? own : {
+		...own,
+		separator: own.separator ?? inherit.separator,
+		keySeparator: own.keySeparator ?? inherit.keySeparator
+	};
+	const whitespace = grammar.whitespace ?? ctx.whitespace;
+	return {
+		grammar,
+		whitespace,
+		inner: {
+			...withStop(ctx, grammar.suffix),
+			whitespace,
+			inherit: void 0
+		}
+	};
+};
+/** The context of a transformation's encoded side, which the transformation's separators apply to. */
+const encodedContext = (grammar, ctx) => ({
+	...ctx,
+	inherit: {
+		separator: grammar.separator,
+		keySeparator: grammar.keySeparator
+	}
+});
+/**
+* The node with its chain of links ending at the type of its encoded side,
+* which is what the encoded side is parsed into and printed from.
+*/
+const linkTarget = (ast, links) => {
+	const last = links[links.length - 1];
+	let target = SchemaAST.toType(ast);
+	for (const link of links) {
+		const source = link === last ? SchemaAST.toType(last.to) : link.to;
+		target = SchemaAST.decodeTo(source, target, link.transformation);
+	}
+	return target;
+};
+/**
+* What is derived for a recursive schema: deriving it again in the same
+* context gives the same result, so the derivation ends.
+*/
+const recursive = (ast, ctx, make) => {
+	const key = `${ctx.whitespace ? 1 : 0}${ctx.stop}`;
+	const known = ctx.recursions.find((r) => r.ast === ast && r.key === key);
+	if (known !== void 0) return known.derived;
+	const derived = make();
+	ctx.recursions.push({
+		ast,
+		key,
+		derived
+	});
+	return derived;
+};
+/** The context for the items of a sequence: unannotated strings also stop at the separator. */
+const itemContext = (grammar, ctx) => withStop(ctx, grammar.separator);
+/** The rest element of an array schema, if any; elements after it are not supported. */
+const restOf = (ast, ctx, what) => {
+	const [head, ...after] = ast.rest;
+	return Arr.isReadonlyArrayNonEmpty(after) ? unsupported(ast, ctx, what) : head;
+};
+/** The contexts of an array schema's elements and its rest. */
+const elementContexts = (ast, rest, grammar, ctx) => {
+	const n = ast.elements.length;
+	return ast.elements.map((_, i) => at(i < n - 1 || rest !== void 0 ? itemContext(grammar, ctx) : ctx, i));
+};
+/** The contexts of a struct's fields, written in order. */
+const fieldContexts = (ast, grammar, ctx) => {
+	const fields = ast.propertySignatures;
+	return fields.map((field, i) => at(i < fields.length - 1 ? itemContext(grammar, ctx) : ctx, field.name));
+};
+const isKeyed = (ast, grammar) => grammar.keySeparator !== void 0 || Arr.isReadonlyArrayNonEmpty(ast.indexSignatures);
+const keySeparatorOf = (grammar, ctx) => {
+	if (grammar.keySeparator === void 0) throw new TypeError(`ParserSchema: a record at ${where(ctx)} needs a keySeparator in its annotation`);
+	return grammar.keySeparator;
+};
+/** The field name of a struct in keyed form: a string. */
+const keyName = (ast, field, ctx, what) => Predicate.isString(field.name) ? field.name : unsupported(ast, ctx, what);
+const propertyName = (key) => Predicate.isNumber(key) ? String(key) : key;
+/** Whether a check (as `Schema.Int` has) restricts numbers to integers. */
+const isIntegral = (checks) => checks !== void 0 && checks.some((check) => check instanceof SchemaAST.FilterGroup ? isIntegral(check.checks) : check.annotations?.arbitraryConstraint?.["number"] === "integer");
+/** Literals with the longest text first, so a literal is never cut short by one it starts with. */
+const byLength = (values) => Arr.sort(values, Order.mapInput(Order.Number, (value) => -String(value).length));
+const isPlainLiteral = (ast) => SchemaAST.isLiteral(ast) && ast.encoding === void 0 && !isAnnotated(ast);
+/** The literals of a union of plain literals, longest first, or `undefined`. */
+const plainLiterals = (ast) => {
+	const literals = Arr.filter(ast.types, isPlainLiteral);
+	return literals.length === ast.types.length ? byLength(literals.map((member) => member.literal)) : void 0;
+};
+const schemaError = (issue) => new Schema.SchemaError(issue);
+const decoder = (schema) => Schema.decodeUnknownResult(schema);
+/** Decodes into the type of `ast`, checks included. */
+const typeDecoder = (ast) => decoder(Schema.make(SchemaAST.toType(ast)));
+const messageOf = (cause) => Predicate.isString(cause) ? cause : Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) ? cause.message : String(cause);
+/** A parser whose failures' causes are `SchemaError`s, as {@link toParser}'s are. */
+const asSchemaErrors = (parser) => P.mapError(parser, (cause) => cause instanceof Schema.SchemaError ? cause : schemaError(new SchemaIssue.InvalidValue({ message: messageOf(cause) })));
+/** Literal text, with optional whitespace around it. */
+const text = (s, ws) => ws ? P.delimited(Ascii.multispace0, Token.literal(s), Ascii.multispace0) : Token.literal(s);
+const derive = (ast, ctx) => {
+	const { grammar, inner, whitespace } = resolve(ast, ctx);
+	let parser;
+	if (grammar.parser !== void 0) parser = P.tryMap(asSchemaErrors(grammar.parser), typeDecoder(ast));
+	else if (ast.encoding !== void 0) parser = decoded(ast, ast.encoding, grammar, inner);
+	else parser = checked(ast, structural(ast, grammar, inner));
+	if (grammar.prefix !== void 0) parser = P.preceded(text(grammar.prefix, whitespace), parser);
+	if (grammar.suffix !== void 0) parser = P.terminated(parser, text(grammar.suffix, whitespace));
+	const label = lookup(ast, "identifier") ?? ast.annotations?.expected;
+	return Predicate.isString(label) ? P.expected(parser, label) : parser;
+};
+/** Runs the checks on `ast` (its filters) on the parser's output. */
+const checked = (ast, parser) => ast.checks === void 0 ? parser : P.tryMap(parser, decoder(Schema.Unknown.check(...ast.checks)));
+/**
+* Parses the encoded side of a transformation and decodes it. The encoded
+* side is parsed into its own type, so the last link decodes from that type
+* rather than from the fully encoded form.
+*/
+const decoded = (ast, links, grammar, ctx) => {
+	const from = derive(links[links.length - 1].to, encodedContext(grammar, ctx));
+	return P.tryMap(from, decoder(Schema.make(linkTarget(ast, links))));
+};
+const structural = (ast, grammar, ctx) => Match.valueTags(ast, {
+	String: () => unannotatedString(ctx, 1),
+	Number: (number) => isIntegral(number.checks) ? integer : Ascii.float,
+	BigInt: () => Ascii.decBigInt,
+	Boolean: () => P.alt(P.as(Token.literal("true"), true), P.as(Token.literal("false"), false)),
+	Null: () => P.as(Token.literal("null"), null),
+	Undefined: () => P.succeed(void 0),
+	Void: () => P.succeed(void 0),
+	Never: () => P.reject,
+	Literal: (lit) => literal(lit.literal),
+	Enum: (e) => P.alt(...byLength(e.enums.map(([, value]) => value)).map(literal)),
+	TemplateLiteral: (template) => templateLiteral(template, ctx),
+	Arrays: (arrays) => sequenceOf(arrays, grammar, ctx),
+	Objects: (objects) => isKeyed(objects, grammar) ? keyed(objects, grammar, ctx) : positional(objects, grammar, ctx),
+	Union: (union) => alternatives(union, ctx),
+	Suspend: (suspend) => recursive(suspend, ctx, () => P.suspend(() => derive(suspend.thunk(), ctx))),
+	Declaration: (other) => unsupported(other, ctx, "parser"),
+	Unknown: (other) => unsupported(other, ctx, "parser"),
+	Any: (other) => unsupported(other, ctx, "parser"),
+	Symbol: (other) => unsupported(other, ctx, "parser"),
+	UniqueSymbol: (other) => unsupported(other, ctx, "parser"),
+	ObjectKeyword: (other) => unsupported(other, ctx, "parser")
+});
+const unannotatedString = (ctx, min) => {
+	const s = Token.takeTill(ctx.stop, { min });
+	return ctx.whitespace ? P.preceded(Ascii.multispace0, P.map(s, (value) => value.trimEnd())) : s;
+};
+const integer = /*#__PURE__*/ asSchemaErrors(Ascii.decInt);
+const literal = (value) => P.as(Token.literal(String(value)), value);
+const templateLiteral = (ast, ctx) => P.taken(P.seq(...ast.parts.map((part, i) => {
+	const next = ast.parts[i + 1];
+	const partCtx = next !== void 0 && SchemaAST.isLiteral(next) ? withStop(ctx, String(next.literal)) : ctx;
+	return SchemaAST.isString(part) && !isAnnotated(part) ? unannotatedString(partCtx, 0) : derive(part, at(partCtx, i));
+})));
+const alternatives = (ast, ctx) => {
+	const literals = plainLiterals(ast);
+	return literals !== void 0 ? P.alt(...literals.map(literal)) : P.alt(...ast.types.map((member) => derive(member, ctx)));
+};
+/**
+* Parses `items` in order, then any number of `rest`, with `separator`
+* between the ones present. The output has the value of item `i` at index
+* `i` (a hole when an optional item is missing), then the rest.
+*/
+const sequence = (items, rest, separator) => {
+	const n = items.length;
+	const tail = (needSeparator) => {
+		if (rest === void 0) return P.sync(() => new Array(n));
+		const values = separator === void 0 ? P.repeat(rest) : needSeparator ? P.repeat(P.preceded(separator, rest)) : P.separated(rest, separator);
+		return P.map(values, (xs) => {
+			const out = new Array(n);
+			for (let j = 0; j < xs.length; j++) out[n + j] = xs[j];
+			return out;
+		});
+	};
+	const memo = [];
+	const from = (i, needSeparator) => {
+		const key = i * 2 + (needSeparator ? 1 : 0);
+		const known = memo[key];
+		if (known !== void 0) return known;
+		let parser;
+		if (i === n) parser = tail(needSeparator);
+		else {
+			const item = items[i];
+			const head = needSeparator && separator !== void 0 ? P.preceded(separator, item.parser) : item.parser;
+			const present = P.map(P.seq(head, from(i + 1, true)), ([value, out]) => {
+				out[i] = value;
+				return out;
+			});
+			parser = item.optional ? P.alt(present, from(i + 1, needSeparator)) : present;
+		}
+		memo[key] = parser;
+		return parser;
+	};
+	return from(0, false);
+};
+const separatorOf = (grammar, ctx) => grammar.separator === void 0 ? void 0 : text(grammar.separator, ctx.whitespace);
+const sequenceOf = (ast, grammar, ctx) => {
+	const head = restOf(ast, ctx, "parser");
+	const contexts = elementContexts(ast, head, grammar, ctx);
+	const items = ast.elements.map((element, i) => ({
+		parser: derive(element, contexts[i]),
+		optional: SchemaAST.isOptional(element)
+	}));
+	const rest = head === void 0 ? void 0 : derive(head, at(itemContext(grammar, ctx), items.length));
+	return P.map(sequence(items, rest, separatorOf(grammar, ctx)), (out) => out.filter((_, i) => i in out));
+};
+const positional = (ast, grammar, ctx) => {
+	const fields = ast.propertySignatures;
+	const contexts = fieldContexts(ast, grammar, ctx);
+	const items = fields.map((field, i) => ({
+		parser: derive(field.type, contexts[i]),
+		optional: SchemaAST.isOptional(field.type)
+	}));
+	return P.map(sequence(items, void 0, separatorOf(grammar, ctx)), (out) => Record.fromEntries(fields.flatMap((field, i) => i in out ? [[propertyName(field.name), out[i]]] : [])));
+};
+const keyed = (ast, grammar, ctx) => {
+	const keySeparator = keySeparatorOf(grammar, ctx);
+	const between = text(keySeparator, ctx.whitespace);
+	const valueCtx = itemContext(grammar, ctx);
+	const known = ast.propertySignatures.map((field) => {
+		const name = keyName(ast, field, ctx, "parser");
+		const value = derive(field.type, at(valueCtx, name));
+		return P.map(P.preceded(P.seq(Token.literal(name), between), value), (v) => [
+			name,
+			v,
+			true
+		]);
+	});
+	const indexed = ast.indexSignatures.map((signature) => {
+		const key = derive(signature.parameter, at(withStop(ctx, keySeparator), "<key>"));
+		const value = derive(signature.type, at(valueCtx, "<value>"));
+		return P.map(P.separatedPair(key, between, value), ([k, v]) => [
+			propertyName(k),
+			v,
+			false
+		]);
+	});
+	const entry = P.alt(...known, ...indexed);
+	const separator = separatorOf(grammar, ctx);
+	const entries = separator === void 0 ? P.repeat(entry) : P.separated(entry, separator);
+	const missing = ast.propertySignatures.map((field) => P.expected(P.reject, describeLiteral(`${String(field.name)}${keySeparator}`)));
+	return P.flatMap(P.tryMap(entries, (es) => assemble(ast, es)), ([value, absent]) => absent === void 0 ? P.succeed(value) : missing[absent]);
+};
+/**
+* Builds the object from its entries, declared fields first, rejecting
+* duplicate keys. Also returns the index of the first required field
+* missing, if any.
+*/
+const assemble = (ast, entries) => {
+	const values = MutableHashMap.empty();
+	for (const [key, value] of entries) {
+		if (MutableHashMap.has(values, key)) return Result.fail(schemaError(new SchemaIssue.Pointer([key], new SchemaIssue.InvalidValue({ message: "Duplicate key" }))));
+		MutableHashMap.set(values, key, value);
+	}
+	const out = [];
+	let absent;
+	ast.propertySignatures.forEach((field, i) => {
+		const name = propertyName(field.name);
+		const value = MutableHashMap.get(values, name);
+		if (Option.isSome(value)) out.push([name, value.value]);
+		else if (absent === void 0 && !SchemaAST.isOptional(field.type)) absent = i;
+	});
+	for (const [key, value, isKnown] of entries) if (!isKnown) out.push([key, value]);
+	return Result.succeed([Record.fromEntries(out), absent]);
+};
+/** The issue for a value that cannot be written at the node `ctx` is at. */
+const unwritable = (ctx, message, value) => {
+	const issue = new SchemaIssue.InvalidValue({ message }, value, { reportInput: true });
+	return Arr.isReadonlyArrayNonEmpty(ctx.path) ? new SchemaIssue.Pointer(ctx.path, issue) : issue;
+};
+const writing = (show) => (value, out) => {
+	out.push(show(value));
+};
+const nothing = (_, __) => void 0;
+const printerOf = (ast, ctx) => {
+	const { grammar, inner } = resolve(ast, ctx);
+	let print;
+	if (grammar.print !== void 0) print = writing(grammar.print);
+	else if (grammar.parser !== void 0) print = unprintable(ctx);
+	else if (ast.encoding !== void 0) print = encoded(ast, ast.encoding, grammar, inner);
+	else print = printerFor(ast, grammar, inner);
+	const prefix = grammar.prefix;
+	const suffix = grammar.suffix;
+	if (prefix === void 0 && suffix === void 0) return print;
+	const inside = print;
+	return (value, out) => {
+		if (prefix !== void 0) out.push(prefix);
+		const issue = inside(value, out);
+		if (suffix !== void 0) out.push(suffix);
+		return issue;
+	};
+};
+const unprintable = (ctx) => (value) => unwritable(ctx, "This value has a parser in its annotation but no print, so it cannot be written", value);
+/** Encodes a transformation's value and prints its encoded side. */
+const encoded = (ast, links, grammar, ctx) => {
+	const to = printerOf(links[links.length - 1].to, encodedContext(grammar, ctx));
+	const encode = Schema.encodeUnknownResult(Schema.make(linkTarget(ast, links)));
+	return (value, out) => {
+		const result = encode(value);
+		return Result.isSuccess(result) ? to(result.success, out) : result.failure.issue;
+	};
+};
+const printerFor = (ast, grammar, ctx) => Match.valueTags(ast, {
+	String: () => stringPrinter(ctx),
+	Number: () => writing(String),
+	BigInt: () => writing(String),
+	Boolean: () => writing(String),
+	Null: () => writing(String),
+	Undefined: () => nothing,
+	Void: () => nothing,
+	Never: () => nothing,
+	Literal: () => writing(String),
+	Enum: () => writing(String),
+	TemplateLiteral: () => writing(String),
+	Arrays: (arrays) => arraysPrinter(arrays, grammar, ctx),
+	Objects: (objects) => isKeyed(objects, grammar) ? keyedPrinter(objects, grammar, ctx) : positionalPrinter(objects, grammar, ctx),
+	Union: (union) => unionPrinter(union, ctx),
+	Suspend: (suspend) => recursive(suspend, ctx, () => {
+		let print;
+		return (value, out) => (print ??= printerOf(suspend.thunk(), ctx))(value, out);
+	}),
+	Declaration: (other) => unsupported(other, ctx, "printer"),
+	Unknown: (other) => unsupported(other, ctx, "printer"),
+	Any: (other) => unsupported(other, ctx, "printer"),
+	Symbol: (other) => unsupported(other, ctx, "printer"),
+	UniqueSymbol: (other) => unsupported(other, ctx, "printer"),
+	ObjectKeyword: (other) => unsupported(other, ctx, "printer")
+});
+/**
+* Writes a string as an unannotated string is parsed: refusing one that
+* would not read back, being empty or holding a character that ends it.
+*/
+const stringPrinter = (ctx) => (value, out) => {
+	if (value === "") return unwritable(ctx, "An empty string cannot be written here", value);
+	const stop = Arr.findFirst(Array.from(ctx.stop), (c) => value.includes(c));
+	if (Option.isSome(stop)) return unwritable(ctx, `A string containing ${describeLiteral(stop.value)} cannot be written here`, value);
+	if (ctx.whitespace && value.trim() !== value) return unwritable(ctx, "A string with whitespace around it cannot be written here", value);
+	out.push(value);
+};
+/** Writes values with a separator between them, stopping at the first that cannot be written. */
+const writeAll = (writes, separator, out) => {
+	for (let i = 0; i < writes.length; i++) {
+		if (i > 0) out.push(separator);
+		const issue = writes[i](out);
+		if (issue !== void 0) return issue;
+	}
+};
+const arraysPrinter = (ast, grammar, ctx) => {
+	const head = restOf(ast, ctx, "printer");
+	const contexts = elementContexts(ast, head, grammar, ctx);
+	const elements = ast.elements.map((element, i) => printerOf(element, contexts[i]));
+	const rest = head === void 0 ? nothing : printerOf(head, at(itemContext(grammar, ctx), elements.length));
+	const separator = grammar.separator ?? "";
+	return (value, out) => writeAll(value.map((element, i) => (o) => (elements[i] ?? rest)(element, o)), separator, out);
+};
+const positionalPrinter = (ast, grammar, ctx) => {
+	const contexts = fieldContexts(ast, grammar, ctx);
+	const fields = ast.propertySignatures.map((field, i) => ({
+		name: propertyName(field.name),
+		print: printerOf(field.type, contexts[i])
+	}));
+	const separator = grammar.separator ?? "";
+	return (value, out) => writeAll(fields.filter((field) => Record.has(value, field.name)).map((field) => (o) => field.print(value[field.name], o)), separator, out);
+};
+const keyedPrinter = (ast, grammar, ctx) => {
+	const keySeparator = keySeparatorOf(grammar, ctx);
+	const valueCtx = itemContext(grammar, ctx);
+	const fields = ast.propertySignatures.map((field) => {
+		const name = keyName(ast, field, ctx, "printer");
+		return {
+			name,
+			print: printerOf(field.type, at(valueCtx, name))
+		};
+	});
+	const names = fields.map((field) => field.name);
+	const indexed = ast.indexSignatures.map((signature) => ({
+		is: Schema.is(Schema.make(SchemaAST.toType(signature.parameter))),
+		key: printerOf(signature.parameter, at(withStop(ctx, keySeparator), "<key>")),
+		value: printerOf(signature.type, at(valueCtx, "<value>"))
+	}));
+	const entry = (key, print, k, v) => (out) => key(k, out) ?? (out.push(keySeparator), print(v, out));
+	return (value, out) => {
+		const writes = fields.filter((field) => Record.has(value, field.name)).map((field) => entry(writing(String), field.print, field.name, value[field.name]));
+		for (const key of Record.keys(value)) {
+			const signature = names.includes(key) ? void 0 : indexed.find((s) => s.is(key));
+			if (signature !== void 0) writes.push(entry(signature.key, signature.value, key, value[key]));
+		}
+		return writeAll(writes, grammar.separator ?? "", out);
+	};
+};
+/** Writes a union's value with the first member it belongs to that can write it. */
+const unionPrinter = (ast, ctx) => {
+	if (plainLiterals(ast) !== void 0) return writing(String);
+	const members = ast.types.map((member) => ({
+		is: Schema.is(Schema.make(SchemaAST.toType(member))),
+		print: printerOf(member, ctx)
+	}));
+	return (value, out) => {
+		let issue;
+		for (const member of members) {
+			if (!member.is(value)) continue;
+			const mark = out.length;
+			issue = member.print(value, out);
+			if (issue === void 0) return void 0;
+			out.length = mark;
+		}
+		return issue ?? unwritable(ctx, "No member of the union can write this value", value);
+	};
 };
+//#endregion
+export { annotate, annotationKey, fromSchema, make, toParser, toPrinter };
+
 //# sourceMappingURL=ParserSchema.js.map