@pubid/pubid 0.1.20 → 0.1.22

package/dist/flavors/iso/index.js

@@ -2,6 +2,7 @@ import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
 import { PubidDate, Language, Iteration } from "../../model/component.js";
 import { isoGrammar } from "./grammar.js";
 import { IsoBundledIdentifier, IsoDirectives, IsoDirectivesSupplement, IsoEdition, IsoPublisher, IsoSupplementIdentifier, IsoTcDocument, isoClassForType, locateStage, } from "./model.js";
+import { ISO_TYPED_STAGES } from "./stages.generated.js";
 /**
  * Port of lib/pubid/iso/{builder,normalizer}.rb. Class dispatch follows
  * the Ruby Builder: joint → Combined (unreachable by the corpus),
@@ -246,7 +247,14 @@ class IsoBuilder {
             }
         }
         const state = typeStateFromToken(s(tree["type_with_stage"]), "is");
-        const typeKey = state?.entry.typeCode ?? "is";
+        // The explicit URN type token pins the class: a stage's abbreviation
+        // can overwrite type_with_stage with an IS-only stage ("WDA" for
+        // 90.93), and the document must stay a TR/TS (the Ruby builder reads
+        // the same document_type hint).
+        const documentType = s(tree["document_type"]);
+        const typeKey = documentType !== undefined
+            ? documentType.toLowerCase()
+            : state?.entry.typeCode ?? "is";
         if (typeKey === "dir-sup")
             return this.buildDirectivesSupplement(tree, state);
         if (typeKey === "dir")
@@ -334,8 +342,264 @@ function parseHuman(input) {
     }
     return new IsoBuilder().build(tree);
 }
+// --- URN ingestion (lib/pubid/iso/urn_parser.rb) ----------------------------
+// RFC 5141-bis typed-stage abbreviations → stage codes. "DIS"/"ADIS" are
+// ISO ladder stages the reference maps; everything else mirrors the gem's
+// TYPED_STAGE_REVERSE_MAP verbatim.
+const URN_STAGE_ABBRS = {
+    WD: "wd", WDS: "wds", CD: "cd", CDV: "cdv", DIS: "dis", FDIS: "fdis",
+    PDAM: "pdam", DAM: "dam", FDAM: "fdamd", DCOR: "dcor", FDCOR: "fdcor",
+    CDTS: "cdts", DTS: "dts", FDTS: "fdts",
+};
+const URN_TYPE_TOKENS = new Set([
+    "tr", "ts", "pas", "guide", "dir", "dir-sup", "iwa-sup", "isp", "iwa", "r", "data",
+]);
+const URN_SUPP_TYPES = new Set(["amd", "cor", "sup", "add"]);
+// The URN type tokens are the gem's type keys; the ts leaf for ISO/R is
+// keyed "rec".
+const URN_TYPE_KEYS = { r: "rec" };
+function urnStageByHarmonized(code) {
+    const candidates = ISO_TYPED_STAGES.filter((s) => s.harmonized?.includes(code));
+    // The gem prefers the IS family when a code is shared across families
+    // (pubid#570 — the registry order is load-order dependent there).
+    return candidates.find((s) => s.typeCode === "is") ?? candidates[0];
+}
+// When the URN gives a harmonized code and no type token, the document is
+// an IS: prefer the non-published IS stages (PRF over the published IS for
+// 60.00), then the stage covering the most codes (WD over WDS).
+function urnIsStageByHarmonized(code) {
+    const candidates = ISO_TYPED_STAGES.filter((s) => s.typeCode === "is" && s.harmonized?.includes(code));
+    if (candidates.length === 0)
+        return undefined;
+    const nonPublished = candidates.filter((s) => s.stageCode !== "published");
+    const pool = nonPublished.length > 0 ? nonPublished : candidates;
+    let best = pool[0];
+    for (const candidate of pool) {
+        if ((candidate.harmonized?.length ?? 0) > (best.harmonized?.length ?? 0))
+            best = candidate;
+    }
+    return best;
+}
+// The URN carries parts as "10164:-5-1-1" or "9001-1"; split into
+// number / part / subpart (a subpart keeps its dashes).
+function parseUrnNumberPart(raw) {
+    if (raw === undefined)
+        return [undefined, undefined, undefined];
+    if (/^\w+:-/.test(raw)) {
+        const segments = raw.split(":-");
+        const tail = segments.slice(1).join("-").split("-");
+        return [
+            segments[0],
+            tail[0],
+            tail.length > 1 ? tail.slice(1).join("-") : undefined,
+        ];
+    }
+    if (raw.includes("-")) {
+        const segments = raw.split("-");
+        return [
+            segments[0],
+            segments[1],
+            segments.length > 2 ? segments.slice(2).join("-") : undefined,
+        ];
+    }
+    return [raw, undefined, undefined];
+}
+function parseIsoUrn(urn) {
+    if (!urn.startsWith("urn:iso:std:"))
+        throw new Error(`Invalid ISO URN: ${urn}`);
+    let parts = urn.slice("urn:iso:std:".length).split(":");
+    // A trailing "ser" marks an all-parts identifier.
+    let allParts = false;
+    if (parts[parts.length - 1] === "ser") {
+        parts = parts.slice(0, -1);
+        allParts = true;
+    }
+    const publishers = (parts.shift() ?? "").split("-").map((p) => p.toUpperCase());
+    let typeCode;
+    if (parts[0] !== undefined && URN_TYPE_TOKENS.has(parts[0].toLowerCase())) {
+        typeCode = parts.shift().toLowerCase();
+    }
+    let [number, part, subpart] = parseUrnNumberPart(parts.shift());
+    let year;
+    if (/^\d{4}$/.test(parts[0] ?? ""))
+        year = parts.shift();
+    // URN-style part notation can trail the year (":10164:2019:-22").
+    if ((parts[0] ?? "").startsWith("-")) {
+        const partStr = parts.shift();
+        [number, part, subpart] = parseUrnNumberPart(`${number}${partStr}`);
+    }
+    if (year === undefined && /^\d{4}$/.test(parts[0] ?? ""))
+        year = parts.shift();
+    let edition;
+    if ((parts[0] ?? "").startsWith("ed-"))
+        edition = parts.shift().slice(3);
+    let languages;
+    if (parts[0] !== undefined && !/^\d+$/.test(parts[0]) &&
+        !/^(amd|cor|sup|add|v\d+|stage-|ed-)/i.test(parts[0]) &&
+        !(parts[0].toUpperCase() in URN_STAGE_ABBRS) &&
+        !/^[A-Za-z]+\.\d+$/.test(parts[0])) {
+        languages = parts.shift().split(",").map((l) => l.toUpperCase()).join("/");
+    }
+    // Stage: either "stage-XX.XX[.vN]" (harmonized) or a typed abbreviation
+    // ("WD", "CD.2").
+    let stageCode;
+    let stageFromAbbr;
+    let stageIteration;
+    if ((parts[0] ?? "").startsWith("stage-")) {
+        const stageStr = parts.shift();
+        stageCode = stageStr.slice(6).replace(/\.v\d+$/i, "");
+        const iteration = /\.v(\d+)$/i.exec(stageStr);
+        if (iteration !== null)
+            stageIteration = iteration[1];
+    }
+    else if ((parts[0] !== undefined && parts[0].toUpperCase() in URN_STAGE_ABBRS) ||
+        (parts[0] !== undefined && /^[A-Za-z]+\.\d+$/.test(parts[0]) &&
+            (parts[0].toUpperCase().split(".")[0] ?? "") in URN_STAGE_ABBRS)) {
+        const stageAbbr = parts[0].toUpperCase();
+        // A supplement-family stage directly before its own supplement type
+        // token ("...:FDAM:amd:1:v1") names the SUPPLEMENT's stage: consuming
+        // it as the base's stage builds the base as a base-less supplement,
+        // which cannot render (the gem guards the same way).
+        const family = locateStage(stageAbbr.split(".")[0] ?? "")?.typeCode;
+        const supplementFollows = (family !== undefined &&
+            ["amd", "cor", "suppl", "add"].includes(family)) &&
+            parts.slice(1).some((token) => URN_SUPP_TYPES.has(token.toLowerCase()) &&
+                (URN_TYPE_KEYS[token.toLowerCase()] ?? token.toLowerCase()) === family);
+        if (!supplementFollows) {
+            parts.shift();
+            if (stageAbbr.includes(".")) {
+                const abbrPart = stageAbbr.split(".")[0];
+                const iterationPart = stageAbbr.split(".")[1];
+                stageCode = URN_STAGE_ABBRS[abbrPart];
+                stageFromAbbr = abbrPart;
+                stageIteration = iterationPart;
+            }
+            else {
+                stageCode = URN_STAGE_ABBRS[stageAbbr];
+                stageFromAbbr = stageAbbr;
+            }
+        }
+    }
+    // Supplements (amd, cor, sup, add), left-to-right: each wraps the previous.
+    const supplements = [];
+    while (parts.length > 0) {
+        const supp = {};
+        if ((parts[0] ?? "").startsWith("stage-")) {
+            supp.stage = parts.shift().slice(6).replace(/\.v\d+$/i, "");
+        }
+        else if (parts[0] !== undefined && parts[0].toUpperCase() in URN_STAGE_ABBRS) {
+            supp.stage = URN_STAGE_ABBRS[parts.shift().toUpperCase()];
+        }
+        if (parts[0] !== undefined && URN_SUPP_TYPES.has(parts[0].toLowerCase())) {
+            supp.type = parts.shift().toLowerCase();
+        }
+        if (/^\d+$/.test(parts[0] ?? "")) {
+            if (/^\d{4}$/.test(parts[0]))
+                supp.year = parts.shift();
+            else
+                supp.number = parts.shift();
+        }
+        if ((parts[0] ?? "").startsWith("v")) {
+            const version = parts.shift().slice(1);
+            supp.number = version.split(".")[0];
+        }
+        if (supp.year === undefined && /^\d{4}$/.test(parts[0] ?? ""))
+            supp.year = parts.shift();
+        if (parts[0] !== undefined && !/^\d+$/.test(parts[0]) &&
+            !/^(amd|cor|sup|add|v\d+|stage-)/i.test(parts[0])) {
+            supp.languages = parts.shift().split(",").map((l) => l.toUpperCase()).join("/");
+        }
+        supplements.push(supp);
+    }
+    // Builder tree, mirroring the gem's build_identifier.
+    const base = {};
+    if (publishers[0] !== undefined && publishers[0] !== "") {
+        base["publisher"] = publishers[0];
+        if (publishers.length > 1) {
+            base["copublishers"] = publishers.slice(1).map((c) => ({ copublisher: c }));
+        }
+    }
+    if (part !== undefined || subpart !== undefined) {
+        base["number_with_part"] = [number, part, subpart].filter((p) => p !== undefined).join("-");
+    }
+    else if (number !== undefined) {
+        base["number"] = number;
+    }
+    if (year !== undefined)
+        base["date"] = year;
+    if (edition !== undefined)
+        base["edition"] = edition;
+    if (typeCode !== undefined && typeCode !== "is") {
+        base["type_with_stage"] = typeCode.toUpperCase();
+        // Pin the document class against the stage block below overwriting
+        // type_with_stage (the Ruby builder reads the same hint).
+        base["document_type"] = (URN_TYPE_KEYS[typeCode] ?? typeCode).toUpperCase();
+    }
+    if (stageCode !== undefined) {
+        let stage;
+        if (stageFromAbbr !== undefined) {
+            stage = locateStage(stageFromAbbr) ??
+                ISO_TYPED_STAGES.find((s) => s.stageCode === stageCode);
+        }
+        else if (typeCode === undefined || typeCode === "is") {
+            stage = urnIsStageByHarmonized(stageCode);
+            // FCD is a legacy spelling of the DIS stage in URN form.
+            if (stageCode === "40.00" && stage?.stageCode === "fcd") {
+                stage = ISO_TYPED_STAGES.find((s) => s.stageCode === "dis" && s.harmonized?.includes("40.00")) ?? stage;
+            }
+        }
+        stage ??= urnStageByHarmonized(stageCode);
+        if (stage !== undefined)
+            base["type_with_stage"] = stage.abbr[0] ?? "";
+        else
+            base["stage"] = stageCode;
+        if (stageIteration !== undefined)
+            base["stage_iteration"] = stageIteration;
+    }
+    if (languages !== undefined)
+        base["languages"] = languages;
+    let tree = base;
+    for (const supp of supplements) {
+        // A bare language token with no supplement identity names the BASE
+        // document (the gem merges it the same way — a wrapper would drop it).
+        if (supp.type === undefined && supp.stage === undefined &&
+            supp.number === undefined && supp.year === undefined &&
+            supp.languages !== undefined) {
+            base["languages"] = supp.languages;
+            continue;
+        }
+        const suppTree = {};
+        if (supp.stage !== undefined) {
+            const stage = ISO_TYPED_STAGES.find((s) => s.stageCode === supp.stage);
+            suppTree["type_with_stage"] = stage !== undefined
+                ? stage.abbr[0] ?? ""
+                : supp.stage.toUpperCase();
+        }
+        if (supp.type !== undefined && suppTree["type_with_stage"] === undefined) {
+            suppTree["type_with_stage"] = supp.type.toUpperCase();
+        }
+        if (supp.number !== undefined)
+            suppTree["number"] = supp.number;
+        if (supp.year !== undefined)
+            suppTree["date"] = supp.year;
+        if (supp.languages !== undefined)
+            suppTree["languages"] = supp.languages;
+        tree = { base: tree, ...suppTree };
+    }
+    const identifier = new IsoBuilder().build(tree);
+    if (allParts) {
+        identifier.all_parts = true;
+    }
+    return identifier;
+}
 export function isoGrammarImplementation() {
     return {
+        // Inverse of the ISO UrnGenerator (lib/pubid/iso/urn_parser.rb): the
+        // reference rebuilds a builder hash straight from the positional URN
+        // fields, so the port does the same against the shared IsoBuilder.
+        parseUrn(urn) {
+            return parseIsoUrn(urn);
+        },
         parse(input) {
             return parseHuman(input);
         },

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

@@ -61,7 +61,7 @@ export declare abstract class IsoIdentifier extends BaseIdentifier {
     protected stageString(): string;
     /** Render with an EXPLICIT long-format flag (the supplement
      * renderer propagates its own context to the base). */
