@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/idf/grammar.js

@@ -0,0 +1,71 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/idf/parser.rb — 1:1. Root: supplement_identifier |
+ * identifier_publisher.
+ */
+const IS_ABBRS = [
+    "PWI", "NP", "NWIP", "AWI", "WD", "CD", "FCD", "DIS", "FPD", "FDIS",
+    "PRF", "Fpr", "WDR", "WDA", "WDAR",
+];
+const RM_ABBRS = [
+    "PWI RM", "NP RM", "AWI RM", "WD RM", "CD RM", "PDRM", "DRM", "FDRM",
+    "PRF RM", "RM",
+];
+const SUPPLEMENT_ABBRS = ["AMD", "COR"];
+function abbrAlternation(tokens) {
+    const sorted = [...new Set(tokens)].sort((a, b) => b.length - a.length);
+    return sorted.map((t) => str(t)).reduce((a, b) => a.or(b));
+}
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const dash = str("-").or(str("‑")).or(str("‐"));
+    const word = match("\\w");
+    const digit = match("\\d");
+    const digits = digit.repeat(1, Infinity);
+    rule("prefix_sole_publisher", () => str("IDF").as("publisher"));
+    rule("number", () => word.repeat(1, 5));
+    rule("date", () => digits
+        .then(dash.then(digit.repeat(2, 2)).maybe())
+        .then(dash.then(digit.repeat(2, 2)).maybe())
+        .as("date"));
+    rule("part_and_subpart", () => dash.then(space.maybe())
+        .then(word.repeat(0, Infinity))
+        .then(dash.then(word.repeat(0, Infinity)).repeat(0, Infinity).maybe()));
+    rule("number_with_part", () => ref(rules, "number").then(ref(rules, "part_and_subpart").maybe()).as("number_with_part"));
+    rule("all_parts", () => str("(all parts)").as("all_parts"));
+    rule("type_with_stage", () => abbrAlternation([...IS_ABBRS, ...RM_ABBRS]).as("type_with_stage")
+        .then(digit.as("stage_iteration").then(space).maybe()));
+    rule("language", () => str("(")
+        .then((match("[a-z]").repeat(1, Infinity).then(str(",").maybe())).or(match("[EFARDS]").then(str("/").maybe())).repeat(0, Infinity).as("languages"))
+        .then(str(")")));
+    rule("stage_iteration", () => str(".").then(digit.as("stage_iteration")));
+    rule("second_part", () => ref(rules, "number_with_part")
+        .then(ref(rules, "stage_iteration").maybe())
+        .then(space.maybe())
+        .then(str(":").then(ref(rules, "date")).maybe()));
+    rule("third_part", () => space.maybe().then(ref(rules, "language").maybe()).then(ref(rules, "all_parts").maybe()));
+    rule("identifier_publisher_no_third", () => ref(rules, "prefix_sole_publisher")
+        .then(space.maybe())
+        .then(str("/").maybe())
+        .then(ref(rules, "type_with_stage").maybe())
+        .then(space.maybe())
+        .then(ref(rules, "second_part")));
+    rule("identifier_publisher", () => ref(rules, "identifier_publisher_no_third").then(ref(rules, "third_part")));
+    rule("supplement_type_with_stage", () => abbrAlternation(SUPPLEMENT_ABBRS).as("type_with_stage"));
+    rule("supplement_identifier_no_third", () => ref(rules, "identifier_publisher_no_third").as("base")
+        .then(space.maybe().then(str("/")).then(space.maybe()))
+        .then(ref(rules, "supplement_type_with_stage"))
+        .then(space.maybe())
+        .then(ref(rules, "second_part")));
+    rule("supplement_identifier", () => ref(rules, "supplement_identifier_no_third").then(ref(rules, "third_part")));
+    rule("identifier", () => ref(rules, "supplement_identifier").or(ref(rules, "identifier_publisher")));
+    return rules;
+}
+export const idfGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

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

@@ -0,0 +1,2 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare function idfGrammarImplementation(): FlavorImplementation;

package/dist/flavors/idf/index.js

