@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/gost/prefix_routes.js

@@ -0,0 +1,192 @@
+/**
+ * GENERATED from the Ruby gem (Pubid.prefix_flavors after
+ * eager_load_flavors!) — the prefix→flavors routing table. Regenerate
+ * from the pubid gem with:
+ *   bundle exec ruby -e 'require "pubid"; Pubid.eager_load_flavors!;
+ *     require "json"; puts JSON.pretty_generate(Pubid.prefix_flavors
+ *     .transform_values { |v| v.sort })'
+ * Do not edit by hand.
+ *
+ * Used by the gost flavor's foreign-adoption routing (prefix_owner in
+ * index.ts): the single flavor owning the longest matching prefix parses
+ * the adopted identifier; joint prefixes (ISO/IEC, ANSI/AMCA…) fall
+ * through to the sorted fallback loop.
+ */
+export const PREFIX_ROUTES = {
+    "10.": ["doi"],
+    "3GPP": ["tgpp"],
+    "AI": ["nist"],
+    "AMCA": ["amca"],
+    "AMS": ["nist"],
+    "ANSI": ["ansi"],
+    "ANSI/AMCA": ["amca", "ansi"],
+    "ANSI/ASHRAE": ["ansi", "ashrae"],
+    "API": ["api"],
+    "ASHRAE": ["ashrae"],
+    "ASME": ["asme"],
+    "ASTM": ["astm"],
+    "ATN": ["adobe"],
+    "Adobe": ["adobe"],
+    "BCP": ["ietf"],
+    "BH": ["nist"],
+    "BIP": ["bsi"],
+    "BIPM": ["bipm"],
+    "BMS": ["nist"],
+    "BS": ["bsi"],
+    "BS EN": ["bsi"],
+    "BS EN IEC": ["bsi"],
+    "BS EN ISO": ["bsi"],
+    "BS IEC": ["bsi"],
+    "BS ISO": ["bsi"],
+    "BSI": ["bsi"],
+    "BSS": ["nist"],
+    "CC": ["calconnect"],
+    "CCAUV": ["bipm"],
+    "CCEM": ["bipm"],
+    "CCL": ["bipm"],
+    "CCM": ["bipm"],
+    "CCPR": ["bipm"],
+    "CCQM": ["bipm"],
+    "CCRI": ["bipm"],
+    "CCSDS": ["ccsds"],
+    "CCT": ["bipm"],
+    "CCTF": ["bipm"],
+    "CCU": ["bipm"],
+    "CEN": ["cen_cenelec"],
+    "CGPM": ["bipm"],
+    "CHIPS": ["nist"],
+    "CIE": ["cie"],
+    "CIPM": ["bipm"],
+    "CIRC": ["nist"],
+    "CISPR": ["iec"],
+    "CJ": ["gb"],
+    "CJ/T": ["gb"],
+    "CLC": ["cen_cenelec"],
+    "CR": ["cen_cenelec"],
+    "CRPL": ["nist"],
+    "CS": ["nist"],
+    "CSA": ["csa"],
+    "CSM": ["nist"],
+    "CSWP": ["nist"],
+    "CWA": ["cen_cenelec"],
+    "DB": ["gb"],
+    "DB/T": ["gb"],
+    "DB/Z": ["gb"],
+    "DD": ["bsi"],
+    "DL": ["gb"],
+    "DL/T": ["gb"],
+    "DOI:": ["doi"],
+    "EAB": ["nist"],
+    "ECMA": ["ecma"],
+    "EN": ["cen_cenelec"],
+    "ENV": ["cen_cenelec"],
+    "EP": ["bsi"],
+    "ES": ["cen_cenelec"],
+    "ETSI": ["etsi"],
+    "EVS": ["evs"],
+    "EVS EN": ["evs"],
+    "EVS EN ISO": ["evs"],
+    "EVS EN ISO/IEC": ["evs"],
+    "EVS-EN": ["evs"],
+    "EVS-EN ISO": ["evs"],
+    "EVS-EN ISO/IEC": ["evs"],
+    "FIPS": ["nist"],
+    "FYI": ["ietf"],
+    "GB": ["gb"],
+    "GB/T": ["gb"],
+    "GB/Z": ["gb"],
+    "GBn": ["gb"],
+    "GBn/T": ["gb"],
+    "GBn/Z": ["gb"],
+    "GCR": ["nist"],
+    "GOST": ["gost"],
+    "HB": ["bsi", "gb", "nist"],
+    "HB/T": ["gb"],
+    "HD": ["cen_cenelec"],
+    "HJ": ["gb"],
+    "HJ/T": ["gb"],
+    "IALA": ["iala"],
+    "IANA": ["iana"],
+    "IDF": ["idf"],
+    "IEC": ["iec"],
+    "IEC/ISO": ["iec", "iso"],
+    "IECEE": ["iec"],
+    "IECEx": ["iec"],
+    "IECQ": ["iec"],
+    "IEEE": ["ieee"],
+    "IHO": ["iho"],
+    "IR": ["nist"],
+    "ISBN": ["isbn"],
+    "ISO": ["iso"],
+    "ISO/IEC": ["iec", "iso"],
+    "ISO/IEC/IEEE": ["iec", "ieee", "iso"],
+    "ITU": ["itu"],
+    "JB": ["gb"],
+    "JB/T": ["gb"],
+    "JCGM": ["jcgm"],
+    "JCRB": ["bipm"],
+    "JG": ["gb"],
+    "JG/T": ["gb"],
+    "JIS": ["jis"],
+    "JPCRD": ["nist"],
+    "JRES": ["nist"],
+    "LCIRC": ["nist"],
+    "MH": ["gb"],
+    "MH/T": ["gb"],
+    "MONO": ["nist"],
+    "MP": ["nist"],
+    "Metrologia": ["bipm"],
+    "NA": ["bsi"],
+    "NBS": ["nist"],
+    "NCSTAR": ["nist"],
+    "NIST": ["nist"],
+    "NSRDS": ["nist"],
+    "NWIRP": ["nist"],
+    "NY": ["gb"],
+    "NY/T": ["gb"],
+    "OASIS": ["oasis"],
+    "OGC": ["ogc"],
+    "OIML": ["oiml"],
+    "OMG": ["omg"],
+    "OWMWP": ["nist"],
+    "PAS": ["bsi"],
+    "PC": ["nist"],
+    "PD": ["bsi"],
+    "PLATEAU": ["plateau"],
+    "PMG": ["easc"],
+    "PP": ["bsi"],
+    "QB": ["gb"],
+    "QB/T": ["gb"],
+    "RB": ["nist"],
+    "RFC": ["ietf"],
+    "RMG": ["easc"],
+    "RPT": ["nist"],
+    "SAE": ["sae"],
+    "SIBS": ["nist"],
+    "SL": ["gb"],
+    "SL/T": ["gb"],
+    "SP": ["nist"],
+    "STD": ["ietf"],
+    "T/": ["gb"],
+    "TB": ["gb"],
+    "TB/T": ["gb"],
+    "TD": ["gb"],
+    "TD/T": ["gb"],
+    "TIBM": ["nist"],
+    "TN": ["nist"],
+    "TS": ["bsi"],
+    "TTB": ["nist"],
+    "UN": ["un"],
+    "VTS": ["nist"],
+    "W3C": ["w3c"],
+    "XEP": ["xsf"],
+    "YY": ["gb"],
+    "YY/T": ["gb"],
+    "ZB": ["gb"],
+    "ZB/T": ["gb"],
+    "doi:": ["doi"],
+    "draft": ["ietf"],
+    "ГОСТ": ["gost"],
+    "ПМГ": ["easc"],
+    "РМГ": ["easc"],
+};

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

