@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/cen_cenelec/model.js

@@ -0,0 +1,490 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { PubidDate } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+export const TYPED_STAGES = [
+    { code: "pwien", stage_code: "preliminary", type_code: "en", abbr: "pWI EN" },
+    { code: "pren", stage_code: "proposal", type_code: "en", abbr: "prEN" },
+    { code: "fpren", stage_code: "final_proposal", type_code: "en", abbr: "FprEN" },
+    { code: "fven", stage_code: "formal_vote", type_code: "en", abbr: "FV prEN" },
+    { code: "ven", stage_code: "vote", type_code: "en", abbr: "vEN" },
+    { code: "puben", stage_code: "published", type_code: "en", abbr: "EN" },
+    { code: "rven", stage_code: "review", type_code: "en", abbr: "rvEN" },
+    { code: "racen", stage_code: "reactivation", type_code: "en", abbr: "racEN" },
+    { code: "wden", stage_code: "withdrawn", type_code: "en", abbr: "wdEN" },
+    { code: "pubts", stage_code: "published", type_code: "ts", abbr: "TS" },
+    { code: "prts", stage_code: "proposal", type_code: "ts", abbr: "prTS" },
+    { code: "pubtr", stage_code: "published", type_code: "tr", abbr: "TR" },
+    { code: "pubcwa", stage_code: "published", type_code: "cwa", abbr: "CWA" },
+    { code: "pubguide", stage_code: "published", type_code: "guide", abbr: "Guide" },
+    { code: "pubhd", stage_code: "published", type_code: "hd", abbr: "HD" },
+    { code: "pubes", stage_code: "published", type_code: "es", abbr: "ES" },
+    { code: "pubcr", stage_code: "published", type_code: "cr", abbr: "CR" },
+    { code: "pubenv", stage_code: "published", type_code: "env", abbr: "ENV" },
+];
+export const DEFAULT_TYPED_STAGE = TYPED_STAGES.find((s) => s.code === "puben");
+export function locateStage(abbr) {
+    const up = abbr.toUpperCase();
+    return TYPED_STAGES.find((s) => s.abbr.toUpperCase() === up);
+}
+export function locateStageByCode(code) {
+    return TYPED_STAGES.find((s) => s.code === code);
+}
+export const PUBLISHER_TYPES = ["CWA", "HD", "ES", "CR", "ENV"];
+const TYPE_CLASS = {
+    en: "european-norm",
+    ts: "technical-specification",
+    tr: "technical-report",
+    guide: "guide",
+    cwa: "cen-workshop-agreement",
+    hd: "harmonization-document",
+    es: "european-specification",
+    cr: "cen-report",
+    env: "european-prestandard",
+};
+const CLASS_SHORT = {
+    "european-norm": "EN",
+    "technical-specification": "TS",
+    "technical-report": "TR",
+    guide: "Guide",
+    "cen-workshop-agreement": "CWA",
+    "harmonization-document": "HD",
+    "cenelec-harmonization-document": "HD",
+    "european-specification": "ES",
+    "cen-report": "CR",
+    "european-prestandard": "ENV",
+};
+export function locateTypeClass(typeCode) {
+    const key = typeCode;
+    return key in TYPE_CLASS ? key : undefined;
+}
+const dateWire = {
+    wire: "date",
+    to: "date",
+    toWire: (model) => {
+        const date = model["date"];
+        if (date === undefined)
+            return undefined;
+        // The shared flattener turns a single-field date into the bare "year"
+        // scalar; a month keeps the nested form.
+        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;
+    },
+};
+const stageWire = {
+    wire: "stage",
+    to: "typedStage",
+    toWire: (model) => {
+        const stage = model["typedStage"];
+        return stage?.code;
+    },
+    fromWire: (hash) => {
+        const code = hash["stage"];
+        if (typeof code !== "string")
+            return undefined;
+        return locateStageByCode(code);
+    },
+};
+export class CenIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+        part: { type: "string" },
+        date: { type: PubidDate },
+        typedStage: { type: "string" },
+        type: { type: "string" },
+        publisher: { type: "string" },
+        copublishers: { type: "string", collection: true },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, dateWire, stageWire, { wire: "publisher", to: "publisher" }, { wire: "copublishers", to: "copublishers" });
+    root() {
+        return this;
+    }
+    toUrn() {
+        return new CenUrnGenerator(this).generate();
+    }
+}
+function draftAbbr(id) {
+    const abbr = id.typedStage?.abbr;
+    return abbr === "prEN" || abbr === "FprEN" ? abbr : undefined;
+}
+function supplementToken(id) {
+    const self = id;
+    const prefix = self["_supplement"] === "corrigendum" ? "AC" : "A";
+    let result = `${prefix}${self["number"] ?? ""}`;
+    if (self["year"] !== undefined && self["year"] !== "") {
+        result += `:${self["year"]}`;
+        if (self["month"] !== undefined && self["month"] !== "")
+            result += `-${self["month"]}`;
+    }
+    return result;
+}
+function renderSingle(id, classShort) {
+    const parts = [];
+    const isDraftStage = draftAbbr(id) !== undefined;
+    const typeShort = isDraftStage
+        ? id.typedStage.type_code.toUpperCase()
+        : id.type ?? classShort ?? "EN";
+    let useSlashBeforeType = false;
+    if (PUBLISHER_TYPES.includes(typeShort)) {
+        parts.push(id.typedStage !== undefined && id.typedStage.abbr !== typeShort
+            ? id.typedStage.abbr
+            : typeShort);
+    }
+    else if (isDraftStage) {
+        parts.push(id.typedStage.abbr);
+    }
+    else if (id.publisher !== undefined) {
+        parts.push(id.publisher);
+        useSlashBeforeType = true;
+    }
+    if (id.copublishers !== undefined && id.copublishers.length > 0) {
+        const copubStr = id.copublishers.join("/");
+        if (parts.length > 0) {
+            parts[parts.length - 1] = `${parts[parts.length - 1]}/${copubStr}`;
+        }
+        else {
+            parts.push(copubStr);
+        }
+    }
+    if (typeShort !== "EN" && typeShort !== "Guide" && !PUBLISHER_TYPES.includes(typeShort)) {
+        parts.push(useSlashBeforeType && parts.length > 0 ? `/${typeShort}` : typeShort);
+    }
+    else if (typeShort === "Guide") {
+        parts.push("Guide");
+    }
+    if (id.number !== undefined) {
+        parts.push(id.part !== undefined ? `${id.number}-${id.part}` : id.number);
+    }
+    let result = "";
+    parts.forEach((part, idx) => {
+        if (idx > 0 && !part.startsWith("/"))
+            result += " ";
+        result += part;
+    });
+    if (id.date !== undefined && id.date.present()) {
+        result += `:${id.date.render()}`;
+    }
+    return result;
+}
+function renderAdopted(id) {
+    const publishers = [id.publisher, ...(id.copublishers ?? [])].filter((p) => p !== undefined && p !== "");
+    const draft = draftAbbr(id);
+    if (draft !== undefined && publishers.length > 0)
+        publishers[0] = draft;
+    let result = publishers.join("/");
+    const adopted = id["adopted"];
+    if (adopted !== undefined)
+        result += ` ${adopted.toHuman()}`;
+    return result;
+}
+const ISO_TYPE_SEGMENT = {
+    "technical-specification": "ts",
+    "technical-report": "tr",
+    guide: "guide",
+};
+/** MR string of a nested iso/iec document read from its wire hash. */
+function mrFromHash(hash) {
+    const type = String(hash["_type"] ?? "");
+    const segments = [];
+    if (type.startsWith("pubid:iso")) {
+        // ISO's MR string dashes copublishers onto the publisher slot
+        // ("iso-iec.27017.2026"); IEC's does not.
+        const copubs = Array.isArray(hash["copublishers"]) ? hash["copublishers"].map(String) : [];
+        segments.push(["iso", ...copubs.map((c) => c.toLowerCase())].join("-"));
+    }
+    else if (type.startsWith("pubid:iec")) {
+        segments.push("iec");
+    }
+    const typeSuffix = type.split(":")[2] ?? "";
+    const typeSegment = ISO_TYPE_SEGMENT[typeSuffix];
+    if (typeSegment !== undefined)
+        segments.push(typeSegment);
+    const identity = [hash["number"], hash["part"], hash["subpart"]]
+        .map((s) => String(s ?? ""))
+        .filter((s) => s !== "")
+        .join("-");
+    if (identity !== "")
+        segments.push(identity);
+    if (hash["year"] !== undefined)
+        segments.push(String(hash["year"]));
+    const base = hash["base"];
+    if (base !== undefined && typeof base === "object" && !Array.isArray(base)) {
+        const baseMr = mrFromHash(base);
+        const suffixTag = typeSuffix.endsWith("amendment") ? "amd" : "cor";
+        const suffix = [hash["number"], hash["year"]]
+            .map((s) => String(s ?? ""))
+            .filter((s) => s !== "")
+            .map((s, i) => (i === 0 ? s : `.${s}`))
+            .join("");
+        return suffix === "" ? `${baseMr}_${suffixTag}` : `${baseMr}_${suffixTag}.${suffix}`;
+    }
+    return segments.join(".");
+}
+// --- URN -----------------------------------------------------------------------
+class CenUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        return this.urnFor(this.identifier);
+    }
+    urnFor(id) {
+        const self = id;
+        const base = self["base"];
+        if (base !== undefined) {
+            return [this.urnFor(base), ...this.supplementSegments(id)].join(":");
+        }
+        const identifiers = self["identifiers"];
+        if (identifiers !== undefined) {
+            const [first, ...rest] = identifiers;
+            return [
+                this.urnFor(first),
+                ...rest.flatMap((s) => ["plus", ...this.supplementSegments(s)]),
+            ].join(":");
+        }
+        const adopted = self["adopted"];
+        if (adopted !== undefined) {
+            const body = [this.mrPublisher(id), this.adoptedMr(adopted)]
+                .filter((s) => s !== undefined && s !== "")
+                .join(".")
+                .replaceAll(".", ":")
+                .replaceAll("_", ":");
+            const segments = [`urn:cen:${body}`];
+            const code = id.typedStage?.stage_code;
+            if (code !== undefined && code !== "published")
+                segments.push(`stage.${code}`);
+            return segments.join(":");
+        }
+        return this.baseUrn(id);
+    }
+    supplementSegments(id) {
+        const self = id;
+        if (self["_supplement"] === "fragment") {
+            return ["frag", String(self["number"] ?? "")].filter((s) => s !== "");
+        }
+        if (self["_supplement"] === "corrigendum") {
+            const segments = ["cor", self["number"], this.supplementDate(self)];
+            return segments.map((s) => String(s ?? "")).filter((s) => s !== "");
+        }
+        const segments = ["amd", self["number"], self["year"]];
+        return segments.map((s) => String(s ?? "")).filter((s) => s !== "");
+    }
+    supplementDate(id) {
+        const year = id["year"];
+        if (year === undefined || year === "")
+            return undefined;
+        return [year, id["month"]].filter((m) => m !== undefined && m !== "").join("-");
+    }
+    mrPublisher(id) {
+        return (id.publisher ?? "en").toLowerCase();
+    }
+    /** The adopted document's MR string (iso/iec supplement recursion). */
+    adoptedMr(adopted) {
+        return mrFromHash(adopted.toHash());
+    }
+    baseUrn(id) {
+        const parts = ["urn", "cen", (id.publisher ?? "en").toLowerCase()];
+        if (id.copublishers !== undefined && id.copublishers.length > 0) {
+            parts[2] = `${parts[2]}-${id.copublishers.map((c) => c.toLowerCase()).join("-")}`;
+        }
+        if (id.number !== undefined) {
+            parts.push(id.part !== undefined ? `${id.number}-${id.part}` : id.number);
+        }
+        if (id.date !== undefined && id.date.present()) {
+            parts.push(id.date.render("urn"));
+        }
+        const code = id.typedStage?.stage_code;
+        if (code !== undefined && code !== "published")
+            parts.push(`stage.${code}`);
+        return parts.join(":");
+    }
+}
+function documentClass(spec) {
+    const defaultPublisher = PUBLISHER_TYPES.includes(spec.short) ? spec.short : "EN";
+    class CenConcrete extends CenIdentifier {
+        static polymorphicName = `pubid:cencenelec:${spec.kind}`;
+        static urnGenerator = CenUrnGenerator;
+        static get attributes() {
+            return extendAttributes(CenIdentifier, {
+                publisher: { type: "string", default: defaultPublisher },
+                type: { type: "string", default: spec.short },
+                adopted: { type: CenIdentifier },
+            });
+        }
+        static get mappings() {
+            return [...CenIdentifier.mappings, { wire: "adopted", to: "adopted" }];
+        }
+        constructor(attrs = {}) {
+            super(attrs);
+            // An ENV adoption renders "ENV <adopted>" (render_european_prestandard).
+            if (this.adopted !== undefined) {
+                this["_envAdopted"] = true;
+            }
+        }
+        render() {
+            if (this.adopted !== undefined) {
+                return `${spec.short} ${this.adopted.toHuman()}`;
+            }
+            return renderSingle(this, spec.short);
+        }
+        root() {
+            return this;
+        }
+        toUrn() {
+            if (this.adopted !== undefined) {
+                const body = [spec.short.toLowerCase(), this.adoptedUrnBody()]
+                    .filter((s) => s !== "")
+                    .join(":");
+                return `urn:cen:${body}`;
+            }
+            return super.toUrn();
+        }
+        adoptedUrnBody() {
+            const adopted = this.adopted;
+            const rawPub = adopted["publisher"];
+            const pub = (typeof rawPub === "string"
+                ? rawPub
+                : typeof rawPub?.publisher === "string"
+                    ? rawPub.publisher
+                    : String(rawPub?.body ?? "")).toLowerCase();
+            const rawType = adopted["type"];
+            const typeKey = this.adopted.constructor.typeKey;
+            const type = typeKey !== undefined && typeKey !== "is"
+                ? typeKey
+                : (typeof rawType === "string" ? rawType : String(rawType?.abbr ?? "")).toLowerCase();
+            const segments = [
+                pub,
+                type,
+                [adopted["number"], adopted["part"], adopted["subpart"]]
+                    .map((s) => String(s ?? ""))
+                    .filter((s) => s !== "")
+                    .join("-"),
+                adopted["year"] ?? this.adopted?.date?.year,
+            ]
+                .map((s) => String(s ?? ""))
+                .filter((s) => s !== "");
+            return segments.join(":");
+        }
+    }
+    registerType(CenConcrete);
+    return CenConcrete;
+}
+export const CEN_DOCUMENT_CLASSES = new Map(Object.keys(TYPE_CLASS).map((key) => [
+    key,
+    documentClass({ kind: TYPE_CLASS[key], short: CLASS_SHORT[TYPE_CLASS[key]] }),
+]));
+// The CENELEC HD variant has its own _type; the builder routes plain HD to
+// the CEN class (Ruby's registry finds it first).
+export const CenelecHarmonizationDocumentClass = documentClass({
+    kind: "cenelec-harmonization-document",
+    short: "HD",
+});
+function supplementClass(kind, extraDefs) {
+    class CenSupplement extends CenIdentifier {
+        static polymorphicName = `pubid:cencenelec:${kind}`;
+        static urnGenerator = CenUrnGenerator;
+        static get attributes() {
+            return extendAttributes(CenIdentifier, {
+                base: { type: CenIdentifier },
+                ...extraDefs,
+            });
+        }
+        static get mappings() {
+            return [
+                ...CenIdentifier.mappings.filter((m) => m.wire !== "publisher" && m.wire !== "copublishers" && m.wire !== "date" && m.wire !== "stage" && m.wire !== "type"),
+                { wire: "base", to: "base" },
+                { wire: "number", to: "number" },
+                { wire: "year", to: "year" },
+                ...(kind === "corrigendum" ? [{ wire: "month", to: "month" }] : []),
+            ];
+        }
+        constructor(attrs = {}) {
+            super(attrs);
+            this["_supplement"] = kind;
+        }
+        render() {
+            const self = this;
+            self["_supplement"] = kind;
+            if (kind === "fragment") {
+                return `${this.base?.toHuman() ?? ""} FRAG${this.number ?? ""}`;
+            }
+            return `${this.base?.toHuman() ?? ""}/${supplementToken(this)}`;
+        }
+        root() {
+            return this.base?.root() ?? this;
+        }
+    }
+    registerType(CenSupplement);
+    return CenSupplement;
+}
+export const AmendmentClass = supplementClass("amendment", { year: { type: "string" } });
+export const CorrigendumClass = supplementClass("corrigendum", { year: { type: "string" }, month: { type: "string" } });
+export const FragmentClass = supplementClass("fragment", {});
+export const ConsolidatedIdentifierClass = (() => {
+    class CenConsolidated extends CenIdentifier {
+        static polymorphicName = "pubid:cencenelec:consolidated-identifier";
+        static urnGenerator = CenUrnGenerator;
+        static get attributes() {
+            return extendAttributes(CenIdentifier, {
+                identifiers: { type: CenIdentifier, collection: true },
+            });
+        }
+        static get mappings() {
+            return [{ wire: "identifiers", to: "identifiers" }];
+        }
+        render() {
+            const [base, ...supplements] = this.identifiers;
+            return ((base?.toHuman() ?? "") +
+                supplements
+                    .map((sub) => {
+                    const self = sub;
+                    return `+${supplementToken(sub)}`;
+                })
+                    .join(""));
+        }
+        root() {
+            return this.identifiers[0]?.root() ?? this;
+        }
+    }
+    registerType(CenConsolidated);
+    return CenConsolidated;
+})();
+export const AdoptedEuropeanNormClass = (() => {
+    class CenAdopted extends CenIdentifier {
+        static polymorphicName = "pubid:cencenelec:adopted-european-norm";
+        static urnGenerator = CenUrnGenerator;
+        static get attributes() {
+            return extendAttributes(CenIdentifier, {
+                publisher: { type: "string", default: "EN" },
+                adopted: { type: CenIdentifier },
+            });
+        }
+        static get mappings() {
+            return [
+                { wire: "publisher", to: "publisher" },
+                { wire: "copublishers", to: "copublishers" },
+                stageWire,
+                { wire: "adopted", to: "adopted" },
+            ];
+        }
+        render() {
+            return renderAdopted(this);
+        }
+        root() {
+            return this;
+        }
+    }
+    registerType(CenAdopted);
+    return CenAdopted;
+})();
+export const EuropeanPrestandardClass = CEN_DOCUMENT_CLASSES.get("env");
+export const EuropeanNormClass = CEN_DOCUMENT_CLASSES.get("en");

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