@@ -0,0 +1,100 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { idfGrammar } from "./grammar.js";
+import { AmendmentClass, CorrigendumClass, IDF_TYPE_CLASSES, IdfTypedStageComponent, InternationalStandardClass, locateStage, } from "./model.js";
+import { Language, PubidDate } from "../../model/component.js";
+/**
+ * Port of lib/pubid/idf/builder.rb — stage lookup, number/part split,
+ * language mapping, supplement wrapping.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const s = String(v);
+    return s.length > 0 ? s : undefined;
+};
+const LANG_CHAR_MAP = {
+    R: "ru", F: "fr", E: "en", A: "ar", S: "es", D: "de",
+};
+function buildIdentifier(tree) {
+    const d = Array.isArray(tree) ? Object.assign({}, ...tree) : tree;
+    return buildFrom(d);
+}
+function buildFrom(d) {
+    if (d["base"] !== undefined) {
+        const base = buildFrom(d["base"]);
+        const attrs = assignAttributes(d);
+        const typedStage = locateStage(str(d["type_with_stage"]) ?? "AMD");
+        const isCor = typedStage?.type_code === "cor";
+        const klass = (isCor ? CorrigendumClass : AmendmentClass);
+        // The supplement's wire "year" is its DATE flattened by the shared
+        // scalar flattener; nothing else changes.
+        return new klass({ ...attrs, base, typedStage: typedStage === undefined ? undefined : new IdfTypedStageComponent(typedStage) });
+    }
+    const rawStage = str(d["type_with_stage"]);
+    const stageIteration = str(d["stage_iteration"]);
+    // The stage abbr may carry a trailing iteration digit in the capture.
+    let stageAbbr = rawStage;
+    let iteration = stageIteration;
+    if (rawStage !== undefined && iteration === undefined && /\d$/.test(rawStage) && !/\b(RM|FDIS|DIS|COR|AMD)\b/.test(rawStage)) {
+        const m = /(\d+)$/.exec(rawStage);
+        if (m !== null) {
+            stageAbbr = rawStage.slice(0, -(m[1] ?? "").length);
+            iteration = m[1];
+        }
+    }
+    const typedStage = locateStage(stageAbbr ?? "");
+    const typeCode = typedStage?.type_code ?? "is";
+    const klass = (IDF_TYPE_CLASSES[typeCode] ?? InternationalStandardClass);
+    const attrs = assignAttributes(d);
+    return new klass({
+        ...attrs,
+        ...(iteration !== undefined ? { stageIteration: iteration } : {}),
+        ...(typedStage !== undefined ? { typedStage: new IdfTypedStageComponent(typedStage) } : {}),
+    });
+}
+function assignAttributes(d) {
+    const attrs = {};
+    if (d["number_with_part"] !== undefined) {
+        const value = String(Array.isArray(d["number_with_part"])
+            ? d["number_with_part"].join("")
+            : d["number_with_part"]);
+        const parts = value.split("-");
+        attrs["number"] = parts.shift();
+        const part = parts.shift();
+        if (part !== undefined && part !== "")
+            attrs["part"] = part;
+        if (parts.length > 0)
+            attrs["subpart"] = parts.join("-");
+    }
+    if (d["date"] !== undefined) {
+        const value = String(Array.isArray(d["date"]) ? d["date"].join("") : d["date"]);
+        if (/^\d{4}(-\d{2})?$/.test(value)) {
+            const [year, month] = value.split("-");
+            attrs["date"] = new PubidDate(month !== undefined ? { year, month } : { year });
+        }
+    }
+    if (d["languages"] !== undefined) {
+        const raw = String(d["languages"]).replaceAll("/", ",");
+        attrs["languages"] = raw
+            .split(",")
+            .map((lang) => lang.trim())
+            .filter((lang) => lang !== "")
+            .map((lang) => new Language({ code: LANG_CHAR_MAP[lang] ?? lang }));
+    }
+    if (d["all_parts"] !== undefined) {
+        attrs["all_parts"] = true;
+    }
+    if (isObj(d["base"])) {
+        // Supplement attrs handled by caller; number/date already read above.
+    }
+    return attrs;
+}
+export function idfGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(idfGrammar, input);
+            return buildIdentifier(tree);
+        },
+    };
+}

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

@@ -0,0 +1,54 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type AttributeTable, type FieldMapping } from "../../model/attribute.js";
+import { Language, PubidDate } from "../../model/component.js";
+/**
+ * Port of lib/pubid/idf: the typed-stage registry (is/rm/amd/cor), the
+ * nested Type/Stage/TypedStage wire objects, supplements carrying a base,
+ * the renderer and the URN generator.
+ */
+export interface IdfTypedStage {
+    name: string;
+    code: string;
+    type_code: string;
+    stage_code?: string;
+    abbr: string[];
+    harmonized_stages?: string[];
+    short_abbr?: string;
+    long_abbr?: string;
+}
+export declare const IS_STAGES: IdfTypedStage[];
+export declare const RM_STAGES: IdfTypedStage[];
+export declare const AMD_STAGE: IdfTypedStage;
+export declare const COR_STAGE: IdfTypedStage;
+export declare function locateStage(abbr: string): IdfTypedStage | undefined;
+export declare function locateStageByTypeCode(typeCode: string): IdfTypedStage | undefined;
+export declare class IdfTypedStageComponent {
+    readonly record: IdfTypedStage;
+    constructor(record: IdfTypedStage);
+    get abbrFirst(): string;
+    /** abbreviation: short/long override else abbr[0]. */
+    abbreviation(formatLong?: boolean): string;
+    typeWire(): Record<string, unknown>;
+    stageWire(): Record<string, unknown>;
+    toWire(): Record<string, unknown>;
+    static fromWire(hash: Record<string, unknown>): IdfTypedStageComponent | undefined;
+}
+export declare abstract class IdfIdentifier extends BaseIdentifier {
+    static attributes: AttributeTable;
+    static mappings: FieldMapping[];
+    readonly publisherBody: string;
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    readonly subpart: string | undefined;
+    readonly date: PubidDate | undefined;
+    readonly languages: Language[] | undefined;
+    readonly all_parts: boolean | undefined;
+    root(): IdfIdentifier;
+}
+export declare const InternationalStandardClass: IdentifierStatic;
+export declare const ReviewedMethodClass: IdentifierStatic;
+export declare const AmendmentClass: IdentifierStatic;
+export declare const CorrigendumClass: IdentifierStatic;
+export declare const IDF_TYPE_CLASSES: Record<string, IdentifierStatic>;
+export declare const IDF_ATTRIBUTES: AttributeTable;

