@tabnas/abnf 0.4.20 → 0.4.22

package/dist/translate.js

@@ -0,0 +1,2016 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger and other contributors, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+const TRANSLATION = Object.freeze({
+    manifest: `{
+  "$schema": "https://tabnas.dev/schema/plugin.schema.json",
+  "name": "@tabnas/abnf",
+  "go": "github.com/tabnas/abnf/go",
+  "rust": "tabnas-abnf",
+  "description": "ABNF (RFC 5234) grammar compiler for the tabnas engine. A host reads an ABNF document by compiling it: the tree it translates is the pure-data GrammarSpec the compiler emits (schema grammar-spec), which the render writes back as ABNF.",
+  "base": "@tabnas/bnf",
+  "engine": "@tabnas/parser",
+  "extensions": [
+    ".abnf"
+  ],
+  "languageId": "abnf",
+  "specDir": "test/spec",
+  "clib": {
+    "dir": "go/clib",
+    "library": "libtabnasabnf",
+    "abi": "v1",
+    "errorCodes": [
+      "usage",
+      "grammar",
+      "handle",
+      "internal"
+    ]
+  },
+  "errorCodes": [],
+  "docs": "https://tabnas.dev/docs/packages",
+  "repository": "https://github.com/tabnas/abnf",
+  "versionSource": "ts/package.json",
+  "translate": {
+    "reads": "tree",
+    "writes": "tree",
+    "root": "object",
+    "schema": "grammar-spec",
+    "render": "alchemy/render.alc",
+    "loss": [
+      "The grammar is written anew from its compiled spec: comments, blank lines and layout are not kept, each rule is written on one line, and the RFC 5234 core rules the compiler added (ALPHA, DIGIT and the rest) are not written, since the compiler adds them again wherever they are referenced.",
+      "A rule is written as the compiler rewrote it: a reference that led an alternative is written back where the alternatives the compiler put in its place still stand together, each followed by one same tail, and is otherwise written as those alternatives; a left recursion is written as the repetition it became, and alternatives the compiler left-factored with their shared prefix written in each of them again.",
+      "Where the compiler reordered a rule's alternatives to tell them apart (a longer lookahead ahead of a shorter one that begins with the same character, a keyword ahead of a character class that can take it), the alternatives that push a helper of the compiler's are put back in the order its numbers record, and the others are written in the compiled order: the rule compiles back the same, and the spec compiled back can differ in the order of the alternates other rules build through it, in the numbers of the compiler's helpers and in the order of its tokens, which is the order the lexer tries two tokens a place expects, so where a keyword and a class that can take it trade places the grammar compiled back accepts what the spec refused (start = ident / \\"if\\" ident with ident = %x61-7A: the spec refuses ifx, and the text compiles back to one that accepts it).",
+      "A left recursion that ran through another rule (P = Q, Q = P \\"+\\" / NR) is written as the compiler rewrote it, with the leading reference that closed the cycle left in place, and compiles back to another spec, since the compiler now substitutes that reference.",
+      "The start rule is written first, as ABNF's start rule is its first; a spec whose start rule was not its first rule compiles back with that rule moved first.",
+      "Terminals are written in RFC 5234's forms: a literal as a quoted string (with %s where it matches exactly and holds a letter) or, where a quoted string cannot hold it, as a numeric value of its code points, a range as %x and its ends, the class of every code point (GBNF's dot) as %x0-10FFFF, and a rule the compiler made a token of (CR = %x0D, referenced as CR) as that rule, after the others.",
+      "A rule the compiler made a token of, whose name is one the compiler could give its literal by itself (B = \\"b\\", or any name of capitals, digits and underscores where the literal holds a character past ASCII), cannot be told from that literal and is written as the literal: it compiles back with the token later in the token table, or under the name the literal gives it.",
+      "Repetitions are written in RFC 5234's forms, *A, 1*A, m*nA, [ A ] for an option over a group and 0*1A for an option over anything else; a repetition of a repetition, which another notation can write and RFC 5234 cannot, is put in a group of its own and compiles back with one more group.",
+      "An empty alternative, which RFC 5234 has no syntax for, is written as nothing between its slashes, which the compiler reads as one; in a rule whose alternatives the compiler emits as its open alternates, where it puts the empty one last wherever it stood, it is written first.",
+      "A spec compiled from another notation compiles back under ABNF's own settings: the group tag on every alternate, and lexer options the other notation adds (GBNF's exact lexing), are ABNF's, and a class of several members, which RFC 5234 cannot write, is written as the alternation of its members, each range a range and each character a string or a range of one, and compiles back as that alternation.",
+      "The tree builders every compiled grammar carries (@node$, @capture$, @bubble$ and @fold$, with their k settings) and its marks are not written, since the compiler makes them again from the rules: a spec whose builders or marks are others compiles back with the compiler's own, and recognises what it recognised.",
+      "A spec the render cannot write as ABNF is refused with TARGET_VALUE_UNREPRESENTABLE, naming what it met: an action (a value annotation's builders, a user action, the probe dispatcher of an optional prefix), a condition or a counter other than a repetition's, an error generator or an alternate modifier, a function reference where a rule or a count is due, a set of tokens at one place, a removal, a clear or the form that edits a rule already installed, a token no ABNF terminal matches (a negated class, a class holding a character past ASCII alone, a class whose flags change what it matches (no u on a class that is negated, reaches past U+FFFF or holds every code point, or u on one that holds a surrogate), a pattern that is neither one class nor an escaped literal, a case-sensitive literal holding a letter and a character no quoted string holds, a case-insensitive literal holding a character past ASCII and no ASCII letter, whose numeric value would match one case alone, a character past U+FFFF), a token set whose tokens are not the class its name gives, a rule with no alternate to open with, a sequence's step with more alternates than a step, a rule the compiler lifted to a token whose name another rule holds, a start that is not the start wrapper every grammar text compiles to (one open alternate that matches nothing and pushes a rule, closed by the end of the source alone), a rule name ABNF cannot spell, the empty name among them, a repetition bounded past what the compiler numbers, a repetition of no copies, whose item the spec does not keep, or a spec that gives its match tokens' order as a list of its own (Go's tokenOrder), whose rules' order, which ranks the tokens, is lost."
+    ]
+  }
+}
+`,
+    render: Object.freeze({ entry: "abnf-render", source: `; ABNF's render: a grammar-spec tree, the GrammarSpec the tabnas BNF
+; compiler (tabnas-bnf) emits for a grammar, written back as RFC 5234
+; ABNF. This is a library of definitions, each named \`abnf-...\`, which a
+; host links with its own program (alchemy's \`compile_sources\`); its entry
+; point is \`abnf-render\`, and nothing else here is the host's to call.
+;
+; A host reads an ABNF document by compiling it: the grammar-spec tree is
+; the pure-data GrammarSpec that \`abnfCompile(src, {recognition: false,
+; strict: true})\` writes (\`abnf_compile\` in Rust, \`AbnfCompile\` in Go;
+; the same text in all three runtimes, which tabnas-bnf's oracle tests
+; hold byte for byte), parsed as JSON. Its schema is \`grammar-spec\`,
+; shared with EBNF and GBNF, whose compilers emit the same shape; the
+; contract is the round trip: the text written here compiles back to the
+; spec it was written from.
+;
+; The spec is a compiled grammar, not the grammar's text, so the render
+; reads the compiler's shapes back into the notation:
+;
+; - A rule the author wrote is a rule of the spec that the spec's
+;   \`meta.provenance\` does not name (a spec without it is read by the
+;   names the compiler gives its rules, a helper's only where it has
+;   the shape of its kind too, and the start wrapper by its shape);
+;   every rule it names is the compiler's: a repetition's, an
+;   option's or a group's helper (\`_gen<n>_star_...\`, \`_plus_\`, \`_opt_\`,
+;   \`_rep_\`, \`_group\`), a sequence's chain steps (\`$alt<i>\`,
+;   \`$step<j>\`), a left-factored tail (\`$fact<k>\`) and the start
+;   wrapper. A helper is written where it is referenced, as the
+;   construct it compiles: a repeat loop (the replace loop every \`*A\`
+;   compiles to, its entry \`{c: {n.rep: 0}, r: <self>}\`) as \`*A\`, a plus
+;   as \`1*A\`, an option over a group as \`[ ... ]\` and over anything else
+;   as \`0*1A\`, a counted repetition as \`m*nA\` (its nested optionals
+;   counted), a group as \`( ... )\`. A factored tail is expanded back
+;   into the alternatives it was factored from, which the compiler
+;   factors again, and alternatives that were each a group, which the
+;   compiler factored into the first, are read back as the groups they
+;   were.
+; - An alternative of a rule is read from the alternates the compiler
+;   emitted for it: a chain of steps, one per segment of terminals and a
+;   reference; a dispatcher's \`$alt<i>\` rules, the gap in their numbers
+;   the empty alternative; or, for a rule whose every alternative is one
+;   segment, its open alternates, each read as the tokens it consumes
+;   (its \`s\` less the \`b\` it gives back) and the rule it pushes, the
+;   lookahead copies the dispatch made of one alternative read as one,
+;   the empty alternative first (the compiler puts it last wherever it
+;   stood), and those that push a helper in the order of the helpers'
+;   numbers, which the compiler gives them before it reorders the
+;   alternatives to tell them apart.
+; - A leading reference the compiler substituted by the referenced rule's
+;   alternatives is written back where those alternatives, each followed
+;   by one same tail, still stand together.
+; - A token is written as the terminal it matches: a fixed token as a
+;   quoted string, \`%s"..."\` where it holds a letter, a case-folding
+;   match token as a quoted string, a range as \`%x<lo>-<hi>\` (a token
+;   set the compiler laid over a contested range read back from its
+;   name, once its tokens are found to be that range), \`[\\s\\S]\` (GBNF's
+;   \`.\`) as \`%x0-10FFFF\`, and the engine's \`#TX\`, \`#NR\`, \`#ST\` and \`#VL\`
+;   by their names. A string a quoted string cannot hold is written as a
+;   numeric value, \`%x<hex>.<hex>\`, which the compiler reads as
+;   case-insensitive where it holds a letter of ASCII and as exact where
+;   it holds none: a case-folding string past ASCII with no such letter,
+;   whose numeric value would match one case alone, is refused. A token
+;   named for a rule the
+;   compiler lifted to it (\`CR = %x0D\` becomes the token \`#CR\`) is
+;   written as that rule, after the others, and referenced by name.
+; - An RFC 5234 core rule (ALPHA, DIGIT, ...) in the spec is not written,
+;   since the compiler adds it again wherever it is referenced, and a
+;   leading reference to one is written back as any other is.
+;
+; What a rule cannot be read back to is refused with
+; TARGET_VALUE_UNREPRESENTABLE, naming the rule: an action other than
+; the tree builders every compiled grammar carries (a value annotation's
+; builders, a user action, the probe dispatcher's), a condition or a
+; counter other than a repeat loop's, an error generator or an alternate
+; modifier (\`e\`, \`h\`), a function reference where a rule or a count is
+; due, a set of tokens at one place, the form that edits a rule already
+; installed (\`{alts, inject}\`), a removal, and a token no ABNF terminal
+; matches (a negated class, a class holding a character past ASCII
+; alone, a class whose flags change what it matches, a pattern that is
+; neither one class nor an escaped literal). A token set whose tokens
+; are not the class its name gives, a rule with no alternate to open
+; with, a sequence's step with more alternates than a step, and a rule
+; the compiler lifted to a token whose name another rule holds are
+; refused too. A spec serialized by Go, which writes its rules in name
+; order and its match tokens' order as a list of its own
+; (\`options.match.tokenOrder\`), is refused when that list holds two
+; tokens or more: the rules' order, which ranks the tokens (the order
+; the lexer tries two tokens a place expects), is lost. The tree
+; builders and the marks are not written: the compiler makes them again
+; from the rules.
+; A spec whose start is not the start wrapper every grammar text
+; compiles to (one open alternate that matches nothing and pushes a
+; rule, closed by the end of the source alone) is refused as well: its
+; text would compile back inside such a wrapper, whose close lets the
+; end of the source come after what the lexer skips.
+;
+; A spec compiled from another notation is written as far as ABNF can say
+; it: a class of several members (GBNF's and EBNF's \`[a-zA-Z_]\`) as the
+; alternation of its members, each range a range and each character a
+; string that matches it exactly, and an engine token by its name.
+;
+; The whole spec is materialized before a line is written: a rule's
+; alternatives are spread over its chain rules and helpers, which the
+; spec keeps elsewhere in its \`rule\` object.
+
+; ---- text and vectors
+
+def abnf-at [v i]
+  get-path (as-path [i]) v
+
+def abnf-num [n]
+  scalar-text csv-options n
+
+def abnf-empty [s]
+  match s
+    case "" true
+    case _ false
+
+def abnf-full [s]
+  match s
+    case "" false
+    case _ true
+
+; Whether the strings a and b are the same: a string cut by itself is two
+; empty strings, and by any other string it is not.
+def abnf-same [a b]
+  match b
+    case "" (abnf-empty a)
+    case _
+      match (split b a)
+        case ["" ""] true
+        case _ false
+
+def abnf-not [x]
+  match x
+    case true false
+    case false true
+
+def abnf-less [a b]
+  match (compare a b)
+    case :less true
+    case _ false
+
+def abnf-some [v]
+  match (count v)
+    case 0 false
+    case _ true
+
+def abnf-none [v]
+  match (count v)
+    case 0 true
+    case _ false
+
+def abnf-rest [v]
+  map (fn [i] (abnf-at v i)) (filter (fn [i] (match i (case 0 false) (case _ true))) (indices v))
+
+def abnf-take [n v]
+  map (fn [i] (abnf-at v i)) (filter (fn [i] (abnf-less i n)) (indices v))
+
+def abnf-drop [n v]
+  map (fn [i] (abnf-at v i)) (filter (fn [i] (abnf-not (abnf-less i n))) (indices v))
+
+; Whether s begins with the non-empty p, ends with it; s after its first
+; p, before its last.
+def abnf-starts [p s]
+  match s
+    case "" false
+    case _ (abnf-empty (abnf-at (split p s) 0))
+
+def abnf-ends [p s]
+  match s
+    case "" false
+    case _ (abnf-empty (top (split p s)))
+
+def abnf-after [p s]
+  string-join p (abnf-rest (split p s))
+
+def abnf-before [p s]
+  string-join p (pop (split p s))
+
+def abnf-digits [s]
+  match s
+    case "" false
+    case _ (chars-within [[48 57]] s)
+
+; The items of two vectors, and of a vector of vectors, in order: each
+; item is named by its place, the places joined as text and read back.
+def abnf-cat [a b]
+  abnf-flat [a b]
+
+def abnf-flat [vv]
+  map
+    fn [t]
+      let [p (split "." t)]
+        get-path (as-path [(number (abnf-at p 0)) (number (abnf-at p 1))]) vv
+    filter abnf-full
+      split ","
+        string-join ","
+          map
+            fn [j]
+              string-join "," (map (fn [i] (string-join "." [(abnf-num j) (abnf-num i)])) (indices (abnf-at vv j)))
+            indices vv
+
+; Whether the string s is among the strings of v.
+def abnf-among [s v]
+  abnf-some (filter (fn [x] (abnf-same x s)) v)
+
+; The items of v whose key is the first of its kind, in order.
+def abnf-unique [keyf v]
+  let [ks (map keyf v)]
+    let [prev (abnf-cat ["\\u0000"] (pop (abnf-cat ks ["\\u0000"])))]
+      let [runs (filter (fn [i] (abnf-not (abnf-same (abnf-at ks i) (abnf-at prev i)))) (indices ks))]
+        map
+          fn [i] (abnf-at v i)
+          filter
+            fn [i]
+              abnf-none (filter (fn [j] (match (abnf-less j i) (case true (abnf-same (abnf-at ks j) (abnf-at ks i))) (case false false))) runs)
+            runs
+
+def abnf-plus [a b]
+  length (string-join "" [(repeat a "x") (repeat b "x")])
+
+def abnf-ones [n]
+  pop (split "x" (repeat n "x"))
+
+def abnf-even [j]
+  abnf-some (filter (fn [d] (abnf-ends d (abnf-num j))) ["0" "2" "4" "6" "8"])
+
+def abnf-fail [what]
+  fail :unrepresentable (string-join "" ["the grammar spec cannot be written as ABNF: " what])
+
+; ---- the spec
+
+def abnf-rec [v]
+  match (kind v)
+    case :record v
+    case _ (record)
+
+def abnf-vec [v]
+  match (kind v)
+    case :vector (as-vector v)
+    case _ []
+
+def abnf-str [v]
+  match (kind v)
+    case :string v
+    case _ ""
+
+def abnf-context [spec]
+  let [o (abnf-rec (get "options" spec))]
+    record
+      entry :rules (abnf-rec (get "rule" spec))
+      entry :fixed (abnf-rec (get-path (as-path ["fixed" "token"]) o))
+      entry :match (abnf-rec (get-path (as-path ["match" "token"]) o))
+      entry :sets (abnf-rec (get "tokenSet" o))
+      entry :prov (get-path (as-path ["meta" "provenance"]) spec)
+      entry :start (abnf-str (get-path (as-path ["rule" "start"]) o))
+
+def abnf-rule [cx name]
+  get-path (as-path [name]) (get :rules cx)
+
+def abnf-has [cx name]
+  match (kind (abnf-rule cx name))
+    case :record true
+    case _ false
+
+; A rule's alternates in one phase, the falsy placeholders the engine
+; skips left out.
+def abnf-open [r]
+  filter (fn [alt] (match (kind alt) (case :record true) (case _ false))) (abnf-vec (get "open" r))
+
+def abnf-close [r]
+  filter (fn [alt] (match (kind alt) (case :record true) (case _ false))) (abnf-vec (get "close" r))
+
+; The tokens an alternate matches: its \`s\`, a string of token names
+; between spaces or a list of them.
+def abnf-s [alt]
+  let [s (get "s" alt)]
+    match (kind s)
+      case :string (filter abnf-full (split " " s))
+      case :vector (map abnf-str (as-vector s))
+      case _ []
+
+def abnf-b [alt]
+  match (kind (get "b" alt))
+    case :number (get "b" alt)
+    case _ 0
+
+def abnf-p [alt]
+  abnf-str (get "p" alt)
+
+def abnf-r [alt]
+  abnf-str (get "r" alt)
+
+def abnf-a [alt]
+  match (kind (get "a" alt))
+    case :string (get "a" alt)
+    case :missing ""
+    case :null ""
+    case _ "?"
+
+; Whether the compiler made the rule: provenance names every rule it
+; synthesized, and a spec without provenance is read by the names it
+; gives them.
+def abnf-made [cx name]
+  match (kind (get :prov cx))
+    case :record
+      match (kind (get-path (as-path [name]) (get :prov cx)))
+        case :string true
+        case _ false
+    case _
+      match (abnf-some (abnf-rest (split "$" name)))
+        case true (abnf-split-name name)
+        case false
+          match (abnf-gen-kind name)
+            case ""
+              match (abnf-same name (get :start cx))
+                case true (abnf-wrapper (abnf-rule cx name))
+                case false false
+            case k (abnf-helper-shape cx name k)
+
+; The kind of helper a name gives, as the compiler names the helpers it
+; makes, \`_gen<n>_<kind>...\` with the kind a repetition's, an option's or
+; a group's (\`_gen3_star_x\`, \`_gen4_group\`), or "" for any other name: a
+; rule the author wrote may begin with \`_gen\` too (\`_general\`).
+def abnf-gen-kind [name]
+  match (abnf-starts "_gen" name)
+    case false ""
+    case true
+      let [parts (split "_" (abnf-after "_gen" name))]
+        match (count parts)
+          case 1 ""
+          case _
+            match (match (abnf-digits (abnf-at parts 0)) (case true (abnf-among (abnf-at parts 1) ["star" "plus" "opt" "rep" "group"])) (case false false))
+              case true (abnf-at parts 1)
+              case false ""
+
+; Whether a name is one the compiler gives a rule it splits off another,
+; every part after a \`$\` one of its own: a dispatcher's alternative
+; (\`$alt<i>\`), a chain's step (\`$step<j>\`), a left-factored tail
+; (\`$fact<k>\`), a probe dispatcher (\`$pd<i>\`) and its parts (\`$probe\`,
+; \`$with\`, \`$no\`, numbered where the name was taken).
+def abnf-split-name [name]
+  abnf-none (filter (fn [p] (abnf-not (abnf-split-part p))) (abnf-rest (split "$" name)))
+
+def abnf-split-part [p]
+  abnf-some (filter (fn [k] (abnf-split-fits k p)) ["alt" "step" "fact" "pd" "probe" "with" "no"])
+
+def abnf-split-fits [k p]
+  match (abnf-starts k p)
+    case false false
+    case true
+      match (abnf-after k p)
+        case "" (abnf-among k ["probe" "with" "no"])
+        case rest (abnf-digits rest)
+
+; A rule named as the compiler names a helper, in a spec that names no
+; provenance, is the compiler's where it has the shape the compiler gives
+; that kind, and the author's otherwise: a repetition's loop has its
+; guarded entry (\`{c: {n.rep: 0}, r: <self>}\`); a plus is its item and the
+; loop after it; an option one element and the empty alternative; a
+; counted repetition copies of one element, and the option or the loop
+; after them; a group any alternatives.
+def abnf-helper-shape [cx name k]
+  match k
+    case "group" true
+    case "star" (abnf-some (filter (fn [alt] (abnf-loop-entry name alt)) (abnf-open (abnf-rule cx name))))
+    case _
+      let [alts (abnf-raw-alts cx name)]
+        match k
+          case "plus" (abnf-plus-shape alts)
+          case "opt" (abnf-opt-shape alts)
+          case _ (abnf-rep-shape alts)
+
+def abnf-loop-entry [name alt]
+  match (abnf-same (abnf-r alt) name)
+    case false false
+    case true
+      let [c (get "c" alt)]
+        match (kind c)
+          case :record (abnf-loop-value c "n.rep" [0])
+          case _ false
+
+def abnf-plus-shape [alts]
+  match (count alts)
+    case 1
+      let [seq (abnf-vec (abnf-at alts 0))]
+        match (count seq)
+          case 2 (abnf-same (abnf-helper-ref (abnf-at seq 1)) "star")
+          case _ false
+    case _ false
+
+def abnf-opt-shape [alts]
+  match (count alts)
+    case 2
+      let [counts (map count alts)]
+        match (abnf-among "0" (map abnf-num counts))
+          case true (abnf-among "1" (map abnf-num counts))
+          case false false
+    case _ false
+
+def abnf-rep-shape [alts]
+  match (count alts)
+    case 1
+      let [seq (abnf-vec (abnf-at alts 0))]
+        match (count seq)
+          case 0 true
+          case _
+            let [lead (match (abnf-among (abnf-helper-ref (top seq)) ["star" "opt"]) (case true (pop seq)) (case false seq))]
+              let [keys (map abnf-el-name lead)]
+                abnf-none (filter (fn [key] (match key (case "" true) (case _ (abnf-not (abnf-same key (abnf-at keys 0)))))) keys)
+    case _ false
+
+; The kind of helper an element references by name, or "".
+def abnf-helper-ref [el]
+  match (get :k el)
+    case :ref (abnf-gen-kind (get :name el))
+    case _ ""
+
+; A token or a reference by its name, any other element "".
+def abnf-el-name [el]
+  match (get :k el)
+    case :tok (string-join "" ["#" (get :name el)])
+    case :ref (string-join "" ["@" (get :name el)])
+    case _ ""
+
+; The start wrapper the compiler adds, which \`options.rule.start\` names:
+; one open alternate that consumes nothing and pushes the grammar's start
+; rule, and the end of the source, and nothing else, to close it.
+def abnf-wrapper [r]
+  let [o (abnf-open r)]
+    match (count o)
+      case 1
+        let [a (abnf-at o 0)]
+          match (match (abnf-some (abnf-s a)) (case true false) (case false (abnf-full (abnf-p a))))
+            case false false
+            case true
+              let [c (abnf-close r)]
+                match (count c)
+                  case 0 false
+                  case _ (abnf-none (filter (fn [x] (abnf-not (abnf-wrapper-end x))) c))
+      case _ false
+
+; A close alternate that matches the end of the source and goes nowhere.
+def abnf-wrapper-end [alt]
+  match (abnf-same (string-join " " (abnf-s alt)) "#ZZ")
+    case false false
+    case true (abnf-empty (abnf-target alt))
+
+; Every grammar text compiles to a start wrapper around its start rule,
+; and the wrapper's close lets the end of the source come after what the
+; lexer skips (\`ab \` where the grammar is \`ab\`). So the rule
+; \`options.rule.start\` names must be that wrapper: a spec that starts at
+; another rule, or at a wrapper without its close, would come back
+; accepting what it refuses.
+def abnf-check-start [cx]
+  match (abnf-wrapper (abnf-rule cx (get :start cx)))
+    case true true
+    case false (abnf-fail (string-join "" ["the start rule " (get :start cx) " is not the start wrapper every grammar text compiles to (one open alternate that matches nothing and pushes a rule, closed by the end of the source alone)"]))
+
+; The kind the tree builders give a rule the author wrote: "user", or
+; "core" for an RFC 5234 core rule the compiler added.
+def abnf-kind [r]
+  let [o (abnf-open r)]
+    match (count o)
+      case 0 "user"
+      case _
+        match (abnf-str (get-path (as-path ["k" "node$" "kind"]) (abnf-at o 0)))
+          case "core" "core"
+          case _ "user"
+
+; ---- what the spec may hold
+
+; Every alternate is one the compiler's tree-building grammars are made
+; of: the tokens it matches and gives back (\`s\`, \`b\`), the rule it pushes
+; or replaces itself with (\`p\`, \`r\`), the tree builders (\`a\`, \`k\`), group
+; tags, marks and per-rule scratch (\`g\`, \`m\`, \`u\`), and, in a repeat loop
+; alone, the loop's guard and counter (\`c\`, \`n\`). Anything more is a
+; construct the notation does not write: an error generator (\`e\`), an
+; alternate modifier (\`h\`), a function in place of a rule or a count, an
+; action other than the tree builders, another condition or counter.
+def abnf-alt-keys ["s" "b" "p" "r" "a" "c" "n" "k" "g" "m" "u"]
+
+def abnf-key-text [key]
+  match key
+    case "e" "e (an error generator)"
+    case "h" "h (an alternate modifier)"
+    case _ key
+
+def abnf-check-alt [cx name alt]
+  let [extra (filter (fn [key] (match (abnf-among key abnf-alt-keys) (case true false) (case false (abnf-given (get key alt))))) (keys alt))]
+    match (count extra)
+      case 0 (abnf-check-parts cx name alt)
+      case _ (abnf-fail (string-join "" ["rule " name " has an alternate carrying " (string-join ", " (map abnf-key-text extra)) ", which is not written"]))
+
+def abnf-check-parts [cx name alt]
+  let [a (abnf-a alt)]
+    match (abnf-among a ["" "@node$" "@capture$" "@bubble$" "@fold$"])
+      case false
+        match (abnf-starts "@probe" (abnf-action-text alt))
+          case true (abnf-fail (string-join "" ["rule " name " is the probe dispatcher the compiler makes for an optional prefix ([ X D ] Y), which is not read back"]))
+          case false (abnf-fail (string-join "" ["rule " name " carries an action (" (abnf-action-text alt) "), which is not written"]))
+      case true
+        let [tokens (abnf-check-s name (get "s" alt))]
+          let [next (count (map (fn [key] (abnf-check-next name key (get key alt))) ["p" "r"]))]
+            let [back (abnf-check-back name (get "b" alt))]
+              abnf-check-loop cx name alt
+
+; The tokens: a string of names between spaces, or a list of names, one
+; place each; a place holding a set of tokens (names between spaces, or a
+; list) chooses among them, which the render does not read back.
+def abnf-check-s [name s]
+  match (kind s)
+    case :missing true
+    case :null true
+    case :string true
+    case :vector
+      match (abnf-none (filter (fn [t] (match (kind t) (case :string (abnf-some (abnf-rest (split " " t)))) (case _ true))) (as-vector s)))
+        case true true
+        case false (abnf-fail (string-join "" ["rule " name " has an alternate whose s holds, at one place, a set of tokens or something other than a token's name, which is not written"]))
+    case _ (abnf-fail (string-join "" ["rule " name " has an alternate whose s is not tokens, which is not written"]))
+
+; The rule an alternate pushes or replaces itself with: a name, or none;
+; a function reference (\`@name\`) chooses at run time and is not written.
+def abnf-check-next [name key v]
+  match (kind v)
+    case :missing true
+    case :null true
+    case :boolean (match v (case false true) (case _ (abnf-fail (string-join "" ["rule " name " has an alternate whose " key " is not a rule, which is not written"]))))
+    case :string
+      match (abnf-starts "@" v)
+        case true (abnf-fail (string-join "" ["rule " name " has an alternate whose " key " is the function reference " v ", which is not written"]))
+        case false true
+    case _ (abnf-fail (string-join "" ["rule " name " has an alternate whose " key " is not a rule, which is not written"]))
+
+def abnf-check-back [name v]
+  match (kind v)
+    case :missing true
+    case :null true
+    case :number true
+    case :boolean (match v (case false true) (case _ (abnf-fail (string-join "" ["rule " name " has an alternate whose b is not a count, which is not written"]))))
+    case _ (abnf-fail (string-join "" ["rule " name " has an alternate whose b is not a count (" (abnf-str v) "), which is not written"]))
+
+; A repeat loop's guard (\`c: {n.rep: 0}\`) and counter (\`n: {rep: 0}\` or
+; \`{rep: 1}\`), in the loop the compiler makes for a repetition and the
+; steps of its item, and nowhere else.
+def abnf-loop-rule [cx name]
+  abnf-same (abnf-helper-kind cx (abnf-at (split "$" name) 0)) "star"
+
+def abnf-check-loop [cx name alt]
+  let [c (get "c" alt)]
+    let [n (get "n" alt)]
+      match (match (abnf-given c) (case true true) (case false (abnf-given n)))
+        case false true
+        case true
+          match (abnf-loop-rule cx name)
+            case false (abnf-fail (string-join "" ["rule " name " carries a condition or a counter outside a repetition's loop, which is not written"]))
+            case true
+              match (match (abnf-given c) (case false true) (case true (match (kind c) (case :record (abnf-loop-value c "n.rep" [0])) (case _ false))))
+                case false (abnf-fail (string-join "" ["rule " name " carries a condition other than its loop's, which is not written"]))
+                case true
+                  match (match (abnf-given n) (case false true) (case true (match (kind n) (case :record (abnf-loop-value n "rep" [0 1])) (case _ false))))
+                    case false (abnf-fail (string-join "" ["rule " name " carries a counter other than its loop's, which is not written"]))
+                    case true true
+
+; Whether an alternate gives a field: the engine reads a field that is
+; missing, null or false as one it does not give.
+def abnf-given [v]
+  match (kind v)
+    case :missing false
+    case :null false
+    case :boolean (match v (case false false) (case _ true))
+    case _ true
+
+def abnf-loop-value [rec key allowed]
+  match (keys rec)
+    case [only]
+      match (abnf-same only key)
+        case false false
+        case true
+          let [v (get-path (as-path [key]) rec)]
+            abnf-some (filter (fn [x] (match (compare v x) (case :equal true) (case _ false))) allowed)
+    case _ false
+
+def abnf-action-text [alt]
+  match (kind (get "a" alt))
+    case :string (get "a" alt)
+    case :vector (string-join " " (map abnf-str (as-vector (get "a" alt))))
+    case _ "a function"
+
+; A rule's phases: a list of alternates each, or none; the form that edits
+; a rule already installed (\`{alts, inject}\`) is not written.
+def abnf-check-phase [name phase v]
+  match (kind v)
+    case :missing true
+    case :null true
+    case :vector true
+    case :record (abnf-fail (string-join "" ["rule " name " gives its " phase " alternates as alts and an inject, which edits a rule already installed and is not written"]))
+    case _ (abnf-fail (string-join "" ["rule " name " gives its " phase " alternates in a form that is not a list, which is not written"]))
+
+def abnf-check-rule [cx name]
+  let [r (abnf-rule cx name)]
+    match (kind r)
+      case :record
+        let [phases (count (map (fn [phase] (abnf-check-phase name phase (get phase r))) ["open" "close"]))]
+          match (count (abnf-open r))
+            case 0 (abnf-fail (string-join "" ["rule " name " has no alternate to open with, which no grammar text writes"]))
+            case _ (count (map (fn [alt] (abnf-check-alt cx name alt)) (abnf-cat (abnf-open r) (abnf-close r))))
+      case :null (abnf-fail (string-join "" ["rule " name " is removed, which is not written"]))
+      case _ (abnf-fail (string-join "" ["rule " name " is not a rule's alternates, which is not written"]))
+
+; A spec serialized by Go writes its keys in name order and its match
+; tokens' order in a list of its own (\`options.match.tokenOrder\`): the
+; rules' order, which decides the order the compiler gives the tokens
+; again, is lost, and with it which of two tokens that both match wins.
+def abnf-check-order [spec]
+  let [order (get-path (as-path ["options" "match" "tokenOrder"]) spec)]
+    match (kind order)
+      case :vector
+        match (abnf-less (count (as-vector order)) 2)
+          case true true
+          case false (abnf-fail "it gives its match tokens' order as a list of its own (tokenOrder, Go's serialization, whose keys are in name order), and the order of the rules, which their precedence follows, is lost")
+      case _ true
+
+def abnf-check [spec cx]
+  match (get "clear" spec)
+    case true (abnf-fail "it clears the grammar it is installed on, which is not written")
+    case _
+      let [order (abnf-check-order spec)]
+        let [start (abnf-check-start cx)]
+          let [rules (count (map (fn [name] (abnf-check-rule cx name)) (keys (get :rules cx))))]
+            abnf-check-sets cx (abnf-used cx)
+
+; ---- tokens
+
+def abnf-bare [t]
+  abnf-after "#" t
+
+def abnf-lit [text cs]
+  record
+    entry :k :lit
+    entry :text text
+    entry :cs cs
+
+def abnf-class [pat flags]
+  record
+    entry :k :class
+    entry :pat pat
+    entry :flags flags
+
+; A pattern's escapes taken back off: an escaped backslash is a pair, any
+; other escape one backslash before the character it escapes.
+def abnf-unescape [s]
+  string-join "\\\\" (map (fn [piece] (string-join "" (split "\\\\" piece))) (split "\\\\\\\\" s))
+
+; A match token's source, \`@~/^.../flags\`: a class, or a case-folding
+; literal.
+def abnf-match-token [t m]
+  let [parts (split "/" m)]
+    let [flags (top parts)]
+      let [src (string-join "/" (pop (abnf-rest parts)))]
+        match (abnf-starts "^" src)
+          case false (abnf-fail (string-join "" ["the token " t " is the pattern " m ", which no ABNF terminal matches"]))
+          case true
+            let [body (abnf-after "^" src)]
+              match (abnf-starts "[" body)
+                case true
+                  match (abnf-class-pattern body)
+                    case false (abnf-fail (string-join "" ["the token " t " is the pattern " m ", which is not one class the render reads, and no ABNF terminal matches it"]))
+                    case true
+                      match (abnf-flags-fit body flags)
+                        case true (abnf-class body flags)
+                        case false (abnf-fail (string-join "" ["the token " t " is the class " m ", whose flags (" (match flags (case "" "none") (case _ flags)) ") change what it matches, and no ABNF terminal matches it"]))
+                case false
+                  match flags
+                    case "i"
+                      match (abnf-escaped-literal body)
+                        case true (abnf-lit (abnf-unescape body) false)
+                        case false (abnf-fail (string-join "" ["the token " t " is the pattern " m ", which is not a literal the render reads, and no ABNF terminal matches it"]))
+                    case _ (abnf-fail (string-join "" ["the token " t " is the pattern " m ", which no ABNF terminal matches"]))
+
+; Whether a pattern's body is one class as the compiler writes one:
+; \`[\`, an optional \`^\`, members each a \`\\uXXXX\` or \`\\u{X...}\` escape, alone
+; or the low end of a range, and \`]\` ending it; or \`[\\s\\S]\`, which
+; another notation's \`.\` compiles to.
+def abnf-class-pattern [body]
+  match body
+    case "[\\\\s\\\\S]" true
+    case _
+      match (abnf-ends "]" body)
+        case false false
+        case true
+          let [inner (abnf-before "]" (abnf-after "[" body))]
+            match (abnf-some (filter (fn [c] (abnf-some (abnf-rest (split c inner)))) ["[" "]"]))
+              case true false
+              case false
+                let [pieces (split "\\\\u" (match (abnf-starts "^" inner) (case true (abnf-after "^" inner)) (case false inner)))]
+                  match (abnf-empty (abnf-at pieces 0))
+                    case false false
+                    case true
+                      let [members (abnf-rest pieces)]
+                        match (count members)
+                          case 0 false
+                          case _
+                            match (abnf-ends "-" (top members))
+                              case true false
+                              case false (abnf-none (filter (fn [m] (abnf-not (abnf-member-piece m))) members))
+
+def abnf-member-piece [piece]
+  let [core (match (abnf-ends "-" piece) (case true (abnf-before "-" piece)) (case false piece))]
+    match (abnf-starts "{" core)
+      case true
+        match (abnf-ends "}" core)
+          case false false
+          case true
+            let [h (abnf-before "}" (abnf-after "{" core))]
+              match (abnf-among (abnf-num (length h)) ["1" "2" "3" "4" "5" "6"])
+                case false false
+                case true (abnf-hex-only h)
+      case false
+        match (length core)
+          case 4 (abnf-hex-only core)
+          case _ false
+
+def abnf-hex-only [h]
+  match h
+    case "" false
+    case _ (chars-within [[48 57] [65 70] [97 102]] h)
+
+; Whether a pattern's body is a literal as the compiler escapes one: every
+; character a pattern reads otherwise (\`\\ ^ $ . * + ? ( ) [ ] { } |\`)
+; after a backslash, and a backslash before nothing else.
+def abnf-meta-chars ["^" "$" "." "*" "+" "?" "(" ")" "[" "]" "{" "}" "|"]
+
+def abnf-escaped-literal [body]
+  let [rest (abnf-strip-escapes abnf-strip-escapes abnf-meta-chars (string-join "" (split "\\\\\\\\" body)))]
+    match (abnf-some (abnf-rest (split "\\\\" rest)))
+      case true false
+      case false (abnf-none (filter (fn [c] (abnf-some (abnf-rest (split c rest)))) abnf-meta-chars))
+
+def abnf-strip-escapes [self cs s]
+  match (count cs)
+    case 0 s
+    case _ (self self (pop cs) (string-join "" (split (string-join "" ["\\\\" (top cs)]) s)))
+
+; A token set's class, read back from its name, which the compiler gives
+; the class it lays over the atoms (\`rx_\` and the pattern, each character
+; that is not a letter or a digit an underscore, in capitals). Each member
+; of the pattern is a \`\\u\` escape, \`\\uXXXX\` or \`\\u{X...}\`, alone or the
+; low end of a range; the name keeps their digits and order.
+def abnf-hex-lower [h]
+  string-join "a" (split "A" (string-join "b" (split "B" (string-join "c" (split "C" (string-join "d" (split "D" (string-join "e" (split "E" (string-join "f" (split "F" h)))))))))))
+
+def abnf-hex-upper [h]
+  string-join "A" (split "a" (string-join "B" (split "b" (string-join "C" (split "c" (string-join "D" (split "d" (string-join "E" (split "e" (string-join "F" (split "f" h)))))))))))
+
+def abnf-set-member [piece]
+  let [parts (split "_" piece)]
+    match (abnf-empty (abnf-at parts 0))
+      case true
+        record
+          entry :text (string-join "" ["\\\\u{" (abnf-hex-lower (abnf-at parts 1)) "}"])
+          entry :braced true
+          entry :range (match (count parts) (case 4 true) (case _ false))
+      case false
+        record
+          entry :text (string-join "" ["\\\\u" (abnf-hex-lower (abnf-at parts 0))])
+          entry :braced false
+          entry :range (match (count parts) (case 2 true) (case _ false))
+
+def abnf-set-token [t]
+  let [rest (abnf-after "RX_" (abnf-bare t))]
+    match rest
+      case "__S_S" (abnf-class "[\\\\s\\\\S]" "u")
+      case _
+        let [pieces (split "_U" rest)]
+          let [members (map abnf-set-member (abnf-rest pieces))]
+            let [negated (abnf-same (abnf-at pieces 0) "__")]
+              let [body (string-join "" (map (fn [m] (string-join "" [(get :text m) (match (get :range m) (case true "-") (case false ""))])) members))]
+                let [pat (string-join "" ["[" (match negated (case true "^") (case false "")) body "]"])]
+                  match (abnf-same (abnf-class-name pat) (abnf-bare t))
+                    case false (abnf-fail (string-join "" ["the token set " t " names no class the render can read back"]))
+                    case true
+                      match negated
+                        case true (abnf-class pat "u")
+                        case false (abnf-class pat (match (abnf-some (filter (fn [m] (get :braced m)) members)) (case true "u") (case false "")))
+
+; The name the compiler gives a class's token: \`rx_\` and its pattern, every
+; character but a letter or a digit an underscore, in capitals, with the
+; underscores at the end taken off.
+def abnf-class-name [pat]
+  let [u (abnf-hex-upper (string-join "U" (split "u" (string-join "S" (split "s" pat)))))]
+    let [n (string-join "_" (split "[" (string-join "_" (split "]" (string-join "_" (split "^" (string-join "_" (split "-" (string-join "_" (split "\\\\" (string-join "_" (split "{" (string-join "_" (split "}" u))))))))))))))]
+      abnf-trim-end (string-join "" ["RX_" n])
+
+def abnf-trim-end [s]
+  match (abnf-ends "_" s)
+    case true (abnf-trim-end-once (abnf-before "_" s))
+    case false s
+
+def abnf-trim-end-once [s]
+  match (abnf-ends "_" s)
+    case true (abnf-before "_" s)
+    case false s
+
+; ---- code points and the ranges a class holds
+
+; A code point, from its one to six hexadecimal digits in either case, as
+; three numbers, its bytes from the highest, each the place of its two
+; digits among \`abnf-hex-pairs\`: code points are ordered as these are.
+def abnf-cp [h]
+  let [x (abnf-six (abnf-hex-upper h))]
+    let [high (abnf-pair-start x)]
+      let [rest (abnf-after high x)]
+        vector (abnf-pair-index high) (abnf-pair-index (abnf-pair-start rest)) (abnf-pair-index (abnf-pair-end rest))
+
+def abnf-six [h]
+  string-join "" [(match (length h) (case 1 "00000") (case 2 "0000") (case 3 "000") (case 4 "00") (case 5 "0") (case _ "")) h]
+
+def abnf-pair-start [x]
+  abnf-at (filter (fn [p] (abnf-starts p x)) abnf-hex-pairs) 0
+
+def abnf-pair-end [x]
+  abnf-at (filter (fn [p] (abnf-ends p x)) abnf-hex-pairs) 0
+
+def abnf-pair-index [p]
+  abnf-at (filter (fn [i] (abnf-same (abnf-at abnf-hex-pairs i) p)) (indices abnf-hex-pairs)) 0
+
+def abnf-cp-order [a b]
+  match (compare (abnf-at a 0) (abnf-at b 0))
+    case :equal
+      match (compare (abnf-at a 1) (abnf-at b 1))
+        case :equal (compare (abnf-at a 2) (abnf-at b 2))
+        case other other
+    case other other
+
+def abnf-cp-before [a b]
+  match (abnf-cp-order a b)
+    case :less true
+    case _ false
+
+def abnf-cp-is [a b]
+  match (abnf-cp-order a b)
+    case :equal true
+    case _ false
+
+; The code point after one: its low byte one more, carried into the bytes
+; above it.
+def abnf-cp-next [c]
+  match (abnf-at c 2)
+    case 255
+      match (abnf-at c 1)
+        case 255 (vector (abnf-plus (abnf-at c 0) 1) 0 0)
+        case _ (vector (abnf-at c 0) (abnf-plus (abnf-at c 1) 1) 0)
+    case _ (vector (abnf-at c 0) (abnf-at c 1) (abnf-plus (abnf-at c 2) 1))
+
+def abnf-cp-max [cps]
+  abnf-at (filter (fn [c] (abnf-none (filter (fn [d] (abnf-cp-before c d)) cps))) cps) 0
+
+def abnf-span [lo hi]
+  record
+    entry :lo lo
+    entry :hi hi
+
+; The members of a class's pattern, read as \`abnf-class-pattern\` admits
+; them: each a range, from its low end's digits to its high end's (a
+; character alone is a range of one); \`[\\s\\S]\` every code point. A
+; negated class's are the ones it excludes.
+def abnf-class-hex-spans [body]
+  match body
+    case "[\\\\s\\\\S]" [(abnf-span "0" "10FFFF")]
+    case _
+      let [inner (abnf-before "]" (abnf-after "[" body))]
+        let [pieces (abnf-rest (split "\\\\u" (match (abnf-starts "^" inner) (case true (abnf-after "^" inner)) (case false inner))))]
+          let [lows (map (fn [p] (abnf-ends "-" p)) pieces)]
+            let [ends (abnf-cat [false] lows)]
+              map
+                fn [i]
+                  let [lo (abnf-piece-hex (abnf-at pieces i))]
+                    match (abnf-at lows i)
+                      case true (abnf-span lo (abnf-piece-hex (abnf-at pieces (abnf-plus i 1))))
+                      case false (abnf-span lo lo)
+                filter (fn [i] (abnf-not (abnf-at ends i))) (indices pieces)
+
+def abnf-piece-hex [p]
+  let [core (match (abnf-ends "-" p) (case true (abnf-before "-" p)) (case false p))]
+    match (abnf-starts "{" core)
+      case true (abnf-before "}" (abnf-after "{" core))
+      case false core
+
+def abnf-class-spans [body]
+  map (fn [s] (abnf-span (abnf-cp (get :lo s)) (abnf-cp (get :hi s)))) (abnf-class-hex-spans body)
+
+; Ranges sorted by their low ends and merged where they overlap or meet:
+; two lists of ranges hold the same code points when these are the same.
+def abnf-spans-merged [spans]
+  let [sorted (abnf-spans-sorted spans)]
+    let [starts (filter (fn [i] (abnf-none (filter (fn [j] (match (abnf-less j i) (case true (abnf-not (abnf-cp-before (abnf-cp-next (get :hi (abnf-at sorted j))) (get :lo (abnf-at sorted i))))) (case false false))) (indices sorted)))) (indices sorted))]
+      map (fn [k] (abnf-block-span sorted starts k)) (indices starts)
+
+def abnf-block-span [sorted starts k]
+  let [from (abnf-at starts k)]
+    let [members (filter (fn [i] (match (abnf-less i from) (case true false) (case false (abnf-before-start starts k i)))) (indices sorted))]
+      abnf-span (get :lo (abnf-at sorted from)) (abnf-cp-max (map (fn [i] (get :hi (abnf-at sorted i))) members))
+
+def abnf-before-start [starts k i]
+  match (abnf-less (abnf-plus k 1) (count starts))
+    case true (abnf-less i (abnf-at starts (abnf-plus k 1)))
+    case false true
+
+def abnf-spans-sorted [spans]
+  let [ranks (map (fn [i] (count (filter (fn [j] (match (abnf-cp-order (get :lo (abnf-at spans j)) (get :lo (abnf-at spans i))) (case :less true) (case :equal (abnf-less j i)) (case _ false))) (indices spans)))) (indices spans))]
+    map (fn [k] (abnf-at spans (abnf-at (filter (fn [i] (match (compare (abnf-at ranks i) k) (case :equal true) (case _ false))) (indices spans)) 0))) (indices spans)
+
+def abnf-spans-same [a b]
+  match (compare (count a) (count b))
+    case :equal (abnf-none (filter (fn [i] (match (abnf-cp-is (get :lo (abnf-at a i)) (get :lo (abnf-at b i))) (case true (abnf-not (abnf-cp-is (get :hi (abnf-at a i)) (get :hi (abnf-at b i))))) (case false true))) (indices a)))
+    case _ false
+
+; Whether two lists of ranges hold every code point between them, each
+; once: a negated class's ranges and the ranges it matches.
+def abnf-spans-tile [a b]
+  let [all (abnf-spans-sorted (abnf-cat (abnf-spans-merged a) (abnf-spans-merged b)))]
+    match (count all)
+      case 0 false
+      case _
+        match (match (abnf-cp-is (get :lo (abnf-at all 0)) (abnf-cp "0")) (case true (abnf-cp-is (get :hi (top all)) (abnf-cp "10FFFF"))) (case false false))
+          case false false
+          case true
+            let [nexts (abnf-rest all)]
+              abnf-none (filter (fn [i] (abnf-not (abnf-cp-is (get :lo (abnf-at nexts i)) (abnf-cp-next (get :hi (abnf-at all i)))))) (indices nexts))
+
+; Whether a class's flags are the ones it is matched with once its text is
+; written and compiled back. Every compiler here gives \`u\` to a class that
+; is negated, holds a character past U+FFFF or is \`[\\s\\S]\`, and to no
+; other. Without \`u\` such a class matches one UTF-16 code unit, half of a
+; character past U+FFFF, and with it one code point. A class of other
+; characters matches the same either way, unless it holds a surrogate,
+; which \`u\` matches only where it stands alone.
+def abnf-flags-fit [body flags]
+  match (abnf-wants-u body)
+    case true (abnf-same flags "u")
+    case false
+      match (abnf-holds-surrogate body)
+        case true (abnf-empty flags)
+        case false (abnf-among flags ["" "u"])
+
+def abnf-wants-u [body]
+  match body
+    case "[\\\\s\\\\S]" true
+    case _
+      match (abnf-starts "[^" body)
+        case true true
+        case false (abnf-some (abnf-rest (split "\\\\u{" body)))
+
+; A class none of whose members is past U+FFFF holds a surrogate where a
+; range's low end is not above U+DFFF and its high end not below U+D800.
+def abnf-holds-surrogate [body]
+  abnf-some (filter (fn [s] (match (abnf-hex-from (get :lo s) ["E" "F"]) (case true false) (case false (abnf-hex-from (get :hi s) ["D8" "D9" "DA" "DB" "DC" "DD" "DE" "DF" "E" "F"])))) (abnf-class-hex-spans body))
+
+def abnf-hex-from [h prefixes]
+  let [x (abnf-hex-upper h)]
+    match (length x)
+      case 4 (abnf-some (filter (fn [p] (abnf-starts p x)) prefixes))
+      case _ false
+
+; A token set is the class its name gives when the tokens it lays over
+; that class are the class: their ranges, merged, are the class's ranges,
+; or, for a negated class, every code point the class does not exclude.
+; The compiler lays a contested class over the atoms of a partition, each
+; a token of its own, and names the set for the class; the render writes
+; the class the name gives, so a set whose tokens match anything else is
+; refused.
+def abnf-check-sets [cx used]
+  count (map (fn [k] (abnf-check-set cx (string-join "" ["#" k]))) (filter (fn [k] (match (abnf-starts "RX_" k) (case true (abnf-some (abnf-rest (split (string-join "" [" #" k " "]) used)))) (case false false))) (keys (get :sets cx))))
+
+def abnf-check-set [cx t]
+  let [cls (abnf-set-token t)]
+    let [pat (get :pat cls)]
+      let [spans (abnf-flat (map (fn [m] (abnf-member-spans cx t m)) (abnf-vec (get-path (as-path [(abnf-bare t)]) (get :sets cx)))))]
+        let [own (abnf-class-spans pat)]
+          match (match (abnf-starts "[^" pat) (case true (abnf-spans-tile own spans)) (case false (abnf-spans-same (abnf-spans-merged own) (abnf-spans-merged spans))))
+            case true true
+            case false (abnf-fail (string-join "" ["the token set " t " lays tokens over its class " pat " that match other characters than the class does, and the render writes the class the set's name gives"]))
+
+def abnf-member-spans [cx t m]
+  let [src (match (kind m) (case :string (abnf-str (get-path (as-path [m]) (get :match cx)))) (case _ ""))]
+    let [body (abnf-after "^" (string-join "/" (pop (abnf-rest (split "/" src)))))]
+      match (match (abnf-starts "@" src) (case true (match (abnf-class-pattern body) (case true (match (abnf-starts "[^" body) (case true false) (case false (abnf-flags-fit body (top (split "/" src)))))) (case false false))) (case false false))
+        case true (abnf-class-spans body)
+        case false (abnf-fail (string-join "" ["the token set " t " holds " (abnf-str m) ", which is not one class the render reads"]))
+
+def abnf-engine-token [t]
+  match t
+    case "#TX" (record (entry :k :engine) (entry :name "TX"))
+    case "#NR" (record (entry :k :engine) (entry :name "NR"))
+    case "#ST" (record (entry :k :engine) (entry :name "ST"))
+    case "#VL" (record (entry :k :engine) (entry :name "VL"))
+    case _ (abnf-fail (string-join "" ["the token " t " is defined nowhere in the spec"]))
+
+def abnf-token [cx t]
+  let [f (get-path (as-path [t]) (get :fixed cx))]
+    match (kind f)
+      case :string (abnf-lit f true)
+      case _
+        let [m (get-path (as-path [t]) (get :match cx))]
+          match (kind m)
+            case :string (abnf-match-token t m)
+            case _
+              match (kind (get-path (as-path [(abnf-bare t)]) (get :sets cx)))
+                case :vector (abnf-set-token t)
+                case _ (abnf-engine-token t)
+
+; ---- reading a rule's alternatives
+
+; An element of an alternative as the spec holds it: a token, or a
+; reference to a rule (the compiler's helpers among them).
+def abnf-tok-el [t]
+  record
+    entry :k :tok
+    entry :name t
+
+def abnf-ref-el [n]
+  record
+    entry :k :ref
+    entry :name n
+
+; The tokens an alternate consumes, and the rule it hands over to.
+def abnf-consumed [alt]
+  let [s (abnf-s alt)]
+    let [b (abnf-b alt)]
+      abnf-take (count (filter (fn [j] (abnf-not (abnf-less j b))) (indices s))) s
+
+def abnf-target [alt]
+  match (abnf-p alt)
+    case "" (abnf-r alt)
+    case p p
+
+def abnf-entry-els [alt]
+  let [toks (map abnf-tok-el (abnf-consumed alt))]
+    match (abnf-target alt)
+      case "" toks
+      case to (push (abnf-ref-el to) toks)
+
+def abnf-entry-key [alt]
+  string-join "" [(string-join " " (abnf-consumed alt)) "|" (abnf-target alt)]
+
+; A rule whose alternatives are each one segment: its open alternates,
+; each read as what it consumes and pushes, a dispatch's lookahead copies
+; of one alternative read as one; the empty alternative first, which the
+; compiler puts last wherever it stood, so that either place compiles
+; back the same. An alternate that consumes nothing and pushes nothing is
+; the empty alternative, or a guard that ends it on what may follow; two
+; or more bare ones (\`a ::= | \`) are as many empty alternatives.
+def abnf-simple-alts [r]
+  let [alts (abnf-flat (map (fn [alt] (map (fn [i] (abnf-entry-els alt)) (indices (abnf-ones (abnf-copies (abnf-open r) alt))))) (abnf-unique abnf-entry-key (abnf-open r))))]
+    let [bare (count (filter abnf-bare-empty (abnf-open r)))]
+      let [empties (match (abnf-some (filter abnf-none alts)) (case false []) (case true (map (fn [i] []) (indices (abnf-ones (match (abnf-less bare 2) (case true 1) (case false bare)))))))]
+        abnf-cat empties (abnf-number-order (filter abnf-some alts))
+
+; How many times an alternative stands among the open alternates: the
+; lookahead copies a dispatch makes of one alternative consume and push the
+; same and look ahead at different tokens, and are one; alternates alike
+; in everything are as many alternatives as there are of them.
+def abnf-copies [open alt]
+  let [group (filter (fn [a] (abnf-same (abnf-entry-key a) (abnf-entry-key alt))) open)]
+    let [counts (map (fn [a] (count (filter (fn [b] (abnf-same (abnf-whole-key b) (abnf-whole-key a))) group))) group)]
+      abnf-at (filter (fn [c] (abnf-none (filter (fn [d] (abnf-less c d)) counts))) counts) 0
+
+def abnf-whole-key [alt]
+  string-join "" [(string-join " " (abnf-s alt)) "|" (abnf-num (abnf-b alt)) "|" (abnf-target alt)]
+
+def abnf-bare-empty [alt]
+  match (abnf-some (abnf-s alt))
+    case true false
+    case false (abnf-empty (abnf-target alt))
+
+; The compiler reorders a rule's alternatives to tell them apart (a
+; longer lookahead first, a keyword ahead of a class that takes it), and
+; numbers the helpers it makes for them, in the order the alternatives
+; were written, before it does. So the alternatives that push a helper
+; are put back in the order of the helpers' numbers, among their own
+; places; the others keep theirs.
+def abnf-alt-number [alt]
+  match (count alt)
+    case 0 -1
+    case _
+      let [last (top alt)]
+        match (get :k last)
+          case :ref
+            match (abnf-starts "_gen" (get :name last))
+              case true
+                let [d (abnf-at (split "_" (abnf-after "_gen" (get :name last))) 0)]
+                  match (abnf-digits d)
+                    case true (number d)
+                    case false -1
+              case false -1
+          case _ -1
+
+def abnf-number-order [alts]
+  let [nums (map abnf-alt-number alts)]
+    let [slots (filter (fn [i] (abnf-not (abnf-less (abnf-at nums i) 0))) (indices alts))]
+      let [rank (fn [i] (count (filter (fn [j] (match (compare (abnf-at nums j) (abnf-at nums i)) (case :less true) (case :equal (abnf-less j i)) (case _ false))) slots)))]
+        let [ranks (map rank slots)]
+          map (fn [i] (abnf-number-at alts nums slots ranks i)) (indices alts)
+
+def abnf-number-at [alts nums slots ranks i]
+  match (abnf-less (abnf-at nums i) 0)
+    case true (abnf-at alts i)
+    case false
+      let [k (count (filter (fn [j] (abnf-less j i)) slots))]
+        abnf-at alts (abnf-at slots (abnf-at (filter (fn [m] (match (compare (abnf-at ranks m) k) (case :equal true) (case _ false))) (indices slots)) 0))
+
+; The first alternative that is not empty: an option's.
+def abnf-filled [alts]
+  abnf-at (filter abnf-some alts) 0
+
+; The steps of a chain, each a segment: the tokens its open alternate
+; consumes and the rule it pushes, the next step named in its close.
+def abnf-chain-walk [self cx name depth acc]
+  let [r (abnf-chain-step name (abnf-rule cx name))]
+    let [els (abnf-cat acc (abnf-entry-els (abnf-at (abnf-open r) 0)))]
+      match (count (abnf-close r))
+        case 0 els
+        case _
+          match (abnf-r (abnf-at (abnf-close r) 0))
+            case "" els
+            case next
+              match (abnf-less (count depth) 200)
+                case false (abnf-fail (string-join "" ["rule " name " is a sequence of more than 200 segments, which the render does not follow"]))
+                case true (self self cx next (push 1 depth) els)
+
+def abnf-chain [cx name]
+  abnf-chain-walk abnf-chain-walk cx name [] []
+
+; A dispatcher's alternatives: one rule per alternative, \`<rule>$alt<i>\`,
+; and the empty one where a number is missing, or last.
+def abnf-head-name [name i]
+  string-join "" [name "$alt" (abnf-num i)]
+
+def abnf-dispatch-alts [cx name r]
+  let [nums (indices (push 0 (abnf-open r)))]
+    let [present (filter (fn [i] (abnf-has cx (abnf-head-name name i))) nums)]
+      let [last (top present)]
+        let [gaps (filter (fn [i] (match (abnf-less i last) (case true (abnf-not (abnf-among (abnf-num i) (map abnf-num present)))) (case false false))) nums)]
+          let [empty (abnf-some (filter (fn [alt] (abnf-empty (abnf-target alt))) (abnf-open r)))]
+            match (count gaps)
+              case 0
+                abnf-cat (map (fn [i] (abnf-chain cx (abnf-head-name name i))) present) (match empty (case true [[]]) (case false []))
+              case 1
+                map
+                  fn [i]
+                    match (abnf-has cx (abnf-head-name name i))
+                      case true (abnf-chain cx (abnf-head-name name i))
+                      case false []
+                  filter (fn [i] (abnf-not (abnf-less last i))) nums
+              case _ (abnf-fail (string-join "" ["rule " name " dispatches to alternatives the render cannot place"]))
+
+; Whether the rule dispatches to \`$alt\` rules of its own.
+def abnf-dispatches [cx name r]
+  abnf-some (filter (fn [alt] (abnf-starts (string-join "" [name "$alt"]) (abnf-target alt))) (abnf-open r))
+
+; A loop's item: what its continue alternate takes, a token it consumes,
+; or the rule its iteration (\`<loop>$alt0\`) pushes.
+def abnf-loop-item [cx name r]
+  let [conts (filter (fn [alt] (abnf-full (abnf-r alt))) (abnf-rest (abnf-open r)))]
+    match (count conts)
+      case 0 (abnf-fail (string-join "" ["the repetition " name " repeats nothing"]))
+      case _
+        let [c (abnf-at conts 0)]
+          match (abnf-same (abnf-r c) name)
+            case true
+              match (abnf-consumed c)
+                case [t] (abnf-tok-el t)
+                case _ (abnf-fail (string-join "" ["the repetition " name " repeats more than one token"]))
+            case false
+              match (abnf-p (abnf-at (abnf-open (abnf-rule cx (abnf-r c))) 0))
+                case "" (abnf-fail (string-join "" ["the repetition " name " repeats nothing"]))
+                case item (abnf-ref-el item)
+
+; A tail repeat, \`X = prefix [ sep X ]\`, which the compiler makes a loop
+; in the rule's close: the separator matched and the rule replaced.
+def abnf-is-tail [name r]
+  match (count (abnf-close r))
+    case 2
+      let [c (abnf-at (abnf-close r) 0)]
+        match (abnf-a c)
+          case "@fold$" (abnf-same (abnf-r c) name)
+          case _ false
+    case _ false
+
+; The alternatives of a rule as the spec holds them, each a vector of
+; elements; a tail repeat as its prefix and the option around its
+; separator and itself.
+def abnf-raw-alts [cx name]
+  let [r (abnf-rule cx name)]
+    match (abnf-is-tail name r)
+      case true
+        let [prefix (map abnf-tok-el (abnf-consumed (abnf-at (abnf-open r) 0)))]
+          let [sep (map abnf-tok-el (abnf-consumed (abnf-at (abnf-close r) 0)))]
+            vector
+              push
+                record
+                  entry :k :tail
+                  entry :seq (push (abnf-ref-el name) sep)
+                prefix
+      case false
+        match (abnf-dispatches cx name r)
+          case true (abnf-dispatch-alts cx name r)
+          case false
+            match (count (abnf-close r))
+              case 0 (abnf-simple-alts r)
+              case _
+                match (abnf-r (abnf-at (abnf-close r) 0))
+                  case "" (abnf-simple-alts r)
+                  case _ (vector (abnf-chain cx name))
+
+; A step of a sequence's chain, as the compiler makes one: one open
+; alternate, a segment of the sequence, and at most one close alternate,
+; which names the next step. A rule that replaces itself in its close and
+; has more alternates than that is no chain the render reads back.
+def abnf-chain-step [name r]
+  match (match (count (abnf-open r)) (case 1 (abnf-less (count (abnf-close r)) 2)) (case _ false))
+    case true r
+    case false (abnf-fail (string-join "" ["rule " name " replaces itself in its close as a sequence's step does, and has more alternates than a step, which is not read back"]))
+
+; ---- the compiler's helpers, read back
+
+; The kind of a helper the compiler named: \`_gen<n>_<kind>...\`.
+def abnf-helper-kind [cx name]
+  match (abnf-made cx name)
+    case false ""
+    case true
+      match (abnf-starts "_gen" name)
+        case true
+          let [parts (split "_" (abnf-after "_gen" name))]
+            match (abnf-digits (abnf-at parts 0))
+              case true (abnf-at parts 1)
+              case false ""
+        case false
+          match (abnf-among "fact" (map (fn [p] (abnf-before-digits p)) (abnf-rest (split "$" name))))
+            case true "fact"
+            case false ""
+
+def abnf-before-digits [p]
+  match (abnf-starts "fact" p)
+    case true (match (abnf-digits (abnf-after "fact" p)) (case true "fact") (case false p))
+    case false p
+
+; An alternative with its factored tails expanded back: one whose last
+; element is a left-factored tail (\`<rule>$fact<k>\`) is the prefix before
+; it followed by each of the tail's alternatives in turn.
+def abnf-expand [self cx alt]
+  match (count alt)
+    case 0 [alt]
+    case _
+      let [last (top alt)]
+        match (get :k last)
+          case :ref
+            match (abnf-helper-kind cx (get :name last))
+              case "fact"
+                let [prefix (pop alt)]
+                  abnf-flat (map (fn [tail] (self self cx (abnf-cat prefix tail))) (abnf-raw-alts cx (get :name last)))
+              case _ [alt]
+          case _ [alt]
+
+def abnf-alts [cx name]
+  abnf-flat (map (fn [alt] (abnf-split-group cx name alt)) (abnf-flat (map (fn [alt] (abnf-expand abnf-expand cx alt)) (abnf-raw-alts cx name))))
+
+; The compiler factors a rule's alternatives that are each one group
+; (\`( A x ) | ( A y )\`) into the first group, whose sequence then ends in
+; the rule's own factored tail (\`<rule>$fact<k>\`); such an alternative is
+; read back as the groups it was, one alternative each.
+def abnf-split-group [cx name alt]
+  match (count alt)
+    case 1
+      let [el (abnf-at alt 0)]
+        match (get :k el)
+          case :ref
+            match (abnf-helper-kind cx (get :name el))
+              case "group"
+                let [inner (abnf-raw-alts cx (get :name el))]
+                  match (count inner)
+                    case 1
+                      let [seq (abnf-at inner 0)]
+                        match (abnf-owned-fact cx name seq)
+                          case true (map (fn [one] [(abnf-grp-el one)]) (abnf-expand abnf-expand cx seq))
+                          case false [alt]
+                    case _ [alt]
+              case _ [alt]
+          case _ [alt]
+    case _ [alt]
+
+def abnf-owned-fact [cx name seq]
+  match (count seq)
+    case 0 false
+    case _
+      let [last (top seq)]
+        match (get :k last)
+          case :ref
+            match (abnf-helper-kind cx (get :name last))
+              case "fact" (abnf-starts (string-join "" [name "$fact"]) (get :name last))
+              case _ false
+          case _ false
+
+; A group read back from a factored alternative: an element of its own,
+; written as a group is.
+def abnf-grp-el [seq]
+  record
+    entry :k :grp
+    entry :seq seq
+
+; The parts a repetition counts: the item, how many at least, how many
+; at most ("" for no bound). A bounded one ends in nested options, each
+; over a group of the item and the next option, the innermost over the
+; item alone: \`[ A [ A [ A ] ] ]\`. The compiler numbers them as it makes
+; them, the innermost group first, under the number it gave the
+; repetition: group n, option n+1 over it, group n+2, ..., so the
+; outermost option's number says how deep they go.
+def abnf-gen-number [name]
+  number (abnf-at (split "_" (abnf-after "_gen" name)) 0)
+
+def abnf-rep-chain [cx rep opt]
+  let [n (abnf-gen-number rep)]
+    let [inner-name (string-join "" ["_gen" (abnf-num n) "_group"])]
+      match (abnf-has cx inner-name)
+        case false (abnf-fail (string-join "" ["the repetition " rep " is not numbered as the compiler numbers one"]))
+        case true
+          let [inner (abnf-raw-alts cx inner-name)]
+            match (count (abnf-at inner 0))
+              case 1
+                let [span (count (filter (fn [j] (abnf-not (abnf-less j n))) (indices (abnf-ones (abnf-plus (abnf-gen-number opt) 1)))))]
+                  record
+                    entry :item (abnf-at (abnf-at inner 0) 0)
+                    entry :depth (count (filter abnf-even (indices (abnf-ones span))))
+              case _ (abnf-fail (string-join "" ["the repetition " rep " is not numbered as the compiler numbers one"]))
+
+def abnf-rep-parts [cx name]
+  let [seq (abnf-at (abnf-raw-alts cx name) 0)]
+    let [last (match (count seq) (case 0 (abnf-fail (string-join "" ["the repetition " name " repeats its item no times, and the spec does not keep the item"]))) (case _ (top seq)))]
+      let [lead (pop seq)]
+        match (abnf-helper-kind cx (abnf-str (get :name last)))
+          case "star"
+            record
+              entry :item (abnf-loop-item cx (get :name last) (abnf-rule cx (get :name last)))
+              entry :min (count lead)
+              entry :max ""
+          case "opt"
+            let [chain (abnf-rep-chain cx name (get :name last))]
+              record
+                entry :item (get :item chain)
+                entry :min (count lead)
+                entry :max (abnf-num (abnf-plus (count lead) (get :depth chain)))
+          case _
+            record
+              entry :item (abnf-at seq 0)
+              entry :min (count seq)
+              entry :max (abnf-num (count seq))
+
+; Whether an option is over a group.
+def abnf-opt-group [cx name]
+  let [alts (abnf-raw-alts cx name)]
+    let [inner (abnf-at (abnf-filled alts) 0)]
+      match (get :k inner)
+        case :ref (abnf-same (abnf-helper-kind cx (get :name inner)) "group")
+        case _ false
+
+; An element's structure as one string, a helper by what it compiles (a
+; counted repetition by its item and counts, not by the nested options
+; it compiles to, which are as deep as its count).
+def abnf-key [self cx el]
+  match (get :k el)
+    case :tok (get :name el)
+    case :tail "[tail]"
+    case :grp (string-join "" ["group(" (abnf-key-seq self cx (get :seq el)) ")"])
+    case :ref
+      let [name (get :name el)]
+        match (abnf-helper-kind cx name)
+          case "" (string-join "" ["@" name])
+          case "star" (string-join "" ["*(" (self self cx (abnf-loop-item cx name (abnf-rule cx name))) ")"])
+          case "rep"
+            let [parts (abnf-rep-parts cx name)]
+              string-join "" ["rep(" (abnf-num (get :min parts)) "," (get :max parts) "," (self self cx (get :item parts)) ")"]
+          case kind (string-join "" [kind "(" (string-join "|" (map (fn [seq] (abnf-key-seq self cx seq)) (abnf-alts cx name))) ")"])
+
+def abnf-key-seq [self cx seq]
+  string-join " " (map (fn [e] (self self cx e)) seq)
+
+def abnf-seq-keys [cx seq]
+  map (fn [el] (abnf-key abnf-key cx el)) seq
+
+; ---- characters
+
+; A literal's characters as their code points, which a notation writes
+; where a quoted string cannot hold a character, and the names the
+; compiler derives from a literal's text.
+
+; The ASCII characters, each with its two hexadecimal digits.
+def abnf-ascii [["\\u0000" "00"] ["\\u0001" "01"] ["\\u0002" "02"] ["\\u0003" "03"] ["\\u0004" "04"] ["\\u0005" "05"] ["\\u0006" "06"] ["\\u0007" "07"] ["\\b" "08"] ["\\t" "09"] ["\\n" "0A"] ["\\u000b" "0B"] ["\\f" "0C"] ["\\r" "0D"] ["\\u000e" "0E"] ["\\u000f" "0F"] ["\\u0010" "10"] ["\\u0011" "11"] ["\\u0012" "12"] ["\\u0013" "13"] ["\\u0014" "14"] ["\\u0015" "15"] ["\\u0016" "16"] ["\\u0017" "17"] ["\\u0018" "18"] ["\\u0019" "19"] ["\\u001a" "1A"] ["\\u001b" "1B"] ["\\u001c" "1C"] ["\\u001d" "1D"] ["\\u001e" "1E"] ["\\u001f" "1F"] [" " "20"] ["!" "21"] ["\\"" "22"] ["#" "23"] ["$" "24"] ["%" "25"] ["&" "26"] ["'" "27"] ["(" "28"] [")" "29"] ["*" "2A"] ["+" "2B"] ["," "2C"] ["-" "2D"] ["." "2E"] ["/" "2F"] ["0" "30"] ["1" "31"] ["2" "32"] ["3" "33"] ["4" "34"] ["5" "35"] ["6" "36"] ["7" "37"] ["8" "38"] ["9" "39"] [":" "3A"] [";" "3B"] ["<" "3C"] ["=" "3D"] [">" "3E"] ["?" "3F"] ["@" "40"] ["A" "41"] ["B" "42"] ["C" "43"] ["D" "44"] ["E" "45"] ["F" "46"] ["G" "47"] ["H" "48"] ["I" "49"] ["J" "4A"] ["K" "4B"] ["L" "4C"] ["M" "4D"] ["N" "4E"] ["O" "4F"] ["P" "50"] ["Q" "51"] ["R" "52"] ["S" "53"] ["T" "54"] ["U" "55"] ["V" "56"] ["W" "57"] ["X" "58"] ["Y" "59"] ["Z" "5A"] ["[" "5B"] ["\\\\" "5C"] ["]" "5D"] ["^" "5E"] ["_" "5F"] ["\`" "60"] ["a" "61"] ["b" "62"] ["c" "63"] ["d" "64"] ["e" "65"] ["f" "66"] ["g" "67"] ["h" "68"] ["i" "69"] ["j" "6A"] ["k" "6B"] ["l" "6C"] ["m" "6D"] ["n" "6E"] ["o" "6F"] ["p" "70"] ["q" "71"] ["r" "72"] ["s" "73"] ["t" "74"] ["u" "75"] ["v" "76"] ["w" "77"] ["x" "78"] ["y" "79"] ["z" "7A"] ["{" "7B"] ["|" "7C"] ["}" "7D"] ["~" "7E"] ["\\u007f" "7F"]]
+
+; A piece of a literal's text: a run of its characters (\`:raw\`), or one
+; character as its code point (\`:cp\`). A run is cut at each place it
+; holds a character, which is put back as its code point between the
+; pieces, and the empty runs are left out.
+def abnf-raw-seg [s]
+  record
+    entry :raw s
+
+def abnf-cp-seg [h]
+  record
+    entry :cp h
+
+def abnf-cut-seg [c h seg]
+  match (kind (get :raw seg))
+    case :string
+      let [pieces (split c (get :raw seg))]
+        abnf-flat (map (fn [i] (match i (case 0 [(abnf-raw-seg (abnf-at pieces 0))]) (case _ [(abnf-cp-seg h) (abnf-raw-seg (abnf-at pieces i))]))) (indices pieces))
+    case _ [seg]
+
+; A string's pieces with each of the characters given cut out as its code
+; point, in turn.
+def abnf-code-walk [self chars segs]
+  match (count chars)
+    case 0 segs
+    case _
+      let [ch (top chars)]
+        self self (pop chars) (filter abnf-kept-seg (abnf-flat (map (fn [seg] (abnf-cut-seg (abnf-at ch 0) (abnf-at ch 1) seg)) segs)))
+
+def abnf-kept-seg [seg]
+  match (get :raw seg)
+    case "" false
+    case _ true
+
+; A literal's characters as their code points, in order: its ASCII
+; characters cut out first, then each run of other characters taken
+; apart.
+def abnf-codes [text]
+  let [present (filter (fn [ch] (abnf-some (abnf-rest (split (abnf-at ch 0) text)))) abnf-ascii)]
+    let [segs (abnf-code-walk abnf-code-walk present [(abnf-raw-seg text)])]
+      abnf-flat (map (fn [seg] (abnf-wide-codes text seg)) segs)
+
+; The sixteen hexadecimal digits, and the 256 pairs of them.
+def abnf-hex-digits ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"]
+
+def abnf-hex-pairs
+  abnf-flat (map (fn [a] (map (fn [b] (string-join "" [a b])) abnf-hex-digits)) abnf-hex-digits)
+
+; The start of each block of 256 code points in the Basic Multilingual
+; Plane, by which a character past ASCII is found.
+def abnf-blocks [0 256 512 768 1024 1280 1536 1792 2048 2304 2560 2816 3072 3328 3584 3840 4096 4352 4608 4864 5120 5376 5632 5888 6144 6400 6656 6912 7168 7424 7680 7936 8192 8448 8704 8960 9216 9472 9728 9984 10240 10496 10752 11008 11264 11520 11776 12032 12288 12544 12800 13056 13312 13568 13824 14080 14336 14592 14848 15104 15360 15616 15872 16128 16384 16640 16896 17152 17408 17664 17920 18176 18432 18688 18944 19200 19456 19712 19968 20224 20480 20736 20992 21248 21504 21760 22016 22272 22528 22784 23040 23296 23552 23808 24064 24320 24576 24832 25088 25344 25600 25856 26112 26368 26624 26880 27136 27392 27648 27904 28160 28416 28672 28928 29184 29440 29696 29952 30208 30464 30720 30976 31232 31488 31744 32000 32256 32512 32768 33024 33280 33536 33792 34048 34304 34560 34816 35072 35328 35584 35840 36096 36352 36608 36864 37120 37376 37632 37888 38144 38400 38656 38912 39168 39424 39680 39936 40192 40448 40704 40960 41216 41472 41728 41984 42240 42496 42752 43008 43264 43520 43776 44032 44288 44544 44800 45056 45312 45568 45824 46080 46336 46592 46848 47104 47360 47616 47872 48128 48384 48640 48896 49152 49408 49664 49920 50176 50432 50688 50944 51200 51456 51712 51968 52224 52480 52736 52992 53248 53504 53760 54016 54272 54528 54784 55040 55296 55552 55808 56064 56320 56576 56832 57088 57344 57600 57856 58112 58368 58624 58880 59136 59392 59648 59904 60160 60416 60672 60928 61184 61440 61696 61952 62208 62464 62720 62976 63232 63488 63744 64000 64256 64512 64768 65024 65280]
+
+; A piece of a literal that holds no ASCII character: characters of the
+; Basic Multilingual Plane, each as its code point, in order. The run is
+; cut at each character it holds, found a block of 256 at a time: the
+; block of its least character is the last whose start that character is
+; not below, the characters of that block the run holds are the escapes
+; there it holds, and the rest of the run is taken the same way.
+def abnf-wide-codes [text seg]
+  match (kind (get :raw seg))
+    case :string
+      let [raw (get :raw seg)]
+        match (chars-within [[128 55295] [57344 65535]] raw)
+          case false (abnf-fail (string-join "" ["the literal " (quoted text) " holds a character past U+FFFF, which the render does not spell as a numeric value"]))
+          case true
+            let [found (abnf-wide-chars abnf-wide-chars text raw [])]
+              map (fn [piece] (get :cp piece)) (abnf-code-walk abnf-code-walk found [(abnf-raw-seg raw)])
+    case _ [(get :cp seg)]
+
+def abnf-wide-chars [self text run acc]
+  match run
+    case "" acc
+    case _
+      let [b (top (filter (fn [i] (chars-within [[(abnf-at abnf-blocks i) 65535]] run)) (indices abnf-blocks)))]
+        let [hh (abnf-at abnf-hex-pairs b)]
+          let [found (filter (fn [ch] (abnf-some (abnf-rest (split (abnf-at ch 0) run)))) (map (fn [l] [(unquoted (string-join "" ["\\"\\\\u" (abnf-hex-lower hh) (abnf-hex-lower l) "\\""])) (abnf-point-hex hh l)]) abnf-hex-pairs))]
+            match (count found)
+              case 0 (abnf-fail (string-join "" ["the literal " (quoted text) " holds a character the render cannot spell"]))
+              case _ (self self text (abnf-strip-chars abnf-strip-chars found run) (abnf-cat acc found))
+
+; A code point's digits as ABNF writes them, without leading zeros.
+def abnf-point-hex [hh l]
+  match hh
+    case "00" l
+    case _
+      match (abnf-starts "0" hh)
+        case true (string-join "" [(abnf-after "0" hh) l])
+        case false (string-join "" [hh l])
+
+def abnf-strip-chars [self chars s]
+  match (count chars)
+    case 0 s
+    case _ (self self (pop chars) (string-join "" (split (abnf-at (top chars) 0) s)))
+
+def abnf-has-letter [text]
+  abnf-not (chars-within [[0 64] [91 96] [123 1114111]] text)
+
+; ---- token names
+
+; The name the compiler derives for a literal's token: the text in
+; capitals, each character that is not a letter or a digit an underscore,
+; the underscores at either end taken off, \`T\` when nothing is left, and a
+; number after it when the name is taken. A token with any other name is a
+; rule the compiler lifted to a token.
+def abnf-upper-pairs [["a" "A"] ["b" "B"] ["c" "C"] ["d" "D"] ["e" "E"] ["f" "F"] ["g" "G"] ["h" "H"] ["i" "I"] ["j" "J"] ["k" "K"] ["l" "L"] ["m" "M"] ["n" "N"] ["o" "O"] ["p" "P"] ["q" "Q"] ["r" "R"] ["s" "S"] ["t" "T"] ["u" "U"] ["v" "V"] ["w" "W"] ["x" "X"] ["y" "Y"] ["z" "Z"]]
+
+def abnf-swap-walk [self pairs s]
+  match (count pairs)
+    case 0 s
+    case _
+      let [pair (top pairs)]
+        self self (pop pairs) (string-join (abnf-at pair 1) (split (abnf-at pair 0) s))
+
+def abnf-word-chars [[48 57] [65 90] [97 122]]
+
+def abnf-base-name [text]
+  let [up (abnf-swap-walk abnf-swap-walk abnf-upper-pairs text)]
+    let [others (filter (fn [ch] (abnf-not (chars-within abnf-word-chars (abnf-at ch 0)))) abnf-ascii)]
+      let [under (abnf-swap-walk abnf-swap-walk (map (fn [ch] [(abnf-at ch 0) "_"]) others) up)]
+        let [pieces (split "_" under)]
+          let [full (filter (fn [i] (abnf-full (abnf-at pieces i))) (indices pieces))]
+            match (count full)
+              case 0 "T"
+              case _
+                let [lo (abnf-at full 0)]
+                  let [hi (top full)]
+                    string-join "_" (map (fn [i] (abnf-at pieces i)) (filter (fn [i] (match (abnf-less i lo) (case true false) (case false (abnf-not (abnf-less hi i))))) (indices pieces)))
+
+def abnf-derived [bare text]
+  match (chars-within [[48 57] [65 90] [95 95]] bare)
+    case false false
+    case true
+      match (chars-within [[0 127]] text)
+        case false true
+        case true
+          let [base (abnf-base-name text)]
+            match (abnf-same bare base)
+              case true true
+              case false
+                match (abnf-starts base bare)
+                  case true (abnf-digits (abnf-after base bare))
+                  case false false
+
+; Every token name the alternates match, one string.
+def abnf-used [cx]
+  let [rules (get :rules cx)]
+    string-join ""
+      vector
+        " "
+        string-join " "
+          map
+            fn [name]
+              let [r (get-path (as-path [name]) rules)]
+                string-join " " (abnf-flat (map abnf-s (abnf-cat (abnf-open r) (abnf-close r))))
+            keys rules
+        " "
+
+; ---- references written back
+
+; The compiler substitutes a reference that leads an alternative by the
+; referenced rule's alternatives, each followed by what followed the
+; reference (\`a = b "x"\`, \`b = "y" / "z"\` compiles \`a\` as \`"y" "x" / "z"
+; "x"\`), and compiles the reference back to the same alternatives. So
+; where a run of a rule's alternatives is another rule's alternatives,
+; each followed by one same tail, the reference is written back in their
+; place. A candidate is a rule the written file can name, with its
+; alternatives' keys; a rule that is one reference (\`a = b\`) is none,
+; since the compiler leaves such a rule a reference rather than
+; substituting it.
+def abnf-candidates [cx names]
+  filter
+    fn [c] (abnf-not (abnf-alias-keys (get :keys c)))
+    map (fn [n] (record (entry :name n) (entry :keys (map (fn [seq] (abnf-seq-keys cx seq)) (abnf-alts cx n))))) names
+
+def abnf-alias-keys [ks]
+  match (count ks)
+    case 1
+      match (count (abnf-at ks 0))
+        case 1 (abnf-starts "@" (abnf-at (abnf-at ks 0) 0))
+        case _ false
+    case _ false
+
+; Whether alternatives are one alternative of one reference to a rule:
+; a rule the compiler leaves as it is.
+def abnf-alias [cx alts]
+  match (count alts)
+    case 1
+      let [seq (abnf-at alts 0)]
+        match (count seq)
+          case 1
+            match (get :k (abnf-at seq 0))
+              case :ref (abnf-empty (abnf-helper-kind cx (get :name (abnf-at seq 0))))
+              case _ false
+          case _ false
+    case _ false
+
+; Whether the alternative's keys begin with the candidate alternative's,
+; and what follows them ("\\u0000" where they do not).
+def abnf-prefix-tail [ks cs]
+  match (abnf-less (count ks) (count cs))
+    case true "\\u0000"
+    case false
+      match (abnf-same (string-join "\\u0001" (abnf-take (count cs) ks)) (string-join "\\u0001" cs))
+        case true (string-join "\\u0001" (abnf-drop (count cs) ks))
+        case false "\\u0000"
+
+; Whether the candidate's alternatives, each followed by one same tail,
+; are the alternatives from position i on.
+def abnf-cand-matches [c ka i]
+  let [k (count (get :keys c))]
+    match (abnf-less (count ka) (abnf-plus i k))
+      case true false
+      case false
+        let [first (abnf-prefix-tail (abnf-at ka i) (abnf-at (get :keys c) 0))]
+          match first
+            case "\\u0000" false
+            case _ (abnf-none (filter (fn [j] (abnf-not (abnf-same (abnf-prefix-tail (abnf-at ka (abnf-plus i j)) (abnf-at (get :keys c) j)) first))) (indices (get :keys c))))
+
+; The candidate, other than the rule itself, whose alternatives stand at
+; position i: where several do, the one with the most alternatives, and
+; among those the one the spec defines first. The spec cannot tell \`a = b
+; ";"\` with \`b = c "("\` from \`a = c "(" ";"\`, nor a reference from two
+; rules that begin alike by chance; a grammar written from the top down
+; defines the rule an author named before the ones it is made of.
+def abnf-cand-at [cands ka i self]
+  let [hits (filter (fn [c] (match (abnf-same (get :name c) self) (case true false) (case false (abnf-cand-matches c ka i)))) cands)]
+    let [most (filter (fn [c] (abnf-none (filter (fn [d] (abnf-less (count (get :keys c)) (count (get :keys d)))) hits))) hits)]
+      match (count most)
+        case 0 null
+        case _ (abnf-at most 0)
+
+; A rule's alternatives with the references written back: each run a
+; candidate covers, from the first position one stands at that no other
+; run covers, written as the reference and the tail; the alternatives
+; as they are where no run is found, and where writing one back would
+; leave the rule one reference, which the compiler would not substitute.
+def abnf-unsub [cx cands self alts]
+  match (count cands)
+    case 0 alts
+    case _
+      let [ka (map (fn [seq] (abnf-seq-keys cx seq)) alts)]
+        let [best (map (fn [i] (abnf-cand-at cands ka i self)) (indices alts))]
+          let [covers (fn [j i] (match (kind (abnf-at best j)) (case :record (match (abnf-less j i) (case true (abnf-less i (abnf-plus j (count (get :keys (abnf-at best j)))))) (case false false))) (case _ false)))]
+            let [accepted (map (fn [i] (match (kind (abnf-at best i)) (case :record (abnf-none (filter (fn [j] (covers j i)) (indices alts)))) (case _ false))) (indices alts))]
+              let [out (abnf-flat (map (fn [i] (abnf-unsub-at cx alts best accepted covers i)) (indices alts)))]
+                match (abnf-alias cx out)
+                  case true alts
+                  case false out
+
+def abnf-unsub-at [cx alts best accepted covers i]
+  match (abnf-at accepted i)
+    case true
+      let [c (abnf-at best i)]
+        vector (abnf-cat [(abnf-ref-el (get :name c))] (abnf-drop (count (abnf-at (get :keys c) 0)) (abnf-at alts i)))
+    case false
+      match (abnf-some (filter (fn [j] (match (abnf-at accepted j) (case true (covers j i)) (case false false))) (indices alts)))
+        case true []
+        case false [(abnf-at alts i)]
+
+; ---- ABNF's terminals
+
+; A literal: a quoted string where it can hold the text (\`%s\` before it
+; when the match is exact and the text holds a letter), and otherwise a
+; numeric value, \`%x\` and each character's code point, which tabnas-abnf
+; reads as a case-insensitive string where it holds a letter of ASCII,
+; with the folding a case-insensitive pattern has, and as an exact one
+; where it holds none. So a case-insensitive literal holding a character
+; past ASCII, which may have cases, and no letter of ASCII is refused: its
+; numeric value would match the one case it spells.
+def abnf-lit-text [text cs]
+  match text
+    case "" "\\"\\""
+    case _
+      match (chars-within [[32 33] [35 126]] text)
+        case true
+          match cs
+            case true
+              match (abnf-has-letter text)
+                case true (string-join "" ["%s\\"" text "\\""])
+                case false (string-join "" ["\\"" text "\\""])
+            case false (string-join "" ["\\"" text "\\""])
+        case false
+          match cs
+            case true
+              match (abnf-has-letter text)
+                case true (abnf-fail (string-join "" ["the case-sensitive literal " (quoted text) " holds a character a quoted string cannot hold, and a numeric value matches case-insensitively"]))
+                case false (string-join "" ["%x" (string-join "." (abnf-codes text))])
+            case false
+              match (match (abnf-has-letter text) (case true true) (case false (chars-within [[0 127] [65536 1114111]] text)))
+                case true (string-join "" ["%x" (string-join "." (abnf-codes text))])
+                case false (abnf-fail (string-join "" ["the case-insensitive literal " (quoted text) " holds a character past ASCII that may have cases and no ASCII letter, and a numeric value without a letter matches exactly"]))
+
+; A code point of a class's pattern, \`\\uXXXX\` or \`\\u{X...}\`, as ABNF's
+; hexadecimal digits.
+def abnf-escape-hex [e]
+  match (abnf-starts "\\\\u" e)
+    case false ""
+    case true
+      let [h (abnf-after "\\\\u" e)]
+        match (abnf-starts "{" h)
+          case true (abnf-hex-upper (abnf-before "}" (abnf-after "{" h)))
+          case false
+            match (abnf-starts "00" h)
+              case true (abnf-hex-upper (abnf-after "00" h))
+              case false (abnf-hex-upper h)
+
+; A class: one range as \`%x<lo>-<hi>\`, the only class ABNF writes; a
+; class of several members, which another notation writes, as the
+; alternation of its members, each range a range and each character a
+; string that matches it exactly, or a range of one where a string cannot
+; hold it; \`[\\s\\S]\` (GBNF's \`.\`) as the range of every code point. A
+; negated class has no ABNF form.
+def abnf-class-text [pat flags]
+  match pat
+    case "[\\\\s\\\\S]" "%x0-10FFFF"
+    case _ (abnf-range-text pat)
+
+def abnf-range-text [pat]
+  let [body (abnf-before "]" (abnf-after "[" pat))]
+    match (abnf-starts "^" body)
+      case true (abnf-fail (string-join "" ["the class " pat " is negated, which ABNF has no form for"]))
+      case false
+        let [members (abnf-class-members body)]
+          match (abnf-none (filter (fn [m] (abnf-empty (get :lo m))) members))
+            case false (abnf-fail (string-join "" ["the class " pat " is not a range ABNF writes"]))
+            case true
+              match (count members)
+                case 0 (abnf-fail (string-join "" ["the class " pat " is empty"]))
+                case 1 (abnf-member-text pat (abnf-at members 0))
+                case _ (string-join "" ["( " (string-join " / " (map (fn [m] (abnf-member-text pat m)) members)) " )"])
+
+; A class's members, each \`\\uXXXX\` or \`\\u{X...}\` alone or the low end of a
+; range: its digits and its high end's, ABNF's hexadecimal digits.
+def abnf-class-members [body]
+  let [pieces (abnf-rest (split "\\\\u" body))]
+    let [prev (abnf-cat [""] pieces)]
+      map
+        fn [i]
+          let [piece (abnf-at pieces i)]
+            match (abnf-ends "-" piece)
+              case true
+                record
+                  entry :lo (abnf-escape-hex (string-join "" ["\\\\u" (abnf-before "-" piece)]))
+                  entry :hi (abnf-escape-hex (string-join "" ["\\\\u" (abnf-str (abnf-at pieces (abnf-plus i 1)))]))
+              case false
+                record
+                  entry :lo (abnf-escape-hex (string-join "" ["\\\\u" piece]))
+                  entry :hi (abnf-escape-hex (string-join "" ["\\\\u" piece]))
+        filter (fn [i] (abnf-not (abnf-ends "-" (abnf-at prev i)))) (indices pieces)
+
+; A member: a range as a range; a character as a string that matches it
+; exactly where a string can hold it, and otherwise, below U+0080, as a
+; range of one, which the compiler reads as that character. A character
+; past ASCII that no string holds is refused, since a range of one is read
+; without regard to case.
+def abnf-member-text [pat m]
+  match (abnf-same (get :lo m) (get :hi m))
+    case false (string-join "" ["%x" (get :lo m) "-" (get :hi m)])
+    case true
+      let [h (get :lo m)]
+        let [h4 (string-join "" [(match (length h) (case 1 "000") (case 2 "00") (case 3 "0") (case _ "")) (abnf-hex-lower h)])]
+          match (abnf-ascii-code h4)
+            case false (abnf-fail (string-join "" ["the class " pat " holds U+" (abnf-hex-upper h4) " alone, which ABNF writes only as a numeric value, read without regard to case"]))
+            case true
+              let [c (unquoted (string-join "" ["\\"\\\\u" h4 "\\""]))]
+                match (chars-within [[32 33] [35 126]] c)
+                  case true (abnf-lit-text c true)
+                  case false (string-join "" ["%x" h "-" h])
+
+; Whether four hexadecimal digits name an ASCII character.
+def abnf-ascii-code [h4]
+  match (abnf-starts "00" h4)
+    case false false
+    case true (abnf-some (filter (fn [d] (abnf-starts d (abnf-after "00" h4))) ["0" "1" "2" "3" "4" "5" "6" "7"]))
+
+; ---- ABNF's elements
+
+; Alternatives' text without the space an empty first or last one leaves
+; at either end (\`a = / "x"\`).
+def abnf-trim-ends [t]
+  let [lead (match (abnf-starts " " t) (case true (abnf-after " " t)) (case false t))]
+    match (abnf-ends " " lead)
+      case true (abnf-before " " lead)
+      case false lead
+
+; A rule name ABNF can spell: a letter, then letters, digits and hyphens.
+def abnf-legal-name [name]
+  match name
+    case "" false
+    case _
+      match (chars-within [[45 45] [48 57] [65 90] [97 122]] name)
+        case false false
+        case true
+          match (abnf-starts "-" name)
+            case true false
+            case false (abnf-none (filter (fn [d] (abnf-starts d name)) ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9"]))
+
+def abnf-ref-text [name]
+  match (abnf-legal-name name)
+    case true name
+    case false (abnf-fail (string-join "" ["the rule " (quoted name) " has a name ABNF cannot spell"]))
+
+; Whether a token is a rule the compiler lifted: a literal's token whose
+; name is not the one the literal gives it, or that nothing references.
+def abnf-lifted [cx used t]
+  let [info (abnf-token cx t)]
+    match (get :k info)
+      case :lit
+        match (abnf-legal-name (abnf-bare t))
+          case false false
+          case true
+            match (abnf-derived (abnf-bare t) (get :text info))
+              case false true
+              case true (abnf-not (abnf-some (abnf-rest (split (string-join "" [" " t " "]) used))))
+      case _ false
+
+def abnf-token-text [cx lifted t]
+  match (abnf-among t lifted)
+    case true (abnf-bare t)
+    case false
+      let [info (abnf-token cx t)]
+        match (get :k info)
+          case :lit (abnf-lit-text (get :text info) (get :cs info))
+          case :class (abnf-class-text (get :pat info) (get :flags info))
+          case :engine (get :name info)
+
+def abnf-rep-text [self cx lifted name]
+  let [parts (abnf-rep-parts cx name)]
+    let [min (abnf-num (get :min parts))]
+      let [count-text (match (get :max parts) (case "" (string-join "" [min "*"])) (case max (match (abnf-same min max) (case true min) (case false (string-join "" [(match min (case "0" "") (case _ min)) "*" max])))))]
+        string-join "" [count-text (self self cx lifted :atom (get :item parts))]
+
+; The element a repetition applies to: a terminal, a rule, a group or an
+; option; any other construct is put in a group of its own.
+def abnf-atom-text [self cx lifted el]
+  match (get :k el)
+    case :tok (abnf-token-text cx lifted (get :name el))
+    case :grp (self self cx lifted :el el)
+    case :ref
+      match (abnf-helper-kind cx (get :name el))
+        case "group" (self self cx lifted :el el)
+        case "opt"
+          match (abnf-opt-group cx (get :name el))
+            case true (self self cx lifted :el el)
+            case false (string-join "" ["( " (self self cx lifted :el el) " )"])
+        case "" (self self cx lifted :el el)
+        case _ (string-join "" ["( " (self self cx lifted :el el) " )"])
+    case _ (string-join "" ["( " (self self cx lifted :el el) " )"])
+
+def abnf-el-text [self cx lifted el]
+  match (get :k el)
+    case :tok (abnf-token-text cx lifted (get :name el))
+    case :tail (string-join "" ["[ " (self self cx lifted :alts [(get :seq el)]) " ]"])
+    case :grp (string-join "" ["( " (self self cx lifted :alts [(get :seq el)]) " )"])
+    case :ref
+      let [name (get :name el)]
+        match (abnf-helper-kind cx name)
+          case "" (abnf-ref-text name)
+          case "star" (string-join "" ["*" (self self cx lifted :atom (abnf-loop-item cx name (abnf-rule cx name)))])
+          case "plus"
+            let [seq (abnf-at (abnf-alts cx name) 0)]
+              string-join "" ["1*" (self self cx lifted :atom (abnf-at seq 0))]
+          case "opt"
+            let [inner (abnf-at (abnf-filled (abnf-alts cx name)) 0)]
+              match (abnf-opt-group cx name)
+                case true (string-join "" ["[ " (self self cx lifted :alts (abnf-alts cx (get :name inner))) " ]"])
+                case false (string-join "" ["0*1" (self self cx lifted :atom inner)])
+          case "rep" (abnf-rep-text self cx lifted name)
+          case "group" (string-join "" ["( " (self self cx lifted :alts (abnf-alts cx name)) " )"])
+          case kind (abnf-fail (string-join "" ["the rule " name " is a helper of a kind the render does not read (" kind ")"]))
+
+def abnf-seq-text [self cx lifted seq]
+  string-join " " (map (fn [el] (self self cx lifted :el el)) seq)
+
+; The text of a rule's or a group's alternatives (\`:alts\`, ABNF's \`/\`
+; between them), of an element (\`:el\`) and of the element a repetition
+; applies to (\`:atom\`): the one function the render recurses through, as
+; \`self\`, a helper's alternatives a level deeper.
+def abnf-text [self cx lifted mode x]
+  match mode
+    case :alts (abnf-trim-ends (string-join " / " (map (fn [seq] (abnf-seq-text self cx lifted seq)) x)))
+    case :el (abnf-el-text self cx lifted x)
+    case :atom (abnf-atom-text self cx lifted x)
+
+; ---- core rules
+
+; The RFC 5234 core rules, in the order the compiler adds them: a pass
+; over them in this order adds every one the grammar references, and
+; another pass every one those reference, until none is missing. So the
+; core rules a spec holds, in its order, rise through this list for the
+; ones the grammar itself referenced, and fall back at the first the core
+; rules referenced instead.
+def abnf-core-order ["ALPHA" "BIT" "CHAR" "CR" "LF" "CRLF" "CTL" "DIGIT" "DQUOTE" "HEXDIG" "HTAB" "OCTET" "SP" "VCHAR" "WSP" "LWSP"]
+
+def abnf-core-index [name]
+  let [found (filter (fn [i] (abnf-same (abnf-at abnf-core-order i) name)) (indices abnf-core-order))]
+    match (count found)
+      case 0 99
+      case _ (abnf-at found 0)
+
+; The core rules the grammar referenced itself: the ones a written rule
+; can name, which the compiler adds again.
+def abnf-direct-core [cx]
+  let [core (filter (fn [n] (match (abnf-made cx n) (case true false) (case false (abnf-same (abnf-kind (abnf-rule cx n)) "core")))) (keys (get :rules cx)))]
+    let [idx (map abnf-core-index core)]
+      let [prev (abnf-cat [-1] idx)]
+        let [falls (filter (fn [i] (abnf-less (abnf-at idx i) (abnf-at prev i))) (indices idx))]
+          match (count falls)
+            case 0 core
+            case _ (abnf-take (abnf-at falls 0) core)
+
+; ---- the file
+
+def abnf-production [cx cands lifted name]
+  string-join "" [(abnf-ref-text name) " = " (abnf-text abnf-text cx lifted :alts (abnf-unsub cx cands name (abnf-alts cx name)))]
+
+def abnf-lifted-production [cx t]
+  let [info (abnf-token cx t)]
+    string-join "" [(abnf-ref-text (abnf-bare t)) " = " (abnf-lit-text (get :text info) (get :cs info))]
+
+; A rule the compiler lifted to a token is written under the token's name,
+; which no rule of the spec may hold already: two productions of one name
+; are one rule.
+def abnf-check-lifted [cx lifted]
+  map
+    fn [t]
+      match (abnf-has cx (abnf-bare t))
+        case true (abnf-fail (string-join "" ["the token " t " is written as a rule named " (abnf-bare t) ", the name of another rule the spec holds"]))
+        case false t
+    lifted
+
+; The grammar's start rule: the one the start wrapper pushes, or the rule
+; \`options.rule.start\` names where it is no wrapper.
+def abnf-start-rule [cx]
+  let [r (abnf-rule cx (get :start cx))]
+    match (abnf-wrapper r)
+      case true (abnf-p (abnf-at (abnf-open r) 0))
+      case false (get :start cx)
+
+def abnf-file [spec]
+  let [cx (abnf-context spec)]
+    let [checked (abnf-check spec cx)]
+      let [names (filter (fn [n] (match (abnf-made cx n) (case true false) (case false (abnf-same (abnf-kind (abnf-rule cx n)) "user")))) (keys (get :rules cx)))]
+        let [start (abnf-start-rule cx)]
+          let [ordered (abnf-cat [start] (filter (fn [n] (abnf-not (abnf-same n start))) names))]
+            let [used (abnf-used cx)]
+              let [tokens (abnf-cat (keys (get :fixed cx)) (keys (get :match cx)))]
+                let [lifted (abnf-check-lifted cx (filter (fn [t] (abnf-lifted cx used t)) tokens))]
+                  let [cands (abnf-candidates cx (abnf-cat ordered (abnf-direct-core cx)))]
+                    string-join ""
+                      vector
+                        string-join "\\n" (abnf-cat (map (fn [n] (abnf-production cx cands lifted n)) ordered) (map (fn [t] (abnf-lifted-production cx t)) lifted))
+                        "\\n"
+
+def abnf-render [input]
+  concat-map abnf-file (select root input)
+` })
+});
+function translate() {
+    return TRANSLATION;
+}
+//# sourceMappingURL=translate.js.map