@@ -0,0 +1,5 @@
+import { Grammar } from "../../grammar/engine.js";
+/** Parser.parse's preprocessing: strip, drop #-comments, collapse runs,
+ * insert the missing colon in "/E2007"-style language-years. */
+export declare function preprocessCie(input: string): string;
+export declare const cieGrammar: Grammar;

package/dist/flavors/cie/grammar.js

@@ -0,0 +1,127 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/cie/parser.rb — the CIE grammar's 17 alternatives,
+ * longest/most-specific first (PEG ordered choice). The dual-style date
+ * era is carried by WHICH rule matched (current_date ":" vs
+ * legacy_date "-"), wrapped in its own marker so the builder can derive
+ * `style` without a separate separator field.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digit = match("[0-9]");
+    const digits = digit.repeat(1, Infinity);
+    const upper = match("[A-Z]");
+    const space = str(" ");
+    const dash = str("-");
+    const colon = str(":");
+    const dot = str(".");
+    const slash = str("/");
+    const comma = str(",");
+    // Year 1900-2099.
+    const yearDigits = str("19").or(str("20")).then(digit.repeat(2, 2));
+    rule("legacy_date", () => dash.then(yearDigits.as("year")).as("legacy_date"));
+    rule("current_date", () => colon.then(yearDigits.as("year")).as("current_date"));
+    rule("date", () => rules["current_date"].or(rules["legacy_date"]));
+    // Legacy NUMBER-YEAR ("001-1980"), optionally with "(RU-2020)".
+    rule("legacy_code_with_year", () => str("CIE").then(space, digits.as("number"), dash, yearDigits.as("year"), ref(rules, "language_paren_year").or(str("")).as("trailing_lang")));
+    rule("code_with_iteration", () => digits.as("number").then(dot, digits.as("iteration")));
+    rule("code_with_part_and_iteration_slash", () => digits.as("number").then(slash, digits.as("part"), dot, digits.as("iteration")));
+    rule("code_with_part_and_iteration_dash", () => digits
+        .as("number")
+        .then(dash, digits.as("part"), dot, digits.as("iteration"), dash.absent()));
+    // Part 1-3 digits, never a 4-digit year and never dot/dash after.
+    rule("code_with_part_dash", () => digits
+        .as("number")
+        .then(dash, digit.repeat(1, 3).as("part"), str("").as("dash_sep"), str("19").or(str("20")).absent(), dot.or(dash).absent()));
+    rule("code_with_part_slash", () => digits
+        .as("number")
+        .then(slash, digits.as("part"), str("").as("slash_sep"), dot.absent()));
+    rule("code_simple", () => digits.as("number"));
+    rule("code", () => rules["code_with_part_and_iteration_slash"]
+        .or(rules["code_with_part_and_iteration_dash"], rules["code_with_iteration"], rules["code_with_part_slash"], rules["code_with_part_dash"], rules["code_simple"]));
+    // Language formats: /E (slash), (DE) (paren), (RU-2021) (paren_year).
+    rule("language_slash", () => slash.then(upper.as("lang_code")).as("language_slash"));
+    rule("language_paren", () => str("(")
+        .then(match("[A-Za-z]").repeat(1, 3).as("lang_code"), str(")"))
+        .as("language_paren"));
+    rule("language_paren_year", () => space
+        .maybe()
+        .then(str("("), upper.repeat(2, Infinity).as("lang_code"), dash, yearDigits.as("trans_year"), str(")"))
+        .as("language_paren_year"));
+    rule("language", () => rules["language_paren_year"]
+        .or(rules["language_paren"], rules["language_slash"]));
+    const sPrefix = () => str("S").then(space);
+    const stageCode = () => str("FDIS").or(str("DIS"), str("DS")).then(space);
+    const docType = () => str("TR").or(str("TS"));
+    // Proceedings paper code: 1+ uppercase letters (OP, PO, PP, …).
+    const paperCode = () => match("[A-Z]").repeat(1, Infinity).as("paper_code");
+    // Techstreet opaque conference variant; lowercase-alnum so it cannot
+    // collide with /E, /Cor or /IEC tails.
+    rule("variant_slug", () => slash.then(match("[0-9a-z]").repeat(1, Infinity).as("variant")));
+    // "CIE x043-OP01".
+    rule("conf_proceedings", () => str("CIE").then(space, str("x"), digits.as("conf_number"), dash, paperCode(), digits.as("paper_number")));
+    // "CIE OP02 1-5".
+    rule("standalone_proceedings", () => str("CIE").then(space, paperCode(), digits.as("paper_number"), space, digits.then(dash, digits).as("page_range")));
+    rule("d_series_identifier", () => str("CIE").then(space, str("D").as("d_prefix"), digits.as("number"), rules["date"]));
+    // "CIE S 007/1998" — narrow number(+iteration) so part_slash can't
+    // greedily eat the /year.
+    rule("standard_with_slash_year", () => str("CIE").then(space, stageCode().maybe().as("stage"), sPrefix().maybe().as("s_prefix"), digits.as("number").then(dot.then(digits.as("iteration")).maybe()), slash, yearDigits.as("slash_year")));
+    // "DIS 025-SP1/E:2019".
+    rule("dis_with_supplement", () => str("CIE").then(space, stageCode().as("stage"), sPrefix().maybe().as("s_prefix"), digits.as("base_number"), dash, str("SP"), digits.as("supplement_number"), dot.then(digits.as("supplement_part")).maybe(), slash, upper.as("lang_code"), colon.as("lang_colon"), yearDigits.as("year")));
+    rule("standard_identifier", () => str("CIE").then(space, stageCode().maybe().as("stage"), sPrefix().maybe().as("s_prefix"), rules["code"], rules["language"]
+        .then(rules["date"])
+        .as("lang_before")
+        .or(rules["date"].then(rules["language"].maybe()).as("date_then_lang"), rules["date"])
+        .maybe()));
+    // "CIE S 014-4/E:2007" (language/year, no ISO reference).
+    rule("standard_with_language_year", () => str("CIE").then(space, stageCode().maybe().as("stage"), sPrefix().maybe().as("s_prefix"), rules["code"], slash, upper.as("lang_code"), colon.as("lang_colon"), yearDigits.as("year")));
+    rule("conference_identifier", () => str("CIE").then(space, str("x").as("conference"), digits.as("conf_number"), rules["date"], space.then(str("Amendment"), space, digits.as("amd_number")).maybe(), rules["variant_slug"].maybe()));
+    // "CIE ISO 11664-1:2019(E)" — the absent-guard rejects "ISO/CIE".
+    rule("joint_with_iso", () => str("CIE")
+        .then(space, str("ISO").as("copublisher"), slash.then(str("CIE")).absent(), space, docType().then(space).maybe().as("doc_type"), stageCode().maybe().as("stage"), digits.as("number"), dash.then(digits.as("part")).maybe(), colon.or(dash).then(yearDigits.as("year")).maybe(), rules["language"].maybe()));
+    rule("joint_with_iso_cie", () => str("CIE").then(space, str("ISO/CIE").as("copublisher"), space, docType().then(space).maybe().as("doc_type"), digits.as("number"), colon.then(yearDigits.as("year")).maybe(), rules["language"].maybe()));
+    // IEC always joins the part with a dot and the year with a dash.
+    rule("joint_with_iec", () => str("CIE").then(space, str("IEC").as("copublisher"), space, digits.as("number"), dot, digits.as("part"), dash, yearDigits.as("year")));
+    // "CIE S 008/E:2001 (ISO 8995-1:2002(E))".
+    rule("identical_with_iso", () => str("CIE").then(space, sPrefix().maybe().as("s_prefix"), digits.as("number"), dot.then(digits.as("iteration"))
+        .or(dash.then(digits.as("part")))
+        .maybe(), slash
+        .then(upper
+        .as("lang_code")
+        .then(colon.as("lang_colon"), yearDigits.as("year"))
+        .or(upper.as("lang_code").then(yearDigits.as("year")), yearDigits.as("slash_year")))
+        .maybe(), space, str("(ISO"), space, match("[0-9A-Z:/.\\-]")
+        .repeat(1, Infinity)
+        .then(str("(").then(match("[A-Z]").repeat(1, Infinity), str(")")).maybe())
+        .as("iso_reference"), str(")")));
+    // "CIE S 009:2002/IEC 62471:2006".
+    rule("dual_with_iec", () => str("CIE").then(space, sPrefix().maybe().as("s_prefix"), digits.as("number"), colon, yearDigits.as("year"), slash, str("IEC"), space, match("[^)\\n]").repeat(1, Infinity).as("iec_identifier")));
+    rule("supplement_identifier", () => str("CIE").then(space, digits.as("base_number"), dash, str("SP"), digits.as("supplement_number"), dot.then(digits.as("supplement_part")).maybe(), colon, yearDigits.as("year")));
+    rule("corrigendum_identifier", () => str("CIE")
+        .then(space, digits.as("base_number"), dash
+        .then(str("SP"), digits.as("base_supplement"), dot.then(digits.as("base_supplement_part")).maybe())
+        .maybe(), colon, yearDigits.as("base_year"), slash, str("Cor"), digits.as("cor_number"), colon, yearDigits.as("cor_year")));
+    rule("bundle_identifier", () => str("CIE").then(space, digits.as("first_number"), dash, str("SP"), digits, dot, digits, colon, yearDigits, comma.then(digits.as("next_number"), dash, str("SP"), digits, dot, digits, colon, yearDigits)
+        .repeat(1, Infinity)
+        .as("bundle_items")));
+    rule("tutorial_bundle", () => str("CIE Tutorials Bundle").then(space, digits.as("bundle_number")));
+    rule("identifier", () => rules["tutorial_bundle"]
+        .or(rules["bundle_identifier"], rules["joint_with_iso_cie"], rules["joint_with_iso"], rules["joint_with_iec"], rules["identical_with_iso"], rules["dis_with_supplement"], rules["dual_with_iec"], rules["corrigendum_identifier"], rules["supplement_identifier"], rules["standard_with_language_year"], rules["standard_with_slash_year"], rules["d_series_identifier"], rules["conf_proceedings"], rules["standalone_proceedings"], 
+    // Before standard_identifier, to catch the 001-1980 pattern.
+    rules["legacy_code_with_year"], rules["conference_identifier"], rules["standard_identifier"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+/** Parser.parse's preprocessing: strip, drop #-comments, collapse runs,
+ * insert the missing colon in "/E2007"-style language-years. */
+export function preprocessCie(input) {
+    return input
+        .trim()
+        .replace(/\s*#.*$/, "")
+        .replace(/\s+/g, " ")
+        .replace(/\/(E|F|G|DE|ES|CN|RU|FR)(\d{4})/g, "/$1:$2");
+}
+export const cieGrammar = { rules: buildRules(), root: "root" };

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

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