@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/oiml/grammar.js

@@ -0,0 +1,180 @@
+import { match, ref, str, } from "../../grammar/engine.js";
+/**
+ * 1:1 port of lib/pubid/oiml/parser.rb (including CommonParseRules).
+ * Rule names match the Ruby rule names so the two files can be diffed
+ * side by side while porting.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    // --- CommonParseRules ---
+    rule("space", () => str(" "));
+    rule("space?", () => ref(rules, "space").maybe());
+    rule("digits", () => match("\\d").repeat(1));
+    rule("year", () => match("\\d").repeat(4, 4).as("year"));
+    rule("comma", () => str(", "));
+    rule("comma?", () => ref(rules, "comma").maybe());
+    rule("comma_space", () => ref(rules, "comma").or(ref(rules, "space")));
+    rule("dash", () => str("-"));
+    rule("dot", () => str("."));
+    rule("words_digits", () => match("[\\dA-Za-z]").repeat(1));
+    rule("words", () => match("[A-Za-z]").repeat(1));
+    rule("words?", () => ref(rules, "words").maybe());
+    rule("year_digits", () => str("19").or(str("20")).then(match("\\d").repeat(2, 2), ref(rules, "digits").absent()));
+    rule("month_digits", () => match("\\d").repeat(2, 2));
+    rule("day_digits", () => match("\\d").repeat(2, 2));
+    rule("originator", () => ref(rules, "organization")
+        .as("publisher")
+        .then(ref(rules, "space?")
+        .then(str("/"), ref(rules, "organization").as("copublisher"))
+        .repeat(0)));
+    rule("comma_month_year", () => ref(rules, "comma").then(ref(rules, "words").as("month"), str(" "), ref(rules, "year_digits").as("year")));
+    rule("year_month", () => ref(rules, "year_digits").then(ref(rules, "dash"), ref(rules, "month_digits")));
+    // organization: OIML's parser never uses it (publisher is the literal
+    // "OIML"); provide a minimal definition so refs resolve.
+    rule("organization", () => str("OIML"));
+    // --- Additional basic rules not in CommonParseRules ---
+    rule("colon", () => str(":"));
+    rule("lparen", () => str("("));
+    rule("rparen", () => str(")"));
+    rule("slash", () => str("/"));
+    // Main identifier pattern - check supplements first
+    rule("identifier", () => ref(rules, "amendment_identifier")
+        .or(ref(rules, "amendment_short"))
+        .or(ref(rules, "annex_letter_identifier"))
+        .or(ref(rules, "annex_identifier"))
+        .or(ref(rules, "plus_supplement_identifier"))
+        .or(ref(rules, "trailing_supplement_identifier"))
+        .or(ref(rules, "bulletin_identifier"))
+        .or(ref(rules, "base")));
+    // Publisher - always "OIML"
+    rule("publisher", () => str("OIML").as("publisher").then(ref(rules, "space")));
+    // Document type - single letter
+    rule("doc_type", () => match("[BDEGRSVX]").as("type").then(ref(rules, "space")));
+    // Bulletin locator - structured YYYY[-II[-SS]]
+    rule("bulletin_date", () => ref(rules, "space")
+        .then(ref(rules, "year_digits").as("year"))
+        .then(ref(rules, "dash").then(ref(rules, "two_digits").as("issue")).maybe())
+        .then(ref(rules, "dash").then(ref(rules, "two_digits").as("sequence")).maybe()));
+    rule("two_digits", () => match("\\d").repeat(2, 2));
+    rule("roman_numeral", () => match("[IVXLCDM]").repeat(1).as("volume_roman"));
+    // Citation form: LXVII(2) 20260211
+    rule("bulletin_citation", () => ref(rules, "space")
+        .then(ref(rules, "roman_numeral"))
+        .then(ref(rules, "lparen"), ref(rules, "digits").as("issue_arabic"), ref(rules, "rparen"))
+        .then(str(" "), match("\\d").repeat(8, 8).as("article_id")));
+    rule("bulletin_identifier", () => ref(rules, "publisher")
+        .then(str("Bulletin").as("type"))
+        .then(ref(rules, "bulletin_citation").or(ref(rules, "bulletin_date")).maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("number_only", () => ref(rules, "digits").as("number"));
+    rule("part_number", () => ref(rules, "dash").then(ref(rules, "digits")
+        .then(ref(rules, "slash").then(ref(rules, "dash"), ref(rules, "digits")).repeat(0))
+        .as("part")));
+    rule("subpart_number", () => ref(rules, "dash").then(ref(rules, "digits").as("subpart")));
+    rule("named_suffix", () => ref(rules, "dash")
+        .then(str("GUM")
+        .then(ref(rules, "space"), ref(rules, "digits"))
+        .or(match("[A-Za-z]").repeat(1).then(str("_").maybe(), ref(rules, "digits")).repeat(0))
+        .as("code_suffix"))
+        .or(str(" ").then(str("Brochure").as("code_suffix"), str("").as("space_suffix"))));
+    rule("full_number", () => ref(rules, "number_only")
+        .then(ref(rules, "part_number"), ref(rules, "subpart_number"), ref(rules, "named_suffix").maybe())
+        .or(ref(rules, "number_only").then(ref(rules, "part_number"), ref(rules, "named_suffix").maybe()))
+        .or(ref(rules, "number_only").then(ref(rules, "named_suffix").maybe())));
+    rule("edition_number", () => str("6th")
+        .or(str("5th"))
+        .or(str("4th"))
+        .or(str("3rd"))
+        .or(str("2nd"))
+        .or(str("1st"))
+        .or(match("\\d").repeat(1).then(str("th").or(str("nd")).or(str("rd")).or(str("st"))))
+        .as("edition"));
+    rule("edition_text", () => str("Edition").or(str("edition")));
+    rule("edition_portion", () => str(", ")
+        .or(ref(rules, "space"))
+        .then(ref(rules, "edition_number").maybe(), ref(rules, "space?"), ref(rules, "edition_text"), ref(rules, "space?"), ref(rules, "year_digits").as("year"))
+        .as("edition_format"));
+    rule("date", () => ref(rules, "edition_portion")
+        // pubid#403: both sides of the colon are whitespace-tolerant
+        .or(ref(rules, "space?").then(ref(rules, "colon"), ref(rules, "space?"), ref(rules, "year_digits").as("year")))
+        .or(ref(rules, "space?").then(ref(rules, "lparen"), ref(rules, "year_digits").as("year"), ref(rules, "rparen"))));
+    rule("stage_iteration", () => match("\\d").repeat(1).then(str("."), match("\\d").repeat(1)).or(match("\\d").repeat(1)).as("iteration"));
+    rule("stage_abbr", () => str("WD").or(str("CD")).as("stage"));
+    rule("draft_stage", () => ref(rules, "space").then(ref(rules, "stage_iteration").maybe(), ref(rules, "stage_abbr")));
+    // Language codes: two-letter OIML codes before the single letters
+    rule("lang_single", () => match("[EFRXDSCAU]"));
+    rule("lang_multi_oiml", () => str("PO").or(str("PT")).or(str("PE")).or(str("SR")));
+    rule("lang_multi", () => match("[a-z]").repeat(2, 2));
+    rule("language_code", () => ref(rules, "lang_single")
+        .then(ref(rules, "slash"), ref(rules, "lang_single"))
+        .or(ref(rules, "lang_multi_oiml"))
+        .or(ref(rules, "lang_single"))
+        .or(ref(rules, "lang_multi"))
+        .as("language"));
+    rule("language_with_space", () => ref(rules, "space")
+        .then(ref(rules, "lparen"), ref(rules, "language_code"), ref(rules, "rparen"))
+        .then(str("").as("space_before_lang")));
+    rule("language_without_space", () => ref(rules, "lparen").then(ref(rules, "language_code"), ref(rules, "rparen")));
+    rule("language_portion", () => ref(rules, "language_with_space").or(ref(rules, "language_without_space")));
+    // Amendment identifier - "Amendment (YYYY) to BASE"
+    rule("amendment_identifier", () => str("Amendment")
+        .then(ref(rules, "space"), ref(rules, "lparen"), ref(rules, "year_digits").as("year"), ref(rules, "rparen"))
+        .then(str(" "), str("to"), str(" "))
+        .then(ref(rules, "base_without_language").as("base"))
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("amendment_short", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number").as("base_code"))
+        .then(str(" "), str("Amendment").as("amd_marker"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), ref(rules, "space?"), ref(rules, "year_digits").as("year"))
+        .as("edition_format")
+        .or(ref(rules, "colon").then(ref(rules, "space?"), ref(rules, "year_digits").as("year"))))
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("trailing_supplement_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Amendment").or(str("Errata")).as("trailing_marker"))
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("plus_supplement_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str("+"), str("Amendment").or(str("Errata")).as("plus_marker"))
+        .then(ref(rules, "colon").then(ref(rules, "year_digits").as("year")).maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("annex_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Annexes").as("annex_marker"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), str(" "), ref(rules, "year_digits").as("year"))
+        .as("edition_format")
+        .or(ref(rules, "colon").then(ref(rules, "year_digits").as("year")))
+        .maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("annex_letter_value", () => match("[A-Z]").then(ref(rules, "dash").then(match("[A-Z]")).maybe()).as("annex_letter"));
+    rule("annex_letter_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Annex"), str(" "), ref(rules, "annex_letter_value"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), str(" "), ref(rules, "year_digits").as("year"))
+        .or(ref(rules, "colon").then(ref(rules, "year_digits").as("year")))
+        .maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("base_without_language", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number"))
+        .then(ref(rules, "date").maybe())
+        .then(ref(rules, "draft_stage").maybe()));
+    rule("base", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number"))
+        .then(ref(rules, "date").maybe())
+        .then(ref(rules, "draft_stage").maybe())
+        .then(ref(rules, "language_portion").maybe()));
+    return rules;
+}
+export const oimlGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

package/dist/flavors/oiml/implementation.d.ts

@@ -0,0 +1,9 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { ParseFailed } from "../../grammar/engine.js";
+/**
+ * Grammar-backed OIML on the unified model: the model classes are
+ * BaseIdentifier subclasses, so they satisfy the Identifier adapter
+ * directly (toHash/toHuman/toUrn/fromHash come from the model).
+ */
+export declare function oimlGrammarImplementation(): FlavorImplementation;
+export { ParseFailed };

