@pubid/pubid 0.1.5 → 0.1.7

package/README.md

@@ -87,12 +87,28 @@ The conformance gate enforces corpus mode over the whole testsuite on
 every CI run: 42/42 flavors, canonical hash, human form, URN, alias
 normalization, negative rejection and deserialize idempotency.
 
-Grammar-backed parsing (novel identifiers beyond the published corpus)
-lands wave by wave and takes over per flavor — the same gate then
-enforces parity, so a wave can never regress below the floor corpus
-mode set (waves: core model → parser engine → builder → normalizer →
-renderer → urn → iso → iec → …). **No wave has shipped yet**; until one
-does, every flavor is corpus-only.
+## Grammar mode: open-universe runtime parsing
+
+All 42 flavors are grammar-backed and ship the wave plan end to end
+(core model → parser engine → builder → normalizer → renderer → urn →
+per-flavor grammars). Grammar implementations parse real-world
+identifiers far beyond the published corpus — novel spellings, unseen
+numbers, live catalogues — and the conformance gate still enforces
+parity with the corpus floor on every run, so a grammar can never
+regress below what corpus mode set:
+
+```ts
+import { grammarImplementation } from "@pubid/pubid";
+
+const oiml = grammarImplementation("oiml")!;
+oiml.parse("OIML R 60-1:2021");            // any published identifier
+oiml.parse(oiml.parse("OIML R 117-1").toUrn()!); // URNs ingest back
+```
+
+`grammarImplementation` is exported from the package root. URN ingestion
+ships per flavor where the Ruby reference implements a URN parser
+(oiml today; the remaining flavors throw a clear "not yet supported"
+error naming this issue until their ports land).
 
 ## Development
 

package/dist/conformance/implementation.d.ts

