@pubid/pubid 0.1.19 → 0.1.21

package/dist/conformance/runner.js

@@ -29,7 +29,13 @@ export function checkCase(testCase, impl) {
     for (const alias of testCase.nonNormalizedAliases ?? []) {
         try {
             const aliased = impl.parse(alias.spelling);
-            if (aliased.toHuman() !== testCase.representations.human) {
+            // A multi-round chain walks another render/parse round per
+            // recorded `rounds` until it reaches the canonical human.
+            let human = aliased.toHuman();
+            for (let round = 1; round < (alias.rounds ?? 1); round += 1) {
+                human = impl.parse(human).toHuman();
+            }
+            if (human !== testCase.representations.human) {
                 mismatches.push(`${label} alias ${alias.spelling}`);
             }
         }

package/dist/corpus/types.d.ts

@@ -13,6 +13,9 @@ export interface Representations {
 export interface Spelling {
     spelling: string;
     style?: string;
+    /** Render/parse rounds the spelling needs to reach the canonical human;
+     * present only above 1 (a documented multi-round normalization chain). */
+    rounds?: number;
 }
 export interface ErrorExpectation {
     /** Neutral rejection code - never an implementation class. */

package/dist/flavors/ieee/index.js

@@ -501,11 +501,15 @@ class IeeeBuilder {
         // An explicit joint stage on the draft ("=DFDIS.3") IS the stage —
         // it outranks the ordinal ladder, which classifies IEEE-internal
         // drafts only (docs/IEEE-DRAFT-STAGES.md §1.3).
+        let draftVersionPresent = false;
         if (parsed["draft"] !== undefined) {
             let draftData = parsed["draft"];
             if (Array.isArray(draftData)) {
                 draftData = mergeParsedArray(draftData);
             }
+            // A verbatim draft designator string is a version in itself.
+            if (!isObj(draftData))
+                draftVersionPresent = true;
             if (isObj(draftData) && draftData["draft_iso_stage"] !== undefined) {
                 const stage = extractValue(draftData["draft_iso_stage"]) ?? "";
                 // The doubled-D alias ("DFDIS") carries its own draft marker;
@@ -516,9 +520,21 @@ class IeeeBuilder {
                     : stage;
             }
             if (isObj(draftData) && draftData["draft_version"] !== undefined) {
+                draftVersionPresent = true;
                 const dv = draftData["draft_version"];
                 const version = Array.isArray(dv) ? dv.map((v) => extractValue(v) ?? "").join("") : extractValue(dv);
                 if (version !== undefined) {
+                    // A draft version that IS an ISO stage token ("/DCD1" and
+                    // "/CD1" both capture "CD1") takes that stage on a plain IEEE
+                    // document (docs/IEEE-DRAFT-STAGES.md §1.3, "DDIS" = DIS); a
+                    // joint ISO-led stage-word draft keeps its generic project
+                    // stage.
+                    const pubs = parsed["publishers"];
+                    const copubs = isObj(pubs) ? pubs["copublishers"] : undefined;
+                    const joint = copubs !== undefined && (Array.isArray(copubs) ? copubs.length > 0 : true);
+                    const stageMatch = /^(FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)\d*$/.exec(version);
+                    if (!joint && stageMatch !== null)
+                        return stageMatch[1];
                     // relaton's hyphenated "/D-2" spelling captures the dash inside
                     // draft_version; the stage registry keys on "D2". A date-embedded
                     // version ("3-2017-07") keys on its leading ordinal.
@@ -534,7 +550,7 @@ class IeeeBuilder {
                 return "P";
             if (typeValue === "Std")
                 return "Std";
-            if (typeValue === "Draft Std" && parsed["draft"] === undefined && parsed["digit_draft"] === undefined) {
+            if (typeValue === "Draft Std" && !draftVersionPresent && parsed["digit_draft"] === undefined) {
                 return "D1";
             }
             if (/^No\.?$/.test(typeValue))

package/dist/flavors/nist/index.js

@@ -1259,6 +1259,15 @@ export function nistGrammarImplementation() {
             const { cleaned, format } = preprocessNist(input);
             const base = cleaned.replace(/\s*\(all parts\)\s*$/, "");
             const tree = toBuilderTree(cachedRuntime(base));
+            // The reference's language_code rule captures its separator with
+            // the code (".uppl"); the baked nist artifact labels the code
+            // alone. Restore the reference's slice for a trailing dot-prefixed
+            // code, so the renderer prints the canonical double-dot face
+            // ("NIST.SP.955-S..uppl").
+            const dotted = /\.([a-z]{2,4})$/.exec(base);
+            if (dotted && tree["translation"] === dotted[1]) {
+                tree["translation"] = `.${dotted[1]}`;
+            }
             const marked = base !== cleaned
                 ? { ...tree, all_parts: true }
                 : tree;

package/dist/flavors/nist/preprocessor.js

@@ -266,8 +266,11 @@ export function preprocessNist(input) {
     // normalize_legacy_corpus_spellings: catalogue forms the grammar and
     // the renderers cannot round-trip on their own. Each rule mirrors an
     // already-parseable spelling of the same document.
-    // The mr renderer prints the translation code with its own leading
-    // dot ("955-S..uppl"); the grammar wants one dot.
+    // The reference's mr translation CODE keeps its own leading dot
+    // (".uppl") and its renderer adds the separator dot, so the canonical
+    // face is "955-S..uppl". The grammar reads the collapsed single-dot
+    // spelling and captures the dot with the code; collapse here so a
+    // double-dot input reads the same way.
     cleaned = cleaned.replace(/\.\./g, ".");
     // Trailing-dot addendum spelling; the canonical render comes from
     // the lowercase ".add" parse ("NBS.TN.467pt1.Add." -> ".add").

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 (orgParts.length) {
+                    const org = orgs[orgParts.join("-")];
+                    if (org === undefined)
+                        throw new Error(`unknown adopted org in ${JSON.stringify(body)}`);
+                    text += ` ${org}`;
                 }
-                if (iteration === undefined || parts.length) {
-                    throw new Error(`malformed supplement in ${JSON.stringify(body)}`);
+                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();
                 }
-                text += kind === "amd" ? `/A${iteration}` : `/AC${iteration}`;
-                if (yearTail)
-                    text += `:${yearTail}`;
+                const year = parts.shift();
+                text += `-${org} ${number}`;
+                if (part !== undefined)
+                    text += `-${part}`;
+                if (year !== undefined)
+                    text += `:${year}`;
             }
-            // 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 });
+            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)}`);
+            }
+            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,50 @@ 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);
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "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",