@thomasfosterau/effect-parse 0.3.0 → 0.4.1

package/dist/ParserSchema.d.ts

@@ -1,7 +1,6 @@
 import * as Result from "effect/Result";
 import { Parser } from "./Parser.js";
 import * as Schema from "effect/Schema";
-//#region src/ParserSchema.d.ts
 /**
  * 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
@@ -226,5 +225,4 @@ export declare const toPrinter: <S extends Schema.ConstraintCodec<unknown, unkno
 export declare const fromSchema: <S extends Schema.ConstraintCodec<unknown, unknown, never, never> & Schema.Top>(schema: S, options?: {
   readonly encode?: ((value: S["Type"]) => string) | undefined;
 }) => Schema.decodeTo<Schema.toType<S>, Schema.String>;
-//#endregion
 //# sourceMappingURL=ParserSchema.d.ts.map

package/dist/ParserSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParserSchema.d.ts","names":[],"sources":["../src/ParserSchema.ts"],"mappings":";;;;;;;;;;;;qBA4Da;;YAGD;cACE;;;;;;gBAME,iBAAiB;;;;;;;;;;iBAWhB,QAAQ;;WAEd,WAAW,OAAO;;WAElB;;;;;;;;iBASM,aAAa,WAAW,OAAO,SAAS,OAAO,QAAQ,IAAI,OAAO;;;;;;;;qBA0CtE,OAAQ,GAAG,GAAG,QAAQ,OAAO,GAAG,mBAAmB,UAAU,QAAQ,OAAK,aAAa;;;;;;;;;;iBAuBnF,QAAQ;;;;;;;WAOd,SAAS,OAAO;;WAEhB,UAAU,OAAO;;WAEjB;;WAEA;;WAEA;;;;;WAKA;;;;;;;WAOA;;;;;;;;;;YAWC,WAAW,eAAe,QAAQ,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;qBAqB7C;GAEV,WACC,YAAY,WAAW,MACrB,UAAU,OAAO,KAAK,MAAM,MAAM,YAAY,kCAAkC;GACnF,UAAU,OAAO,KAAK,MAAM,GAAG,YAAY,WAAW,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsDzD,WAAY,UAAU,OAAO,4BACxC,QAAQ,MACP,OAAO,WAAW,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCf,YAAa,UAAU,OAAO,mDACzC,QAAQ,QACL,OAAO,cAAc,OAAO,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;qBAmC1C,aAAc,UAAU,OAAO,kDAAkD,OAAO,KACnG,QAAQ,GACR;WAAqB,WAAW,OAAO;MACtC,OAAO,SAAS,OAAO,OAAO,IAAI,OAAO"}
+{"version":3,"file":"ParserSchema.d.ts","names":[],"sources":["../src/ParserSchema.ts"],"mappings":";;;;;;;;;;;qBA4Da;;YAGD;cACE;;;;;;gBAME,iBAAiB;;;;;;;;;;iBAWhB,QAAQ;;WAEd,WAAW,OAAO;;WAElB;;;;;;;;iBASM,aAAa,WAAW,OAAO,SAAS,OAAO,QAAQ,IAAI,OAAO;;;;;;;;qBA0CtE,OAAQ,GAAG,GAAG,QAAQ,OAAO,GAAG,mBAAmB,UAAU,QAAQ,OAAK,aAAa;;;;;;;;;;iBAuBnF,QAAQ;;;;;;;WAOd,SAAS,OAAO;;WAEhB,UAAU,OAAO;;WAEjB;;WAEA;;WAEA;;;;;WAKA;;;;;;;WAOA;;;;;;;;;;YAWC,WAAW,eAAe,QAAQ,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;qBAqB7C;GAEV,WACC,YAAY,WAAW,MACrB,UAAU,OAAO,KAAK,MAAM,MAAM,YAAY,kCAAkC;GACnF,UAAU,OAAO,KAAK,MAAM,GAAG,YAAY,WAAW,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsDzD,WAAY,UAAU,OAAO,4BACxC,QAAQ,MACP,OAAO,WAAW,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCf,YAAa,UAAU,OAAO,mDACzC,QAAQ,QACL,OAAO,cAAc,OAAO,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;qBAmC1C,aAAc,UAAU,OAAO,kDAAkD,OAAO,KACnG,QAAQ,GACR;WAAqB,WAAW,OAAO;MACtC,OAAO,SAAS,OAAO,OAAO,IAAI,OAAO"}

package/dist/ParserSchema.js

@@ -4,10 +4,10 @@ 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 Arr from "effect/Array";
 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";
@@ -16,7 +16,7 @@ import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-//#region src/ParserSchema.ts
+// src/ParserSchema.ts
 /**
 * Effect `Schema`s and parsers, in both directions.
 *
@@ -255,7 +255,7 @@ 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("")
+		stop: Arr.sort([...ctx.stop.split(""), text[0]], Order.String).join("")
 	};
 };
 const at = (ctx, key) => ({
@@ -679,7 +679,6 @@ const unionPrinter = (ast, ctx) => {
 		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

package/dist/ParserSchema.js.map

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

package/dist/ParserStream.d.ts

@@ -3,7 +3,6 @@ import { Parser } from "./Parser.js";
 import * as Effect from "effect/Effect";
 import * as ParseError from "./ParseError.js";
 import * as Stream from "effect/Stream";
-//#region src/ParserStream.d.ts
 /**
  * Input kinds that can be streamed in chunks.
  *
@@ -128,6 +127,5 @@ export declare const parseResponse: {
   <A, E, R>(parser: Parser<A, E, R, Uint8Array>): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>;
   <A, E, R>(self: Response, parser: Parser<A, E, R, Uint8Array>): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>;
 };
-//#endregion
 export {};
 //# sourceMappingURL=ParserStream.d.ts.map

package/dist/ParserStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParserStream.d.ts","names":[],"sources":["../src/ParserStream.ts"],"mappings":";;;;;;;;;;;;YA8CY,qBAAqB,aAAa;;;;;;;iBA8B7B,iBAAiB;;WAEvB,QAAQ,OAAO;;;;;;;;;;;;;;;;;;qBAmBb;GACV,GAAG,GAAG,GAAG,UAAU,WAClB,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,MACzB,IAAI,IAAI,MAAM,OAAO,OAAO,OAAO,IAAI,IAAI,QAAQ,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;GAC3G,UAAU,WAAW,IAAI,IAAI,GAAG,GAAG,GAClC,MAAM,OAAO,OAAO,OAAO,QAAQ,KAAK,IAAI,KAC5C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,KAC1B,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;;qBAiM7C;GACV,GAAG,GAAG,GAAG,UAAU,WAClB,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,MACzB,IAAI,IAAI,MAAM,OAAO,OAAO,OAAO,IAAI,IAAI,QAAQ,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;GAC3G,UAAU,WAAW,IAAI,IAAI,GAAG,GAAG,GAClC,MAAM,OAAO,OAAO,OAAO,QAAQ,KAAK,IAAI,KAC5C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,KAC1B,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;;;;;;;;;;;;qBA2B7C,gCAAgC;WAAyC;;;;;;;;;;;;;;;;;;;;;;;qBAuBzE;GACV,GAAG,GAAG,GACL,QAAQ,OAAO,GAAG,GAAG,GAAG,eACtB,MAAM,eAAe,iBAAiB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;GAChG,GAAG,GAAG,GACL,MAAM,eAAe,cACrB,QAAQ,OAAO,GAAG,GAAG,GAAG,cACvB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;;qBAiC/C;GACV,GAAG,GAAG,GACL,QAAQ,OAAO,GAAG,GAAG,GAAG,eACtB,MAAM,aAAa,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;GAC7E,GAAG,GAAG,GACL,MAAM,UACN,QAAQ,OAAO,GAAG,GAAG,GAAG,cACvB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW"}
+{"version":3,"file":"ParserStream.d.ts","names":[],"sources":["../src/ParserStream.ts"],"mappings":";;;;;;;;;;;YA+CY,qBAAqB,aAAa;;;;;;;iBAgC7B,iBAAiB;;WAEvB,QAAQ,OAAO;;;;;;;;;;;;;;;;;;qBAmBb;GACV,GAAG,GAAG,GAAG,UAAU,WAClB,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,MACzB,IAAI,IAAI,MAAM,OAAO,OAAO,OAAO,IAAI,IAAI,QAAQ,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;GAC3G,UAAU,WAAW,IAAI,IAAI,GAAG,GAAG,GAClC,MAAM,OAAO,OAAO,OAAO,QAAQ,KAAK,IAAI,KAC5C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,KAC1B,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;;qBA4M7C;GACV,GAAG,GAAG,GAAG,UAAU,WAClB,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,MACzB,IAAI,IAAI,MAAM,OAAO,OAAO,OAAO,IAAI,IAAI,QAAQ,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;GAC3G,UAAU,WAAW,IAAI,IAAI,GAAG,GAAG,GAClC,MAAM,OAAO,OAAO,OAAO,QAAQ,KAAK,IAAI,KAC5C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,UAAU,iBAAiB,KAC1B,OAAO,OAAO,GAAG,KAAK,WAAW,WAAW,IAAI,KAAK;;;;;;;;;;;;qBA2B7C,gCAAgC;WAAyC;;;;;;;;;;;;;;;;;;;;;;;qBAuBzE;GACV,GAAG,GAAG,GACL,QAAQ,OAAO,GAAG,GAAG,GAAG,eACtB,MAAM,eAAe,iBAAiB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;GAChG,GAAG,GAAG,GACL,MAAM,eAAe,cACrB,QAAQ,OAAO,GAAG,GAAG,GAAG,cACvB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;;qBAiC/C;GACV,GAAG,GAAG,GACL,QAAQ,OAAO,GAAG,GAAG,GAAG,eACtB,MAAM,aAAa,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW;GAC7E,GAAG,GAAG,GACL,MAAM,UACN,QAAQ,OAAO,GAAG,GAAG,GAAG,cACvB,OAAO,OAAO,GAAG,WAAW,WAAW,KAAK,WAAW"}

package/dist/ParserStream.js

@@ -1,6 +1,7 @@
 import * as Predicate from "effect/Predicate";
 import { Fail, Failure, State, fromSource } from "./Input.js";
 import * as Registry from "./internal/compiler/registry.js";
+import { isEmptyUnits } from "./internal/text.js";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
@@ -8,7 +9,7 @@ import * as ParseError from "./ParseError.js";
 import * as Run from "./internal/run.js";
 import * as Stack from "./internal/stack.js";
 import * as Stream from "effect/Stream";
-//#region src/ParserStream.ts
+// src/ParserStream.ts
 /**
 * Running parsers over Effect `Stream`s of input chunks.
 *
@@ -34,10 +35,11 @@ import * as Stream from "effect/Stream";
 *
 * @since 0.1.0
 */