@@ -7,6 +7,9 @@
 export interface FlavorImplementation {
     /** Parse a canonical human form; must throw on a bad input. */
     parse(input: string): Identifier;
+    /** Inverse of toUrn for flavors whose reference implements a URN
+     *  parser; when absent, "urn:" inputs throw a not-supported error. */
+    parseUrn?(urn: string): Identifier;
 }
 export interface Identifier {
     /** The canonical serialized form - compared byte-exactly against the corpus identifier record. */

package/dist/flavors/bipm/index.js

@@ -422,6 +422,45 @@ class BipmBuilder {
 export function bipmGrammarImplementation() {
     const builder = new BipmBuilder();
     return {
+        // Inverse of BipmUrnGenerator (lib/pubid/bipm/urn_parser.rb): rebuild
+        // the identifier DIRECTLY from the URN fields — the printed forms carry
+        // surface detail (meeting ordinals, French wording) the URN omits.
+        parseUrn(urn) {
+            const body = urn.replace(/^urn:bipm:/, "");
+            // Keep trailing empty segments (gem splits with -1).
+            const parts = body.split(":");
+            const presence = (v) => v === undefined || v === "" ? undefined : v;
+            if (parts[0] === "metrologia") {
+                return new BipmMetrologiaArticle({
+                    number: presence(parts[1]),
+                    issue: parts[2],
+                    article: parts[3],
+                });
+            }
+            if (parts[0] === "si-brochure") {
+                return new BipmSiBrochure({
+                    number: presence(parts[2]),
+                    language: (parts[1] ?? "").toUpperCase(),
+                    edition: parts[2],
+                    version: parts[3],
+                    years: parts[4],
+                });
+            }
+            const group = (parts[0] ?? "").toUpperCase();
+            if (parts[1] === "meeting") {
+                return new BipmMeeting({
+                    group,
+                    number: parts[2] ?? "",
+                    year: parts[3] ? Number(parts[3]) : undefined,
+                });
+            }
+            return new BipmCommitteeDocument({
+                group,
+                type_code: presence(parts[1])?.toUpperCase(),
+                number: presence(parts[2]),
+                year: parts[3] ? Number(parts[3]) : undefined,
+            });
+        },
         parse(input) {
             const normalized = UPDATE_CODES[input] ?? input;
             const tree = parseGrammar(bipmGrammar, normalized);

package/dist/flavors/iec/index.js

@@ -1,4 +1,5 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { TYPED_STAGES } from "./model.js";
 import { Language, PubidDate } from "../../model/component.js";
 import { iecGrammar, preprocessIec } from "./grammar.js";
 import { locateStage, IEC_CLASSES, } from "./model.js";
@@ -493,6 +494,27 @@ for (const klass of [
 export function iecGrammarImplementation() {
     const builder = new IecBuilder();
     return {
+        // Inverse of the IEC UrnGenerator (lib/pubid/iec/urn_parser.rb):
+        // reassemble the positional URN fields into a text code, parse it, then
+        // attach languages and the all-parts wrap.
+        parseUrn(urn) {
+            const parsed = urnToCode(urn);
+            if (!parsed)
+                throw new Error(`Invalid IEC URN: ${urn}`);
+            const [code, lang, allParts] = parsed;
+            // The reference parses the unprefixed rebuild and its grammar
+            // defaults the IEC publisher; the ts grammar needs it explicit.
+            const id = this.parse(code);
+            if (lang && lang !== "" && "languages" in id) {
+                id.languages = lang
+                    .split("-")
+                    .map((c) => new Language({ code: c }));
+            }
+            if (allParts) {
+                id.all_parts = true;
+            }
+            return id;
+        },
         parse(input) {
             let tree;
             try {
@@ -505,3 +527,61 @@ export function iecGrammarImplementation() {
         },
     };
 }
+// Port of Relaton::Iec.urn_to_code + the slot helpers
+// (lib/pubid/iec/urn_parser.rb): reassemble the positional URN fields into
+// a text code. Returns [code, language, allParts].
+function urnToCode(urn) {
+    const fields = urn.toUpperCase().split(":");
+    if (fields.length < 5)
+        return undefined;
+    const [head, num, date, type, deliv, lang] = fields.slice(3, 9);
+    let allParts = false;
+    let code = head.replaceAll("-", "/");
+    const typeCode = typeSlotToCode(type);
+    if (typeCode !== "")
+        code += ` ${typeCode}`;
+    code += ` ${num}`;
+    if (date !== undefined && date !== "")
+        code += `:${date}`;
+    code += adjunctToCode(fields.slice(9));
+    if ((deliv ?? "").toLowerCase() === "ser") {
+        allParts = true;
+    }
+    else if (deliv !== undefined) {
+        const edition = editionSlotToCode(deliv);
+        if (edition)
+            code += ` ${edition}`;
+        else if (deliv !== "")
+            code += ` ${deliv}`;
+    }
+    return [code, lang?.toLowerCase(), allParts];
+}
+// The type slot holds a legacy type token ("TS"), a stage
+// ("STAGE-10.20"), or both ("TS-STAGE-50.00"); a stage is written back as
+// the abbreviation resolved from the typed-stage registry.
+function typeSlotToCode(type) {
+    if (type === undefined || type === "")
+        return "";
+    const match = type.match(/^([A-Z]+-)?STAGE-([\d.]+)$/);
+    if (!match)
+        return type;
+    const stageType = (match[1] ?? "IS-").replace("-", "").toLowerCase();
+    const stage = TYPED_STAGES.find((t) => t.typeCode === stageType && (t.harmonized ?? "") === match[2]);
+    return stage ? stage.abbr : "";
+}
+// "ED-7" in the deliverable slot is an edition, not a deliverable code.
+function editionSlotToCode(deliv) {
+    const match = deliv?.match(/^ED-(.+)$/);
+    return match ? `ED${match[1]}` : undefined;
+}
+// Adjuncts are (relation, type, number, date) quartets; a "PLUS" relation
+// yields "+", otherwise "/".
+function adjunctToCode(fields) {
+    if (!fields.length)
+        return "";
+    const [rel = "", type = "", num = "", date = ""] = fields.slice(0, 4);
+    let code = (rel === "" ? "/" : "+") + type + num;
+    if (date !== "")
+        code += `:${date}`;
+    return code + adjunctToCode(fields.slice(4));
+}

package/dist/flavors/ieee/index.js

@@ -895,12 +895,21 @@ class IeeeBuilder {
         });
     }
     buildIecIeeCopublished(parsed) {
-        const content = extractValue(parsed["content"]);
+        const contentRaw = extractValue(parsed["content"]);
         let copublishedNumber;
         let draftInfo;
         let iecYear;
         let dateInfo;
-        if (content !== undefined) {
+        let relationships;
+        if (contentRaw !== undefined) {
+            // A bare (unparenthesised) revision narrative printed after the code
+            // is the same relationship prose as the parenthetical form (C3
+            // ruling) — rewrite it into the parenthetical shape so both
+            // spellings collapse onto one canonical.
+            let content = contentRaw;
+            const bare = content.match(/^(.+?) (Revis(?:ion|on) (?:of|to) IEEE Std .+)$/);
+            if (bare !== null)
+                content = `${bare[1]} (${bare[2]})`;
             if (content.includes("IEC:")) {
                 copublishedNumber = content.split(" IEC:")[0]?.trim();
             }
@@ -923,10 +932,35 @@ class IeeeBuilder {
                 if (iecPart !== undefined)
                     iecYear = iecPart.split(" ")[0];
             }
+            // The parenthetical tail is classified, not swallowed (C3 ruling):
+            // a "(Revision of IEEE Std ...)" narrative is a relationship, not
+            // identity — it lands in `relationships` so the URN carries it as
+            // the rel. segment and the canonical human drops it; an "(MM/DD)"
+            // print date is non-identity and dropped; anything else keeps the
+            // historical date_info rendering.
             if (content.includes(" (")) {
                 const datePart = content.split(" (")[1];
                 if (datePart !== undefined && datePart.includes(")")) {
-                    dateInfo = datePart.split(")")[0];
+                    const tail = datePart.split(")")[0];
+                    const revision = tail !== undefined
+                        ? tail.match(/^Revis(?:ion|on) (?:of|to) IEEE Std (.+)$/)
+                        : null;
+                    if (tail !== undefined && revision !== null) {
+                        let related;
+                        try {
+                            related = ieeeParseSingle(revision[1]);
+                        }
+                        catch {
+                            related = { toHuman: () => revision[1] };
+                        }
+                        relationships = [new IeeeRelationship("revision_of", [related], [])];
+                    }
+                    else if (tail !== undefined && /^\d{2}\/\d{2}$/.test(tail)) {
+                        // print date — non-identity, dropped
+                    }
+                    else if (tail !== undefined) {
+                        dateInfo = tail;
+                    }
                 }
             }
         }
@@ -937,6 +971,8 @@ class IeeeBuilder {
             attrs["iec_year"] = iecYear;
         if (dateInfo !== undefined)
             attrs["date_info"] = dateInfo;
+        if (relationships !== undefined)
+            attrs["relationships"] = relationships;
         Object.assign(attrs, copublishedStructured(copublishedNumber));
         return new IecIeeeCopublishedClass(attrs);
     }

package/dist/flavors/ieee/model.js

@@ -474,10 +474,9 @@ export function renderIeeeBase(id) {
             result += `Rev${id.revision}`;
         if (draftObj !== undefined) {
             let printed = draftObj.render();
-            if (iecIeeOnly) {
-                printed = printed.split(", ")[0];
-            }
-            else if (id.publisher === "IEEE" && (id.draft_status ?? "") === "") {
+            // The draft designator carries its date on every lead
+            // (docs/IEEE-DRAFT-STAGES.md §3) — mirrors the ruby render fix.
+            if (id.publisher === "IEEE" && (id.draft_status ?? "") === "") {
                 // The long comma form for dated project drafts; the
                 // unapproved-draft keeps its pinned single-comma form.
                 printed = printed.replace(/, ([A-Z][a-z]+) (\d{4})$/, ", $1, $2");

package/dist/flavors/index.js

@@ -1,3 +1,4 @@
+import { lookupUrnParser, parseUrnFor } from "../urn/parsers.js";
 import { oimlGrammarImplementation } from "./oiml/implementation.js";
 import { xsfGrammarImplementation } from "./xsf/index.js";
 import { doiGrammarImplementation } from "./doi/index.js";
@@ -47,6 +48,32 @@ import { ialaGrammarImplementation } from "./iala/index.js";
  * flavor NOT listed falls back to corpus mode.
  */
 export function grammarImplementation(flavor) {
+    const impl = grammarImplementationSwitch(flavor);
+    if (impl === undefined)
+        return undefined;
+    // "urn:" inputs route to the flavor's URN parser where the reference
+    // implements one (impl.parseUrn or the registry in src/urn/parsers.ts
+    // mirroring lib/pubid/<flavor>/urn_parser.rb); flavors without one whose
+    // own grammar accepts URN spellings keep parsing them natively
+    // (pubid/pubid-ts#1).
+    const urnDef = lookupUrnParser(flavor);
+    if (impl.parseUrn === undefined && urnDef === undefined)
+        return impl;
+    return {
+        parse(input) {
+            if (/^urn:/i.test(input)) {
+                if (impl.parseUrn)
+                    return impl.parseUrn(input);
+                return parseUrnFor(urnDef, input, impl.parse);
+            }
+            return impl.parse(input);
+        },
+        ...(impl.parseUrn
+            ? { parseUrn: impl.parseUrn }
+            : { parseUrn: (urn) => parseUrnFor(urnDef, urn, impl.parse) }),
+    };
+}
+function grammarImplementationSwitch(flavor) {
     switch (flavor) {
         case "oiml":
             return oimlGrammarImplementation();

package/dist/flavors/itu/grammar.js

@@ -61,7 +61,16 @@ function buildRules() {
     rule("attachment", () => space.then(str("attachment").as("attachment")));
     // "ITU-T Q.120-Q.139 (11/1988)" — one document covering a range.
     rule("range_end", () => dash.then(letter.repeat(1, 3).then(dot, digits).as("range_end")));
-    rule("part", () => dash.then(digits.as("part")));
+    rule("date_part", () => space.then(str("("), digits.as("month").then(str("/")).maybe(), digit.repeat(4, 4).as("year"), str(")")));
+    // A "-YYYYMM" approval date — the "200307" of "T-REC-T.4-200307-I" and
+    // "ITU-T T.4-200307". ITU's own edition suffix is short ("-5"), so six
+    // digits that read as a plausible year (19xx/20xx) and month (01-12) are
+    // the date, never a part. A six-digit run that fails either test
+    // ("-200313", "-180001") is still a part, as it was before.
+    rule("yyyymm_year", () => str("19").or(str("20")).then(digit.repeat(2, 2)));
+    rule("yyyymm_month", () => str("0").then(match("[1-9]")).or(str("1").then(match("[0-2]"))));
+    rule("yyyymm_shape", () => rules["yyyymm_year"].then(rules["yyyymm_month"], digit.absent()));
+    rule("part", () => dash.then(rules["yyyymm_shape"].absent(), digits.as("part")));
     rule("parts", () => rules["part"].repeat(0, Infinity).as("parts"));
     // Imp code first: the standard code needs digits, which "Imp712" lacks.
     rule("imp_code", () => str("Imp")
@@ -70,7 +79,21 @@ function buildRules() {
     rule("standard_code", () => rules["number"]
         .then(rules["series_suffix"].maybe(), rules["subseries"].maybe(), rules["parts"], rules["qualifier_glued"].maybe()));
     rule("code", () => rules["imp_code"].or(rules["standard_code"]));
-    rule("date_part", () => space.then(str("("), digits.as("month").then(str("/")).maybe(), digit.repeat(4, 4).as("year"), str(")")));
+    // The status letter that trails the date in a publication id — "I" (in
+    // force) or "S" (superseded). It names the state of the edition, not the
+    // edition, so it is parsed and dropped. "S" is also the Spanish language
+    // suffix, so it is a status ONLY in the full "T-REC-…" id, where ITU
+    // always writes one; after an "ITU-T …-YYYYMM" print form only "I" is,
+    // and "-S" stays the language ("ITU-T Z.100-199911-S").
+    rule("id_status", () => dash.then(match("[IS]"), match("[A-Za-z0-9]").absent()));
+    rule("print_id_status", () => dash.then(str("I"), match("[A-Za-z0-9]").absent()));
+    rule("yyyymm_date", () => dash.then(rules["yyyymm_year"].as("year"), rules["yyyymm_month"].as("month"), digit.absent()));
+    rule("id_date", () => rules["yyyymm_date"].then(rules["print_id_status"].maybe()));
+    // Either date spelling of a Recommendation.
+    rule("document_date", () => rules["date_part"].or(rules["id_date"]));
+    // "ITU-T REC T.4", "ITU-T REC-T.4" — the redundant type word of ITU's
+    // own URLs. Not captured: a Recommendation is the default type.
+    rule("rec_word", () => str("REC").then(space.or(dash)));
     // "(V14)" plus the bare spellings "V2", "v10", "v.1" — all
     // normalise to the parenthesised form on render.
     rule("version_part", () => space.then(str("(V")
@@ -103,9 +126,9 @@ function buildRules() {
         .then(digits.then(dot.then(digits).repeat(0, Infinity)).as("supplement_number")));
     rule("supplement_date", () => space.then(str("("), digits.as("supplement_month").then(str("/")).maybe(), digit.repeat(4, 4).as("supplement_year"), str(")")));
     rule("base_with_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe()));
+        .then(rules["sector"], space, rules["rec_word"].maybe(), rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe()));
     rule("base_without_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe()));
+        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe()));
     // Series-code documents ("EMC-5", "SEC-QKD"): 2+ letter mnemonic,
     // dash-joined number. The OB guard keeps "ITU-T OB-1" a clean parse
     // failure rather than an escaped ArgumentError.
@@ -165,16 +188,39 @@ function buildRules() {
     rule("supplement_identifier", () => rules["chained_supplement"]
         .or(rules["slash_chained_supplement"], rules["supplement_with_base"], rules["supplement_series_only"]));
     rule("with_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"], space, rules["rec_word"].maybe(), rules["series"], dot, rules["code"], rules["range_end"].maybe(), rules["code_suffixes"], rules["combined_suffixes"].maybe(), rules["series_word"].maybe(), rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe(), rules["language"].maybe()));
     rule("without_series", () => rules["itu_prefix"]
-        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"], space, rules["code"], rules["code_suffixes"], rules["attachment"].maybe(), rules["version_part"].maybe(), rules["document_date"].maybe(), rules["language"].maybe()));
     rule("ob_series", () => str("OB").as("series"));
     rule("ob_dot_body", () => dot.then(rules["number"]));
     rule("ob_no_body", () => space.then(str("No."), space, rules["number"]));
+    // "ITU OB 1000" — metanorma-itu's docidentifier ("Annex to ITU OB %").
+    // Accepted as an input spelling only; it renders "ITU OB No. 1000", the
+    // form ITU's own bulletin site uses.
+    rule("ob_bare_body", () => space.then(rules["number"]));
+    // The date as a bulletin prints it — "ITU-T OB.1096 - 15.III.2016": day,
+    // Roman month, year. The months are tried longest first, because PEG
+    // takes the first alternative that matches and "I" would otherwise win
+    // on "III"; "XIII" matches "XII", then fails on the required dot.
+    rule("roman_month", () => str("XII")
+        .or(str("XI"))
+        .or(str("X"))
+        .or(str("IX"))
+        .or(str("VIII"))
+        .or(str("VII"))
+        .or(str("VI"))
+        .or(str("V"))
+        .or(str("IV"))
+        .or(str("III"))
+        .or(str("II"))
+        .or(str("I")));
+    rule("ob_roman_date", () => str(" - ")
+        .then(digit.repeat(2, 2).as("day"), dot, rules["roman_month"].as("roman_month"), dot, digit.repeat(4, 4).as("year")));
+    rule("ob_date", () => rules["date_part"].or(rules["ob_roman_date"]));
     rule("ob_with_sector", () => rules["itu_prefix"]
-        .then(rules["sector"].then(space).maybe(), rules["ob_series"], rules["ob_dot_body"].or(rules["ob_no_body"]), rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"].then(space).maybe(), rules["ob_series"], rules["ob_dot_body"].or(rules["ob_no_body"]).or(rules["ob_bare_body"]), rules["ob_date"].maybe(), rules["language"].maybe()));
     rule("ob_long_form", () => rules["itu_prefix"]
-        .then(rules["sector"].then(space).maybe(), str("Operational Bulletin").as("_op_bull"), space, str("No."), space, rules["number"], rules["date_part"].maybe(), rules["language"].maybe()));
+        .then(rules["sector"].then(space).maybe(), str("Operational Bulletin").as("_op_bull"), space, str("No."), space, rules["number"], rules["ob_date"].maybe(), rules["language"].maybe()));
     rule("special_publication", () => rules["ob_with_sector"].or(rules["ob_long_form"]));
     rule("annex_to_identifier", () => str("Annex to").then(space, rules["special_publication"].as("annex_to")));
     rule("handbook", () => rules["itu_prefix"]
@@ -191,8 +237,24 @@ function buildRules() {
     rule("common_text_twin", () => space
         .then(str("|"), space, match("[^|]").repeat(1, Infinity))
         .as("common_text_twin"));
+    // ITU's publication id — "T-REC-T.4-200307-I",
+    // "R-REC-BO.1130-5-202602-I": <sector>-REC-<number>[-<edition>]-<YYYYMM>
+    // [-<status>], the name ITU gives each edition in its URLs and PDF
+    // files. It builds the plain Recommendation it names and renders in the
+    // print form ("ITU-T T.4 (07/2003)"). The date is required: without it
+    // the string names no edition. No other rule starts with a bare sector
+    // letter, so the slot is free.
+    rule("publication_id", () => rules["sector"]
+        .then(dash, str("REC"), dash, rules["series"], dot, rules["code"], rules["yyyymm_date"], rules["id_status"].maybe(), rules["language"].maybe()));
+    // The Radio Regulations — "ITU-R RR", "ITU-R RR (2020)", and the URL
+    // spelling "ITU-R RR-2020". Always ITU-R. The trailing any.absent? is
+    // load-bearing: PEG ordered choice never re-enters the alternation once
+    // an alternative succeeds, so a partial match on "ITU-R RR.1" must fail
+    // here and fall through to with_series.
+    rule("radio_regulations", () => rules["itu_prefix"]
+        .then(str("R").as("sector"), space, str("RR").as("radio_regulations"), rules["date_part"].or(dash.then(digit.repeat(4, 4).as("year"))).maybe(), rules["language"].maybe(), match(".").absent()));
     rule("identifier", () => rules["annex_to_identifier"]
-        .or(rules["special_publication"], rules["supplement_identifier"], rules["annex_identifier"], rules["appendix_identifier"], rules["report_identifier"], rules["handbook"], rules["numeric_question"], rules["letter_question"], rules["with_series"], rules["contribution"], rules["series_code_identifier"], rules["without_series"]));
+        .or(rules["special_publication"], rules["supplement_identifier"], rules["annex_identifier"], rules["appendix_identifier"], rules["report_identifier"], rules["handbook"], rules["numeric_question"], rules["letter_question"], rules["radio_regulations"], rules["with_series"], rules["contribution"], rules["series_code_identifier"], rules["without_series"], rules["publication_id"]));
     rule("root", () => rules["identifier"]
         .then(rules["common_text_twin"])
         .or(rules["identifier"]));

package/dist/flavors/itu/index.js

@@ -1,7 +1,7 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
 import { PubidDate } from "../../model/component.js";
 import { ituGrammar, normalizeWhitespaceItu } from "./grammar.js";
-import { ITU_CLASSES, ITU_LANGUAGES, ItuCode, ItuDesignation, } from "./model.js";
+import { ITU_CLASSES, ITU_LANGUAGES, ItuCode, ItuDesignation, ItuSpecialPublication, } from "./model.js";
 /**
  * Port of lib/pubid/itu/builder.rb — the exact dispatch order:
  * annex_to → annex_number → appendix_number → OB/_op_bull →
@@ -43,6 +43,9 @@ class ItuBuilder {
         if (tree["appendix_number"] !== undefined) {
             return this.withTwin(this.buildAppendixOfRecommendation(tree), twin);
         }
+        if (tree["radio_regulations"] !== undefined) {
+            return this.withTwin(this.buildRadioRegulations(tree), twin);
+        }
         if ((s(tree["series"]) === "OB" && tree["series_dash"] === undefined) || tree["_op_bull"] !== undefined) {
             return this.withTwin(this.buildSpecialPublication(tree), twin);
         }
@@ -98,17 +101,34 @@ class ItuBuilder {
         });
     }
     buildDate(tree) {
-        return new PubidDate({ year: s(tree["year"]), month: s(tree["month"]) });
+        // The Roman month of a bulletin date ("15.III.2016") is stored as the
+        // two-digit month every other ITU date uses; the day marks the spelling.
+        const roman = s(tree["roman_month"]);
+        const month = roman !== undefined
+            ? (ItuSpecialPublication.ROMAN_MONTHS.indexOf(roman) + 1).toString().padStart(2, "0")
+            : s(tree["month"]);
+        return new PubidDate({ year: s(tree["year"]), month, day: s(tree["day"]) });
     }
-    /** OB is cross-bureau — the sector of legacy strings is dropped. */
+    /** OB keeps the sector of the TSB spelling ("ITU-T OB.1096") — it is a
+     * spelling, not identity (ItuSpecialPublication ignores it in ==). */
     buildSpecialPublication(tree) {
         return new ITU_CLASSES["special_publication"]({
+            sector: s(tree["sector"]),
             series: "OB",
             code: tree["number"] !== undefined ? this.buildCode(tree) : undefined,
             date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
             language: normLanguage(tree["language"]),
         });
     }
+    /** "ITU-R RR (2020)" — the series carries the whole designation. */
+    buildRadioRegulations(tree) {
+        return new ITU_CLASSES["radio_regulations"]({
+            sector: s(tree["sector"]),
+            series: "RR",
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+            language: normLanguage(tree["language"]),
+        });
+    }
     buildAnnexTo(inner) {
         const data = flatten(inner);
         const base = this.buildSpecialPublication(data);

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

@@ -78,6 +78,13 @@ export declare class ItuHandbook extends ItuIdentifier {
     renderBase(): string;
 }
 export declare class ItuSpecialPublication extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    static ROMAN_MONTHS: string[];
+    renderBase(): string;
+    private renderObDate;
+}
+export declare class ItuRadioRegulations extends ItuIdentifier {
     static polymorphicName: string;
     static mappings: FieldMapping[];
     renderBase(): string;
@@ -169,6 +176,7 @@ export declare const ITU_CLASSES: {
     readonly report: typeof ItuReport;
     readonly handbook: typeof ItuHandbook;
     readonly special_publication: typeof ItuSpecialPublication;
+    readonly radio_regulations: typeof ItuRadioRegulations;
     readonly contribution: typeof ItuContribution;
     readonly question: typeof ItuQuestion;
     readonly combined: typeof ItuCombinedIdentifier;

package/dist/flavors/itu/model.js

@@ -218,6 +218,11 @@ const SUPPLEMENT_MAPPINGS = keyValue({ wire: "sector", to: "sector", toWire: (m)
 function urnDateSegment(id) {
     if (!(id.date instanceof PubidDate))
         return undefined;
+    // Only an Operational Bulletin's printed date carries a day
+    // ("15.III.2016"); it is in `==`, so it must reach the URN too.
+    if (id.date.day !== undefined && id.date.month !== undefined) {
+        return `${id.date.day}/${id.date.month}/${id.date.year}`;
+    }
     return id.date.month !== undefined ? `${id.date.month}/${id.date.year}` : id.date.year;
 }
 export class ItuUrnGenerator extends BaseUrnGenerator {
@@ -245,7 +250,14 @@ export class ItuUrnGenerator extends BaseUrnGenerator {
     }
     generateBaseUrn(id) {
         const parts = ["urn", "itu"];
-        parts.push(id.sector !== undefined ? id.sector.toLowerCase() : "itu");
+        // An Operational Bulletin is cross-bureau: its sector is a spelling,
+        // not identity (see ItuSpecialPublication), so it stays out of the URN.
+        if (id.sector !== undefined && !(id instanceof ItuSpecialPublication)) {
+            parts.push(id.sector.toLowerCase());
+        }
+        else {
+            parts.push("itu");
+        }
         // Reports number independently of Recommendations — the marker must
         // reach the URN or the two same-numbered documents collide.
         if (id instanceof ItuReport)
@@ -338,18 +350,43 @@ attachUrn(ItuHandbook);
 export class ItuSpecialPublication extends ItuIdentifier {
     static polymorphicName = "pubid:itu:special-publication";
     static mappings = STANDARD_MAPPINGS;
+    static ROMAN_MONTHS = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"];
     renderBase() {
-        let result = `ITU ${this.series} No. ${this.code?.number ?? ""}`;
-        if (this.date instanceof PubidDate) {
-            result += this.date.month !== undefined
-                ? ` (${this.date.month.padStart(2, "0")}/${this.date.year})`
-                : ` (${this.date.year})`;
+        const number = this.code?.number ?? "";
+        const result = this.sector !== undefined
+            ? `ITU-${this.sector} ${this.series}.${number}`
+            : `ITU ${this.series} No. ${number}`;
+        return result + this.renderObDate();
+    }
+    renderObDate() {
+        if (!(this.date instanceof PubidDate))
+            return "";
+        if (this.date.day !== undefined && this.date.month !== undefined) {
+            const roman = ItuSpecialPublication.ROMAN_MONTHS[Number(this.date.month) - 1] ?? "";
+            return ` - ${this.date.day.padStart(2, "0")}.${roman}.${this.date.year}`;
         }
-        return result;
+        if (this.date.month !== undefined) {
+            return ` (${this.date.month.padStart(2, "0")}/${this.date.year})`;
+        }
+        return ` (${this.date.year})`;
     }
 }
 registerType(ItuSpecialPublication);
 attachUrn(ItuSpecialPublication);
+// The ITU Radio Regulations — the treaty text revised by each World
+// Radiocommunication Conference (hand-off itu-relaton-query-forms).
+// It has no document number: "RR" is the whole designation, stored as
+// the series; "ITU-R RR-2020" (URL spelling) normalizes to
+// "ITU-R RR (2020)".
+export class ItuRadioRegulations extends ItuIdentifier {
+    static polymorphicName = "pubid:itu:radio-regulations";
+    static mappings = STANDARD_MAPPINGS;
+    renderBase() {
+        return `ITU-${this.sector} ${this.series}${this.dateSuffix()}`;
+    }
+}
+registerType(ItuRadioRegulations);
+attachUrn(ItuRadioRegulations);
 export class ItuContribution extends ItuIdentifier {
     static polymorphicName = "pubid:itu:contribution";
     static mappings = STANDARD_MAPPINGS;
@@ -585,6 +622,7 @@ export const ITU_CLASSES = {
     report: ItuReport,
     handbook: ItuHandbook,
     special_publication: ItuSpecialPublication,
+    radio_regulations: ItuRadioRegulations,
     contribution: ItuContribution,
     question: ItuQuestion,
     combined: ItuCombinedIdentifier,