-    renderWithFormat(formatLong: boolean): string;
+    renderWithFormat(formatLong: boolean, withLanguages?: boolean): string;
     /** Ruby SupplementRenderer renders the base with the wrapper's
      * detected context (stage_format_long propagates down the chain;
      * with_date being non-nil pins it against re-detection — a nested

package/dist/flavors/iso/model.js

@@ -119,7 +119,7 @@ export class IsoIdentifier extends BaseIdentifier {
     }
     /** Render with an EXPLICIT long-format flag (the supplement
      * renderer propagates its own context to the base). */
-    renderWithFormat(formatLong) {
+    renderWithFormat(formatLong, withLanguages = true) {
         let result = "";
         if (this.typeKey() === "iwa") {
             const stage = this.typedStageState === undefined ? "" : stageAbbr(this.typedStageState.entry, formatLong);
@@ -141,7 +141,8 @@ export class IsoIdentifier extends BaseIdentifier {
         const num = this.numberPortion(true);
         if (num !== "")
             result += result === "" ? num : ` ${num}`;
-        result += this.languagePortion(this.languageSingle());
+        if (withLanguages)
+            result += this.languagePortion(this.languageSingle());
         if (this.all_parts === true)
             result += " (all parts)";
         return result;
@@ -152,7 +153,11 @@ export class IsoIdentifier extends BaseIdentifier {
      * amendment renders "AMD" under a "CD Cor" top but "Amd" under a
      * "Cor." top). */
     renderAsSupplementBase(long) {
-        return this.renderWithFormat(long);
+        // The reference re-renders a nested base from the four propagated
+        // options alone, and that rebuilt context defaults to
+        // with_language_code :none — only the outermost identifier renders
+        // its own language portion.
+        return this.renderWithFormat(long, false);
     }
     stageStringFor(formatLong) {
         const ts = this.typedStageState;
@@ -618,12 +623,15 @@ export class IsoSupplementIdentifier extends IsoSingleIdentifier {
     });
     static mappings = SUPPLEMENT_MAPPINGS;
     render() {
-        return this.renderSupplement(this.stageFormatLong());
+        return this.renderSupplement(this.stageFormatLong(), false);
     }
     renderAsSupplementBase(long) {
-        return this.renderSupplement(long);
+        return this.renderSupplement(long, true);
     }
-    renderSupplement(long) {
+    // The reference renders a nested base from a rebuilt context whose
+    // with_language_code defaults to :none, so only the outermost
+    // identifier of a chain renders its language portion.
+    renderSupplement(long, asBase) {
         const base = this.base;
         const baseStr = base === undefined ? "" : base.renderAsSupplementBase(long);
         const ts = this.typedStageState;
@@ -635,7 +643,8 @@ export class IsoSupplementIdentifier extends IsoSingleIdentifier {
                 result += " ";
             result += num;
         }
-        result += this.languagePortion(this.languageSingle());
+        if (!asBase)
+            result += this.languagePortion(this.languageSingle());
         return result;
     }
 }

package/dist/flavors/nist/model.js

@@ -688,7 +688,10 @@ function nistClass(spec) {
         }
         renderMr() {
             if (spec.style === "fips") {
-                let result = this.seriesCode() ?? "";
+                // The MR form keeps a parsed publisher ("NIST.FIPS.197-upd1" is the
+                // DOI suffix NIST publishes); a bare FIPS invents none.
+                const series = this.seriesCode() ?? "";
+                let result = this.publisher !== undefined ? `${this.publisher}.${series}` : series;
                 if (this.number !== undefined)
                     result += `.${this.number}`;
                 if (this.part instanceof NistPart)

package/dist/urn/parsers.js

@@ -1,10 +1,36 @@
 import { splitParts, withYear } from "./types.js";
-import { grammarImplementation } from "../flavors/index.js";
-import { NationalAdoption } from "../flavors/evs/model.js";
 // Each parser mirrors lib/pubid/<flavor>/urn_parser.rb#parse_urn exactly —
 // including its lossiness (dropped segments stay dropped) and its error
 // cases. The parity fixture (test/fixtures/urn-parity.json) pins the
 // reference behavior for ~93k corpus URNs.
+// The adopted CEN spine consumes its own supplements; their urn segments
+// carry the consolidation marker ("plus" = "+A1", its absence = "/A1") —
+// cen_cenelec/urn_generator.rb's supplement_segments.
+function adoptedSupplement(parts) {
+    let faces = "";
+    while (["plus", "slash", "amd", "cor", "frag"].includes(parts[0] ?? "")) {
+        let sep = "/";
+        let kind;
+        if (parts[0] === "plus" || parts[0] === "slash") {
+            sep = parts.shift() === "plus" ? "+" : "/";
+            kind = parts.shift();
+        }
+        else {
+            kind = parts.shift();
+        }
+        const num = /^\d{1,3}$/.test(parts[0] ?? "") ? parts.shift() : undefined;
+        const yr = /^\d{4}$/.test(parts[0] ?? "") ? parts.shift() : undefined;
+        const iter = num ?? "";
+        const year = yr !== undefined ? `:${yr}` : "";
+        if (kind === "amd")
+            faces += `${sep}A${iter}${year}`;
+        else if (kind === "cor")
+            faces += `${sep}AC${iter}${year}`;
+        else
+            faces += ` FRAG${iter}`;
+    }
+    return faces;
+}
 export const URN_PARSERS = {
     // lib/pubid/ansi/urn_parser.rb
     ansi: {
@@ -459,64 +485,111 @@ export const URN_PARSERS = {
             return parse(text);
         },
     },
-    // lib/pubid/evs/urn_parser.rb — EN [org] number[:year] with an optional
-    // amd/cor iteration tail; the rebuilt text is parsed as a CEN adoption.
+    // lib/pubid/evs/urn_parser.rb — reassemble the identifier's human text
+    // (draft prefix, adopted org, national annex, language, supplements)
+    // and delegate to the EVS grammar, exactly like the reference.
     evs: {
         prefix: "urn:evs:",
         reconstruct(body, parse) {
             const parts = splitParts(body);
-            const type = parts.shift() ?? "";
-            if (type.toLowerCase() !== "en") {
-                throw new Error(`unsupported type in ${JSON.stringify(body)}`);
-            }
+            const draft = parts[0] === "pr";
+            if (draft)
+                parts.shift();
             const orgs = {
                 iso: "ISO",
                 "iso-iec": "ISO/IEC",
                 iec: "IEC",
                 cispr: "CISPR",
             };
-            const orgParts = [];
-            while (parts[0] !== undefined && /^[a-z][a-z-]*$/.test(parts[0])) {
-                orgParts.push(parts.shift());
+            const types = { ts: "TS", tr: "TR" };
+            // The trailing language and the EVS-level national annex peel
+            // before the body dispatch — both are EVS-level, never CEN
+            // segments.
+            let language;
+            const last = parts[parts.length - 1];
+            if (parts.length > 1 && last !== undefined && /^(et-en|et|en)$/.test(last)) {
+                language = parts.pop();
             }
-            let text = "EN";
-            if (orgParts.length) {
-                const org = orgs[orgParts.join("-")];
-                if (org === undefined)
-                    throw new Error(`unknown adopted org in ${JSON.stringify(body)}`);
-                text += ` ${org}`;
+            let naPresent = false;
+            let naYear;
+            const naIndex = parts.indexOf("na");
+            if (naIndex >= 0) {
+                parts.splice(naIndex, 1);
+                naPresent = true;
+                if (/^\d{4}$/.test(parts[naIndex] ?? ""))
+                    naYear = parts.splice(naIndex, 1)[0];
             }
-            const number = parts.shift();
-            if (number === undefined)
-                throw new Error(`missing number in ${JSON.stringify(body)}`);
-            text += ` ${number}`;
-            const year = parts.shift();
-            if (year)
-                text += `:${year}`;
-            if (parts.length) {
-                const yearTail = parts[parts.length - 1]?.match(/^\d{4}$/) ? parts.pop() : undefined;
-                const kind = parts.shift();
-                const iteration = parts.shift();
-                if (kind !== "amd" && kind !== "cor") {
-                    throw new Error(`malformed supplement in ${JSON.stringify(body)}`);
+            const head = parts.shift() ?? "";
+            let text = draft ? "prEVS" : "EVS";
+            if (/^en$/i.test(head)) {
+                text += "-EN";
+                const orgParts = [];
+                while (parts[0] !== undefined && /^[a-z][a-z-]*$/.test(parts[0])) {
+                    orgParts.push(parts.shift());
                 }
-                if (iteration === undefined || parts.length) {
-                    throw new Error(`malformed supplement in ${JSON.stringify(body)}`);
+                if (orgParts.length) {
+                    const org = orgs[orgParts.join("-")];
+                    if (org === undefined)
+                        throw new Error(`unknown adopted org in ${JSON.stringify(body)}`);
+                    text += ` ${org}`;
                 }
-                text += kind === "amd" ? `/A${iteration}` : `/AC${iteration}`;
-                if (yearTail)
-                    text += `:${yearTail}`;
+                const number = parts.shift();
+                if (number === undefined)
+                    throw new Error(`missing number in ${JSON.stringify(body)}`);
+                text += ` ${number}`;
+                const year = parts.shift();
+                if (year !== undefined)
+                    text += `:${year}`;
+                text += adoptedSupplement(parts);
+            }
+            else if (head === "ts" || head === "tr") {
+                const number = parts.shift();
+                const year = parts.shift();
+                text += `-${types[head]} ${number}`;
+                if (year !== undefined)
+                    text += `:${year}`;
+            }
+            else if (head === "iso" || head === "iec" || head === "cispr") {
+                const org = orgs[head];
+                const number = parts.shift();
+                let part;
+                if (/^\d+$/.test(parts[0] ?? "") && !/^\d{4}$/.test(parts[0]) && parts.length > 1) {
+                    part = parts.shift();
+                }
+                const year = parts.shift();
+                text += `-${org} ${number}`;
+                if (part !== undefined)
+                    text += `-${part}`;
+                if (year !== undefined)
+                    text += `:${year}`;
+            }
+            else if (/^\d/.test(head)) {
+                const number = head;
+                const year = parts.shift();
+                text += ` ${number}`;
+                if (year !== undefined)
+                    text += `:${year}`;
+            }
+            else {
+                throw new Error(`unsupported shape in ${JSON.stringify(body)}`);
             }
-            // The reference constructs NationalAdoption around a parsed CEN
-            // base (lib/pubid/evs/urn_parser.rb) rather than re-parsing the
-            // rebuilt text as EVS.
-            const cen = grammarImplementation("cen_cenelec");
-            const base = cen.parse(text);
-            return new NationalAdoption({ base });
+            if (parts.length)
+                throw new Error(`trailing segments in ${JSON.stringify(body)}`);
+            if (naPresent) {
+                text += "+NA";
+                if (naYear !== undefined)
+                    text += `:${naYear}`;
+            }
+            if (language !== undefined)
+                text += ` ${language}`;
+            return parse(text);
         },
     },
-    // lib/pubid/nist/urn_parser.rb — type token upcased via the reference
-    // map; ".supp" stripped; ".r<N>" revision suffix split off the payload.
+    // lib/pubid/nist/urn_parser.rb — the generator dot-joins the identity's
+    // fields after the number; reassemble the human spelling the flavor
+    // parser reads (edition/volume glue onto the number, a revision glues
+    // after them, ".supp" marks supplementability, ".supp-<v>" is "sup<v>",
+    // insert/errata glue).
     nist: {
         prefix: "urn:nist:",
         reconstruct(body, parse) {
@@ -530,17 +603,75 @@ export const URN_PARSERS = {
             const typeToken = parts[0] ?? "";
             const payload = parts[1] ?? "";
             const label = typeUpcase[typeToken.toLowerCase()] ?? typeToken.toUpperCase();
-            const stripped = payload.replace(/\.supp$/, "");
-            const revMatch = stripped.match(/^(.*)\.(r\d+)$/i);
-            const code = revMatch ? revMatch[1] : stripped;
-            const revision = revMatch ? revMatch[2] : undefined;
+            const tokens = payload.split(".");
+            // Ruby's String#split drops trailing empty fields; JS keeps them, and a
+            // trailing "." would become a stray marker that the flavor rejects.
+            while (tokens.length > 0 && tokens[tokens.length - 1] === "")
+                tokens.pop();
+            const code = tokens.shift() ?? "";
+            let marker = "";
+            let part;
+            let edition;
+            let volume;
+            let revision;
+            let supplement;
+            for (const token of tokens) {
+                const supp = /^supp-(.+)$/is.exec(token);
+                if (/^r\d+$/i.test(token))
+                    revision = token;
+                else if (/^e\w+$/i.test(token))
+                    edition = token;
+                else if (/^v\d+$/i.test(token))
+                    volume = token;
+                else if (supp !== null)
+                    supplement = supp[1];
+                else if (token === "supp")
+                    continue; // supplementability marker
+                else if (token === "insert" || token === "errata")
+                    marker += token;
+                else if (/^[A-Z]$/.test(token))
+                    part = token; // part letter, glued to the code
+                else if (/^[A-Z][a-z]+\d{4}$/.test(token)) {
+                    // the edition's additional text ("13e2.June1908")
+                    if (edition !== undefined)
+                        edition = `${edition}.${token}`;
+                }
+                else
+                    marker += `.${token}`;
+            }
             // The NBS-era series carry the NBS imprint in their canonical form
             // ("NBS CSM 1") — the rebuild names the publisher the document
             // carries, or the flavor parse rejects its own URN's rebuild.
             const publisher = typeToken.toLowerCase() === "csm" ? "NBS" : "NIST";
-            let text = `${publisher} ${label} ${code}`;
-            if (revision)
-                text += revision;
+            let text = `${publisher} ${label} ${code}${part ?? ""}${marker}`;
+            text += `${edition ?? ""}${volume ?? ""}${revision ?? ""}`;
+            if (supplement !== undefined)
+                text += `sup${supplement}`;
+            return parse(text);
+        },
+    },
+    // lib/pubid/easc/urn_parser.rb — "urn:easc:<series>[:v]:<number>[:<year>]";
+    // the human face renders the Cyrillic series label
+    // ("ПМГ 02-2008", "ПМГ В 31-2001", "РМГ 151-2025").
+    easc: {
+        prefix: "urn:easc:",
+        reconstruct(body, parse) {
+            const parts = body.split(":");
+            const series = parts.shift() ?? "";
+            if (series === "") {
+                throw new Error(`EASC URN missing series: ${JSON.stringify(body)}`);
+            }
+            const label = series.toUpperCase() === "PMG" ? "ПМГ" : "РМГ";
+            let rest = parts;
+            let separator = " ";
+            if (/^v$/i.test(rest[0] ?? "")) {
+                separator = " В ";
+                rest = rest.slice(1);
+            }
+            const number = rest[0] ?? "";
+            let text = `${label}${separator}${number}`;
+            if (rest[1] !== undefined)
+                text += `-${rest[1]}`;
             return parse(text);
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "TypeScript PubID identifiers: resolution, normalization and canonical hashes for every identifier in the pubid-testsuite corpus (41 standards bodies), with a conformance runner mirroring the Ruby reference",
   "type": "module",
   "license": "MIT",