@pubid/pubid 0.1.3 → 0.1.5

package/dist/conformance/cli.js

@@ -2,6 +2,7 @@ import { loadCorpus } from "../corpus/loader.js";
 import { PendingRegistry } from "./pending.js";
 import { runCorpus } from "./runner.js";
 import { corpusModeImplementation } from "../implementations/corpus-mode.js";
+import { grammarImplementation } from "../flavors/index.js";
 /**
  * The conformance entry point. TESTSUITE_DIR points at a pubid-testsuite
  * checkout's tests/ directory (CI checks it out at the pinned ref).
@@ -19,7 +20,10 @@ export function main(argv) {
     // gate then enforces parity with the corpus floor.
     const implementations = new Map([...corpus.flavors].map(([flavor, payloads]) => [
         flavor,
-        corpusModeImplementation(payloads.cases),
+        // Grammar waves replace corpus mode per flavor: a flavor with a
+        // ported grammar parses open-endedly, and the same gate enforces
+        // parity with the corpus floor.
+        grammarImplementation(flavor) ?? corpusModeImplementation(payloads.cases),
     ]));
     const pending = PendingRegistry.load(pendingPath);
     const report = runCorpus(corpus, implementations, pending);

package/dist/flavors/amca/grammar.d.ts

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const amcaGrammar: Grammar;
+/** Parser.parse normalization. */
+export declare function preprocessAmca(input: string): string;

package/dist/flavors/amca/grammar.js

@@ -0,0 +1,87 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/amca/parser.rb — 1:1. Root: identifier.
+ *
+ * Branch order: interpretation, publication, standard.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    rule("space", () => str(" "));
+    rule("dash", () => str("-"));
+    rule("slash", () => str("/"));
+    rule("lparen", () => str("("));
+    rule("rparen", () => str(")"));
+    rule("dot", () => str("."));
+    rule("digit", () => match("[0-9]"));
+    rule("digits", () => ref(rules, "digit").repeat(1, Infinity));
+    rule("letter", () => match("[A-Za-z]"));
+    rule("year_digits", () => str("19").or(str("20")).then(ref(rules, "digit").repeat(2, 2))
+        .or(ref(rules, "digit").repeat(2, 2)));
+    rule("copublisher", () => str("ANSI").then(ref(rules, "slash")).then(str("AMCA"))
+        .or(str("AMCA")));
+    rule("additional_copublisher", () => ref(rules, "slash")
+        .then(ref(rules, "letter").repeat(2, 10))
+        .then(ref(rules, "space"))
+        .then(ref(rules, "digits"))
+        .then((ref(rules, "dash").then(ref(rules, "digits"))).maybe()));
+    rule("code", () => (ref(rules, "digits")
+        .then((ref(rules, "dash").then(ref(rules, "letter"))).maybe())
+        .then((ref(rules, "dot").then(ref(rules, "digits"))).maybe())).as("code"));
+    rule("type", () => str("Standard").or(str("Publication")));
+    rule("reaffirmation", () => ref(rules, "lparen").then(str("R")).then(ref(rules, "digits").as("reaffirmed")).then(ref(rules, "rparen")));
+    // Consumed but never captured (the Ruby rule has no .as).
+    rule("suffix", () => str("R").or(str("P")));
+    rule("revision", () => ref(rules, "lparen").then(str("Rev")).then(ref(rules, "dot").maybe())
+        .then(ref(rules, "space"))
+        .then(ref(rules, "digits").then(ref(rules, "dash")).then(ref(rules, "digits")).as("revision"))
+        .then(ref(rules, "rparen")));
+    rule("interpretation_code", () => ref(rules, "letter").repeat(2, Infinity).as("interpretation_code")
+        .or(ref(rules, "digits").as("interpretation_code")));
+    rule("interp_keyword", () => ref(rules, "space").then(str("Interp")));
+    const copubSpace = () => ref(rules, "copublisher").as("copublisher").maybe().then(ref(rules, "space"));
+    rule("interpretation_identifier", () => (copubSpace()
+        .then(ref(rules, "code"))
+        .then(ref(rules, "space"))
+        .then(ref(rules, "interpretation_code").then(ref(rules, "interp_keyword"))
+        .or(str("–").or(ref(rules, "dash"))
+        .then(ref(rules, "digits").as("interpretation_year"))
+        .then(ref(rules, "interp_keyword").maybe())))).as("interpretation")
+        .or(copubSpace()
+        .then(ref(rules, "code"))
+        .then(ref(rules, "interp_keyword"))
+        .as("interpretation")));
+    rule("publication_identifier", () => (copubSpace()
+        .then(str("Publication").as("publication_keyword"))
+        .then(ref(rules, "space"))
+        .then(ref(rules, "code"))
+        .then((ref(rules, "dash").then(ref(rules, "year_digits").as("year"))).maybe())
+        .then((ref(rules, "space").then(ref(rules, "revision"))).maybe())
+        .then((ref(rules, "space").then(ref(rules, "reaffirmation"))).maybe())).as("publication"));
+    rule("standard_identifier", () => (copubSpace()
+        .then(ref(rules, "type").as("type").maybe())
+        .then(ref(rules, "space").maybe())
+        .then(ref(rules, "code"))
+        .then((ref(rules, "dash").then(ref(rules, "year_digits").as("year"))).maybe())
+        .then((ref(rules, "space").then(ref(rules, "additional_copublisher"))).maybe())
+        .then(ref(rules, "suffix").maybe())
+        .then((ref(rules, "space").then(ref(rules, "reaffirmation"))).maybe())).as("standard"));
+    rule("identifier", () => ref(rules, "interpretation_identifier")
+        .or(ref(rules, "publication_identifier"))
+        .or(ref(rules, "standard_identifier")));
+    return rules;
+}
+export const amcaGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};
+/** Parser.parse normalization. */
+export function preprocessAmca(input) {
+    let cleaned = input.trim();
+    cleaned = cleaned.replaceAll(/\s+/g, " ");
+    cleaned = cleaned.replaceAll("–", "-");
+    cleaned = cleaned.replace(/[,.]$/, "");
+    return cleaned;
+}

