@pubid/pubid 0.1.18 → 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/ieee/preprocessor.js

@@ -315,6 +315,19 @@ const STAGE_MONTH_NUMBERS = {
 };
 function normalizeJointStageSpellings(input) {
     let cleaned = input;
+    // The three-way ISO-led list glues the language marker to the year
+    // ("ISO/IEC/IEEE 8802-1AC-2018(E)"): the spaced spelling is the
+    // language marker and drops, the glued one prints as parenthetical
+    // content. Re-spell the boundary (Ruby: Parser.normalize_input).
+    // Scoped to the three-way lists - the two-way IEC/IEEE copublished
+    // form keeps its glued (E) as identity ("…:2012(E)").
+    cleaned = cleaned.replace(/^((?:ISO\/IEC\/IEEE|IEEE\/ISO\/IEC|IEEE\/IEC\/ISO)\s+[^()]+?[^()\s])\(E\)$/, "$1 (E)");
+    // The stage-first joint draft's dash part carries a bare comma year
+    // ("IEC/IEEE FDIS P60780-323, 2015"): the joint route takes no bare
+    // year there and the copublished route claims the string, so drop
+    // the non-identity year and let the stage-first route read the dash
+    // part (the rendered face is the dot human).
+    cleaned = cleaned.replace(/^((?:IEC\/IEEE|IEEE\/IEC)\s+(?:FDIS|FCD|CDV|DIS|CD|WD|PWI|NP)\s+P\d+(?:-\d+)+),\s+\d{4}$/, "$1");
     // The IEEE-led joint list's dash/underscore stage tail carries a
     // month-name date ("IEEE/ISO/IEC P29119-2-DIS, December 2011"): the
     // generic route answers with a slashed copublisher, so re-spell the

package/dist/flavors/ieee/update_codes.js

@@ -104,7 +104,7 @@ export const UPDATE_CODES = [
     { plain: "ISO/IEC/IEEE DIS P16326/201x, December 2018", replacement: "ISO/IEC/IEEE DIS P16326-2018-12" },
     { plain: "ISO/IEC/IEEE/P21839, 2019(E)", replacement: "ISO/IEC/IEEE P21839-2019" },
     { plain: "ISO/IEC/IEEE CD2 P12207-2: 201x(E), February 2019", replacement: "ISO/IEC/IEEE CD2 P12207.2-2019-02" },
-    { plain: "ISO/IEC/IEEE P42010.WD4:2019(E)", replacement: "ISO/IEC/IEEE P42010/D-4-2019" },
+    { plain: "ISO/IEC/IEEE P42010.WD4:2019(E)", replacement: "ISO/IEC/IEEE P42010.2019/D4" },
     { plain: "ISO/IEC/IEEE/P16085_DIS, March 2020", replacement: "ISO/IEC/IEEE DIS P16085-2020-03" },
     { plain: "ANSI/IEEE Std: Outdoor Apparatus Bushings", replacement: "ANSI/IEEE Std 21-1976-11" },
     { plain: "Draft National Electrical Safety Code, January 2016", replacement: "IEEE PC2-2016-01" },

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.18",
+  "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",