@pubid/pubid 0.1.19 → 0.1.20

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/package.json

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