@pubid/pubid 0.1.7 → 0.1.9

package/dist/flavors/cen_cenelec/grammar.js

@@ -19,13 +19,18 @@ function buildRules() {
     const anyChar = match("[\\s\\S]");
     const publisherToken = (name) => str(name);
     rule("publisher", () => publisherToken("CWA").or(publisherToken("HD"), publisherToken("ES"), publisherToken("CR"), publisherToken("ENV")).as("publisher")
-        .or(publisherToken("EN").as("publisher").then(slash.then(publisherToken("CLC").as("copublisher")).maybe()))
-        .or(publisherToken("CEN").as("publisher").then(slash.then(publisherToken("CLC").as("copublisher")).maybe()))
-        .or(publisherToken("CLC").as("publisher").then(slash.then(publisherToken("CEN").as("copublisher")).maybe()))
+        .or(publisherToken("EN").as("publisher").then(ref(rules, "copublishers").maybe()))
+        .or(publisherToken("CEN").as("publisher").then(ref(rules, "copublishers").maybe()))
+        .or(publisherToken("CLC").as("publisher").then(ref(rules, "copublishers").maybe()))
         .or(publisherToken("EN").as("publisher")));
     rule("stage_prefix", () => str("FprEN").or(str("prEN")).as("type_with_stage"));
+    rule("copublishers", () => ref(rules, "copublisher").repeat(1, Infinity).as("copublishers"));
+    rule("copublisher", () => slash.then(publisherToken("CLC").or(publisherToken("ETSI")).as("copublisher")));
+    rule("version", () => space.then(str("V")).then(digits.as("v_major")).then(str(".").then(digits.as("v_minor")))
+        .then(str(".").then(digits.as("v_patch")))
+        .as("version"));
     rule("type", () => str("Guide").or(str("GUIDE"), str("TR"), str("TS")).as("type"));
-    rule("number", () => digits.as("number"));
+    rule("number", () => digits.then(match(" [0-9]").then(digits).repeat(0, Infinity)).as("number"));
     rule("part", () => dash.then(match("[0-9-]").repeat(1, Infinity).as("part")));
     rule("parts", () => ref(rules, "part").repeat(0, Infinity).as("parts"));
     rule("year", () => colon.then(digit.repeat(4, 4).as("year")));
@@ -84,6 +89,7 @@ function buildRules() {
         .then(space.then(ref(rules, "adopted_string")).maybe())
         .then(space.then(ref(rules, "type")).or(slash.then(ref(rules, "type"))).maybe())
         .then(space.then(ref(rules, "number")).then(ref(rules, "parts"))
+        .then(ref(rules, "version").maybe())
         .then(ref(rules, "year").maybe())
         .maybe())
         .then(ref(rules, "supplements"))

package/dist/flavors/cen_cenelec/index.js

@@ -1,4 +1,4 @@
-import { parseGrammar } from "../../grammar/engine.js";
+import { parseGrammar, ParseFailed } from "../../grammar/engine.js";
 import { grammarImplementation } from "../index.js";
 import { cenCenelecGrammar, preprocessCenCenelec } from "./grammar.js";
 import { AdoptedEuropeanNormClass, AmendmentClass, CEN_DOCUMENT_CLASSES, ConsolidatedIdentifierClass, CorrigendumClass, DEFAULT_TYPED_STAGE, EuropeanPrestandardClass, FragmentClass, PUBLISHER_TYPES, locateStage, locateTypeClass, } from "./model.js";
@@ -28,6 +28,11 @@ class CenBuilder {
         if (d["fragment_number"] !== undefined) {
             return this.buildFragmentIdentifier(d);
         }
+        // "TR" is a CEN or CLC technical report ("CEN/TR", "CLC/TR") — the
+        // EN publisher never carries it (pubid ruling 2026-10-13).
+        if (str(d["type"]) === "TR" && str(d["publisher"]) === "EN") {
+            throw new ParseFailed('"EN" cannot be "TR": a technical report is "CEN/TR" or "CLC/TR"', 0);
+        }
         const base = this.buildBaseDocument(d);
         if (this.hasSlashSupplements(d)) {
             return this.buildStandaloneSupplement(base, d);
@@ -93,12 +98,26 @@ class CenBuilder {
         if (baseData["publisher"] !== undefined) {
             attrs["publisher"] = str(baseData["publisher"]);
         }
+        if (Array.isArray(baseData["copublishers"])) {
+            const copubs = baseData["copublishers"]
+                .map((c) => str(c["copublisher"]))
+                .filter((c) => c !== undefined);
+            if (copubs.length > 0)
+                attrs["copublishers"] = copubs;
+        }
         if (baseData["copublisher"] !== undefined) {
             attrs["copublishers"] = [str(baseData["copublisher"])];
         }
         if (baseData["number"] !== undefined) {
             attrs["number"] = str(baseData["number"]);
         }
+        if (baseData["version"] !== undefined) {
+            const v = baseData["version"];
+            // the gem's parg capture includes the leading space (" V2.2.1")
+            attrs["version"] = isObj(v)
+                ? ` V${str(v["v_major"])}.${str(v["v_minor"])}.${str(v["v_patch"])}`
+                : str(v);
+        }
         if (Array.isArray(baseData["parts"]) && baseData["parts"].length > 0) {
             const first = baseData["parts"][0];
             attrs["part"] = isObj(first) ? str(first["part"]) : str(first);

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

@@ -26,6 +26,7 @@ export declare abstract class CenIdentifier extends BaseIdentifier {
     static mappings: FieldMapping[];
     readonly number: string | undefined;
     readonly part: string | undefined;
+    readonly version: string | undefined;
     readonly date: PubidDate | undefined;
     readonly typedStage: CenTypedStage | undefined;
     readonly type: string | undefined;

package/dist/flavors/cen_cenelec/model.js

@@ -102,12 +102,13 @@ export class CenIdentifier extends BaseIdentifier {
         number: { type: "string" },
         part: { type: "string" },
         date: { type: PubidDate },
+        version: { type: "string" },
         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" });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, dateWire, { wire: "version", to: "version" }, stageWire, { wire: "publisher", to: "publisher" }, { wire: "copublishers", to: "copublishers" });
     root() {
         return this;
     }
@@ -166,6 +167,8 @@ function renderSingle(id, classShort) {
     }
     if (id.number !== undefined) {
         parts.push(id.part !== undefined ? `${id.number}-${id.part}` : id.number);
+        if (id.version !== undefined)
+            parts[parts.length - 1] += id.version;
     }
     let result = "";
     parts.forEach((part, idx) => {

package/dist/flavors/evs/grammar.js

@@ -1,21 +1,67 @@
-import { ref, str } from "../../grammar/engine.js";
+import { match, ref, str } from "../../grammar/engine.js";
 import { cenCenelecGrammar } from "../cen_cenelec/grammar.js";
 /**
- * Port of lib/pubid/evs/parser.rb — "EVS" ("-" | " ") <CEN identifier>,
- * with the CEN/CENELEC grammar's identifier rule embedded as an atom
- * (the adopted subtree goes straight to the CEN builder as data, no
- * string re-serialization).
+ * Port of the EVS grammar (evs.parg v0.3.0): the national prefix
+ * ("EVS" / "prEVS") over a CEN/CENELEC adoption, a direct ISO/IEC
+ * adoption, or a plain Estonian standard — plus the EVS-list
+ * supplements (the national annex, the COR/AC corrigendum, the AMD
+ * amendment spelling) with their semantic separators. The trailing
+ * language code extracts in the parse wrapper (the CEN adopted spine
+ * is greedy over plain text and would swallow it).
  */
 function buildRules() {
     const rules = {};
     const rule = (name, build) => {
         rules[name] = build();
     };
-    rule("root", () => str("EVS")
+    const digit = match("[0-9]");
+    const digits = digit.repeat(1, Infinity);
+    const year4 = digit.repeat(4, 4);
+    const space = str(" ");
+    const plus = str("+");
+    const slash = str("/");
+    const colon = str(":");
+    // " AMD1:2014" / "+AMD1" — the AMD amendment spelling
+    rule("evs_amd", () => ((plus.or(slash).or(space)).as("amd_separator")
+        .then(str("AMD").as("amd_kind"))
+        .then(digits.as("amd_number"))
+        .then(colon.then(year4.as("amd_year")).maybe())).as("evs_amd"));
+    // "+COR:2015" / "/COR" — the COR spelling (the CEN spine consumes +AC)
+    rule("evs_cor", () => ((plus.or(slash)).as("cor_separator")
+        .then(str("COR").as("cor_kind"))
+        .then(digits.as("cor_number").maybe())
+        .then(colon.then(year4.as("cor_year")).maybe())).as("evs_cor"));
+    // " AC:2015" — the space-separated AC spelling
+    rule("evs_ac", () => (space.as("cor_separator")
+        .then(str("AC").as("cor_kind"))
+        .then(digits.as("cor_number").maybe())
+        .then(colon.then(year4.as("cor_year")).maybe())).as("evs_cor"));
+    // "+NA:2010" / "/NA" — the national annex
+    rule("evs_na", () => ((plus.or(slash)).as("na_separator")
+        .then(str("NA"))
+        .then(colon.then(year4.as("na_year")).maybe())).as("na"));
+    // "EVS-ISO 9001:2015", "EVS-IEC 62368-1:2020"
+    rule("evs_intl", () => ((str("ISO").or(str("IEC"))).as("intl_org")
+        .then(space)
+        .then(digits.as("number"))
+        .then((dash.then(digits.as("part"))).maybe())
+        .then((colon.then(year4.as("year"))).maybe())).as("intl"));
+    // "EVS 921:2019", "EVS-TS 1:2019", "EVS-TR 1:2019"
+    rule("evs_plain", () => (((str("TS").or(str("TR"))).as("evs_type").then(space)).maybe()
+        .then(digits.as("number"))
+        .then((colon.then(year4.as("year"))).maybe())).as("plain"));
+    rule("root", () => str("pr").as("draft_prefix").maybe()
+        .then(str("EVS"))
         .then(str("-").or(str(" ")).as("evs_separator"))
-        .then(ref(cenCenelecGrammar.rules, "identifier").as("adopted")));
+        .then((ref(cenCenelecGrammar.rules, "identifier").as("adopted"))
+        .or(ref(rules, "evs_intl"))
+        .or(ref(rules, "evs_plain")))
+        .then(ref(rules, "evs_amd").maybe())
+        .then(ref(rules, "evs_cor").or(ref(rules, "evs_ac")).maybe())
+        .then(ref(rules, "evs_na").maybe()));
     return rules;
 }
+const dash = str("-");
 export const evsGrammar = {
     rules: buildRules(),
     root: "root",

package/dist/flavors/evs/index.js

@@ -1,24 +1,91 @@
 import { parseGrammar } from "../../grammar/engine.js";
 import { evsGrammar } from "./grammar.js";
 import { buildCenIdentifier } from "../cen_cenelec/index.js";
-import { NationalAdoption } from "./model.js";
+import { EstonianStandard, InternationalAdoption, NationalAdoption } from "./model.js";
 /**
  * Port of lib/pubid/evs/builder.rb — the :adopted subtree (from the
- * embedded CEN grammar) goes to the CEN/CENELEC builder as data.
+ * embedded CEN grammar) goes to the CEN/CENELEC builder as data; the
+ * ISO/IEC and plain shapes carry their captures directly. The trailing
+ * language code extracts before the grammar runs (the CEN adopted spine
+ * is greedy over plain text and would swallow it).
  */
-function buildIdentifier(tree) {
+const LANGUAGE_TAIL = / (et-en|et|en)$/;
+function buildIdentifier(tree, language) {
     const d = Array.isArray(tree)
         ? Object.assign({}, ...tree)
         : tree;
     const separator = d["evs_separator"] !== undefined ? String(d["evs_separator"]) : "-";
-    const base = buildCenIdentifier(d["adopted"]);
-    return new NationalAdoption({ base, separator });
+    const draft = d["draft_prefix"] !== undefined;
+    let id;
+    if (d["adopted"] !== undefined) {
+        // The adopted TS face carries no TS marker ("EVS-EN 16798-1:2019"):
+        // the TS-ness of an EN adoption is metadata, not identity — strip the
+        // type capture before the CEN builder routes on it.
+        const adoptedData = d["adopted"];
+        const tsAdopted = adoptedData["type"] === "TS" &&
+            adoptedData["publisher"] === "EN";
+        const cenTree = tsAdopted
+            ? Object.fromEntries(Object.entries(adoptedData).filter(([k]) => k !== "type"))
+            : adoptedData;
+        id = new NationalAdoption({
+            base: buildCenIdentifier(cenTree),
+            separator, draft_prefix: draft,
+        });
+    }
+    else if (d["intl"] !== undefined) {
+        const intl = d["intl"];
+        id = new InternationalAdoption({
+            number: String(intl["number"] ?? ""),
+            part: intl["part"] !== undefined ? String(intl["part"]) : undefined,
+            intl_org: String(intl["intl_org"] ?? ""),
+            year: intl["year"] !== undefined ? String(intl["year"]) : undefined,
+            separator, draft_prefix: draft,
+        });
+    }
+    else {
+        const plain = (d["plain"] ?? {});
+        id = new EstonianStandard({
+            number: String(plain["number"] ?? ""),
+            separator, language,
+            year: plain["year"] !== undefined ? String(plain["year"]) : undefined,
+            evs_type: plain["evs_type"] !== undefined ? String(plain["evs_type"]) : undefined,
+            draft_prefix: draft,
+        });
+    }
+    attachSupplement(id, d);
+    if (language !== undefined) {
+        id["language"] = language;
+    }
+    return id;
+}
+function attachSupplement(id, d) {
+    if (d["na"] !== undefined) {
+        const na = d["na"];
+        id["na_separator"] = na["na_separator"] !== undefined ? String(na["na_separator"]) : "+";
+        id["na_year"] = na["na_year"] !== undefined ? String(na["na_year"]) : undefined;
+    }
+    if (d["evs_amd"] !== undefined) {
+        const amd = d["evs_amd"];
+        id["amd_separator"] = amd["amd_separator"] !== undefined ? String(amd["amd_separator"]) : "+";
+        id["amd_kind"] = "AMD";
+        id["amd_number"] = amd["amd_number"] !== undefined ? String(amd["amd_number"]) : undefined;
+        id["amd_year"] = amd["amd_year"] !== undefined ? String(amd["amd_year"]) : undefined;
+    }
+    if (d["evs_cor"] !== undefined) {
+        const cor = d["evs_cor"];
+        id["cor_separator"] = cor["cor_separator"] !== undefined ? String(cor["cor_separator"]) : "+";
+        id["cor_kind"] = cor["cor_kind"] !== undefined ? String(cor["cor_kind"]) : "COR";
+        id["cor_number"] = cor["cor_number"] !== undefined ? String(cor["cor_number"]) : undefined;
+        id["cor_year"] = cor["cor_year"] !== undefined ? String(cor["cor_year"]) : undefined;
+    }
 }
 export function evsGrammarImplementation() {
     return {
         parse(input) {
-            const tree = parseGrammar(evsGrammar, input);
-            return buildIdentifier(tree);
+            const language = LANGUAGE_TAIL.exec(input)?.[1];
+            const body = language !== undefined ? input.slice(0, input.length - language.length - 1) : input;
+            const tree = parseGrammar(evsGrammar, body);
+            return buildIdentifier(tree, language);
         },
     };
 }

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

@@ -8,12 +8,48 @@ declare class EvsUrnGenerator extends BaseUrnGenerator<EvsIdentifier> {
 export declare abstract class EvsIdentifier extends BaseIdentifier {
     readonly base: CenIdentifier | undefined;
     readonly separator: string | undefined;
+    readonly draft_prefix: boolean | undefined;
+    readonly language: string | undefined;
+    readonly na_separator: string | undefined;
+    readonly na_year: string | undefined;
+    readonly amd_separator: string | undefined;
+    readonly amd_kind: string | undefined;
+    readonly amd_number: string | undefined;
+    readonly amd_year: string | undefined;
+    readonly cor_separator: string | undefined;
+    readonly cor_kind: string | undefined;
+    readonly cor_number: string | undefined;
+    readonly cor_year: string | undefined;
+    /** "EVS" + separator + the shape's body + the supplements + the language. */
+    render(): string;
+    protected abstract body(): string;
 }
 export declare class NationalAdoption extends EvsIdentifier {
     static polymorphicName: string;
     static urnGenerator: typeof EvsUrnGenerator;
     static attributes: import("../../model/attribute.js").AttributeTable;
     static mappings: FieldMapping[];
-    render(): string;
+    protected body(): string;
+}
+export declare class InternationalAdoption extends EvsIdentifier {
+    readonly intl_org: string | undefined;
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    readonly year: string | undefined;
+    static polymorphicName: string;
+    static urnGenerator: typeof EvsUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    protected body(): string;
+}
+export declare class EstonianStandard extends EvsIdentifier {
+    readonly number: string | undefined;
+    readonly year: string | undefined;
+    readonly evs_type: string | undefined;
+    static polymorphicName: string;
+    static urnGenerator: typeof EvsUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    protected body(): string;
 }
 export {};

package/dist/flavors/evs/model.js

@@ -3,34 +3,196 @@ import { keyValue, extendAttributes } from "../../model/attribute.js";
 import { BaseUrnGenerator } from "../../model/urn-generator.js";
 import { CenIdentifier } from "../cen_cenelec/model.js";
 /**
- * Port of lib/pubid/evs: the national-adoption identifier wrapping a
- * CEN/CENELEC base, the renderer ("EVS" + separator + adopted) and the
- * URN generator (the adopted CEN URN with urn:cen: swapped for
- * urn:evs:).
+ * Port of lib/pubid/evs: the national identifier ("EVS" / "prEVS" over a
+ * CEN adoption, an ISO/IEC adoption, or a plain Estonian standard), the
+ * shared supplements (the national annex, the COR/AC corrigendum, the AMD
+ * amendment spelling, the trailing language code) and the URN faces
+ * (urn:evs:en:…, urn:evs:iso:…, urn:evs:921:2019, urn:evs:ts:1:2019).
  */
 const CEN_NAMESPACE = "urn:cen:";
 const EVS_NAMESPACE = "urn:evs:";
 class EvsUrnGenerator extends BaseUrnGenerator {
     generate() {
-        const adoptedUrn = this.identifier.base?.toUrn() ?? "";
-        if (!adoptedUrn.startsWith(CEN_NAMESPACE)) {
-            throw new Error(`expected adopted CEN URN, got ${JSON.stringify(adoptedUrn)}`);
+        const id = this.identifier;
+        const segments = [];
+        if (id.draft_prefix === true)
+            segments.push("pr");
+        if (id.base) {
+            const adoptedUrn = id.base.toUrn();
+            if (!adoptedUrn.startsWith(CEN_NAMESPACE)) {
+                throw new Error(`expected adopted CEN URN, got ${JSON.stringify(adoptedUrn)}`);
+            }
+            segments.push(...adoptedUrn.slice(CEN_NAMESPACE.length).split(":"));
         }
-        return EVS_NAMESPACE + adoptedUrn.slice(CEN_NAMESPACE.length);
+        else if (id instanceof InternationalAdoption) {
+            segments.push((id.intl_org ?? "").toLowerCase());
+            segments.push(id.part !== undefined ? `${id.number}-${id.part}` : (id.number ?? ""));
+            if (id.year !== undefined)
+                segments.push(id.year);
+        }
+        else {
+            const est = id; // instanceof narrowing via the else branch
+            if (est.evs_type !== undefined)
+                segments.push(est.evs_type.toLowerCase());
+            segments.push(est.number ?? "");
+            if (est.year !== undefined)
+                segments.push(est.year);
+        }
+        if (id.na_separator !== undefined) {
+            segments.push("na");
+            if (id.na_year !== undefined)
+                segments.push(id.na_year);
+        }
+        if (id.amd_separator !== undefined) {
+            if (id.amd_separator === "+")
+                segments.push("plus");
+            segments.push("amd");
+            if (id.amd_number !== undefined)
+                segments.push(id.amd_number);
+            if (id.amd_year !== undefined)
+                segments.push(id.amd_year);
+        }
+        if (id.cor_separator !== undefined) {
+            if (id.cor_separator === "+")
+                segments.push("plus");
+            segments.push("cor");
+            if (id.cor_number !== undefined)
+                segments.push(id.cor_number);
+            if (id.cor_year !== undefined)
+                segments.push(id.cor_year);
+        }
+        if (id.language !== undefined)
+            segments.push(id.language);
+        return EVS_NAMESPACE + segments.join(":");
     }
 }
 export class EvsIdentifier extends BaseIdentifier {
+    /** "EVS" + separator + the shape's body + the supplements + the language. */
+    render() {
+        let result = (this.draft_prefix === true ? "pr" : "") + "EVS" + (this.separator ?? "-");
+        result += this.body();
+        if (this.amd_separator !== undefined) {
+            result += `${this.amd_separator}AMD${this.amd_number ?? ""}`;
+            if (this.amd_year !== undefined)
+                result += `:${this.amd_year}`;
+        }
+        if (this.cor_separator !== undefined) {
+            result += `${this.cor_separator}${this.cor_kind ?? "COR"}${this.cor_number ?? ""}`;
+            if (this.cor_year !== undefined)
+                result += `:${this.cor_year}`;
+        }
+        if (this.na_separator !== undefined) {
+            result += `${this.na_separator}NA`;
+            if (this.na_year !== undefined)
+                result += `:${this.na_year}`;
+        }
+        if (this.language !== undefined)
+            result += ` ${this.language}`;
+        return result;
+    }
 }
+const SHARED_ATTRIBUTES = {
+    draft_prefix: { type: "boolean", default: false },
+    language: { type: "string" },
+    na_separator: { type: "string" },
+    na_year: { type: "string" },
+    amd_separator: { type: "string" },
+    amd_kind: { type: "string" },
+    amd_number: { type: "string" },
+    amd_year: { type: "string" },
+    cor_separator: { type: "string" },
+    cor_kind: { type: "string" },
+    cor_number: { type: "string" },
+    cor_year: { type: "string" },
+};
+const SHARED_MAPPINGS = [
+    { wire: "draft_prefix", to: "draft_prefix" },
+    { wire: "language", to: "language" },
+    { wire: "na_separator", to: "na_separator" },
+    { wire: "na_year", to: "na_year" },
+    { wire: "amd_separator", to: "amd_separator" },
+    { wire: "amd_kind", to: "amd_kind" },
+    { wire: "amd_number", to: "amd_number" },
+    { wire: "amd_year", to: "amd_year" },
+    { wire: "cor_separator", to: "cor_separator" },
+    { wire: "cor_kind", to: "cor_kind" },
+    { wire: "cor_number", to: "cor_number" },
+    { wire: "cor_year", to: "cor_year" },
+];
 export class NationalAdoption extends EvsIdentifier {
     static polymorphicName = "pubid:evs:national-adoption";
     static urnGenerator = EvsUrnGenerator;
     static attributes = extendAttributes(EvsIdentifier, {
         base: { type: CenIdentifier },
         separator: { type: "string", default: "-" },
+        ...SHARED_ATTRIBUTES,
     });
-    static mappings = keyValue({ wire: "base", to: "base" }, { wire: "separator", to: "separator" });
-    render() {
-        return `EVS${this.separator ?? "-"}${this.base?.toHuman() ?? ""}`;
+    static mappings = keyValue({ wire: "base", to: "base" }, { wire: "separator", to: "separator" }, ...SHARED_MAPPINGS);
+    body() {
+        return this.base?.toHuman() ?? "";
+    }
+}
+export class InternationalAdoption extends EvsIdentifier {
+    static polymorphicName = "pubid:evs:international-adoption";
+    static urnGenerator = EvsUrnGenerator;
+    static attributes = extendAttributes(EvsIdentifier, {
+        number: { type: "string" },
+        part: { type: "string" },
+        intl_org: { type: "string" },
+        year: { type: "string" },
+        language: { type: "string" },
+        draft_prefix: { type: "boolean", default: false },
+        na_separator: { type: "string" },
+        na_year: { type: "string" },
+        amd_separator: { type: "string" },
+        amd_kind: { type: "string" },
+        amd_number: { type: "string" },
+        amd_year: { type: "string" },
+        cor_separator: { type: "string" },
+        cor_kind: { type: "string" },
+        cor_number: { type: "string" },
+        cor_year: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "intl_org", to: "intl_org" }, { wire: "year", to: "year" }, { wire: "draft_prefix", to: "draft_prefix" }, { wire: "language", to: "language" }, { wire: "na_separator", to: "na_separator" }, { wire: "na_year", to: "na_year" }, { wire: "amd_separator", to: "amd_separator" }, { wire: "amd_kind", to: "amd_kind" }, { wire: "amd_number", to: "amd_number" }, { wire: "amd_year", to: "amd_year" }, { wire: "cor_separator", to: "cor_separator" }, { wire: "cor_kind", to: "cor_kind" }, { wire: "cor_number", to: "cor_number" }, { wire: "cor_year", to: "cor_year" });
+    body() {
+        let org = `${this.intl_org} ${this.number}`;
+        if (this.part !== undefined)
+            org += `-${this.part}`;
+        if (this.year !== undefined)
+            org += `:${this.year}`;
+        return org;
+    }
+}
+export class EstonianStandard extends EvsIdentifier {
+    static polymorphicName = "pubid:evs:estonian-standard";
+    static urnGenerator = EvsUrnGenerator;
+    static attributes = extendAttributes(EvsIdentifier, {
+        number: { type: "string" },
+        separator: { type: "string", default: "-" },
+        language: { type: "string" },
+        year: { type: "string" },
+        evs_type: { type: "string" },
+        draft_prefix: { type: "boolean", default: false },
+        na_separator: { type: "string" },
+        na_year: { type: "string" },
+        amd_separator: { type: "string" },
+        amd_kind: { type: "string" },
+        amd_number: { type: "string" },
+        amd_year: { type: "string" },
+        cor_separator: { type: "string" },
+        cor_kind: { type: "string" },
+        cor_number: { type: "string" },
+        cor_year: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "separator", to: "separator" }, { wire: "language", to: "language" }, { wire: "year", to: "year" }, { wire: "evs_type", to: "evs_type" });
+    body() {
+        let plain = this.evs_type !== undefined ? `${this.evs_type} ` : "";
+        plain += this.number ?? "";
+        if (this.year !== undefined)
+            plain += `:${this.year}`;
+        return plain;
     }
 }
 registerType(NationalAdoption);
+registerType(InternationalAdoption);
+registerType(EstonianStandard);

package/dist/flavors/iec/index.js

@@ -77,10 +77,11 @@ class IecBuilder {
         Object.assign(attrs, numberComponents(tree["number_with_part"]));
         // Letters-prefixed numbers (IECEE "CAB", "AD") only take digit-first
         // parts — "CAB-G01" rejects (Ruby parity; digit numbers like 61158-X
-        // keep letter parts).
+        // keep letter parts). "DIR" is the exception: the Directives number
+        // is its own grammar branch and takes letter parts ("DIR-IEC-SUP").
         const number = attrs["number"];
         const part = attrs["part"];
-        if (number !== undefined && /^[A-Z]{2,4}$/.test(number) &&
+        if (number !== undefined && /^[A-Z]{2,4}$/.test(number) && number !== "DIR" &&
             part !== undefined && /^[A-Za-z]/.test(part)) {
             throw new ParseFailed(`IEC: letter part ${part} after letters number ${number}`, 0);
         }
@@ -501,7 +502,18 @@ export function iecGrammarImplementation() {
             const parsed = urnToCode(urn);
             if (!parsed)
                 throw new Error(`Invalid IEC URN: ${urn}`);
-            const [code, lang, allParts] = parsed;
+            let [code, lang, allParts] = parsed;
+            // The "ser" slot names every part of the document: the reference
+            // wraps via to_all_parts, which strips the part and the date (a
+            // series names the document across editions, "IEC 60034 (all
+            // parts)"). The part rides dash-joined on the number, the date in
+            // its own slot.
+            if (allParts) {
+                code = code
+                    .replace(/:[^:]*$/, "")
+                    .replace(/\s(19|20)\d\d(-\d\d)?$/, "")
+                    .replace(/-[^\s:-]+$/, "");
+            }
             // The reference parses the unprefixed rebuild and its grammar
             // defaults the IEC publisher; the ts grammar needs it explicit.
             const id = this.parse(code);

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

@@ -6,7 +6,7 @@ import { Language, PubidDate } from "../../model/component.js";
  * runtime attribute driving type derivation and the URN stage slot; the
  * wire hash carries only the stage CODE for non-published drafts.
  */
-export type IecTypeCode = "is" | "tr" | "ts" | "pas" | "srd" | "od" | "guide" | "ish" | "frag" | "trf" | "tec" | "wp" | "sttr" | "amd" | "cor";
+export type IecTypeCode = "is" | "tr" | "ts" | "pas" | "srd" | "od" | "guide" | "ish" | "frag" | "trf" | "tec" | "wp" | "sttr" | "amd" | "cor" | "cs" | "ca";
 export interface TypedStage {
     code: string;
     stageCode: string;

package/dist/flavors/iec/model.js

@@ -15,7 +15,15 @@ export const TYPED_STAGES = [
     TS("trf", "published", "trf", "TRF"),
     TS("amd", "published", "amd", "AMD"),
     TS("cor", "published", "cor", "COR"),
-    TS("np", "np", "is", "NP", "10.20"),
+    // IEC CS (Component Specifications) and IEC CA (Conformity Assessment):
+    // the abbreviation leads the code and the publisher renders as its
+    // default ("IEC CS 033200-TW0001", "IEC CA 01") — gem
+    // ComponentSpecification/ConformityAssessment.
+    TS("cs", "published", "cs", "CS"),
+    TS("ca", "published", "ca", "CA"),
+    // PNW owns harmonized 10.20 (gem: NP stages are 10.00/10.60/… — the
+    // URN "stage-10.20" slot resolves to PNW, not NP).
+    TS("np", "np", "is", "NP"),
     TS("pnw", "pnw", "is", "PNW", "10.20"),
     TS("pwi", "pwi", "is", "PWI", "00.00"),
     TS("anw", "anw", "is", "ANW"),
@@ -57,6 +65,8 @@ const TYPE_NAMES = {
     ts: "technical-specification",
     pas: "publicly-available-specification",
     srd: "systems-reference-document",
+    cs: "component-specification",
+    ca: "conformity-assessment",
     od: "operational-document",
     guide: "guide",
     ish: "interpretation-sheet",
@@ -414,7 +424,7 @@ function iecFragmentClass() {
     registerType(IecFragmentIdentifier);
     return IecFragmentIdentifier;
 }
-const SINGLE_KINDS = ["is", "tr", "ts", "pas", "srd", "od", "guide"];
+const SINGLE_KINDS = ["is", "tr", "ts", "pas", "srd", "od", "guide", "cs", "ca"];
 const KIND_CLASSES = {};
 for (const kind of SINGLE_KINDS) {
     KIND_CLASSES[kind] = iecSingleClass(kind);

package/dist/flavors/ieee/artifact_tree.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from "../../grammar/engine.js";
+export declare function artifactToBuilderTree(shape: unknown): Tree;