@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/oiml/model.js

@@ -0,0 +1,592 @@
+import { ParseFailed } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType, resolveType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+const KIND_BY_TYPE = {
+    B: "basic-publication",
+    D: "document",
+    E: "expert-report",
+    G: "guide",
+    R: "recommendation",
+    S: "seminar-report",
+    V: "vocabulary",
+};
+const TYPE_STRINGS = {
+    "basic-publication": "B",
+    "certification-system": "CS",
+    document: "D",
+    "expert-report": "E",
+    guide: "G",
+    recommendation: "R",
+    "seminar-report": "S",
+    vocabulary: "V",
+};
+function isObj(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str(v) {
+    return v === undefined || v === null ? undefined : String(v);
+}
+/** Ruby Builder#extract_language. */
+function extractLanguage(langData) {
+    if (isObj(langData))
+        return str(langData["language"]);
+    return str(langData);
+}
+/** ---- shared attribute tables (snake_case = default wire names) ---- */
+const SINGLE_ATTRS = {
+    publisher: { type: "string" },
+    language: { type: "string" },
+    parsed_format: { type: "string", default: "short" },
+    number: { type: "string" },
+    part: { type: "string" },
+    subpart: { type: "string" },
+    suffix: { type: "string" },
+    space_suffix: { type: "boolean", default: false },
+    year: { type: "string" },
+    edition: { type: "string" },
+    stage: { type: "string" },
+    iteration: { type: "string" },
+};
+class OimlBase extends BaseIdentifier {
+    effectiveFormat() {
+        return this.parsed_format === "long" ? "long" : "short";
+    }
+}
+/** ---- single documents (CodeNumber + Bulletin) ---- */
+class OimlSingle extends OimlBase {
+    /** Ruby Identifiers::CodeNumber#code. */
+    composedCode() {
+        if (this.number === undefined)
+            return undefined;
+        let result = this.number;
+        if (this.part)
+            result += `-${this.part}`;
+        if (this.subpart)
+            result += `-${this.subpart}`;
+        if (this.suffix)
+            result += `${this.space_suffix ? " " : "-"}${this.suffix}`;
+        return result;
+    }
+    typeString() {
+        return TYPE_STRINGS[this.constructor.polymorphicName.slice("pubid:oiml:".length)] ?? "R";
+    }
+    /** renderSingle — the formatOverride threads through supplement rendering. */
+    render(formatOverride) {
+        const format = formatOverride ?? this.effectiveFormat();
+        let result = `${this.publisher} ${this.typeString()} ${this.composedCode()}`;
+        let usingEditionFormat = false;
+        if (this.edition && this.year) {
+            result += ` ${this.edition} Edition ${this.year}`;
+            usingEditionFormat = true;
+        }
+        else if (this.edition) {
+            result += ` ${this.edition}`;
+            usingEditionFormat = true;
+        }
+        else if (this.year) {
+            if (format === "long") {
+                result += ` Edition ${this.year}`;
+                usingEditionFormat = true;
+            }
+            else {
+                result += `:${this.year}`;
+            }
+        }
+        if (this.stage || this.iteration) {
+            result += " ";
+            if (this.iteration)
+                result += this.iteration;
+            if (this.stage)
+                result += this.stage;
+        }
+        if (this.language) {
+            result +=
+                usingEditionFormat || this.parsed_format === "short_with_space"
+                    ? ` (${this.language})`
+                    : `(${this.language})`;
+        }
+        return result;
+    }
+}
+/** ---- OIML-CS certification-system documents ---- */
+const CS_ATTRS = {
+    ...SINGLE_ATTRS,
+    family: { type: "string" },
+    amendment: { type: "string" },
+    space_separator: { type: "boolean", default: false },
+};
+const CS_MAPPINGS = keyValue(...Object.keys(CS_ATTRS).map((name) => ({ wire: name, to: name })));
+// "OIML-CS PD-05 Edition 6 (Amendment 1)": the number keeps its printed
+// zero padding; the print states an edition instead of a year.
+class OimlCertificationSystem extends OimlSingle {
+    static polymorphicName = "pubid:oiml:certification-system";
+    static attributes = extendAttributes(BaseIdentifier, CS_ATTRS);
+    static mappings = CS_MAPPINGS;
+    render() {
+        let result = `${this.publisher}-CS ${this.family}` +
+            `${this.space_separator ? " " : "-"}${this.number} Edition ${this.edition}`;
+        if (this.amendment)
+            result += ` (Amendment ${this.amendment})`;
+        return result;
+    }
+}
+registerType(OimlCertificationSystem);
+function oimlSingleClass(kind) {
+    const isBulletin = kind === "bulletin";
+    class OimlSingleIdentifier extends OimlSingle {
+        static polymorphicName = `pubid:oiml:${kind}`;
+        static attributes = isBulletin
+            ? extendAttributes(BaseIdentifier, { ...SINGLE_ATTRS, sequence: { type: "string" } })
+            : extendAttributes(BaseIdentifier, SINGLE_ATTRS);
+        render(formatOverride) {
+            if (!isBulletin)
+                return super.render(formatOverride);
+            // renderBulletin
+            if (this.parsed_format === "citation" &&
+                this.year &&
+                this.number &&
+                this.sequence) {
+                return `${this.publisher} Bulletin ${toRoman(Number(this.year) - 1959)}(${Number(this.number)}) ${this.year}${this.number}${this.sequence}`;
+            }
+            let result = `${this.publisher} Bulletin`;
+            if (this.year) {
+                result += ` ${this.year}`;
+                if (this.number)
+                    result += `-${this.number}`;
+                if (this.sequence)
+                    result += `-${this.sequence}`;
+            }
+            if (this.language)
+                result += ` (${this.language})`;
+            return result;
+        }
+    }
+    registerType(OimlSingleIdentifier);
+    return OimlSingleIdentifier;
+}
+const SUPP_ATTRS = {
+    language: { type: "string" },
+    parsed_format: { type: "string", default: "short" },
+    base: { type: OimlSingle },
+    supp_year: { type: "string" },
+    number: { type: "string" },
+    trailing: { type: "boolean", default: false },
+    joined: { type: "boolean", default: false },
+    letter: { type: "string" },
+    year_on_base: { type: "boolean", default: false },
+};
+const SUPP_MAPPINGS = keyValue({ wire: "language", to: "language" }, { wire: "parsed_format", to: "parsed_format" }, { wire: "base", to: "base" }, { wire: "year", to: "supp_year" }, { wire: "number", to: "number" }, { wire: "trailing", to: "trailing" }, { wire: "joined", to: "joined" }, { wire: "letter", to: "letter" }, { wire: "year_on_base", to: "year_on_base" });
+/** ---- supplements (Amendment / Errata) and Annex ---- */
+class OimlSupplement extends OimlBase {
+    supplementType() {
+        const kind = this.constructor.polymorphicName.slice("pubid:oiml:".length);
+        if (kind === "annex")
+            return this.letter ? `Annex ${this.letter}` : "Annexes";
+        return kind === "errata" ? "Errata" : "Amendment";
+    }
+    render() {
+        const kind = this.constructor.polymorphicName.slice("pubid:oiml:".length);
+        if (kind === "annex")
+            return this.renderAnnex();
+        return this.renderSupplement();
+    }
+    /** renderSupplement */
+    renderSupplement() {
+        if (this.joined) {
+            let result = `${stripLanguage(this.base.render())}+${this.supplementType()}`;
+            if (this.supp_year)
+                result += `:${this.supp_year}`;
+            if (this.language)
+                result += ` (${this.language})`;
+            return result;
+        }
+        if (this.trailing) {
+            let result = `${stripLanguage(this.base.render())} ${this.supplementType()}`;
+            if (this.number)
+                result += ` ${this.number}`;
+            if (this.language)
+                result += ` (${this.language})`;
+            return result;
+        }
+        const baseFormat = this.effectiveFormat() !== "short"
+            ? this.effectiveFormat()
+            : this.base.parsed_format === "long"
+                ? "long"
+                : "short";
+        const baseStr = stripLanguage(this.base.render(baseFormat));
+        let result = `${this.supplementType()} (${this.supp_year}) to ${baseStr}`;
+        if (this.language)
+            result += ` (${this.language})`;
+        return result;
+    }
+    /** renderAnnex */
+    renderAnnex() {
+        if (this.year_on_base) {
+            const marker = this.letter ? `Annex ${this.letter}` : "Annexes";
+            let result = `${stripLanguage(this.base.render())} ${marker}`;
+            if (this.language)
+                result += ` (${this.language})`;
+            return result;
+        }
+        const annexFormat = this.effectiveFormat();
+        const baseStr = this.base
+            .render(this.base.parsed_format === "long" ? "long" : "short")
+            .replace(/:.*/, "")
+            .replace(/\s+Edition\s+\d{4}/, "")
+            .replace(/\(.*\)/, "")
+            .trim();
+        let result = baseStr;
+        if (this.letter) {
+            result += ` Annex ${this.letter}`;
+            if (this.supp_year)
+                result += ` Edition ${this.supp_year}`;
+        }
+        else {
+            result += " Annexes";
+            if (this.supp_year) {
+                if (annexFormat === "long") {
+                    result += ` Edition ${this.supp_year}`;
+                }
+                else {
+                    result += `:${this.supp_year}`;
+                }
+            }
+        }
+        if (this.language)
+            result += ` (${this.language})`;
+        return result;
+    }
+}
+function oimlSupplementClass(kind) {
+    class OimlSupplementIdentifier extends OimlSupplement {
+        static polymorphicName = `pubid:oiml:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, SUPP_ATTRS);
+        static mappings = SUPP_MAPPINGS;
+    }
+    registerType(OimlSupplementIdentifier);
+    return OimlSupplementIdentifier;
+}
+const KIND_CLASSES = {};
+for (const kind of [
+    "recommendation", "basic-publication", "document", "guide", "vocabulary",
+    "expert-report", "seminar-report", "bulletin",
+]) {
+    KIND_CLASSES[kind] = oimlSingleClass(kind);
+}
+KIND_CLASSES["certification-system"] = OimlCertificationSystem;
+KIND_CLASSES["amendment"] = oimlSupplementClass("amendment");
+KIND_CLASSES["errata"] = oimlSupplementClass("errata");
+KIND_CLASSES["annex"] = oimlSupplementClass("annex");
+/** ---- URN generator (lib/pubid/oiml/urn_generator.rb, all kinds) ---- */
+class OimlUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const kind = id.constructor.polymorphicName.slice("pubid:oiml:".length);
+        if (kind === "bulletin") {
+            const b = id;
+            const parts = ["urn", "oiml", "bulletin"];
+            if (b.year) {
+                let locator = b.year;
+                if (b.number)
+                    locator += `-${b.number}`;
+                if (b.sequence)
+                    locator += `-${b.sequence}`;
+                parts.push(locator);
+            }
+            if (id.language)
+                parts.push(id.language.toLowerCase());
+            return parts.join(":");
+        }
+        // Certification-system documents: the family-number pair is the
+        // document identity ("cs:pd-05"); the printed edition and trailing
+        // amendment are print states, not URN segments.
+        if (kind === "certification-system") {
+            const cs = id;
+            return ["urn", "oiml", "cs", `${(cs.family ?? "").toLowerCase()}-${cs.number ?? ""}`].join(":");
+        }
+        const isSupp = kind === "amendment" || kind === "errata" || kind === "annex";
+        const single = (isSupp ? id.base : id);
+        const parts = ["urn", "oiml"];
+        // Ruby: `return "r" unless identifier.type` — a supplement has no
+        // type letter, so its URN carries the default "r" (corpus quirk).
+        parts.push(isSupp ? "r" : (TYPE_STRINGS[kind] ?? "r").toLowerCase());
+        // Ruby SupplementIdentifier#code delegates to the wrapped standard.
+        const code = single.composedCode();
+        if (code)
+            parts.push(code);
+        // The trailing-word form keeps the publication year on the base
+        // ("R 138:2009 Amendment 1"); the supplement itself carries only the
+        // ordinal.
+        const year = id.year ??
+            id.supp_year ??
+            (isSupp ? single.year : undefined);
+        if (year)
+            parts.push(year);
+        const stage = id.stage;
+        if (stage)
+            parts.push(stage.toLowerCase());
+        const iteration = id.iteration;
+        if (iteration)
+            parts.push(iteration);
+        if (id.language)
+            parts.push(id.language.toLowerCase());
+        // Ruby's supplement branch appends the ordinal after the language.
+        if (isSupp) {
+            const ordinal = id.number;
+            if (ordinal)
+                parts.push(ordinal);
+        }
+        return parts.join(":");
+    }
+}
+for (const klass of Object.values(KIND_CLASSES)) {
+    klass.urnGenerator = OimlUrnGenerator;
+}
+/** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+// OIML co-publishes some documents jointly with another SDO (ISO so
+// far); the printed reference carries both identifiers joined by "|":
+// "ISO 4064-1:2024|OIML R 49-1:2024". The URN is the OIML side's.
+export class OimlDualPublished extends OimlBase {
+    static polymorphicName = "pubid:oiml:dual-published";
+    static get attributes() {
+        return extendAttributes(OimlBase, {
+            // "string" keeps objects passing through the scalar coercion
+            // untouched (the ieee AdoptedStandard precedent for cross-flavor
+            // members); the constructor coerces bare hashes via the registry.
+            first: { type: "string" },
+            second: { type: "string" },
+        });
+    }
+    static get mappings() {
+        return [
+            { wire: "first", to: "first" },
+            { wire: "second", to: "second" },
+        ];
+    }
+    constructor(attrs = {}) {
+        super(attrs);
+        // The members are cross-flavor (the co-publisher's side arrives as a
+        // bare hash with _type); coerce through the registry - the abstract
+        // BaseIdentifier attribute type cannot dispatch polymorphically.
+        const coerceMember = (v) => {
+            if (v instanceof BaseIdentifier)
+                return v;
+            if (typeof v === "object" && v !== null && "_type" in v) {
+                const klass = resolveType(v["_type"]);
+                if (klass !== undefined) {
+                    return klass.fromHash(v);
+                }
+            }
+            return undefined;
+        };
+        const self = this;
+        const f = coerceMember(self["first"]);
+        const s = coerceMember(self["second"]);
+        if (f !== undefined)
+            self["first"] = f;
+        if (s !== undefined)
+            self["second"] = s;
+    }
+    render() {
+        return `${this.first.toHuman()}|${this.second.toHuman()}`;
+    }
+    toUrn() {
+        // The URN is the OIML side's, whichever position it prints in.
+        const oimlSide = this.second instanceof OimlBase ? this.second : this.first;
+        return oimlSide.toUrn();
+    }
+    root() {
+        return this.second instanceof OimlBase ? this.second : this.first;
+    }
+}
+registerType(OimlDualPublished);
+export function buildOimlIdentifier(tree) {
+    if (!isObj(tree))
+        throw new ParseFailed("OIML: unexpected parse tree", 0);
+    if (tree["cs_series"] !== undefined)
+        return buildCs(tree);
+    if (tree["amd_marker"] !== undefined)
+        return buildShortAmendment(tree);
+    if (tree["base"] !== undefined)
+        return buildSupplement(tree);
+    return buildBaseDocument(tree);
+}
+// OIML-CS documents: family (PD/OD/CID), zero-padded number, the
+// printed "Edition N", and an optional parenthesized trailing
+// amendment. The family-number separator is a spelling flag.
+function buildCs(tree) {
+    const attrs = {
+        publisher: str(tree["publisher"]) ?? "OIML",
+        parsed_format: "short",
+    };
+    const family = str(tree["cs_family"]);
+    if (family !== undefined)
+        attrs["family"] = family;
+    const number = str(tree["number"]);
+    if (number !== undefined)
+        attrs["number"] = number;
+    const edition = str(tree["edition"]);
+    if (edition !== undefined)
+        attrs["edition"] = edition;
+    const amendment = str(tree["cs_amendment"]);
+    if (amendment !== undefined)
+        attrs["amendment"] = amendment;
+    attrs["space_separator"] = tree["cs_separator"] === " ";
+    return new KIND_CLASSES["certification-system"](attrs);
+}
+function buildShortAmendment(tree) {
+    const baseCode = isObj(tree["base_code"]) ? tree["base_code"] : undefined;
+    const base = buildBaseDocument({
+        publisher: tree["publisher"],
+        type: tree["type"],
+        number: baseCode?.["number"],
+        part: baseCode?.["part"],
+        subpart: baseCode?.["subpart"],
+    });
+    const editionFormat = isObj(tree["edition_format"]) ? tree["edition_format"] : undefined;
+    const yearValue = editionFormat ? editionFormat["year"] : tree["year"];
+    const attrs = {
+        publisher: "OIML",
+        base,
+        parsed_format: editionFormat ? "long" : "short",
+    };
+    const suppYear = str(yearValue);
+    if (suppYear !== undefined)
+        attrs["supp_year"] = suppYear;
+    const language = extractLanguage(tree["language"]);
+    if (language !== undefined)
+        attrs["language"] = language;
+    return new KIND_CLASSES["amendment"](attrs);
+}
+function buildSupplement(tree) {
+    const marker = str(tree["trailing_marker"]);
+    const plusMarker = str(tree["plus_marker"]);
+    let kind;
+    if (tree["annex_letter"] !== undefined || tree["annex_marker"] !== undefined) {
+        kind = "annex";
+    }
+    else if (marker === "Errata" || plusMarker === "Errata") {
+        kind = "errata";
+    }
+    else {
+        kind = "amendment";
+    }
+    const base = buildOimlIdentifier(tree["base"]);
+    const editionFormat = isObj(tree["edition_format"]) ? tree["edition_format"] : undefined;
+    const yearValue = editionFormat ? editionFormat["year"] : tree["year"];
+    const attrs = {
+        publisher: "OIML",
+        base,
+        parsed_format: editionFormat ? "long" : "short",
+    };
+    const suppYear = str(yearValue);
+    if (suppYear !== undefined)
+        attrs["supp_year"] = suppYear;
+    const language = extractLanguage(tree["language"]);
+    if (language !== undefined)
+        attrs["language"] = language;
+    const ordinal = str(tree["number"]);
+    if (ordinal !== undefined)
+        attrs["number"] = ordinal;
+    if (marker !== undefined)
+        attrs["trailing"] = true;
+    if (plusMarker !== undefined)
+        attrs["joined"] = true;
+    const letter = str(tree["annex_letter"]);
+    if (letter !== undefined)
+        attrs["letter"] = letter;
+    // Annex with no year of its own but a dated base: the year belongs to
+    // the base and must render glued to it.
+    if (kind === "annex" && !yearValue && base.year)
+        attrs["year_on_base"] = true;
+    return new KIND_CLASSES[kind](attrs);
+}
+function buildBaseDocument(tree) {
+    const type = str(tree["type"]);
+    const kind = type === "Bulletin" ? "bulletin" : KIND_BY_TYPE[type ?? ""] ?? "recommendation";
+    const attrs = {
+        publisher: str(tree["publisher"]) ?? "OIML",
+    };
+    const number = str(tree["number"]);
+    if (number !== undefined)
+        attrs["number"] = number;
+    const part = str(tree["part"]);
+    if (part !== undefined)
+        attrs["part"] = part;
+    const subpart = str(tree["subpart"]);
+    if (subpart !== undefined)
+        attrs["subpart"] = subpart;
+    const codeSuffix = str(tree["code_suffix"]);
+    if (codeSuffix !== undefined)
+        attrs["suffix"] = codeSuffix;
+    if ("space_suffix" in tree)
+        attrs["space_suffix"] = true;
+    const editionFormat = isObj(tree["edition_format"]) ? tree["edition_format"] : undefined;
+    let yearValue;
+    if (editionFormat) {
+        yearValue = editionFormat["year"];
+        const edition = str(editionFormat["edition"]);
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+    }
+    else {
+        yearValue = tree["year"];
+    }
+    const year = str(yearValue);
+    if (year !== undefined)
+        attrs["year"] = year;
+    if (kind === "bulletin")
+        applyBulletinLocator(attrs, tree);
+    attrs["parsed_format"] = editionFormat
+        ? "long"
+        : tree["space_before_lang"] !== undefined
+            ? "short_with_space"
+            : tree["article_id"] !== undefined
+                ? "citation"
+                : "short";
+    const stage = str(tree["stage"]);
+    if (stage !== undefined)
+        attrs["stage"] = stage;
+    const iteration = str(tree["iteration"]);
+    if (iteration !== undefined)
+        attrs["iteration"] = iteration;
+    const language = extractLanguage(tree["language"]);
+    if (language !== undefined)
+        attrs["language"] = language;
+    return new KIND_CLASSES[kind](attrs);
+}
+function applyBulletinLocator(attrs, tree) {
+    const articleId = str(tree["article_id"]);
+    if (articleId) {
+        attrs["year"] = articleId.slice(0, 4);
+        attrs["number"] = articleId.slice(4, 6);
+        attrs["sequence"] = articleId.slice(6, 8);
+        return;
+    }
+    const issue = str(tree["issue"]);
+    if (issue !== undefined)
+        attrs["number"] = issue;
+    const sequence = str(tree["sequence"]);
+    if (sequence !== undefined)
+        attrs["sequence"] = sequence;
+}
+/** ---- shared render helpers ---- */
+function stripLanguage(s) {
+    return s.replace(/\s*\([^)]+\)\s*$/, "").trim();
+}
+function toRoman(n) {
+    const table = [
+        [1000, "M"], [900, "CM"], [500, "D"], [400, "CD"], [100, "C"],
+        [90, "XC"], [50, "L"], [40, "XL"], [10, "X"], [9, "IX"],
+        [5, "V"], [4, "IV"], [1, "I"],
+    ];
+    let out = "";
+    for (const [value, sym] of table) {
+        while (n >= value) {
+            out += sym;
+            n -= value;
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,14 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+export declare const omgGrammar: Grammar;
+export declare class OmgIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly acronym: string;
+    readonly version: string | undefined;
+    readonly part: string | undefined;
+    render(): string;
+}
+export declare function omgGrammarImplementation(): FlavorImplementation;

package/dist/flavors/omg/index.js

@@ -0,0 +1,73 @@
+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 { BaseBuilder } from "../../model/builder.js";
+/**
+ * 1:1 port of lib/pubid/omg/ on the unified model. The Ruby flavor has
+ * no urn_generator, so toUrn() resolves to the base template: only
+ * `part` hits a slot, deriving "urn:omg:-PDF" / bare "urn:omg".
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const acronymChar = match("[A-Za-z0-9+]");
+    const wordBoundary = match("[A-Za-z0-9]").absent();
+    const beta = str(" beta").then(wordBoundary, space.then(match("[0-9]").repeat(1, Infinity), wordBoundary).maybe());
+    const partSeparator = space.or(str("/"));
+    rule("acronym", () => match("[A-Za-z]")
+        .then(acronymChar.repeat(0, Infinity), match("[-/]")
+        .then(acronymChar.repeat(1, Infinity))
+        .repeat(0, Infinity))
+        .as("acronym"));
+    rule("version", () => match("[0-9]")
+        .repeat(1, Infinity)
+        .then(str(".").then(match("[0-9]").repeat(1, Infinity)).repeat(0, Infinity), beta.maybe())
+        .as("version"));
+    rule("part", () => match("[A-Za-z0-9]").repeat(1, Infinity).as("part"));
+    rule("identifier", () => str("OMG").then(space, rules["acronym"], space
+        .then(rules["version"], partSeparator.then(rules["part"]).maybe())
+        .or(space.then(rules["part"]))
+        .maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const omgGrammar = { rules: buildRules(), root: "root" };
+export class OmgIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:omg:specification";
+    static attributes = extendAttributes(BaseIdentifier, {
+        acronym: { type: "string" },
+        version: { type: "string" },
+        part: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "acronym", to: "acronym" }, { wire: "version", to: "version" }, { wire: "part", to: "part" });
+    render() {
+        let result = `OMG ${this.acronym}`;
+        if (this.version !== undefined)
+            result += ` ${this.version}`;
+        if (this.part !== undefined)
+            result += ` ${this.part}`;
+        return result;
+    }
+}
+registerType(OmgIdentifier);
+class OmgBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return OmgIdentifier;
+    }
+}
+export function omgGrammarImplementation() {
+    const builder = new OmgBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(omgGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("OMG: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare const plateauGrammar: Grammar;
+export declare function plateauGrammarImplementation(): FlavorImplementation;