package/dist/flavors/amca/index.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from "../../grammar/engine.js";
+import type { FlavorImplementation, Identifier } from "../../conformance/implementation.js";
+export declare function buildAmcaIdentifier(tree: Tree): Identifier;
+export declare function amcaGrammarImplementation(): FlavorImplementation;

package/dist/flavors/amca/index.js

@@ -0,0 +1,76 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { amcaGrammar, preprocessAmca } from "./grammar.js";
+import { InterpretationClass, PublicationClass, StandardClass } from "./model.js";
+/**
+ * Port of lib/pubid/amca/builder.rb — dispatch plus the flat
+ * attribute extraction.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const strv = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return undefined;
+        const joined = v.flat(10).map(String).join("");
+        return joined.length > 0 ? joined : undefined;
+    }
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function extractAttributes(parsed) {
+    const attributes = {};
+    if (parsed["copublisher"] !== undefined) {
+        attributes["copublisher"] = strv(parsed["copublisher"]);
+    }
+    if (parsed["code"] !== undefined) {
+        attributes["number"] = strv(parsed["code"]);
+    }
+    if (attributes["year"] === undefined && parsed["year"] !== undefined) {
+        attributes["year"] = strv(parsed["year"]);
+    }
+    if (parsed["suffix"] !== undefined) {
+        attributes["suffix"] = strv(parsed["suffix"]);
+    }
+    if (parsed["reaffirmed"] !== undefined) {
+        attributes["reaffirmed"] = strv(parsed["reaffirmed"]);
+    }
+    return attributes;
+}
+export function buildAmcaIdentifier(tree) {
+    const root = flatten(tree);
+    if (root["publication"] !== undefined || root["publication_keyword"] !== undefined || root["revision"] !== undefined) {
+        const parsed = (isObj(root["publication"]) ? root["publication"] : root);
+        const attributes = extractAttributes(parsed);
+        if (parsed["revision"] !== undefined) {
+            attributes["revision"] = strv(parsed["revision"]);
+        }
+        return new PublicationClass(attributes);
+    }
+    if (root["interpretation"] !== undefined || root["interpretation_code"] !== undefined || root["interp_keyword"] !== undefined) {
+        const parsed = (isObj(root["interpretation"]) ? root["interpretation"] : root);
+        const attributes = extractAttributes(parsed);
+        if (parsed["interpretation_code"] !== undefined) {
+            attributes["interpretation_code"] = strv(parsed["interpretation_code"]);
+        }
+        if (attributes["year"] === undefined && parsed["interpretation_year"] !== undefined) {
+            attributes["year"] = strv(parsed["interpretation_year"]);
+        }
+        return new InterpretationClass(attributes);
+    }
+    if (root["standard"] !== undefined) {
+        return new StandardClass(extractAttributes(root["standard"]));
+    }
+    return new StandardClass(extractAttributes(root));
+}
+export function amcaGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(amcaGrammar, preprocessAmca(input));
+            return buildAmcaIdentifier(tree);
+        },
+    };
+}

package/dist/flavors/amca/model.d.ts

@@ -0,0 +1,29 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type AttributeTable, type FieldMapping } from "../../model/attribute.js";
+/**
+ * Port of lib/pubid/amca: the base class with the shared flat wire,
+ * the three leaf types (Standard, Publication, Interpretation), the
+ * renderer and the URN generator.
+ */
+interface TypeMeta {
+    key: string;
+    title: string;
+    short: string | null;
+}
+export declare abstract class AmcaIdentifier extends BaseIdentifier {
+    static attributes: AttributeTable;
+    static mappings: FieldMapping[];
+    readonly publisher: string | undefined;
+    readonly copublisher: string | undefined;
+    readonly year: string | undefined;
+    readonly suffix: string | undefined;
+    readonly reaffirmed: string | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    abstract typeMeta(): TypeMeta;
+    render(): string;
+}
+export declare const StandardClass: IdentifierStatic;
+export declare const PublicationClass: IdentifierStatic;
+export declare const InterpretationClass: IdentifierStatic;
+export {};