@@ -0,0 +1,32 @@
+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";
+export declare const ialaGrammar: Grammar;
+export declare class IalaIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly number: string | undefined;
+    readonly edition: string | undefined;
+    readonly language: string | undefined;
+    /** Single-letter type code (S, R, GA, …). */
+    typeLetter(): string | undefined;
+    render(): string;
+}
+declare class IalaUrnGenerator extends BaseUrnGenerator<IalaIdentifier> {
+    generate(): string;
+}
+export declare class IalaAnnex extends IalaIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof IalaUrnGenerator;
+    readonly base: IalaIdentifier | undefined;
+    readonly annex_form: string | undefined;
+    readonly letter: string | undefined;
+    typeLetter(): string | undefined;
+    render(): string;
+}
+export declare function ialaGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/iala/index.js

@@ -0,0 +1,300 @@
+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";
+/**
+ * 1:1 port of lib/pubid/iala/ — 706 corpus rows. Typed prefixes
+ * (S/R/G/M/C/A/GA/L/X/P), class-driven zero-padding (4 for S/R/G/M/C,
+ * 2+2 dotted for GA, verbatim for the rest), "Ed 2.0" and ":ed2.0"
+ * edition forms, (F) languages, and Annex wrappers. URN is the MRN
+ * form: urn:mrn:iala:pub:<lower-code>[:ed<n>][:<lang>].
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const dash = str("-");
+    const colon = str(":");
+    const dot = str(".");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    // GA before G, or G is left with a dangling "A".
+    rule("type_letter", () => str("GA")
+        .or(str("S"), str("R"), str("G"), str("M"), str("C"), str("A"), str("L"), str("X"), str("P"))
+        .as("type_letter"));
+    // Any length: the dataset zero-pads ("S1070") but canonical unpadded
+    // forms ("M1", "GA1.1") also round-trip.
+    rule("doc_number", () => match("[0-9]").repeat(1, Infinity).as("doc_number"));
+    rule("dotted_number", () => dot.then(digits));
+    rule("number_with_dots", () => rules["doc_number"].then(rules["dotted_number"].repeat(0, Infinity).as("doc_number_dots")));
+    // "-1", "-9-10" — repeated, captured as a list.
+    rule("subpart", () => dash.then(digits.as("subpart_number")).repeat(1, Infinity).as("subpart"));
+    rule("code", () => rules["type_letter"].then(rules["number_with_dots"], rules["subpart"].maybe()));
+    const editionValue = () => digits.then(dot.then(digits).repeat(0, Infinity)).as("edition_value");
+    rule("edition_human", () => space.then(str("Ed"), space, editionValue()).as("edition"));
+    rule("edition_compact", () => colon.then(str("ed"), editionValue()).as("edition"));
+    rule("edition", () => rules["edition_human"].or(rules["edition_compact"]));
+    rule("language", () => space
+        .maybe()
+        .then(str("("), str("E").or(str("F"), str("S"), str("C"), str("A"), str("R")).as("language"), str(")"))
+        .as("language_group"));
+    rule("publisher", () => str("IALA").then(space).maybe());
+    // The letter's absent-lowercase guard keeps "Ed 1"'s E from being
+    // mis-captured as an annex letter.
+    rule("annex_identifier", () => rules["publisher"]
+        .then(rules["type_letter"], rules["number_with_dots"], rules["subpart"].maybe())
+        .as("base")
+        .then(space, str("Annex").or(str("ANNEX")).as("annex_marker"), space
+        .then(match("[A-Z]").as("annex_letter"), match("[a-z]").absent())
+        .maybe(), rules["edition"].maybe(), rules["language"].maybe()));
+    rule("identifier", () => rules["annex_identifier"].or(rules["publisher"]
+        .then(rules["code"], rules["edition"].maybe(), rules["language"].maybe())));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ialaGrammar = { rules: buildRules(), root: "root" };
+const BASE_MAPPINGS = keyValue({ wire: "number", to: "number" }, { wire: "edition", to: "edition" }, { wire: "language", to: "language" });
+export class IalaIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:iala:identifier";
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisher: { type: "string", default: "IALA" },
+        number: { type: "string" },
+        edition: { type: "string" },
+        language: { type: "string" },
+    });
+    static mappings = BASE_MAPPINGS;
+    /** Single-letter type code (S, R, GA, …). */
+    typeLetter() {
+        return this.constructor.typeLetter;
+    }
+    render() {
+        let rendered = `IALA ${this.typeLetter() ?? ""}${this.number ?? ""}`;
+        if (this.edition !== undefined)
+            rendered += ` Ed ${this.edition}`;
+        if (this.language !== undefined)
+            rendered += ` (${this.language})`;
+        return rendered;
+    }
+}
+class IalaUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        if (id instanceof IalaAnnex) {
+            const parts = ["urn:mrn:iala:pub", `${id.base.typeLetter()?.toLowerCase()}${id.base.number}`];
+            parts.push(id.letter !== undefined ? `annex-${id.letter.toLowerCase()}` : "annex");
+            if (id.edition !== undefined)
+                parts.push(`ed${id.edition}`);
+            if (id.language !== undefined)
+                parts.push(id.language.toLowerCase());
+            return parts.join(":");
+        }
+        const parts = ["urn:mrn:iala:pub", `${id.typeLetter()?.toLowerCase()}${id.number}`];
+        if (id.edition !== undefined)
+            parts.push(`ed${id.edition}`);
+        if (id.language !== undefined)
+            parts.push(id.language.toLowerCase());
+        return parts.join(":");
+    }
+}
+const IALA_TYPES = [
+    { kind: "standard", letter: "S", numberWidth: 4 },
+    { kind: "recommendation", letter: "R", numberWidth: 4 },
+    { kind: "guideline", letter: "G", numberWidth: 4 },
+    { kind: "manual", letter: "M", numberWidth: 4 },
+    { kind: "model-course", letter: "C", numberWidth: 4 },
+    { kind: "advice", letter: "A" },
+    { kind: "general-assembly", letter: "GA", numberWidth: 2, dottedSegmentWidth: 2 },
+    { kind: "letter", letter: "L" },
+    { kind: "report", letter: "X" },
+    { kind: "resolution", letter: "P" },
+];
+const TYPE_SPECS = new Map(IALA_TYPES.map((t) => [t.letter, t]));
+function ialaClass(spec) {
+    class IalaTypeIdentifier extends IalaIdentifier {
+        static polymorphicName = `pubid:iala:${spec.kind}`;
+        static urnGenerator = IalaUrnGenerator;
+        static typeLetter = spec.letter;
+    }
+    registerType(IalaTypeIdentifier);
+    return IalaTypeIdentifier;
+}
+const KIND_CLASSES = new Map(IALA_TYPES.map((spec) => [spec.letter, ialaClass(spec)]));
+export class IalaAnnex extends IalaIdentifier {
+    static polymorphicName = "pubid:iala:annex";
+    static attributes = extendAttributes(IalaIdentifier, {
+        base: { type: IalaIdentifier },
+        annex_form: { type: "string" },
+        letter: { type: "string" },
+    });
+    // The inherited block merges with the annex's own maps (lutaml
+    // semantics): number/edition/language + base/annex_form/letter.
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "edition", to: "edition" }, { wire: "language", to: "language" }, { wire: "base", to: "base" }, { wire: "annex_form", to: "annex_form" }, { wire: "letter", to: "letter" });
+    static urnGenerator = IalaUrnGenerator;
+    typeLetter() {
+        return undefined;
+    }
+    render() {
+        let rendered = `${this.base?.toHuman() ?? ""} ${this.annex_form ?? ""}`;
+        if (this.letter !== undefined)
+            rendered += ` ${this.letter}`;
+        if (this.edition !== undefined)
+            rendered += ` Ed ${this.edition}`;
+        if (this.language !== undefined)
+            rendered += ` (${this.language})`;
+        return rendered;
+    }
+}
+registerType(IalaAnnex);
+// ---------------------------------------------------------------------------
+// Builder
+// ---------------------------------------------------------------------------
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const s = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const str = Array.isArray(v) ? v.join("") : String(v);
+    return str.length > 0 ? str : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function subpartToS(subpart) {
+    if (Array.isArray(subpart)) {
+        return subpart
+            .map((h) => (isObj(h) ? s(h["subpart_number"]) : undefined))
+            .filter((v) => v !== undefined)
+            .join("-");
+    }
+    return s(subpart) ?? "";
+}
+function canonicalBase(base, spec) {
+    return spec.numberWidth !== undefined ? base.padStart(spec.numberWidth, "0") : base;
+}
+function canonicalDots(dots, spec) {
+    if (dots === "")
+        return "";
+    if (spec.dottedSegmentWidth === undefined)
+        return dots;
+    return dots
+        .split(".")
+        .map((seg) => (seg === "" ? seg : seg.padStart(spec.dottedSegmentWidth, "0")))
+        .join(".");
+}
+function buildNumber(hash, spec) {
+    const base = s(hash["doc_number"]);
+    if (base === undefined)
+        return undefined;
+    const dots = canonicalDots(s(hash["doc_number_dots"]) ?? "", spec);
+    let subpartStr = hash["subpart"] !== undefined ? `-${subpartToS(hash["subpart"])}` : "";
+    if (subpartStr === "-")
+        subpartStr = "";
+    return `${canonicalBase(base, spec)}${dots}${subpartStr}`;
+}
+class IalaBuilder {
+    build(data) {
+        const hash = flatten(data);
+        if (hash["annex_marker"] !== undefined)
+            return this.buildAnnex(hash);
+        return this.buildFlat(hash);
+    }
+    buildFlat(hash) {
+        const typeLetter = s(hash["type_letter"])?.toUpperCase();
+        const spec = TYPE_SPECS.get(typeLetter ?? "");
+        if (spec === undefined)
+            throw new ParseFailed(`IALA: unknown type letter ${typeLetter}`, 0);
+        const klass = KIND_CLASSES.get(spec.letter);
+        const attrs = {};
+        const number = buildNumber(hash, spec);
+        if (number !== undefined)
+            attrs["number"] = number;
+        const editionHash = isObj(hash["edition"]) ? flatten(hash["edition"]) : undefined;
+        const edition = editionHash !== undefined ? s(editionHash["edition_value"]) : undefined;
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+        const languageHash = isObj(hash["language_group"]) ? flatten(hash["language_group"]) : undefined;
+        const language = languageHash !== undefined ? s(languageHash["language"])?.toUpperCase() : undefined;
+        if (language !== undefined)
+            attrs["language"] = language;
+        return new klass(attrs);
+    }
+    buildAnnex(hash) {
+        const baseHash = flatten(hash["base"]);
+        const base = this.buildFlat(baseHash);
+        const attrs = {
+            base,
+            annex_form: s(hash["annex_marker"]),
+        };
+        const letter = s(hash["annex_letter"]);
+        if (letter !== undefined)
+            attrs["letter"] = letter;
+        const editionHash = isObj(hash["edition"]) ? flatten(hash["edition"]) : undefined;
+        const edition = editionHash !== undefined ? s(editionHash["edition_value"]) : undefined;
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+        const languageHash = isObj(hash["language_group"]) ? flatten(hash["language_group"]) : undefined;
+        const language = languageHash !== undefined ? s(languageHash["language"])?.toUpperCase() : undefined;
+        if (language !== undefined)
+            attrs["language"] = language;
+        return new IalaAnnex(attrs);
+    }
+}
+export function ialaGrammarImplementation() {
+    const builder = new IalaBuilder();
+    const parseHuman = (input) => {
+        const tree = parseGrammar(ialaGrammar, input.trim());
+        if (typeof tree !== "object" || tree === null) {
+            throw new ParseFailed("IALA: unexpected parse tree", 0);
+        }
+        return builder.build(tree);
+    };
+    const URN_PREFIX = "urn:mrn:iala:pub:";
+    /**
+     * Parses an MRN URN by reconstructing the human form and re-parsing
+     * (lib/pubid/iala/urn_parser.rb). The edition marker is
+     * case-insensitive with an optional dot ("Ed1.0" / "ed.1.0"), and
+     * the annex casing mirrors the generator: bare "annex" → "Annex",
+     * lettered "annex-a" → "ANNEX A".
+     */
+    const parseUrn = (urn) => {
+        if (!urn.toLowerCase().startsWith(URN_PREFIX)) {
+            throw new ParseFailed(`Invalid IALA URN: ${JSON.stringify(urn)}`, 0);
+        }
+        const parts = urn.slice(URN_PREFIX.length).split(":");
+        const code = parts[0] ?? "";
+        let edition;
+        let language;
+        let annexForm;
+        let annexLetter;
+        for (const seg of parts.slice(1)) {
+            const annexMatch = /^annex(-([a-z]))?$/i.exec(seg);
+            if (annexMatch !== null) {
+                annexLetter = annexMatch[2]?.toUpperCase();
+                annexForm = annexLetter !== undefined ? "ANNEX" : "Annex";
+            }
+            else if (/^ed\.?/i.test(seg)) {
+                edition = seg.replace(/^ed\.?/i, "");
+            }
+            else if (/^[a-z]$/i.test(seg)) {
+                language = seg.toUpperCase();
+            }
+        }
+        let text = `IALA ${code.toUpperCase()}`;
+        if (annexForm !== undefined)
+            text += ` ${annexForm}`;
+        if (annexLetter !== undefined)
+            text += ` ${annexLetter}`;
+        if (edition !== undefined)
+            text += ` Ed ${edition}`;
+        if (language !== undefined)
+            text += ` (${language})`;
+        return parseHuman(text);
+    };
+    return {
+        parse(input) {
+            const identifier = input.toLowerCase().startsWith(URN_PREFIX) ? parseUrn(input) : parseHuman(input);
+            return identifier;
+        },
+    };
+}

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