package/dist/flavors/oiml/implementation.js

@@ -0,0 +1,16 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { oimlGrammar } from "./grammar.js";
+import { buildOimlIdentifier } from "./model.js";
+/**
+ * Grammar-backed OIML on the unified model: the model classes are
+ * BaseIdentifier subclasses, so they satisfy the Identifier adapter
+ * directly (toHash/toHuman/toUrn/fromHash come from the model).
+ */
+export function oimlGrammarImplementation() {
+    return {
+        parse(input) {
+            return buildOimlIdentifier(parseGrammar(oimlGrammar, input));
+        },
+    };
+}
+export { ParseFailed };

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

@@ -0,0 +1,4 @@
+import type { Tree } from "../../grammar/engine.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+/** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+export declare function buildOimlIdentifier(tree: Tree): BaseIdentifier;

package/dist/flavors/oiml/model.js

@@ -0,0 +1,462 @@
+import { ParseFailed } 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";
+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",
+    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;
+    }
+}
+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" },
+    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: "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.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["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(":");
+        }
+        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);
+        const year = id.year ??
+            id.supp_year;
+        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());
+        return parts.join(":");
+    }
+}
+for (const klass of Object.values(KIND_CLASSES)) {
+    klass.urnGenerator = OimlUrnGenerator;
+}
+/** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+export function buildOimlIdentifier(tree) {
+    if (!isObj(tree))
+        throw new ParseFailed("OIML: unexpected parse tree", 0);
+    if (tree["amd_marker"] !== undefined)
+        return buildShortAmendment(tree);
+    if (tree["base"] !== undefined)
+        return buildSupplement(tree);
+    return buildBaseDocument(tree);
+}
+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;
+    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;
+}