package/dist/flavors/idf/model.js

@@ -0,0 +1,359 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { Language, PubidDate } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+export const IS_STAGES = [
+    { name: "Proposed Work Item for International Standard", code: "pwiis", type_code: "is", stage_code: "pwi", abbr: ["PWI"], harmonized_stages: ["00.00", "00.20", "00.60", "00.92", "00.93", "00.98", "00.99"] },
+    { name: "New Work Item Proposal for International Standard", code: "isnp", type_code: "is", stage_code: "np", abbr: ["NP", "NWIP"], harmonized_stages: ["10.00", "10.20", "10.60", "10.92", "10.93", "10.98"] },
+    { name: "Approved Work Item for International Standard", code: "awiis", type_code: "is", stage_code: "awi", abbr: ["AWI"], harmonized_stages: ["10.99", "20.00"] },
+    { name: "Working Draft for International Standard", code: "wdis", type_code: "is", stage_code: "wd", abbr: ["WD"], harmonized_stages: ["20.20", "20.60", "20.92", "20.93", "20.98", "20.99"] },
+    { name: "Committee Draft for International Standard", code: "cdis", type_code: "is", stage_code: "cd", abbr: ["CD"], harmonized_stages: ["30.00", "30.20", "30.60", "30.92", "30.93", "30.98", "30.99"] },
+    { name: "Final Committee Draft for International Standard", code: "fcdis", type_code: "is", stage_code: "fcd", abbr: ["FCD"], harmonized_stages: ["30.00", "30.20", "30.60", "30.92", "30.93", "30.98", "30.99"] },
+    { name: "Draft International Standard", code: "dis", type_code: "is", stage_code: "dis", abbr: ["DIS", "FPD"], harmonized_stages: ["40.00", "40.20", "40.60", "40.92", "40.93", "40.98", "40.99"] },
+    { name: "Final Draft International Standard", code: "fdis", type_code: "is", stage_code: "fdis", abbr: ["FDIS"], harmonized_stages: ["50.00", "50.20", "50.60", "50.92", "50.98", "50.99"] },
+    { name: "Proof International Standard", code: "prfis", type_code: "is", stage_code: "prf", abbr: ["PRF", "Fpr"], harmonized_stages: ["60.00"] },
+    { name: "International Standard", code: "is", type_code: "is", stage_code: "published", abbr: [""], harmonized_stages: ["60.00", "60.60"] },
+    { name: "Proposed for Withdrawal", code: "wdr", type_code: "is", stage_code: "wdr", abbr: ["WDR"], harmonized_stages: ["90.92"] },
+    { name: "Withdrawal Approved", code: "wda", type_code: "is", stage_code: "wda", abbr: ["WDA"], harmonized_stages: ["90.93"] },
+    { name: "Withdrawal Archived", code: "wdar", type_code: "is", stage_code: "wdar", abbr: ["WDAR"], harmonized_stages: ["95.99"] },
+];
+export const RM_STAGES = [
+    { name: "Proposed Work Item for Reviewed Method", code: "pwirm", type_code: "rm", stage_code: "pwi", abbr: ["PWI RM"], harmonized_stages: ["00.00", "00.20", "00.60", "00.92", "00.93", "00.98", "00.99"] },
+    { name: "New Work Item Proposal for Reviewed Method", code: "nprm", type_code: "rm", stage_code: "np", abbr: ["NP RM"], harmonized_stages: ["10.00", "10.20", "10.60", "10.92", "10.93", "10.98"] },
+    { name: "Approved Work Item for Reviewed Method", code: "awirm", type_code: "rm", stage_code: "awi", abbr: ["AWI RM"], harmonized_stages: ["10.99", "20.00"] },
+    { name: "Working Draft Reviewed Method", code: "wdrm", type_code: "rm", stage_code: "wd", abbr: ["WD RM"], harmonized_stages: ["20.20", "20.60", "20.92", "20.93", "20.98", "20.99"] },
+    { name: "Committee Draft Reviewed Method", code: "cdrm", type_code: "rm", stage_code: "cd", abbr: ["CD RM"], harmonized_stages: ["30.00", "30.20", "30.60", "30.92", "30.93", "30.98", "30.99"] },
+    { name: "Proposed Draft Reviewed Method", code: "pdrm", type_code: "rm", stage_code: "cd", abbr: ["PDRM"], harmonized_stages: ["30.00", "30.20", "30.60", "30.92", "30.93", "30.98", "30.99"] },
+    { name: "Draft Reviewed Method", code: "drm", type_code: "rm", abbr: ["DRM"], harmonized_stages: ["40.00", "40.20", "40.60", "40.92", "40.93", "40.98", "40.99"] },
+    { name: "Final Draft Reviewed Method", code: "fdrm", type_code: "rm", abbr: ["FDRM"], harmonized_stages: ["50.00", "50.20", "50.60", "50.92", "50.98", "50.99"] },
+    { name: "Proof Reviewed Method", code: "prfrm", type_code: "rm", stage_code: "prf", abbr: ["PRF RM"], harmonized_stages: ["50.00", "50.20", "50.60", "50.92", "50.98", "50.99"] },
+    { name: "Published Reviewed Method", code: "pubrm", type_code: "rm", stage_code: "published", abbr: ["RM"], harmonized_stages: ["60.00", "60.60"] },
+];
+export const AMD_STAGE = {
+    name: "Amendment", code: "published", type_code: "amd", stage_code: "published",
+    abbr: ["AMD"], short_abbr: "AMD", long_abbr: "AMD",
+};
+export const COR_STAGE = {
+    name: "Corrigendum", code: "published", type_code: "cor", stage_code: "published",
+    abbr: ["COR"], short_abbr: "COR", long_abbr: "COR",
+};
+const ALL_STAGES = [...IS_STAGES, ...RM_STAGES, AMD_STAGE, COR_STAGE];
+export function locateStage(abbr) {
+    const needle = abbr.trim();
+    if (needle === "")
+        return IS_STAGES.find((s) => s.code === "is");
+    return ALL_STAGES.find((s) => s.abbr.some((a) => a === needle));
+}
+export function locateStageByTypeCode(typeCode) {
+    return ALL_STAGES.find((s) => s.type_code === typeCode && s.stage_code === "published")
+        ?? ALL_STAGES.find((s) => s.type_code === typeCode);
+}
+// --- Wire shapes -------------------------------------------------------------------
+export class IdfTypedStageComponent {
+    record;
+    constructor(record) {
+        this.record = record;
+    }
+    get abbrFirst() {
+        return this.record.abbr[0] ?? "";
+    }
+    /** abbreviation: short/long override else abbr[0]. */
+    abbreviation(formatLong = true) {
+        if (formatLong && this.record.long_abbr !== undefined)
+            return this.record.long_abbr;
+        if (!formatLong && this.record.short_abbr !== undefined)
+            return this.record.short_abbr;
+        return this.abbrFirst;
+    }
+    typeWire() {
+        const out = { name: this.record.name, type_code: this.record.type_code };
+        if (this.abbrFirst !== "")
+            out["abbr"] = this.abbrFirst;
+        return out;
+    }
+    stageWire() {
+        const out = { name: this.record.name };
+        if (this.record.stage_code !== undefined)
+            out["stage_code"] = this.record.stage_code;
+        if (this.abbrFirst !== "")
+            out["abbr"] = this.abbrFirst;
+        if (this.record.harmonized_stages !== undefined)
+            out["harmonized_stages"] = this.record.harmonized_stages;
+        return out;
+    }
+    toWire() {
+        const out = {
+            name: this.record.name,
+            code: this.record.code,
+            type_code: this.record.type_code,
+            ...(this.record.stage_code !== undefined ? { stage_code: this.record.stage_code } : {}),
+            abbr: this.record.abbr,
+        };
+        if (this.record.harmonized_stages !== undefined)
+            out["harmonized_stages"] = this.record.harmonized_stages;
+        if (this.record.short_abbr !== undefined)
+            out["short_abbr"] = this.record.short_abbr;
+        if (this.record.long_abbr !== undefined)
+            out["long_abbr"] = this.record.long_abbr;
+        return out;
+    }
+    static fromWire(hash) {
+        const abbr = Array.isArray(hash["abbr"]) ? hash["abbr"].map(String) : [];
+        const match = ALL_STAGES.find((s) => s.abbr.length === abbr.length && s.abbr.every((a, i) => a === abbr[i]) && s.code === hash["code"]);
+        return match === undefined ? undefined : new IdfTypedStageComponent(match);
+    }
+}
+const publisherWire = {
+    wire: "publisher",
+    to: "publisherBody",
+    toWire: (model) => {
+        const body = model["publisherBody"];
+        return body === undefined ? undefined : { body };
+    },
+    fromWire: (hash) => {
+        const value = hash["publisher"];
+        if (value === undefined || typeof value !== "object")
+            return undefined;
+        return String(value["body"] ?? "");
+    },
+};
+const typedStageObjWire = {
+    wire: "typed_stage",
+    to: "typedStage",
+    toWire: (model) => {
+        const stage = model["typedStage"];
+        return stage instanceof IdfTypedStageComponent ? stage.toWire() : undefined;
+    },
+    fromWire: (hash) => {
+        const value = hash["typed_stage"];
+        if (value === undefined || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        return IdfTypedStageComponent.fromWire(value);
+    },
+};
+// --- The identifier base --------------------------------------------------------
+export class IdfIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisherBody: { type: "string" },
+        number: { type: "string" },
+        part: { type: "string" },
+        subpart: { type: "string" },
+        date: { type: PubidDate },
+        languages: { type: Language, collection: true },
+        all_parts: { type: "boolean", default: false },
+    });
+    static mappings = keyValue(publisherWire, { wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "subpart", to: "subpart" }, {
+        wire: "date",
+        to: "date",
+        toWire: (model) => {
+            const date = model["date"];
+            if (date === undefined)
+                return undefined;
+            if (date.month === undefined)
+                return { year: date.year };
+            return { year: date.year, month: date.month };
+        },
+        fromWire: (hash) => {
+            const nested = hash["date"];
+            if (nested !== undefined && typeof nested === "object" && nested !== null) {
+                const rec = nested;
+                return new PubidDate({ year: rec["year"], month: rec["month"] });
+            }
+            const year = hash["year"];
+            if (typeof year === "string" && year !== "")
+                return new PubidDate({ year });
+            return undefined;
+        },
+    }, { wire: "languages", to: "languages" }, { wire: "all_parts", to: "all_parts" });
+    root() {
+        return this;
+    }
+}
+function languagePortion(id) {
+    if (id.languages === undefined || id.languages.length === 0)
+        return "";
+    return `(${id.languages.map((l) => l.code).join(",")})`;
+}
+function numberPortion(id) {
+    const self = id;
+    const iter = self["stageIteration"];
+    return [
+        id.number !== undefined ? ` ${id.number}` : "",
+        id.part !== undefined ? `-${id.part}` : "",
+        id.subpart !== undefined ? `-${id.subpart}` : "",
+        iter !== undefined ? `.${iter}` : "",
+        id.date?.present() ? `:${id.date.render()}` : "",
+        languagePortion(id),
+    ].join("");
+}
+function renderSingle(id) {
+    const stage = id["typedStage"];
+    const abbr = stage === undefined ? "" : stage.abbreviation();
+    return ["IDF", abbr === "" ? "" : `/${abbr}`].join("") + numberPortion(id);
+}
+// --- URN generator ---------------------------------------------------------------
+class IdfUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const self = id;
+        const stage = self["typedStage"];
+        const typeAbbr = stage === undefined ? "" : stage.abbrFirst;
+        const parts = ["urn", "idf"];
+        if (id.number !== undefined)
+            parts.push(id.number);
+        // The URN keeps each part's leading dash (UrnGenerator::Base urn_part).
+        if (id.part !== undefined)
+            parts.push(`-${id.part}`);
+        if (id.subpart !== undefined)
+            parts.push(`-${id.subpart}`);
+        if (id.date?.year !== undefined)
+            parts.push(id.date.year);
+        // urn_type: the type abbreviation lowercased, "" when absent (the
+        // published IS keeps an empty trailing segment).
+        parts.push(typeAbbr.toLowerCase());
+        if (id.languages !== undefined && id.languages.length > 0) {
+            parts.push(id.languages.map((l) => l.code).join(","));
+        }
+        if (self["base"] !== undefined) {
+            if (stage !== undefined)
+                parts.push(stage.record.type_code);
+            if (id.number !== undefined)
+                parts.push(id.number);
+        }
+        return parts.join(":");
+    }
+}
+function documentClass(spec) {
+    class IdfConcrete extends IdfIdentifier {
+        static polymorphicName = `pubid:idf:${spec.kind}`;
+        static urnGenerator = IdfUrnGenerator;
+        static get attributes() {
+            return extendAttributes(IdfIdentifier, {
+                typedStage: { type: "string" },
+            });
+        }
+        static get mappings() {
+            const stage = locateStageByTypeCode(spec.typeCode);
+            return [
+                ...IdfIdentifier.mappings,
+                {
+                    wire: "type",
+                    to: "typedStage",
+                    toWire: (model) => {
+                        const s = model["typedStage"];
+                        return s instanceof IdfTypedStageComponent ? s.typeWire() : undefined;
+                    },
+                    fromWire: () => undefined,
+                },
+                {
+                    wire: "stage",
+                    to: "typedStage",
+                    toWire: (model) => {
+                        const s = model["typedStage"];
+                        return s instanceof IdfTypedStageComponent ? s.stageWire() : undefined;
+                    },
+                    fromWire: () => undefined,
+                },
+                typedStageObjWire,
+            ];
+        }
+        constructor(attrs = {}) {
+            super(attrs);
+            const self = this;
+            // The publisher body defaults to IDF on the instance (NOT via a
+            // spec default — a default-equal scalar would drop off the wire,
+            // but the nested publisher object always serializes).
+            if (self["publisherBody"] === undefined)
+                self["publisherBody"] = "IDF";
+            if (self["typedStage"] === undefined) {
+                self["typedStage"] = new IdfTypedStageComponent(locateStageByTypeCode(spec.typeCode));
+            }
+        }
+        render() {
+            return renderSingle(this);
+        }
+        toUrn() {
+            return new IdfUrnGenerator(this).generate();
+        }
+    }
+    void spec;
+    registerType(IdfConcrete);
+    return IdfConcrete;
+}
+export const InternationalStandardClass = documentClass({ kind: "international-standard", typeCode: "is" });
+export const ReviewedMethodClass = documentClass({ kind: "reviewed-method", typeCode: "rm" });
+function supplementClass(spec, stage) {
+    class IdfSupplement extends IdfIdentifier {
+        static polymorphicName = `pubid:idf:${spec.kind}`;
+        static urnGenerator = IdfUrnGenerator;
+        static get attributes() {
+            return extendAttributes(IdfIdentifier, {
+                base: { type: IdfIdentifier },
+                typedStage: { type: "string" },
+            });
+        }
+        static get mappings() {
+            // Supplements carry no publisher of their own (Ruby Supplement
+            // Identifier delegates to base; the wire drops it).
+            return [
+                ...IdfIdentifier.mappings.filter((m) => m.wire !== "publisher"),
+                { wire: "base", to: "base" },
+                {
+                    wire: "type",
+                    to: "typedStage",
+                    toWire: (model) => {
+                        const s = model["typedStage"];
+                        return s instanceof IdfTypedStageComponent ? s.typeWire() : undefined;
+                    },
+                    fromWire: () => undefined,
+                },
+                {
+                    wire: "stage",
+                    to: "typedStage",
+                    toWire: (model) => {
+                        const s = model["typedStage"];
+                        return s instanceof IdfTypedStageComponent ? s.stageWire() : undefined;
+                    },
+                    fromWire: () => undefined,
+                },
+                typedStageObjWire,
+            ];
+        }
+        constructor(attrs = {}) {
+            super(attrs);
+            const self = this;
+            if (self["publisherBody"] === undefined)
+                self["publisherBody"] = "IDF";
+            if (self["typedStage"] === undefined) {
+                self["typedStage"] = new IdfTypedStageComponent(stage);
+            }
+        }
+        render() {
+            return [
+                this.base?.toHuman() ?? "",
+                "/",
+                this.typedStage.abbreviation(),
+                " ",
+                this.number ?? "",
+                this.date?.present() ? `:${this.date.render()}` : "",
+            ].join("");
+        }
+        toUrn() {
+            return new IdfUrnGenerator(this).generate();
+        }
+        root() {
+            return this.base?.root() ?? this;
+        }
+    }
+    registerType(IdfSupplement);
+    return IdfSupplement;
+}
+export const AmendmentClass = supplementClass({ kind: "amendment", typeCode: "amd" }, AMD_STAGE);
+export const CorrigendumClass = supplementClass({ kind: "corrigendum", typeCode: "cor" }, COR_STAGE);
+export const IDF_TYPE_CLASSES = {
+    is: InternationalStandardClass,
+    rm: ReviewedMethodClass,
+    amd: AmendmentClass,
+    cor: CorrigendumClass,
+};
+export const IDF_ATTRIBUTES = IdfIdentifier.attributes;

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

@@ -0,0 +1,3 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare function preprocessIec(input: string): string;
+export declare const iecGrammar: Grammar;