@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/bsi/model.js

@@ -0,0 +1,863 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { PubidDate, Publisher } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/bsi: the shared base (single_identifier.rb), the
+ * typed-stage registry (bsi.rb TYPED_STAGES_REGISTRY), the ~25 concrete
+ * identifier classes, the renderer (renderer.rb) and the URN generator
+ * (urn_generator.rb).
+ */
+// --- Code component (components/code.rb — wire {value}) ---------------------------
+export class BsiCode {
+    value;
+    constructor(attrs) {
+        this.value = attrs["value"];
+    }
+    render() {
+        return this.value;
+    }
+    toWire() {
+        return { value: this.value };
+    }
+}
+export const TYPED_STAGES_REGISTRY = [
+    { code: "pubbs", stageCode: "published", typeCode: "bs", abbr: ["BS"], name: "British Standard", harmonizedStages: ["60.00", "60.60"] },
+    { code: "drbs", stageCode: "draft", typeCode: "bs", abbr: ["Draft BS", "DBS"], name: "Draft British Standard", harmonizedStages: ["30.00", "30.20", "30.60", "40.00", "40.20", "40.60"] },
+    { code: "pubpd", stageCode: "published", typeCode: "pd", abbr: ["PD"], name: "Published Document", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubpas", stageCode: "published", typeCode: "pas", abbr: ["PAS"], name: "Publicly Available Specification", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubna", stageCode: "published", typeCode: "na", abbr: ["NA"], name: "National Annex", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubdd", stageCode: "published", typeCode: "dd", abbr: ["DD"], name: "Draft Document", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubflex", stageCode: "published", typeCode: "flex", abbr: ["Flex", "BSI Flex"], name: "BSI Flex", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubhandbook", stageCode: "published", typeCode: "handbook", abbr: ["Handbook", "HB"], name: "BSI Handbook", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubpp", stageCode: "published", typeCode: "pp", abbr: ["PP"], name: "Published Practice", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubbip", stageCode: "published", typeCode: "bip", abbr: ["BIP"], name: "British Industrial Practice", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubaerospace", stageCode: "published", typeCode: "aerospace", abbr: ["BS A", "BS AU", "BS C", "BS M", "BS S", "BS L", "BS TA", "BS MA", "BS PL", "BS QC", "BS G", "BS HC", "BS F", "BS X", "BS B"], name: "Aerospace/Specialized British Standard", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubindex", stageCode: "published", typeCode: "index", abbr: ["Index"], name: "BSI Index", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubmethod", stageCode: "published", typeCode: "method", abbr: ["Method", "Methods"], name: "BSI Method", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubsection", stageCode: "published", typeCode: "section", abbr: ["Section"], name: "BSI Section", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubdisc", stageCode: "published", typeCode: "disc", abbr: ["DISC"], name: "DISC", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubdetailed_spec", stageCode: "published", typeCode: "detailed_specification", abbr: ["DETAILED SPEC"], name: "Detailed Specification", harmonizedStages: ["60.00", "60.60"] },
+    { code: "standalone_amendment", stageCode: "published", typeCode: "amendment", abbr: ["AMD"], name: "Amendment", harmonizedStages: ["60.00", "60.60"] },
+    { code: "pubts", stageCode: "published", typeCode: "ts", abbr: ["TS"], name: "Technical Specification", harmonizedStages: ["60.00", "60.60"] },
+];
+export const DEFAULT_TYPED_STAGE = TYPED_STAGES_REGISTRY[0];
+export function locateStage(abbr) {
+    const needle = abbr.trim().toUpperCase();
+    return TYPED_STAGES_REGISTRY.find((s) => s.abbr.some((a) => a.toUpperCase() === needle));
+}
+export const TYPE_CLASSES = {};
+function locateTypeClass(typeCode) {
+    return TYPE_CLASSES[typeCode];
+}
+/** The wrapped document's identity: walks base/adopted chains (CEN
+ * adopted wrappers hold the foreign id under `adopted`) until a node
+ * carries a number. */
+function deepIdentity(id, seen = 0) {
+    if (seen > 6 || id === null || typeof id !== "object")
+        return undefined;
+    const rec = id;
+    // Root semantics: a wrapper's own number never wins over the base
+    // chain (an AMD/FRAG wrapper keys its URN off the BASE document).
+    for (const key of ["base", "adopted"]) {
+        const next = rec[key];
+        if (next !== null && typeof next === "object") {
+            const found = deepIdentity(next, seen + 1);
+            if (found !== undefined)
+                return found;
+        }
+    }
+    // Bundled identifiers key their identity off the first member.
+    const members = rec["identifiers"];
+    if (Array.isArray(members) && members.length > 0) {
+        return deepIdentity(members[0], seen + 1);
+    }
+    if (rec["number"] !== undefined)
+        return id;
+    return undefined;
+}
+/** Wraps a registry entry so the attribute machinery can coerce the
+ * wire's typed_stage block back into the runtime state. */
+export class BsiTypedStageRef {
+    code;
+    stageCode;
+    typeCode;
+    abbr;
+    name;
+    harmonizedStages;
+    constructor(attrs) {
+        const e = attrs;
+        this.code = e.code;
+        this.stageCode = e.stageCode;
+        this.typeCode = e.typeCode;
+        this.abbr = e.abbr;
+        this.name = e.name;
+        this.harmonizedStages = e.harmonizedStages;
+    }
+}
+class BsiUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "bsi"];
+        if (id.publisher !== undefined) {
+            parts.push(id.publisher.render("urn"));
+        }
+        else {
+            parts.push("bs");
+        }
+        if (id.prefix !== undefined)
+            parts.push(id.prefix.toLowerCase());
+        if (id.flex_prefix !== undefined)
+            parts.push(id.flex_prefix.toLowerCase());
+        // Identity reads walk to the wrapped document when the wrapper has
+        // none of its own; adopted foreign chains (CEN adopted wrappers)
+        // are walked through both the `base` and `adopted` keys.
+        const rootRecord = deepIdentity(id);
+        const root = rootRecord;
+        const urnNumber = id.number ?? (rootRecord !== undefined ? rootRecord.number : undefined);
+        if (urnNumber !== undefined) {
+            let number = urnNumber;
+            if (id.iteration !== undefined && id.iteration !== "") {
+                number += `[${id.iteration}]`;
+            }
+            parts.push(number);
+        }
+        const urnPart = id.part ?? (root !== undefined && rootRecord !== undefined && rootRecord !== id ? rootRecord.part : undefined);
+        if (urnPart !== undefined)
+            parts.push(`-${urnPart}`);
+        const urnSubpart = id.subpart ?? (root !== undefined && rootRecord !== undefined && rootRecord !== id ? rootRecord.subpart : undefined);
+        if (urnSubpart !== undefined)
+            parts.push(`-${urnSubpart}`);
+        if (id.second_number !== undefined)
+            parts.push(`/${id.second_number.render()}`);
+        const urnDate = id.date ?? (root !== undefined && rootRecord !== undefined && rootRecord !== id ? rootRecord.date : undefined);
+        if (urnDate?.present()) {
+            parts.push(urnDate.render("urn"));
+        }
+        else {
+            const urnYear = id.year
+                ?? (root !== undefined && rootRecord !== undefined && rootRecord !== id ? rootRecord.year : undefined);
+            if (urnYear !== undefined)
+                parts.push(urnYear);
+        }
+        if (id.month !== undefined)
+            parts.push(pad2(id.month));
+        if (id.edition !== undefined)
+            parts.push(`v${id.edition}`);
+        if (id.translation_lang !== undefined)
+            parts.push(id.translation_lang.toLowerCase());
+        else if (id.translation_upper !== undefined)
+            parts.push(id.translation_upper.toLowerCase());
+        const typedStage = id.typedStage;
+        if (typedStage !== undefined && typedStage.code !== "pubbs") {
+            parts.push(typedStage.typeCode);
+            parts.push(`stage.${typedStage.stageCode}`);
+        }
+        return parts.join(":");
+    }
+}
+// --- The base class ----------------------------------------------------------------
+export class BsiIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:bsi:identifier";
+    static urnGenerator = BsiUrnGenerator;
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisher: { type: Publisher, default: new Publisher({ body: "BS" }) },
+        prefix: { type: "string" },
+        flex_prefix: { type: "string" },
+        number: { type: "string" },
+        iteration: { type: "string" },
+        part: { type: "string" },
+        subpart: { type: "string" },
+        second_number: { type: BsiCode },
+        date: { type: PubidDate },
+        edition: { type: "string" },
+        month: { type: "integer" },
+        translation_lang: { type: "string" },
+        translation_upper: { type: "string" },
+        explicit_prefix: { type: "boolean", default: false },
+        explicit_publisher: { type: "boolean", default: false },
+        space_separated_part: { type: "boolean", default: false },
+        typedStage: { type: BsiTypedStageRef },
+    });
+    /** The gem serializes the full typed-stage registry entry (type,
+     * stage, typed_stage blocks) for every non-default typed stage. */
+    static compactHash = (model, hash) => {
+        const ts = model.typedStage;
+        if (ts === undefined || ts.code === "pubbs")
+            return;
+        hash["type"] = { name: ts.name, abbr: ts.abbr[0], type_code: ts.typeCode };
+        hash["stage"] = { name: ts.name, stage_code: ts.stageCode, harmonized_stages: ts.harmonizedStages, abbr: ts.abbr[0] };
+        hash["typed_stage"] = { name: ts.name, code: ts.code, type_code: ts.typeCode, stage_code: ts.stageCode, abbr: ts.abbr, harmonized_stages: ts.harmonizedStages };
+    };
+    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "prefix", to: "prefix" }, { wire: "flex_prefix", to: "flex_prefix" }, { wire: "number", to: "number" }, { wire: "iteration", to: "iteration" }, { wire: "part", to: "part" }, { wire: "subpart", to: "subpart" }, { wire: "second_number", to: "second_number" }, { wire: "date", to: "date" }, { wire: "edition", to: "edition" }, { wire: "month", to: "month" }, { wire: "translation_lang", to: "translation_lang" }, { wire: "translation_upper", to: "translation_upper" }, { wire: "explicit_prefix", to: "explicit_prefix" }, { wire: "explicit_publisher", to: "explicit_publisher" }, { wire: "space_separated_part", to: "space_separated_part" }, {
+        wire: "typed_stage",
+        to: "typedStage",
+        fromWire: (h) => {
+            const code = h["typed_stage"];
+            if (code === undefined || code === null || typeof code === "string")
+                return undefined;
+            const entry = code["code"];
+            return TYPED_STAGES_REGISTRY.find((t) => t.code === entry);
+        },
+        toWire: () => undefined,
+    }, {
+        // The consolidated wrapper carries only the `type` block; its
+        // typed stage derives from the type_code.
+        wire: "type",
+        to: "typedStage",
+        fromWire: (h) => {
+            const t = h["type"];
+            if (t === undefined || t === null || typeof t !== "object")
+                return undefined;
+            const tc = t["type_code"];
+            return tc === undefined ? undefined : TYPED_STAGES_REGISTRY.find((x) => x.typeCode === tc);
+        },
+        toWire: () => undefined,
+    });
+    constructor(attrs = {}) {
+        super(attrs);
+        const self = this;
+        if (self["publisher"] === undefined)
+            self["publisher"] = new Publisher({ body: "BS" });
+    }
+    root() {
+        return this;
+    }
+    render() {
+        return renderSingleIdentifier(this);
+    }
+}
+// --- Renderer helpers --------------------------------------------------------------
+function pad2(n) {
+    return String(n).padStart(2, "0");
+}
+function renderSingleIdentifier(id) {
+    const parts = [];
+    if (id.publisher !== undefined)
+        parts.push(id.publisher.render());
+    if (id.flex_prefix !== undefined)
+        parts.push(id.flex_prefix);
+    else if (id.prefix !== undefined)
+        parts.push(id.prefix);
+    if (id.number !== undefined) {
+        let numberStr = id.number;
+        if (id.second_number !== undefined) {
+            numberStr += `/${id.second_number.render()}`;
+        }
+        if (id.part !== undefined) {
+            numberStr += `${id.space_separated_part ? " " : "-"}${id.part.trim()}`;
+        }
+        if (id.subpart !== undefined) {
+            numberStr += `-${id.subpart.trim()}`;
+        }
+        if (id.iteration !== undefined && id.iteration !== "") {
+            numberStr += `[${id.iteration}]`;
+        }
+        parts.push(numberStr);
+    }
+    let result = parts.join(" ");
+    if (id.date?.present()) {
+        result += `:${id.date.render()}`;
+        if (id.month !== undefined)
+            result += `-${pad2(id.month)}`;
+    }
+    if (id.edition !== undefined)
+        result += ` v${id.edition}`;
+    if (id.translation_lang !== undefined)
+        result += ` (${id.translation_lang})`;
+    else if (id.translation_upper !== undefined)
+        result += ` (${id.translation_upper})`;
+    return result;
+}
+function renderNumberWithParts(id) {
+    let numberStr = id.number ?? "";
+    if (id.second_number !== undefined)
+        numberStr += `/${id.second_number.render()}`;
+    if (id.part !== undefined)
+        numberStr += `-${id.part.trim()}`;
+    if (id.subpart !== undefined)
+        numberStr += `-${id.subpart.trim()}`;
+    return numberStr;
+}
+function bsiClass(spec, render) {
+    class BsiConcrete extends BsiIdentifier {
+        static polymorphicName = `pubid:bsi:${spec.kind}`;
+        static urnGenerator = BsiUrnGenerator;
+        render() {
+            return render(this);
+        }
+    }
+    void spec;
+    registerType(BsiConcrete);
+    const klass = BsiConcrete;
+    if (spec.typeCode !== undefined)
+        TYPE_CLASSES[spec.typeCode] = klass;
+    return klass;
+}
+function renderWithTypeAbbr(abbr) {
+    return (id) => {
+        let result = [abbr, id.number !== undefined ? renderNumberWithParts(id) : ""]
+            .filter((s) => s !== "").join(" ");
+        if (id.date?.present()) {
+            result += `:${id.date.render()}`;
+            if (id.month !== undefined)
+                result += `-${pad2(id.month)}`;
+        }
+        if (id.edition !== undefined)
+            result += ` v${id.edition}`;
+        if (id.translation_lang !== undefined)
+            result += ` (${id.translation_lang})`;
+        else if (id.translation_upper !== undefined)
+            result += ` (${id.translation_upper})`;
+        return result;
+    };
+}
+export const BritishStandardClass = bsiClass({ kind: "british-standard", typeCode: "bs" }, (id) => renderSingleIdentifier(id));
+export const DraftDocumentClass = bsiClass({ kind: "draft-document", typeCode: "dd" }, renderWithTypeAbbr("DD"));
+export const PublishedDocumentClass = bsiClass({ kind: "published-document", typeCode: "pd" }, renderWithTypeAbbr("PD"));
+export const PubliclyAvailableSpecificationClass = bsiClass({ kind: "publicly-available-specification", typeCode: "pas" }, renderWithTypeAbbr("PAS"));
+export const TechnicalSpecificationClass = bsiClass({ kind: "technical-specification", typeCode: "ts" }, renderWithTypeAbbr("TS"));
+export const ElectronicBookClass = bsiClass({ kind: "electronic-book", typeCode: "ep" }, (id) => {
+    let result = ["EP", id.number !== undefined ? renderNumberWithParts(id) : ""]
+        .filter((s) => s !== "").join(" ");
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    if (id.edition !== undefined)
+        result += ` Version ${id.edition}`;
+    return result;
+});
+export const AerospaceStandardClass = bsiClass({ kind: "aerospace-standard", typeCode: "aerospace" }, (id) => {
+    const parts = ["BS"];
+    if (id.prefix !== undefined)
+        parts.push(id.prefix);
+    if (id.number !== undefined)
+        parts.push(renderNumberWithParts(id));
+    let result = parts.join(" ");
+    if (id.edition !== undefined && /^[a-zA-Z]$/.test(id.edition))
+        result += id.edition;
+    if (id.date?.present()) {
+        result += `:${id.date.render()}`;
+        if (id.month !== undefined)
+            result += `-${pad2(id.month)}`;
+    }
+    if (id.edition !== undefined && !/^[a-zA-Z]$/.test(id.edition))
+        result += ` v${id.edition}`;
+    if (id.translation_lang !== undefined)
+        result += ` (${id.translation_lang})`;
+    else if (id.translation_upper !== undefined)
+        result += ` (${id.translation_upper})`;
+    return result;
+});
+export const FlexClass = bsiClass({ kind: "flex", typeCode: "flex" }, (id) => {
+    const parts = ["BSI Flex"];
+    if (id.number !== undefined)
+        parts.push(renderNumberWithParts(id));
+    let result = parts.join(" ");
+    if (id.edition !== undefined)
+        result += ` v${id.edition}`;
+    if (id.date?.present()) {
+        result += `:${id.date.render()}`;
+        if (id.month !== undefined)
+            result += `-${pad2(id.month)}`;
+    }
+    return result;
+});
+registerType(BsiIdentifier);
+// --- Suffix-type classes -------------------------------------------------------------
+class ConsolidatedUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        return consolidatedUrn(this.identifier) ?? "";
+    }
+}
+function bsiClassWith(spec, extraAttrs, render) {
+    // 'base' wrappers root through their base document; 'first' through
+    // the first member of their identifiers collection.
+    const rootKind = spec.rootKind;
+    class BsiConcrete extends BsiIdentifier {
+        static polymorphicName = `pubid:bsi:${spec.kind}`;
+        static urnGenerator = spec.kind === "consolidated-identifier" ? ConsolidatedUrnGenerator : BsiUrnGenerator;
+        static attributes = extendAttributes(BsiIdentifier, extraAttrs);
+        static mappings = [
+            ...BsiIdentifier.mappings,
+            ...Object.keys(extraAttrs).map((k) => ({ wire: k, to: k })),
+        ];
+        root() {
+            if (rootKind === "base") {
+                return this.base?.root() ?? this;
+            }
+            if (rootKind === "first") {
+                const first = this.identifiers?.[0];
+                return first !== undefined ? first.root() : this;
+            }
+            return this;
+        }
+        render() {
+            return render(this);
+        }
+    }
+    registerType(BsiConcrete);
+    const klass = BsiConcrete;
+    if (spec.typeCode !== undefined)
+        TYPE_CLASSES[spec.typeCode] = klass;
+    return klass;
+}
+export const IndexClass = bsiClassWith({ kind: "index", typeCode: "index" }, { issue_number: { type: "string" }, index_format: { type: "string" } }, (id) => {
+    const parts = [];
+    if (id.publisher !== undefined)
+        parts.push(id.publisher.render());
+    if (id.number !== undefined)
+        parts.push(id.number);
+    let result = parts.join(" ");
+    if (id.issue_number !== undefined) {
+        result += ` Index Issue ${id.issue_number}`;
+    }
+    else if (id.index_format === "colon") {
+        result += ":Index";
+    }
+    else {
+        result += " Index";
+    }
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const SupplementaryIndexClass = bsiClassWith({ kind: "supplementary-index" }, {}, (id) => {
+    let result = ["BS", id.number !== undefined ? renderNumberWithParts(id) : ""]
+        .filter((x) => x !== "").join(" ");
+    if (id.date?.present()) {
+        result += ` Supplementary Index:${id.date.render()}`;
+        if (id.month !== undefined)
+            result += `-${pad2(id.month)}`;
+    }
+    return result;
+});
+export const ExplanatorySupplementClass = bsiClassWith({ kind: "explanatory-supplement" }, {}, (id) => {
+    let result = ["BS", id.number !== undefined ? renderNumberWithParts(id) : ""]
+        .filter((x) => x !== "").join(" ");
+    if (id.date?.present()) {
+        result += `:Explanatory Supplement:${id.date.render()}`;
+        if (id.month !== undefined)
+            result += `-${pad2(id.month)}`;
+    }
+    return result;
+});
+export const MethodClass = bsiClassWith({ kind: "method", typeCode: "method" }, { method_code: { type: "string" }, method_to: { type: "string" }, method_and: { type: "string" }, is_plural: { type: "boolean" } }, (id) => {
+    const parts = [];
+    if (id.publisher !== undefined)
+        parts.push(id.publisher.render());
+    if (id.number !== undefined) {
+        parts.push(id.part !== undefined ? `${id.number}-${id.part}` : id.number);
+    }
+    let result = parts.join(" ");
+    if (id.method_to !== undefined) {
+        result += `:Methods ${id.method_code} to ${id.method_to}`;
+    }
+    else if (id.method_and !== undefined) {
+        result += `:Methods ${id.method_code} and ${id.method_and}`;
+    }
+    else {
+        result += `:${id.is_plural ? "Methods" : "Method"} ${id.method_code}`;
+    }
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const TestMethodClass = bsiClassWith({ kind: "test-method", typeCode: "test_method" }, { test_series: { type: "string" }, test_id: { type: "string" } }, (id) => {
+    let result = ["BS", id.number ?? ""].join(" ");
+    if (id.test_series !== undefined && id.test_id !== undefined) {
+        result += `:${id.test_series}:${id.test_id}`;
+    }
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const SectionClass = bsiClassWith({ kind: "section", typeCode: "section" }, { section_id: { type: "string" }, section_format: { type: "string" } }, (id) => {
+    const parts = [];
+    if (id.publisher !== undefined)
+        parts.push(id.publisher.render());
+    if (id.number !== undefined)
+        parts.push(id.number);
+    let result = parts.join(" ");
+    result += id.section_format === "colon"
+        ? `:Section ${id.section_id}`
+        : ` Section ${id.section_id}`;
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const DetailedSpecificationClass = bsiClassWith({ kind: "detailed-specification", typeCode: "detailed_specification" }, { spec_code: { type: BsiCode } }, (id) => {
+    let result = ["BS", id.number ?? ""].join(" ");
+    if (id.spec_code !== undefined)
+        result += ` ${id.spec_code.render()}`;
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const DiscClass = bsiClassWith({ kind: "disc", typeCode: "disc" }, {}, (id) => {
+    let numberStr = id.number ?? "";
+    if (id.part !== undefined)
+        numberStr += `-${id.part.trim()}`;
+    let result = ["DISC", numberStr !== "" ? `PD ${numberStr}` : ""].filter((x) => x !== "").join(" ");
+    if (id.date?.present())
+        result += `:${id.date.render()}`;
+    return result;
+});
+export const StandaloneAmendmentClass = bsiClassWith({ kind: "standalone-amendment", typeCode: "amendment" }, { corrigendum: { type: "boolean", default: false }, parenthesized: { type: "boolean", default: false } }, (id) => {
+    const base = id.corrigendum
+        ? `AMD Corrigendum ${id.number}`
+        : `AMD ${id.number}`;
+    return id.parenthesized ? `(${base})` : base;
+});
+export const CommitteeDocumentClass = bsiClassWith({ kind: "committee-document", typeCode: "committee_document" }, {}, (id) => {
+    const yearStr = id.date?.present() ? id.date.render().slice(-2) : "00";
+    return `${yearStr}/${id.number} DC`;
+});
+export class Amendment extends BsiIdentifier {
+    static polymorphicName = "pubid:bsi:amendment";
+    static urnGenerator = BsiUrnGenerator;
+    static attributes = extendAttributes(BsiIdentifier, {
+        base: { type: BsiIdentifier },
+        year: { type: "string" },
+        separator: { type: "string", default: "+" },
+        amd_suffix_form: { type: "boolean", default: false },
+    });
+    static mappings = [
+        ...BsiIdentifier.mappings.filter((m) => m.wire !== "publisher" && m.wire !== "date"),
+        { wire: "base", to: "base" },
+        { wire: "year", to: "year" },
+        { wire: "separator", to: "separator" },
+        { wire: "amd_suffix_form", to: "amd_suffix_form" },
+    ];
+    root() {
+        return this.base?.root() ?? this;
+    }
+    render() {
+        const base = this.base?.toHuman() ?? "";
+        if (this.amd_suffix_form) {
+            const suffix = this.number !== undefined && /^[A-Z]+$/.test(this.number)
+                ? ` AMD ${this.number}`
+                : ` AMD${this.number ?? ""}`;
+            return base === "" ? suffix.trimStart() : `${base}${suffix}`;
+        }
+        let compact = `${this.separator ?? "+"}A${this.number ?? ""}`;
+        if (this.year !== undefined)
+            compact += `:${this.year}`;
+        return `${base}${compact}`;
+    }
+}
+registerType(Amendment);
+export class Corrigendum extends BsiIdentifier {
+    static polymorphicName = "pubid:bsi:corrigendum";
+    static urnGenerator = BsiUrnGenerator;
+    static attributes = extendAttributes(BsiIdentifier, {
+        base: { type: BsiIdentifier },
+        year: { type: "string" },
+        separator: { type: "string", default: "+" },
+    });
+    static mappings = [
+        ...BsiIdentifier.mappings.filter((m) => m.wire !== "publisher" && m.wire !== "date"),
+        { wire: "base", to: "base" },
+        { wire: "year", to: "year" },
+        { wire: "separator", to: "separator" },
+    ];
+    root() {
+        return this.base?.root() ?? this;
+    }
+    render() {
+        let result = this.base?.toHuman() ?? "";
+        result += `${this.separator ?? "+"}C`;
+        if (this.number !== undefined)
+            result += this.number;
+        if (this.year !== undefined)
+            result += `:${this.year}`;
+        return result;
+    }
+}
+registerType(Corrigendum);
+export const SupplementDocumentClass = bsiClassWith({ kind: "supplement-document", rootKind: "base" }, {
+    base: { type: BsiIdentifier },
+    supplement_number: { type: "string" },
+    supplement_year: { type: "integer" },
+    supplement_type: { type: "string", default: "No." },
+    reverse_format: { type: "boolean", default: false },
+    separator: { type: "string", default: ":" },
+}, (id) => {
+    const baseStr = id.base?.toHuman() ?? "";
+    if (id.reverse_format) {
+        const no = id.supplement_type === "No." ? "No. " : "";
+        return `Supplement ${no}${id.supplement_number} (${id.supplement_year}) to ${baseStr}`;
+    }
+    const no = id.supplement_type === "No." ? "No. " : "";
+    return `${baseStr}${id.separator ?? ":"}Supplement ${no}${id.supplement_number}:${id.supplement_year}`;
+});
+export const AddendumDocumentClass = bsiClassWith({ kind: "addendum-document", rootKind: "base" }, {
+    base: { type: BsiIdentifier },
+    addendum_number: { type: "string" },
+    addendum_year: { type: "integer" },
+    addendum_type: { type: "string", default: "No." },
+    separator: { type: "string", default: ":" },
+}, (id) => {
+    const baseStr = id.base?.toHuman() ?? "";
+    const baseHasYear = /:(\d{4})$/.test(baseStr);
+    const sep = id.separator === ":"
+        ? ":"
+        : baseHasYear && !/\d{4}:/.test(baseStr)
+            ? " "
+            : id.separator ?? ":";
+    const no = id.addendum_type === "" ? "" : ` ${id.addendum_type}`;
+    // The renderer prints two spaces before the addendum number (the
+    // gem joins " " + " "); the printed form is the recorded canonical.
+    return `${baseStr}${sep}Addendum${no}  ${id.addendum_number}:${id.addendum_year ?? ""}`;
+});
+export const BundledIdentifierClass = bsiClassWith({ kind: "bundled-identifier", rootKind: "first" }, {
+    identifiers: { type: BsiIdentifier, collection: true },
+    separators: { type: "string", collection: true },
+    common_year: { type: PubidDate },
+    bundle_type: { type: "string" },
+}, (id) => {
+    if (id.identifiers === undefined || id.identifiers.length === 0)
+        return "";
+    if (id.bundle_type !== undefined) {
+        const baseId = id.identifiers[0];
+        const partsList = id.identifiers.slice(1)
+            .map((idd) => idd.part ?? idd.toHuman())
+            .join(" and ");
+        let result = `${baseId.toHuman().replace(/:.*$/, "")}:${id.bundle_type} ${partsList}`;
+        if (id.common_year?.present())
+            result += `:${id.common_year.render()}`;
+        return result;
+    }
+    const parts = [];
+    id.identifiers.forEach((idd, i) => {
+        const self = idd;
+        if (i === 0 || self["explicit_publisher"] === true) {
+            parts.push(idd.toHuman());
+        }
+        else if (self["explicit_prefix"] === true) {
+            let abbrev = "";
+            const prefix = self["prefix"];
+            if (prefix !== undefined && prefix !== "")
+                abbrev = prefix;
+            if (idd.number !== undefined) {
+                abbrev += abbrev === "" ? "" : " ";
+                abbrev += idd.number;
+            }
+            if (idd.part !== undefined)
+                abbrev += `-${idd.part}`;
+            parts.push(abbrev);
+        }
+        else {
+            let abbrev = idd.number ?? "";
+            if (idd.part !== undefined)
+                abbrev += `-${idd.part}`;
+            parts.push(abbrev);
+        }
+        if (i < id.identifiers.length - 1) {
+            parts.push(id.separators?.[i] ?? " and ");
+        }
+    });
+    let result = parts.join("");
+    if (id.common_year?.present() && !result.endsWith(`:${id.common_year.render()}`)) {
+        result += `:${id.common_year.render()}`;
+    }
+    return result;
+});
+export const SetClass = bsiClassWith({ kind: "set", rootKind: "first" }, {
+    identifiers: { type: BsiIdentifier, collection: true },
+    separators: { type: "string", collection: true },
+}, (id) => (id.identifiers ?? []).map((i) => i.toHuman()).join(" + "));
+export const ExpertCommentaryClass = bsiClassWith({ kind: "expert-commentary", rootKind: "base" }, {
+    base: { type: BsiIdentifier },
+    format: { type: "string" },
+    topic: { type: "string" },
+}, (id) => {
+    let baseStr = id.base?.toHuman() ?? "";
+    baseStr = baseStr.replace(/ (Expert Commentary|ExComm(\s*\(.*\))?)$/, "");
+    if (id.format === "full")
+        return `${baseStr} Expert Commentary`;
+    if (id.format === "abbr_with_topic")
+        return `${baseStr} ExComm (${id.topic})`;
+    return `${baseStr} ExComm`;
+});
+export const ValueAddedPublicationClass = (() => {
+    const klass = bsiClassWith({ kind: "value-added-publication", rootKind: "base" }, {
+        base: { type: BsiIdentifier },
+        format: { type: "string" },
+    }, (id) => {
+        const baseStr = id.base?.toHuman() ?? "";
+        if (id.format === "TC")
+            return `${baseStr} - TC`;
+        if (id.format === "PDF")
+            return `${baseStr} PDF`;
+        if (id.format === "BOOK")
+            return `${baseStr} BOOK`;
+        return baseStr;
+    });
+    // #number/#year/#date delegate to base (value_added_publication.rb),
+    // so the wrapper's wire carries them.
+    klass.compactHash = (model, hash) => {
+        const base = model.base;
+        if (base === undefined)
+            return;
+        if (base.number !== undefined)
+            hash["number"] = base.number;
+        if (base.date?.present())
+            hash["year"] = base.date.render();
+    };
+    return klass;
+})();
+export const NationalAnnexClass = bsiClassWith({ kind: "national-annex", typeCode: "na", rootKind: "base" }, {
+    na_supplements: { type: BsiIdentifier, collection: true },
+    base: { type: BsiIdentifier },
+}, (id) => {
+    let result = "NA";
+    for (const supp of id.na_supplements ?? []) {
+        const self = supp;
+        if (supp instanceof Amendment) {
+            result += `+A${self["number"]}:${self["year"]}`;
+        }
+        else if (supp instanceof Corrigendum) {
+            result += `+C${self["number"]}:${self["year"]}`;
+        }
+    }
+    result += " to ";
+    result += id.base !== undefined ? id.base.toHuman() : renderSingleIdentifier(id);
+    return result;
+});
+function renderAdopted(id) {
+    const prefix = id.publisher !== undefined ? id.publisher.render() : "BS";
+    let result = prefix;
+    if (id.base !== undefined)
+        result += ` ${id.base.toHuman()}`;
+    if (id.edition !== undefined)
+        result += ` ED${id.edition}`;
+    if (id.reaffirmation_year !== undefined)
+        result += ` (R${id.reaffirmation_year})`;
+    if (id.translation_lang !== undefined) {
+        result += id.translation_suffix_type === "version"
+            ? ` (${id.translation_lang} version)`
+            : id.translation_suffix_type === "Translation"
+                ? ` (${id.translation_lang} Translation)`
+                : ` (${id.translation_lang})`;
+    }
+    else if (id.translation_upper !== undefined) {
+        result += id.translation_suffix_type === "Translation"
+            ? ` (${id.translation_upper} Translation)`
+            : ` (${id.translation_upper})`;
+    }
+    if (id.expert_commentary !== undefined && id.expert_commentary) {
+        result += id.expert_commentary_topic !== undefined
+            ? ` ExComm (${id.expert_commentary_topic})`
+            : " ExComm";
+    }
+    return result;
+}
+const adoptedAttrs = {
+    base: { type: BsiIdentifier },
+    edition: { type: "string" },
+    translation_lang: { type: "string" },
+    translation_upper: { type: "string" },
+    translation_suffix_type: { type: "string" },
+    reaffirmation_year: { type: "string" },
+    expert_commentary: { type: "boolean" },
+    expert_commentary_topic: { type: "string" },
+};
+export const AdoptedEuropeanNormClass = bsiClassWith({ kind: "adopted-european-norm", rootKind: "base" }, adoptedAttrs, renderAdopted);
+export const AdoptedInternationalStandardClass = bsiClassWith({ kind: "adopted-international-standard", rootKind: "base" }, adoptedAttrs, renderAdopted);
+export const ConsolidatedIdentifierClass = bsiClassWith({ kind: "consolidated-identifier", rootKind: "first" }, {
+    identifiers: { type: BsiIdentifier, collection: true },
+}, (id) => {
+    const [baseId, ...supplements] = id.identifiers ?? [];
+    if (baseId === undefined)
+        return "";
+    let result = baseId.toHuman()
+        .replace(/ ExComm \(.*?\)$/, "")
+        .replace(/ ExComm$/, "")
+        .replace(/ - TC$/, "")
+        .replace(/ PDF$/, "")
+        .replace(/ \([A-Z][a-z]+\)$/, "");
+    // The gem serializes only the `type` block onto the consolidated
+    // wrapper (the members carry their own full typed-stage trio).
+    ConsolidatedIdentifierClass.compactHash =
+        (model, hash) => {
+            const ts = model.typedStage;
+            if (ts === undefined || ts.code === "pubbs")
+                return;
+            hash["type"] = { name: ts.name, abbr: ts.abbr[0], type_code: ts.typeCode };
+        };
+    for (const supp of supplements) {
+        if (supp instanceof Amendment) {
+            if (supp.amd_suffix_form) {
+                result += supp.number !== undefined && /^[A-Z]+$/.test(supp.number)
+                    ? ` AMD ${supp.number}`
+                    : ` AMD${supp.number ?? ""}`;
+            }
+            else {
+                result += `${supp.separator ?? "+"}A${supp.number ?? ""}`;
+                if (supp.year !== undefined)
+                    result += `:${supp.year}`;
+            }
+        }
+        else if (supp instanceof Corrigendum) {
+            result += `${supp.separator ?? "+"}C`;
+            if (supp.number !== undefined)
+                result += supp.number;
+            if (supp.year !== undefined)
+                result += `:${supp.year}`;
+        }
+        else {
+            result += supp.toHuman();
+        }
+    }
+    const baseSelf = baseId;
+    if (baseSelf["expert_commentary"] !== undefined) {
+        result += baseSelf["expert_commentary_topic"] !== undefined
+            ? ` ExComm (${baseSelf["expert_commentary_topic"]})`
+            : " ExComm";
+    }
+    if (baseSelf["tracked_changes"] !== undefined)
+        result += " - TC";
+    const tl = baseSelf["translation_lang"];
+    if (tl !== undefined) {
+        const tsType = baseSelf["translation_suffix_type"];
+        result += tsType === "version"
+            ? ` (${tl} version)`
+            : tsType === "Translation"
+                ? ` (${tl} Translation)`
+                : ` (${tl})`;
+    }
+    else {
+        const tu = baseSelf["translation_upper"];
+        if (tu !== undefined) {
+            const tsType = baseSelf["translation_suffix_type"];
+            result += tsType === "Translation" ? ` (${tu} Translation)` : ` (${tu})`;
+        }
+    }
+    const ry = baseSelf["reaffirmation_year"];
+    if (ry !== undefined)
+        result += ` (R${ry})`;
+    return result;
+});
+// ConsolidatedIdentifier#to_urn override (renderer.rb class method):
+// base URN plus per-supplement segments.
+export function consolidatedUrn(id) {
+    const [base, ...supplements] = id.identifiers ?? [];
+    if (base === undefined)
+        return undefined;
+    let urn = base.toUrn();
+    if (urn === undefined)
+        return undefined;
+    for (const supp of supplements) {
+        if (supp instanceof Amendment) {
+            urn += `:amd:${supp.number ?? ""}`;
+            if (supp.year !== undefined)
+                urn += `:${supp.year}`;
+        }
+        else if (supp instanceof Corrigendum) {
+            urn += `:cor:${supp.number ?? ""}`;
+            if (supp.year !== undefined)
+                urn += `:${supp.year}`;
+        }
+    }
+    return urn;
+}