package/dist/flavors/amca/model.js

@@ -0,0 +1,146 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+const BASE_ATTRS = {
+    publisher: { type: "string", default: "AMCA" },
+    copublisher: { type: "string" },
+    year: { type: "string" },
+    suffix: { type: "string" },
+    reaffirmed: { type: "string" },
+};
+const BASE_MAPPINGS = keyValue({ wire: "publisher", to: "publisher" }, { wire: "copublisher", to: "copublisher" }, { wire: "year", to: "year" }, { wire: "suffix", to: "suffix" }, { wire: "reaffirmed", to: "reaffirmed" });
+export class AmcaIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, BASE_ATTRS);
+    static mappings = BASE_MAPPINGS;
+    constructor(attrs = {}) {
+        super(attrs);
+        const self = this;
+        if (self["publisher"] === undefined)
+            self["publisher"] = "AMCA";
+    }
+    render() {
+        return renderBase(this);
+    }
+}
+function renderDocument(id, title) {
+    // "AMCA Standard 803-02 (R2008)": the year joins the number with a
+    // bare dash; the reaffirmation prints with the R prefix.
+    let result = [id.copublisher, title, id.number ?? ""].filter((p) => p !== "").join(" ");
+    if (id.year !== undefined)
+        result += `-${id.year}`;
+    return result;
+}
+function renderBase(id) {
+    let result = renderDocument(id, id.typeMeta().title);
+    if (id.reaffirmed !== undefined)
+        result += ` (R${id.reaffirmed})`;
+    return result;
+}
+class AmcaUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "amca"];
+        if (id.number !== undefined)
+            parts.push(id.number);
+        if (id.year !== undefined)
+            parts.push(id.year);
+        if (id.suffix !== undefined)
+            parts.push(id.suffix.toLowerCase());
+        const code = id.interpretation_code;
+        if (code !== undefined)
+            parts.push(`interp.${code.toLowerCase()}`);
+        const revision = id.revision;
+        if (revision !== undefined)
+            parts.push(`rev.${revision}`);
+        if (id.reaffirmed !== undefined)
+            parts.push(`reaff.${id.reaffirmed}`);
+        if (id.copublisher !== undefined)
+            parts.push(`copub.${id.copublisher.toLowerCase()}`);
+        parts[1] = id.publisher !== undefined ? id.publisher.toLowerCase() : "amca";
+        parts.push(id.typeMeta().key);
+        return parts.join(":");
+    }
+}
+export const StandardClass = (() => {
+    class Standard extends AmcaIdentifier {
+        static polymorphicName = "pubid:amca:standard";
+        static urnGenerator = AmcaUrnGenerator;
+        static attributes = extendAttributes(AmcaIdentifier, {
+            number: { type: "string" },
+        });
+        static mappings = [
+            ...BASE_MAPPINGS,
+            { wire: "number", to: "number" },
+        ];
+        typeMeta() {
+            return { key: "standard", title: "Standard", short: null };
+        }
+    }
+    registerType(Standard);
+    return Standard;
+})();
+export const PublicationClass = (() => {
+    class Publication extends AmcaIdentifier {
+        static polymorphicName = "pubid:amca:publication";
+        static urnGenerator = AmcaUrnGenerator;
+        static attributes = extendAttributes(AmcaIdentifier, {
+            number: { type: "string" },
+            revision: { type: "string" },
+        });
+        static mappings = [
+            ...BASE_MAPPINGS,
+            { wire: "number", to: "number" },
+            { wire: "revision", to: "revision" },
+        ];
+        typeMeta() {
+            return { key: "publication", title: "Publication", short: null };
+        }
+        render() {
+            // The revision and the reaffirmation are separate optional
+            // groups in the grammar, so either or both can appear.
+            let result = renderDocument(this, "Publication");
+            if (this.revision !== undefined)
+                result += ` (Rev. ${this.revision})`;
+            if (this.reaffirmed !== undefined)
+                result += ` (R${this.reaffirmed})`;
+            return result;
+        }
+    }
+    registerType(Publication);
+    return Publication;
+})();
+export const InterpretationClass = (() => {
+    class Interpretation extends AmcaIdentifier {
+        static polymorphicName = "pubid:amca:interpretation";
+        static urnGenerator = AmcaUrnGenerator;
+        static attributes = extendAttributes(AmcaIdentifier, {
+            number: { type: "string" },
+            interpretation_code: { type: "string" },
+        });
+        static mappings = [
+            ...BASE_MAPPINGS,
+            { wire: "number", to: "number" },
+            { wire: "interpretation_code", to: "interpretation_code" },
+        ];
+        typeMeta() {
+            return { key: "interpretation", title: "Interpretation", short: "Interp" };
+        }
+        render() {
+            let result = [this.copublisher, this.number ?? ""].filter((p) => p !== "").join(" ");
+            if (this.interpretation_code !== undefined) {
+                result += ` ${this.interpretation_code} Interp`;
+            }
+            else if (this.year !== undefined) {
+                result += ` – ${this.year}`;
+            }
+            else {
+                result += " Interp";
+            }
+            if (this.suffix !== undefined)
+                result += ` ${this.suffix}`;
+            return result;
+        }
+    }
+    registerType(Interpretation);
+    return Interpretation;
+})();