-const concat = (a, b) => {
+const concat = (first, b) => {
+	const a = first;
 	if (Predicate.isString(a)) return a + b;
 	if (a instanceof Uint8Array) {
-		if (a.length === 0) return b;
+		if (a.byteLength === 0) return b;
 		const out = new Uint8Array(a.length + b.length);
 		out.set(a);
 		out.set(b, a.length);
@@ -116,6 +118,7 @@ var Incremental = class {
 	/** The input length at the last attempt, and where that attempt ran out of input. */
 	attempted = 0;
 	restart = 0;
+	pushed = 0;
 	/** Set once an attempt settles: a success (with its end offset) or a definite failure. */
 	settled;
 	constructor(parser, context, empty) {
@@ -152,17 +155,21 @@ var Incremental = class {
 		}
 	}
 	push(chunk) {
-		if (chunk.length === 0) return;
+		if (isEmptyUnits(chunk)) return;
 		this.append(chunk);
 		if (this.settled !== void 0) return;
+		if (++this.pushed === 1) return;
 		const added = this.length - this.attempted;
 		if (added < (this.attempted - this.restart) / 2) return;
 		if (this.kind === 0 && added < this.attempted / 8) return;
 		this.attempt();
 	}
-	/** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */
-	step(state) {
-		return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state);
+	/**
+	* The step attempts run: the parser's compiled code if it was compiled
+	* (the resumable build, unless `resumable` is false), else the interpreter.
+	*/
+	step(state, resumable = true) {
+		return Stack.run(Registry.stepFor(this.parser, state, resumable) ?? this.parser.step, state);
 	}
 	attempt() {
 		const state = new State(this.input(), {
@@ -185,8 +192,9 @@ var Incremental = class {
 			if (settled.pos === this.length) return Effect.succeed(settled.value);
 		} else if (settled === void 0) {
 			const state = new State(this.input(), { context: this.context });
-			state.resume = this.resume;
-			const a = this.step(state);
+			const resumable = this.attempted > 0;
+			if (resumable) state.resume = this.resume;
+			const a = this.step(state, resumable);
 			if (a !== Fail && state.pos === state.end) return Effect.succeed(a);
 		}
 		const all = this.input();
@@ -276,7 +284,6 @@ const parseReadable = /*#__PURE__*/ dual(2, (self, parser) => parseAll(Stream.fr
 * @category combinators
 */
 const parseResponse = /*#__PURE__*/ dual(2, (self, parser) => parseReadable(self.body ?? new ReadableStream({ start: (c) => c.close() }), parser));
-//#endregion
 export { ReadError, parseAll, parseMany, parseReadable, parseResponse };
 
 //# sourceMappingURL=ParserStream.js.map

package/dist/ParserStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"ParserStream.js","names":[],"sources":["../src/ParserStream.ts"],"sourcesContent":["/**\n * Running parsers over Effect `Stream`s of input chunks.\n *\n * This is where nom's and winnow's *partial* (streaming) parsing meets\n * Effect: chunks are buffered and the parser runs in partial mode, so a\n * value split across chunk boundaries is reported as `Incomplete` and\n * retried once more data arrives. When the stream ends, the leftover input\n * is parsed in complete mode.\n *\n * @example\n * ```ts\n * import { Effect, Stream } from \"effect\"\n * import { Ascii, Parser, ParserStream, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const line = Parser.terminated(Ascii.decInt, Token.literal(\"\\n\"))\n *\n * const program = Stream.make(\"1\\n2\", \"3\\n\", \"4\\n\").pipe(\n *   ParserStream.parseMany(line),\n *   Stream.runCollect\n * )\n * // Effect.runSync(program) => [1, 23, 4]\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport * as Stream from \"effect/Stream\"\nimport type { BinaryInput, Input, Source } from \"./Input.js\"\nimport { Fail, Failure, fromSource, State } from \"./Input.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport * as Registry from \"./internal/compiler/registry.js\"\nimport type * as Resume from \"./internal/resume.js\"\nimport * as Run from \"./internal/run.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport type { Parser } from \"./Parser.js\"\n\n/**\n * Input kinds that can be streamed in chunks.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Chunkable = string | Uint8Array | ReadonlyArray<unknown>\n\nconst concat = <I extends Chunkable>(a: I, b: I): I => {\n  if (Predicate.isString(a)) return (a + (b as string)) as I\n  if (a instanceof Uint8Array) {\n    if (a.length === 0) return b\n    const out = new Uint8Array(a.length + (b as Uint8Array).length)\n    out.set(a)\n    out.set(b as Uint8Array, a.length)\n    return out as I\n  }\n  return [...a, ...(b as ReadonlyArray<unknown>)] as unknown as I\n}\n\nconst sliceFrom = <I extends Chunkable>(input: I, offset: number): I =>\n  (Predicate.isString(input) ? input.slice(offset) : input.slice(offset)) as I\n\nconst noProgress = (input: Input, offset: number) =>\n  ParseError.fromFailure<never>(\n    input,\n    new Failure(offset, \"Assert\", [], [], false, undefined, \"`parseMany` parsers must always consume\", 0),\n    \"Cut\"\n  )\n\n/**\n * Options for {@link parseMany}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseManyOptions<I> {\n  /** The empty input, used to initialise the buffer (inferred from the first chunk if omitted). */\n  readonly empty?: Source<I> | undefined\n}\n\n/**\n * Transforms a stream of input chunks into a stream of parsed values by\n * applying `parser` repeatedly. Each application must consume input.\n *\n * Services required by the parser are taken from the stream's context.\n * Error offsets are relative to the internal buffer of unconsumed input,\n * which is also the `input` of the reported `ParseError`.\n *\n * A parser compiled with the `Compiler` module runs compiled, with the\n * build that handles partial input (see `Parser.run`); a value that fails\n * or needs more input is parsed again interpreted, so errors and\n * `Incomplete` are the interpreter's.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseMany: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Stream.suspend(() => {\n      const step = parser.step\n      let buffer: I | undefined = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n\n      const drain = (context: any, partial: boolean): Effect.Effect<Array<A>, ParseError.ParseError<E>> => {\n        const out: Array<A> = []\n        if (buffer === undefined) return Effect.succeed(out)\n        const input = buffer\n        // One state for the whole buffer, reset before each value\n        const state = new State(input)\n        let offset = 0\n        while (offset < input.length) {\n          state.reset(offset, { partial, context })\n          const a = Run.runOn(parser, step, state)\n          if (a === Fail) {\n            if (partial && state.mode === \"Incomplete\") break\n            return Effect.fail(ParseError.fromFailure<E>(input, state.reportedFailure(), state.mode, state.encoding))\n          }\n          if (state.pos === offset) return Effect.fail(noProgress(input, offset))\n          out.push(a)\n          offset = state.pos\n        }\n        buffer = sliceFrom(input, offset)\n        return Effect.succeed(out)\n      }\n\n      const feed = (source: Source<I>) =>\n        Effect.flatMap(Effect.context<R>(), (context) =>\n          Effect.suspend(() => {\n            const chunk = fromSource<I>(source)\n            buffer = buffer === undefined ? chunk : concat(buffer, chunk)\n            return drain(context, true)\n          })\n        )\n\n      const finish = Effect.flatMap(Effect.context<R>(), (context) => Effect.suspend(() => drain(context, false)))\n\n      return self.pipe(\n        Stream.mapEffect(feed),\n        Stream.flattenIterable,\n        Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable)))\n      )\n    })\n)\n\n/**\n * Parses a stream of chunks incrementally, as one input. Chunks are parsed\n * as they arrive, in partial mode; when the parser runs out of input, its\n * repetitions keep checkpoints (see `internal/resume.ts`), so the next\n * attempt carries on from where the last one stopped instead of starting\n * over.\n */\nclass Incremental<A, E, I extends Chunkable> {\n  private kind: 0 | 1 | 2 | undefined\n  private text = \"\"\n  private bytes = new Uint8Array(0)\n  private items: Array<unknown> = []\n  private length = 0\n  private readonly resume: Resume.Checkpoints = new Map()\n  /** The input length at the last attempt, and where that attempt ran out of input. */\n  private attempted = 0\n  private restart = 0\n  /** Set once an attempt settles: a success (with its end offset) or a definite failure. */\n  private settled: { readonly value: A; readonly pos: number } | \"failed\" | undefined\n\n  constructor(\n    private readonly parser: Parser<A, E, any, I>,\n    private readonly context: Context.Context<never>,\n    empty: I | undefined\n  ) {\n    if (empty !== undefined) this.append(empty)\n  }\n\n  private append(chunk: I): void {\n    if (Predicate.isString(chunk)) {\n      this.kind ??= 0\n      this.text += chunk\n      this.length += chunk.length\n    } else if (chunk instanceof Uint8Array) {\n      this.kind ??= 1\n      const needed = this.length + chunk.length\n      if (needed > this.bytes.length) {\n        // Grow geometrically, so appending costs amortized constant time per byte\n        const grown = new Uint8Array(Math.max(needed, this.bytes.length * 2, 4096))\n        grown.set(this.bytes.subarray(0, this.length))\n        this.bytes = grown\n      }\n      this.bytes.set(chunk, this.length)\n      this.length = needed\n    } else {\n      this.kind ??= 2\n      for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i])\n      this.length = this.items.length\n    }\n  }\n\n  private input(): I {\n    switch (this.kind) {\n      case 1:\n        return this.bytes.subarray(0, this.length) as I\n      case 2:\n        // Items are only appended between attempts, after each state has read its `end`\n        return this.items as unknown as I\n      default:\n        return this.text as I\n    }\n  }\n\n  push(chunk: I): void {\n    if (chunk.length === 0) return\n    this.append(chunk)\n    if (this.settled !== undefined) return\n    // An attempt re-reads what the last one could not finish, from `restart`;\n    // waiting until at least half as much new input has arrived keeps the\n    // total work linear in the input. Strings are also copied when they are\n    // flattened, so they wait for a fraction of the whole input too.\n    const added = this.length - this.attempted\n    if (added < (this.attempted - this.restart) / 2) return\n    if (this.kind === 0 && added < this.attempted / 8) return\n    this.attempt()\n  }\n\n  /** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */\n  private step(state: State<I>): unknown {\n    return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state)\n  }\n\n  private attempt(): void {\n    const state = new State(this.input(), { partial: true, context: this.context })\n    state.resume = this.resume\n    const a = this.step(state)\n    this.attempted = this.length\n    if (a !== Fail) {\n      this.settled = { value: a as A, pos: state.pos }\n    } else if (state.mode === \"Incomplete\") {\n      this.restart = state.failure.offset\n    } else {\n      this.settled = \"failed\"\n    }\n  }\n\n  finish(): Effect.Effect<A, ParseError.ParseError<E>> {\n    const settled = this.settled\n    if (settled !== undefined && settled !== \"failed\") {\n      if (settled.pos === this.length) return Effect.succeed(settled.value)\n    } else if (settled === undefined) {\n      // The last attempt, in complete mode, resumes from the checkpoints too\n      const state = new State(this.input(), { context: this.context })\n      state.resume = this.resume\n      const a = this.step(state)\n      if (a !== Fail && state.pos === state.end) return Effect.succeed(a as A)\n    }\n    // The error comes from an ordinary parse of the whole input, so it is the\n    // same as if the input had been parsed in one go\n    const all = this.input()\n    const state = new State(all, { context: this.context })\n    const a = Stack.run(this.parser.step, state)\n    if (a !== Fail && state.pos === state.end) return Effect.succeed(a)\n    if (a !== Fail) state.backtrack(\"Eof\", [\"end of input\"])\n    return Effect.fail(ParseError.fromFailure<E>(all, state.reportedFailure(), state.mode, state.encoding))\n  }\n}\n\n/**\n * Parses an entire stream of chunks as a single complete input.\n *\n * Parsing does not wait for the stream to end: each chunk is parsed as it\n * arrives, in partial mode, and when the parser runs out of input its\n * repetitions (`repeat`, `separated`, `fold`, `escaped`, ...) remember how\n * far they got, so that the next attempt resumes there rather than starting\n * over. A large document, such as the body of a `fetch` response, is\n * therefore parsed while it downloads, and is ready soon after its last\n * byte. Use {@link parseReadable} or {@link parseResponse} for web streams.\n *\n * The result and any `ParseError` are those of parsing the whole input at\n * once: errors are reported once the stream has ended, by an ordinary\n * interpreted parse of the whole input. A parser compiled with the\n * `Compiler` module streams compiled too (with a build that handles partial\n * input), which is several times faster. As with compiled parsers,\n * callbacks should be pure: the elements parsed before a checkpoint are\n * not parsed again, and on failure everything is parsed again.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseAll: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Effect.flatMap(Effect.context<R>(), (context) =>\n      Effect.suspend(() => {\n        const empty = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n        const incremental = new Incremental(parser, context as Context.Context<never>, empty)\n        return Effect.flatMap(\n          Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource<I>(chunk)))),\n          () => Effect.suspend(() => incremental.finish())\n        )\n      })\n    )\n)\n\n/**\n * An error reading a `ReadableStream` given to {@link parseReadable} or\n * {@link parseResponse}.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class ReadError extends /*#__PURE__*/ Data.TaggedError(\"ReadError\")<{ readonly cause: unknown }> {}\n\n/**\n * Parses a web `ReadableStream` of bytes, such as the body of a `fetch`\n * response, incrementally (see {@link parseAll}): the bytes are parsed as\n * they arrive, without waiting for the end of the stream or decoding them\n * first. Use a byte parser, e.g. one built from `Text.utf8`.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const csvLine = Parser.separated(Text.utf8.takeTill(\",\\n\"), Text.utf8.literal(\",\"))\n * const csv = Parser.separated(csvLine, Text.utf8.literal(\"\\n\"))\n *\n * const response = await fetch(\"https://example.com/data.csv\")\n * const rows = await Effect.runPromise(ParserStream.parseReadable(response.body!, csv))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseReadable: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: ReadableStream<BinaryInput>) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseAll(\n      Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),\n      parser,\n      { empty: new Uint8Array(0) }\n    )\n)\n\n/**\n * Parses the body of a `fetch` `Response` incrementally, as it downloads\n * (see {@link parseReadable}). A response without a body is parsed as empty\n * input. The status is not checked.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const lines = Parser.separated(Text.utf8.tillLineEnding, Text.utf8.lineEnding)\n *\n * const response = await fetch(\"https://example.com/log.txt\")\n * const value = await Effect.runPromise(ParserStream.parseResponse(response, lines))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseResponse: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser)\n)\n"],"mappings":"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"}
+{"version":3,"file":"ParserStream.js","names":[],"sources":["../src/ParserStream.ts"],"sourcesContent":["/**\n * Running parsers over Effect `Stream`s of input chunks.\n *\n * This is where nom's and winnow's *partial* (streaming) parsing meets\n * Effect: chunks are buffered and the parser runs in partial mode, so a\n * value split across chunk boundaries is reported as `Incomplete` and\n * retried once more data arrives. When the stream ends, the leftover input\n * is parsed in complete mode.\n *\n * @example\n * ```ts\n * import { Effect, Stream } from \"effect\"\n * import { Ascii, Parser, ParserStream, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const line = Parser.terminated(Ascii.decInt, Token.literal(\"\\n\"))\n *\n * const program = Stream.make(\"1\\n2\", \"3\\n\", \"4\\n\").pipe(\n *   ParserStream.parseMany(line),\n *   Stream.runCollect\n * )\n * // Effect.runSync(program) => [1, 23, 4]\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport { dual } from \"effect/Function\"\nimport * as Stream from \"effect/Stream\"\nimport type { BinaryInput, Input, Source } from \"./Input.js\"\nimport { Fail, Failure, fromSource, State } from \"./Input.js\"\nimport * as ParseError from \"./ParseError.js\"\nimport * as Registry from \"./internal/compiler/registry.js\"\nimport type * as Resume from \"./internal/resume.js\"\nimport * as Run from \"./internal/run.js\"\nimport * as Stack from \"./internal/stack.js\"\nimport { isEmptyUnits } from \"./internal/text.js\"\nimport type { Parser } from \"./Parser.js\"\n\n/**\n * Input kinds that can be streamed in chunks.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Chunkable = string | Uint8Array | ReadonlyArray<unknown>\n\nconst concat = <I extends Chunkable>(first: I, b: I): I => {\n  // Widened so the checks below narrow it (a type parameter does not narrow).\n  const a: Chunkable = first\n  if (Predicate.isString(a)) return (a + (b as string)) as I\n  if (a instanceof Uint8Array) {\n    if (a.byteLength === 0) return b\n    const out = new Uint8Array(a.length + (b as Uint8Array).length)\n    out.set(a)\n    out.set(b as Uint8Array, a.length)\n    return out as I\n  }\n  return [...a, ...(b as ReadonlyArray<unknown>)] as unknown as I\n}\n\nconst sliceFrom = <I extends Chunkable>(input: I, offset: number): I =>\n  (Predicate.isString(input) ? input.slice(offset) : input.slice(offset)) as I\n\nconst noProgress = (input: Input, offset: number) =>\n  ParseError.fromFailure<never>(\n    input,\n    new Failure(offset, \"Assert\", [], [], false, undefined, \"`parseMany` parsers must always consume\", 0),\n    \"Cut\"\n  )\n\n/**\n * Options for {@link parseMany}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseManyOptions<I> {\n  /** The empty input, used to initialise the buffer (inferred from the first chunk if omitted). */\n  readonly empty?: Source<I> | undefined\n}\n\n/**\n * Transforms a stream of input chunks into a stream of parsed values by\n * applying `parser` repeatedly. Each application must consume input.\n *\n * Services required by the parser are taken from the stream's context.\n * Error offsets are relative to the internal buffer of unconsumed input,\n * which is also the `input` of the reported `ParseError`.\n *\n * A parser compiled with the `Compiler` module runs compiled, with the\n * build that handles partial input (see `Parser.run`); a value that fails\n * or needs more input is parsed again interpreted, so errors and\n * `Incomplete` are the interpreter's.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseMany: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Stream.suspend(() => {\n      const step = parser.step\n      let buffer: I | undefined = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n\n      const drain = (context: any, partial: boolean): Effect.Effect<Array<A>, ParseError.ParseError<E>> => {\n        const out: Array<A> = []\n        if (buffer === undefined) return Effect.succeed(out)\n        const input = buffer\n        // One state for the whole buffer, reset before each value\n        const state = new State(input)\n        let offset = 0\n        while (offset < input.length) {\n          state.reset(offset, { partial, context })\n          const a = Run.runOn(parser, step, state)\n          if (a === Fail) {\n            if (partial && state.mode === \"Incomplete\") break\n            return Effect.fail(ParseError.fromFailure<E>(input, state.reportedFailure(), state.mode, state.encoding))\n          }\n          if (state.pos === offset) return Effect.fail(noProgress(input, offset))\n          out.push(a)\n          offset = state.pos\n        }\n        buffer = sliceFrom(input, offset)\n        return Effect.succeed(out)\n      }\n\n      const feed = (source: Source<I>) =>\n        Effect.flatMap(Effect.context<R>(), (context) =>\n          Effect.suspend(() => {\n            const chunk = fromSource<I>(source)\n            buffer = buffer === undefined ? chunk : concat(buffer, chunk)\n            return drain(context, true)\n          })\n        )\n\n      const finish = Effect.flatMap(Effect.context<R>(), (context) => Effect.suspend(() => drain(context, false)))\n\n      return self.pipe(\n        Stream.mapEffect(feed),\n        Stream.flattenIterable,\n        Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable)))\n      )\n    })\n)\n\n/**\n * Parses a stream of chunks incrementally, as one input. Chunks are parsed\n * as they arrive, in partial mode; when the parser runs out of input, its\n * repetitions keep checkpoints (see `internal/resume.ts`), so the next\n * attempt carries on from where the last one stopped instead of starting\n * over.\n */\nclass Incremental<A, E, I extends Chunkable> {\n  private kind: 0 | 1 | 2 | undefined\n  private text = \"\"\n  private bytes = new Uint8Array(0)\n  private items: Array<unknown> = []\n  private length = 0\n  private readonly resume: Resume.Checkpoints = new Map()\n  /** The input length at the last attempt, and where that attempt ran out of input. */\n  private attempted = 0\n  private restart = 0\n  private pushed = 0\n  /** Set once an attempt settles: a success (with its end offset) or a definite failure. */\n  private settled: { readonly value: A; readonly pos: number } | \"failed\" | undefined\n\n  constructor(\n    private readonly parser: Parser<A, E, any, I>,\n    private readonly context: Context.Context<never>,\n    empty: I | undefined\n  ) {\n    if (empty !== undefined) this.append(empty)\n  }\n\n  private append(chunk: I): void {\n    if (Predicate.isString(chunk)) {\n      this.kind ??= 0\n      this.text += chunk\n      this.length += chunk.length\n    } else if (chunk instanceof Uint8Array) {\n      this.kind ??= 1\n      const needed = this.length + chunk.length\n      if (needed > this.bytes.length) {\n        // Grow geometrically, so appending costs amortized constant time per byte\n        const grown = new Uint8Array(Math.max(needed, this.bytes.length * 2, 4096))\n        grown.set(this.bytes.subarray(0, this.length))\n        this.bytes = grown\n      }\n      this.bytes.set(chunk, this.length)\n      this.length = needed\n    } else {\n      this.kind ??= 2\n      for (let i = 0; i < chunk.length; i++) this.items.push(chunk[i])\n      this.length = this.items.length\n    }\n  }\n\n  private input(): I {\n    switch (this.kind) {\n      case 1:\n        return this.bytes.subarray(0, this.length) as I\n      case 2:\n        // Items are only appended between attempts, after each state has read its `end`\n        return this.items as unknown as I\n      default:\n        return this.text as I\n    }\n  }\n\n  push(chunk: I): void {\n    if (isEmptyUnits(chunk)) return\n    this.append(chunk)\n    if (this.settled !== undefined) return\n    // The first attempt waits for a second chunk: an input that arrives in\n    // one chunk (most small responses) is parsed once, by `finish`, instead\n    // of once in partial mode and again in complete mode, since a repetition\n    // that completes without resuming keeps no checkpoint\n    if (++this.pushed === 1) return\n    // An attempt re-reads what the last one could not finish, from `restart`;\n    // waiting until at least half as much new input has arrived keeps the\n    // total work linear in the input. Strings are also copied when they are\n    // flattened, so they wait for a fraction of the whole input too.\n    const added = this.length - this.attempted\n    if (added < (this.attempted - this.restart) / 2) return\n    if (this.kind === 0 && added < this.attempted / 8) return\n    this.attempt()\n  }\n\n  /**\n   * The step attempts run: the parser's compiled code if it was compiled\n   * (the resumable build, unless `resumable` is false), else the interpreter.\n   */\n  private step(state: State<I>, resumable = true): unknown {\n    return Stack.run(Registry.stepFor(this.parser, state, resumable) ?? this.parser.step, state)\n  }\n\n  private attempt(): void {\n    const state = new State(this.input(), { partial: true, context: this.context })\n    state.resume = this.resume\n    const a = this.step(state)\n    this.attempted = this.length\n    if (a !== Fail) {\n      this.settled = { value: a as A, pos: state.pos }\n    } else if (state.mode === \"Incomplete\") {\n      this.restart = state.failure.offset\n    } else {\n      this.settled = \"failed\"\n    }\n  }\n\n  finish(): Effect.Effect<A, ParseError.ParseError<E>> {\n    const settled = this.settled\n    if (settled !== undefined && settled !== \"failed\") {\n      if (settled.pos === this.length) return Effect.succeed(settled.value)\n    } else if (settled === undefined) {\n      // The last attempt, in complete mode, resumes from the checkpoints too;\n      // with no attempt before it, it is an ordinary parse\n      const state = new State(this.input(), { context: this.context })\n      const resumable = this.attempted > 0\n      if (resumable) state.resume = this.resume\n      const a = this.step(state, resumable)\n      if (a !== Fail && state.pos === state.end) return Effect.succeed(a as A)\n    }\n    // The error comes from an ordinary parse of the whole input, so it is the\n    // same as if the input had been parsed in one go\n    const all = this.input()\n    const state = new State(all, { context: this.context })\n    const a = Stack.run(this.parser.step, state)\n    if (a !== Fail && state.pos === state.end) return Effect.succeed(a)\n    if (a !== Fail) state.backtrack(\"Eof\", [\"end of input\"])\n    return Effect.fail(ParseError.fromFailure<E>(all, state.reportedFailure(), state.mode, state.encoding))\n  }\n}\n\n/**\n * Parses an entire stream of chunks as a single complete input.\n *\n * Parsing does not wait for the stream to end: each chunk is parsed as it\n * arrives, in partial mode, and when the parser runs out of input its\n * repetitions (`repeat`, `separated`, `fold`, `escaped`, ...) remember how\n * far they got, so that the next attempt resumes there rather than starting\n * over. A large document, such as the body of a `fetch` response, is\n * therefore parsed while it downloads, and is ready soon after its last\n * byte. Use {@link parseReadable} or {@link parseResponse} for web streams.\n *\n * The result and any `ParseError` are those of parsing the whole input at\n * once: errors are reported once the stream has ended, by an ordinary\n * interpreted parse of the whole input. A parser compiled with the\n * `Compiler` module streams compiled too (with a build that handles partial\n * input), which is several times faster. As with compiled parsers,\n * callbacks should be pure: the elements parsed before a checkpoint are\n * not parsed again, and on failure everything is parsed again.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseAll: {\n  <A, E, R, I extends Chunkable>(\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): <E0, R0>(self: Stream.Stream<Source<I>, E0, R0>) => Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<NoInfer<I>>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>\n} = /*#__PURE__*/ dual(\n  (args) => Stream.isStream(args[0]),\n  <I extends Chunkable, E0, R0, A, E, R>(\n    self: Stream.Stream<Source<I>, E0, R0>,\n    parser: Parser<A, E, R, I>,\n    options?: ParseManyOptions<I>\n  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R> =>\n    Effect.flatMap(Effect.context<R>(), (context) =>\n      Effect.suspend(() => {\n        const empty = options?.empty === undefined ? undefined : fromSource<I>(options.empty)\n        const incremental = new Incremental(parser, context as Context.Context<never>, empty)\n        return Effect.flatMap(\n          Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource<I>(chunk)))),\n          () => Effect.suspend(() => incremental.finish())\n        )\n      })\n    )\n)\n\n/**\n * An error reading a `ReadableStream` given to {@link parseReadable} or\n * {@link parseResponse}.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class ReadError extends /*#__PURE__*/ Data.TaggedError(\"ReadError\")<{ readonly cause: unknown }> {}\n\n/**\n * Parses a web `ReadableStream` of bytes, such as the body of a `fetch`\n * response, incrementally (see {@link parseAll}): the bytes are parsed as\n * they arrive, without waiting for the end of the stream or decoding them\n * first. Use a byte parser, e.g. one built from `Text.utf8`.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const csvLine = Parser.separated(Text.utf8.takeTill(\",\\n\"), Text.utf8.literal(\",\"))\n * const csv = Parser.separated(csvLine, Text.utf8.literal(\"\\n\"))\n *\n * const response = await fetch(\"https://example.com/data.csv\")\n * const rows = await Effect.runPromise(ParserStream.parseReadable(response.body!, csv))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseReadable: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: ReadableStream<BinaryInput>) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: ReadableStream<BinaryInput>,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseAll(\n      Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),\n      parser,\n      { empty: new Uint8Array(0) }\n    )\n)\n\n/**\n * Parses the body of a `fetch` `Response` incrementally, as it downloads\n * (see {@link parseReadable}). A response without a body is parsed as empty\n * input. The status is not checked.\n *\n * @example\n * ```ts\n * import { Effect } from \"effect\"\n * import { Parser, ParserStream, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const lines = Parser.separated(Text.utf8.tillLineEnding, Text.utf8.lineEnding)\n *\n * const response = await fetch(\"https://example.com/log.txt\")\n * const value = await Effect.runPromise(ParserStream.parseResponse(response, lines))\n * ```\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const parseResponse: {\n  <A, E, R>(\n    parser: Parser<A, E, R, Uint8Array>\n  ): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>\n} = /*#__PURE__*/ dual(\n  2,\n  <A, E, R>(\n    self: Response,\n    parser: Parser<A, E, R, Uint8Array>\n  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>\n    parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser)\n)\n"],"mappings":"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"}

package/dist/Syntax.d.ts

@@ -4,7 +4,6 @@ import * as Option from "effect/Option";
 import * as Context from "effect/Context";
 import * as ParseError from "./ParseError.js";
 import { ErrorInfo, Green } from "./internal/syntax.js";
-//#region src/Syntax.d.ts
 /**
  * Marks a parser as a rule of the syntax tree: in a {@link parse}, each
  * match becomes a named node of the given kind, spanning the input it
@@ -396,6 +395,5 @@ export declare const replace: <A, E>(tree: Tree<A, E, string>, start: number, en
  * @category parsing
  */
 export declare const diff: <I extends Input>(before: I, after: I) => Edit | undefined;
-//#endregion
 export {};
 //# sourceMappingURL=Syntax.d.ts.map

package/dist/Syntax.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Syntax.d.ts","names":[],"sources":["../src/Syntax.ts"],"mappings":"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"}
+{"version":3,"file":"Syntax.d.ts","names":[],"sources":["../src/Syntax.ts"],"mappings":"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"}