@@ -0,0 +1,19 @@
+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";
+export declare const ianaGrammar: Grammar;
+declare class IanaUrnGenerator extends BaseUrnGenerator<IanaIdentifier> {
+    generate(): string;
+}
+export declare class IanaIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof IanaUrnGenerator;
+    readonly number: string;
+    readonly sub_registry: string | undefined;
+    render(): string;
+}
+export declare function ianaGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/iana/index.js

@@ -0,0 +1,71 @@
+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";
+/**
+ * 1:1 port of lib/pubid/iana/ on the unified model. Registry slugs; the
+ * top-level slug is stored as `number`, the optional sub-slug under the
+ * `sub_registry` wire name. URN: urn:iana:<slug>[:<sub-slug>] (the Ruby
+ * flavor's own urn_generator, mirrored as a template subclass).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const slug = match("[a-zA-Z0-9._\\-]").repeat(1, Infinity);
+    rule("slug", () => slug);
+    rule("iana_prefix", () => str("IANA").then(str(" ")).maybe());
+    rule("identifier", () => rules["iana_prefix"]
+        .then(slug.as("registry"), str("/").then(slug.as("sub_registry")).maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ianaGrammar = { rules: buildRules(), root: "root" };
+class IanaUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const parts = ["urn", "iana", this.identifier.number];
+        if (this.identifier.sub_registry !== undefined)
+            parts.push(this.identifier.sub_registry);
+        return parts.join(":");
+    }
+}
+export class IanaIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:iana:registry";
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+        sub_registry: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "sub_registry", to: "sub_registry" });
+    static urnGenerator = IanaUrnGenerator;
+    render() {
+        return this.sub_registry === undefined
+            ? `IANA ${this.number}`
+            : `IANA ${this.number}/${this.sub_registry}`;
+    }
+}
+registerType(IanaIdentifier);
+class IanaBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return IanaIdentifier;
+    }
+    cast(key, value) {
+        if (key === "registry")
+            return { number: String(value) };
+        return value;
+    }
+}
+export function ianaGrammarImplementation() {
+    const builder = new IanaBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ianaGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("IANA: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const idfGrammar: Grammar;