package/dist/flavors/ansi/index.d.ts

@@ -0,0 +1,24 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { Publisher, Language } from "../../model/component.js";
+export declare const ansiGrammar: Grammar;
+declare class AnsiUrnGenerator extends BaseUrnGenerator<AnsiIdentifier> {
+    generate(): string;
+}
+export declare class AnsiIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof AnsiUrnGenerator;
+    readonly number: string;
+    readonly part: string | undefined;
+    readonly year: string | undefined;
+    readonly publisher: Publisher;
+    readonly copublishers: Publisher[];
+    readonly languages: Language[];
+    render(): string;
+}
+export declare function ansiGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/ansi/index.js

@@ -0,0 +1,147 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { BaseBuilder } from "../../model/builder.js";
+import { Publisher, Language } from "../../model/component.js";
+/**
+ * 1:1 port of lib/pubid/ansi/ on the unified model. Copublishers
+ * (controlled vocabulary) rewrite the URN namespace; the dash segment
+ * serializes as `part` (Ruby Builder split-on-dash), the ":YYYY" form as
+ * `year`; "Std" is consumed and dropped; languages round-trip.
+ */
+const ORGANIZATIONS = ["ISO", "IEC", "IEEE", "SAE", "ASME", "ASTM"];
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const spaceQ = space.maybe();
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const dashDigits = str("-").then(digits).maybe();
+    rule("copublishers", () => str("/")
+        .then(spaceQ, ORGANIZATIONS.reduce((acc, org) => acc.or(str(org)), str(ORGANIZATIONS[0])).as("copublisher"))
+        .repeat(1, Infinity)
+        .as("copublishers"));
+    rule("std_keyword", () => str("Std").then(space).maybe());
+    rule("number_with_part", () => match("[A-Z]")
+        .repeat(1, Infinity)
+        .then(digits, str(".").then(digits).repeat(0, 3), match("[A-Z]").maybe(), dashDigits)
+        .or(digits.then(str(".").then(digits, match("[a-z]").maybe()).repeat(0, 2), dashDigits))
+        .as("number_with_part"));
+    rule("year_digits", () => str("19").or(str("20")).then(match("\\d").repeat(2, 2), digits.absent()));
+    rule("date", () => str(":").then(rules["year_digits"].as("date")));
+    rule("language", () => str("(")
+        .then(match("[a-z]")
+        .repeat(2, Infinity)
+        .then(str(",").maybe())
+        .repeat(0, Infinity)
+        .as("languages"), str(")")));
+    rule("identifier_with_copublishers", () => str("ANSI")
+        .as("publisher")
+        .then(rules["copublishers"], space, rules["std_keyword"])
+        .then(rules["number_with_part"])
+        .then(rules["date"].maybe())
+        .then(rules["language"].maybe()));
+    rule("identifier_sole", () => str("ANSI")
+        .as("publisher")
+        .then(space, rules["std_keyword"], rules["number_with_part"])
+        .then(rules["date"].maybe())
+        .then(rules["language"].maybe()));
+    rule("identifier", () => rules["identifier_with_copublishers"].or(rules["identifier_sole"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ansiGrammar = { rules: buildRules(), root: "root" };
+class AnsiUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "ansi", id.number];
+        if (id.part !== undefined)
+            parts.push(`-${id.part}`);
+        if (id.year !== undefined)
+            parts.push(id.year);
+        if (id.copublishers.length > 0) {
+            parts[1] = ["ansi", ...id.copublishers.map((c) => c.body.toLowerCase())].join("-");
+        }
+        if (id.languages.length > 0) {
+            parts.push(id.languages.map((l) => l.code).join(","));
+        }
+        return parts.join(":");
+    }
+}
+export class AnsiIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:ansi:standard";
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+        part: { type: "string" },
+        year: { type: "string" },
+        copublishers: { type: Publisher, collection: true, initializeEmpty: true },
+        languages: { type: Language, collection: true, initializeEmpty: true },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "year", to: "year" }, { wire: "publisher", to: "publisher" }, { wire: "copublishers", to: "copublishers" }, { wire: "languages", to: "languages" });
+    static urnGenerator = AnsiUrnGenerator;
+    render() {
+        const publisherPortion = this.copublishers.length > 0
+            ? [this.publisher.body, ...this.copublishers.map((p) => p.body)].join("/")
+            : this.publisher.body;
+        let numberPortion = this.number;
+        if (this.part !== undefined)
+            numberPortion += `-${this.part}`;
+        if (this.year !== undefined)
+            numberPortion += `:${this.year}`;
+        let result = `${publisherPortion} ${numberPortion}`;
+        if (this.languages.length > 0)
+            result += `(${this.languages.map((l) => l.code).join(",")})`;
+        return result;
+    }
+}
+registerType(AnsiIdentifier);
+function extractCopublishers(raw) {
+    const list = Array.isArray(raw) ? raw : [raw];
+    return list.map((p) => {
+        const body = typeof p === "object" && p !== null && "copublisher" in p
+            ? String(p["copublisher"])
+            : String(p);
+        return new Publisher({ body });
+    });
+}
+class AnsiBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return AnsiIdentifier;
+    }
+    cast(key, value) {
+        if (key === "number_with_part") {
+            // Ruby Builder: split on "-", first segment = number, second = part.
+            const segments = String(value).split("-");
+            return segments[1] === undefined ? { number: segments[0] } : { number: segments[0], part: segments[1] };
+        }
+        if (key === "publisher") {
+            return { publisher: new Publisher({ body: String(value) }) };
+        }
+        if (key === "copublishers") {
+            return { copublishers: extractCopublishers(value) };
+        }
+        if (key === "date") {
+            return { year: String(value) };
+        }
+        if (key === "languages") {
+            return { languages: this.parseLanguages(value) };
+        }
+        return value;
+    }
+}
+export function ansiGrammarImplementation() {
+    const builder = new AnsiBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ansiGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("ANSI: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

package/dist/flavors/api/grammar.d.ts

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const apiGrammar: Grammar;
+/** Parser#parse normalization: the MPMP typo. */
+export declare function preprocessApi(input: string): string;

package/dist/flavors/api/grammar.js

@@ -0,0 +1,79 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/api/parser.rb — 1:1. Root: identifier.
+ *
+ * Branch order: combined, MPMS, typed, typeless.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    rule("space", () => str(" "));
+    rule("dash", () => str("-"));
+    rule("slash", () => str("/"));
+    rule("colon", () => str(":"));
+    rule("dot", () => str("."));
+    rule("digit", () => match("[0-9]"));
+    rule("digits", () => ref(rules, "digit").repeat(1, Infinity));
+    rule("letter", () => match("[A-Z]"));
+    rule("letters", () => ref(rules, "letter").repeat(1, Infinity));
+    rule("publisher", () => str("API").then(ref(rules, "space")));
+    rule("doc_type", () => str("MPMS").or(str("BULL")).or(str("SPEC")).or(str("STD"))
+        .or(str("RP")).or(str("TR")).or(str("COS")).or(str("PUBL"))
+        .as("type"));
+    rule("chapter_notation", () => ref(rules, "space").then(str("CH")).then(ref(rules, "space"))
+        .then(ref(rules, "digits").as("chapter")));
+    rule("number_with_part", () => match("[0-9A-Z]").repeat(1, Infinity).as("number")
+        .then((ref(rules, "dash").then((match("[0-9A-Z]").repeat(1, Infinity)).as("part"))).maybe()));
+    rule("digits_with_letter", () => ref(rules, "digits").then(ref(rules, "letter").maybe()));
+    rule("year", () => ref(rules, "digit").repeat(4, 4).as("year"));
+    rule("date_dash", () => ref(rules, "dash").then(ref(rules, "year")));
+    rule("date_colon", () => ref(rules, "colon").then(ref(rules, "year")));
+    rule("reaffirmation", () => ref(rules, "space").then(str("(R")).then(ref(rules, "year")).then(str(")")));
+    rule("part_notation", () => str(", Part ").then(ref(rules, "digits").as("part_number")));
+    rule("edition_notation", () => str(", ")
+        .then(ref(rules, "digits").as("edition_number"))
+        .then(str("st").or(str("nd")).or(str("rd")).or(str("th")))
+        .then(str(" edition")));
+    rule("mpms_identifier", () => ref(rules, "publisher")
+        .then(str("MPMS").as("type"))
+        .then(ref(rules, "chapter_notation"))
+        .then((ref(rules, "dot").then(ref(rules, "digits_with_letter").as("section"))).maybe())
+        .then((ref(rules, "dot").then(ref(rules, "digits_with_letter").as("subsection"))).maybe())
+        .then(ref(rules, "date_dash").or(ref(rules, "date_colon")).maybe()));
+    const docTail = () => ref(rules, "number_with_part")
+        .then(ref(rules, "part_notation").maybe())
+        .then(ref(rules, "date_dash").or(ref(rules, "date_colon")).maybe());
+    rule("typed_identifier", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "space"))
+        .then(docTail())
+        .then(ref(rules, "reaffirmation").maybe()));
+    rule("typeless_identifier", () => ref(rules, "publisher")
+        .then(docTail())
+        .then(ref(rules, "reaffirmation").maybe()));
+    rule("second_identifier", () => ref(rules, "doc_type")
+        .then(ref(rules, "space"))
+        .then(docTail()));
+    rule("combined_identifier", () => ref(rules, "mpms_identifier")
+        .or(ref(rules, "typed_identifier"))
+        .or(ref(rules, "typeless_identifier"))
+        .as("first")
+        .then(ref(rules, "slash"))
+        .then(ref(rules, "second_identifier").as("second"))
+        .then(ref(rules, "edition_notation").maybe()));
+    rule("identifier", () => ref(rules, "combined_identifier")
+        .or(ref(rules, "mpms_identifier"))
+        .or(ref(rules, "typed_identifier"))
+        .or(ref(rules, "typeless_identifier")));
+    return rules;
+}
+export const apiGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};
+/** Parser#parse normalization: the MPMP typo. */
+export function preprocessApi(input) {
+    return input.replaceAll("API MPMP", "API MPMS");
+}

package/dist/flavors/api/index.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from "../../grammar/engine.js";
+import type { FlavorImplementation, Identifier } from "../../conformance/implementation.js";
+export declare function buildApiIdentifier(tree: Tree): Identifier;
+export declare function apiGrammarImplementation(): FlavorImplementation;