@pubid/pubid 0.1.7 → 0.1.9

package/dist/flavors/ieee/index.js

@@ -1,9 +1,11 @@
 import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { PubidRuntime } from "../../parg/runtime.js";
+import { artifactToBuilderTree } from "./artifact_tree.js";
 import { grammarImplementation } from "../index.js";
 import { ieeeGrammar } from "./grammar.js";
 import { preParse, preprocessIeee } from "./preprocessor.js";
 import { applyUpdateCodes } from "./update_codes.js";
-import { AdoptedStandardClass, AieeClass, AmendmentClass, ConformanceClass, CorrigendumClass, CsaDualPublishedClass, DualPublishedClass, IecIeeeCopublishedClass, IeeeCode, IeeeDraft, IeeeRelationship, IeeeTypedStage, InterpretationClass, IreClass, JointDevelopmentClass, MultiNumberedClass, NescDraftClass, NescEditionClass, NescHandbookClass, NescRedlineClass, NescStandardClass, ProjectDraftIdentifierClass, SiStandardClass, StandardClass, locateStage, } from "./model.js";
+import { AdoptedStandardClass, AieeClass, AmendmentClass, ConformanceClass, CorrigendumClass, CsaDualPublishedClass, DualPublishedClass, IecIeeeCopublishedClass, IeeeCode, IeeeDraft, IeeeRelationship, IeeeTypedStage, InterpretationClass, IreClass, JointDevelopmentClass, MultiNumberedClass, NescDraftClass, NescEditionClass, NescHandbookClass, NescPreprintClass, NescRedlineClass, NescStandardClass, DRAFT_MONTH_NAMES, ProjectDraftIdentifierClass, SiStandardClass, StandardClass, locateStage, } from "./model.js";
 /**
  * Port of lib/pubid/ieee/{builder}.rb + Identifier.parse orchestration
  * (pre-parser dispatch, adopted/dual constructors, sub-builders).
@@ -34,6 +36,7 @@ class IeeeBuilder {
     originalInput = "";
     build(parsed) {
         const d = Array.isArray(parsed) ? mergeParsedArray(parsed) : parsed;
+        this.normalizeDraftDashYear(d);
         if (d["ieee_portion"] !== undefined && d["csa_portion"] !== undefined) {
             return this.buildCsaDualPublished(d);
         }
@@ -55,6 +58,117 @@ class IeeeBuilder {
         return this.buildSingleIdentifier(d, false);
     }
     // --- single identifier -----------------------------------------------------
+    // The artifact binds a dash-year draft tail as a second draft element
+    // ({draft_version: {dash_year: ...}}); the reference's builder hoists
+    // the dash fields and rejoins the version ("D9-2006", "/DPub2-2012").
+    normalizeDraftDashYear(d) {
+        const raw = d["draft"];
+        if (raw === undefined)
+            return;
+        const drafts = Array.isArray(raw) ? raw : [raw];
+        // The compound-stage captures nest inside the draft elements (the
+        // artifact's binding); the hand mirror bound them top-level, so the
+        // joint-designator block reads them from `parsed` directly.
+        for (const key of ["draft_iso_stage", "draft_iso_iteration", "draft_stage_d", "draft_stage_year"]) {
+            if (d[key] === undefined) {
+                for (const e of drafts) {
+                    if (isObj(e) && e[key] !== undefined) {
+                        d[key] = e[key];
+                        break;
+                    }
+                }
+            }
+        }
+        for (const e of drafts) {
+            if (!isObj(e))
+                continue;
+            const dv = e["draft_version"];
+            if (!isObj(dv))
+                continue;
+            if (dv["dash_year"] !== undefined)
+                e["dash_year"] = dv["dash_year"];
+            if (dv["dash_month"] !== undefined)
+                e["dash_month"] = dv["dash_month"];
+            delete e["draft_version"];
+        }
+        // A numeric month trailing a draft is the draft's own date: it embeds
+        // in the designator ("D09, 04 2011" -> "D09-2011-04") rather than
+        // printing the long-format comma face (a month name keeps the comma,
+        // "D7.2, Nov 2006") - pubid ruling 2026-10-13.
+        if (d["dash_year"] === undefined && d["draft"] !== undefined) {
+            const m = d["month"] ?? d["trailing_month"];
+            const y = d["year"] ?? d["trailing_year"];
+            const mVal = extractValue(m);
+            const yVal = extractValue(y);
+            if (mVal !== undefined && /^\d{1,2}$/.test(String(mVal)) && yVal !== undefined) {
+                const host = drafts.find((e) => isObj(e) && e["draft_version"] !== undefined);
+                if (host !== undefined && isObj(host)) {
+                    const hv = host["draft_version"];
+                    const joined = Array.isArray(hv)
+                        ? hv.map((v) => (isObj(v) ? (v["value"] ?? "") : String(v))).join("")
+                        : String(extractValue(hv) ?? "");
+                    host["draft_version"] = [joined, String(yVal), String(mVal)]
+                        .filter((s) => s !== "")
+                        .join("-");
+                    delete d["month"];
+                    delete d["year"];
+                    delete d["trailing_month"];
+                    delete d["trailing_year"];
+                }
+            }
+        }
+        const dash = drafts.find((e) => isObj(e) && e["dash_year"] !== undefined) ??
+            (d["dash_year"] !== undefined ? d : undefined);
+        if (dash === undefined || d["year"] !== undefined)
+            return;
+        const objs = drafts.filter(isObj);
+        const joined = objs
+            .map((e) => e["draft_version"])
+            .filter((v) => v !== undefined)
+            .map((v) => (isObj(v) ? (v["value"] ?? "") : String(v)))
+            .join("");
+        const bareJointDraft = d["joint_publishers"] !== undefined &&
+            d["part"] === undefined && d["iso_stage"] === undefined &&
+            objs.some((e) => e["draft_version"] !== undefined);
+        const dashLed = joined.startsWith("-");
+        const dashYear = extractValue(dash["dash_year"]);
+        const dashMonth = dash["dash_month"];
+        if (bareJointDraft && dashLed) {
+            d["part"] = dashYear;
+        }
+        else if (dashMonth !== undefined || dashLed) {
+            // A dash_month beside a draft host is the draft's own date
+            // ("/R-i-2011-04" -> "D09-2011-04"); with no host it is the
+            // identifier's year/month.
+            const host = objs.find((e) => e["draft_version"] !== undefined);
+            const dm = extractValue(dashMonth);
+            if (dm !== undefined && host !== undefined) {
+                const hv = host["draft_version"];
+                const joined = Array.isArray(hv)
+                    ? hv.map((v) => (isObj(v) ? (v["value"] ?? "") : String(v))).join("")
+                    : String(extractValue(hv) ?? "");
+                host["draft_version"] = [joined, dashYear, String(dm)].join("-");
+                delete dash["dash_year"];
+                delete dash["dash_month"];
+            }
+            else {
+                d["year"] = dashYear;
+                d["month"] = dm;
+            }
+        }
+        else {
+            const host = objs.find((e) => e["draft_version"] !== undefined);
+            if (host !== undefined) {
+                host["draft_version"] = `${joined}-${dashYear}`;
+                delete dash["dash_year"];
+                delete dash["dash_month"];
+            }
+            else {
+                d["year"] = dashYear;
+                d["month"] = extractValue(dashMonth);
+            }
+        }
+    }
     buildSingleIdentifier(parsed, buildingSecondary) {
         const parsedHash = asHash(parsed);
         if (!buildingSecondary && parsedHash["primary_identifier"] !== undefined &&
@@ -98,6 +212,27 @@ class IeeeBuilder {
         if (parsedHash["joint_publishers"] !== undefined || parsedHash["iso_stage"] !== undefined) {
             return this.buildJointDevelopment(parsedHash);
         }
+        // The ORDINAL-LESS D= designator on a multi-publisher row is the
+        // joint compound form ("ISO/IEC/IEEE P16326:2017/D=WD.4a"); the
+        // ordinal compound ("D8=DIS.3") is a project draft whatever the
+        // publishers — the D-ordinal is the draft, the stage the target.
+        if (parsedHash["draft_iso_stage"] !== undefined) {
+            const draftHash = parsedHash["draft"] !== undefined
+                ? asHash(parsedHash["draft"])
+                : undefined;
+            const hasOrdinal = extractValue(parsedHash["draft_version"]) !== undefined ||
+                extractValue(draftHash?.["draft_version"]) !== undefined;
+            if (!hasOrdinal) {
+                const pubData = parsedHash["publishers"] !== undefined
+                    ? asHash(parsedHash["publishers"])
+                    : undefined;
+                const copubs = pubData?.["copublishers"] !== undefined
+                    ? (Array.isArray(pubData["copublishers"]) ? pubData["copublishers"] : [pubData["copublishers"]])
+                    : [];
+                if (copubs.length > 0)
+                    return this.buildJointDevelopment(parsedHash);
+            }
+        }
         const attributes = this.extractAttributes(parsedHash);
         if (parsedHash["relationship_type"] !== undefined || parsedHash["relationship_clause"] !== undefined) {
             attributes["relationships"] = this.buildRelationships(parsedHash);
@@ -215,7 +350,12 @@ class IeeeBuilder {
                 codeStr = codeStr.replace(/^P/, "");
         }
         if (codeStr !== undefined && codeParts.length > 0) {
-            codeStr += `.${codeParts.join(".")}`;
+            // Captures carry their own separator when present (the artifact's
+            // part/subpart bind ".18" / "-10"); bare tokens fall back to the
+            // hand grammar's part_sep. Joins verbatim like the reference's
+            // extract_attributes — a dashed "62271-37-082" stays dashed.
+            const partSep = extractValue(parsed["part_sep"]) ?? ".";
+            codeStr += codeParts.map((cp) => /^[._-]/.test(cp) ? cp : `${partSep}${cp}`).join("");
         }
         if (codeStr !== undefined && parsed["year"] === undefined && codeParts.length === 0) {
             const m = /^(.+)-(\d{4})$/.exec(codeStr);
@@ -261,7 +401,15 @@ class IeeeBuilder {
             /^IEEE\s/.test(this.originalInput)) {
             typeValue = "Std";
         }
-        if (typeValue !== undefined)
+        // The canonical type word is the short form (C2 ruling):
+        // "IEEE Standard 495-2007" and "IEEE Std 495-2007" are the same
+        // identifier. A DRAFT type word never reaches the wire (the
+        // draft-ness rides draft_status + the draft component; "Draft Std"
+        // is banned from canonical output) - it still feeds
+        // determineStageAbbr below (the version-less D1 fabrication).
+        if (typeValue === "Standard")
+            typeValue = "Std";
+        if (typeValue !== undefined && !/^Draft/.test(typeValue))
             attributes["type"] = typeValue;
         const typedStageAbbr = this.determineStageAbbr(typeValue, parsed);
         if (typedStageAbbr !== undefined) {
@@ -270,11 +418,13 @@ class IeeeBuilder {
                 attributes["typed_stage"] = new IeeeTypedStage(record);
         }
         attributes["draft_status"] = draftStatusValue;
-        for (const key of ["edition", "revision"]) {
+        for (const key of ["edition", "revision", "rev_sep"]) {
             const value = extractValue(parsed[key]);
             if (value !== undefined)
                 attributes[key] = value;
         }
+        if (parsed["rev_bare"] !== undefined)
+            attributes["rev_bare"] = true;
         if (attributes["edition_month"] === undefined) {
             const month = extractValue(parsed["month"]);
             if (month !== undefined)
@@ -299,6 +449,13 @@ class IeeeBuilder {
             attributes["interpretation"] = true;
         if (parsed["redline"] !== undefined)
             attributes["redline"] = true;
+        // Glued identity year-month provenance (gem#520): the input tail is
+        // the glued "-YYYY-MM" on a draft-free, revision-free identity.
+        if (attributes["month"] !== undefined && attributes["year"] !== undefined &&
+            attributes["draft"] === undefined && attributes["revision"] === undefined &&
+            /-\d{4}-\d{2}$/.test(this.originalInput ?? "")) {
+            attributes["month_glued"] = true;
+        }
         return attributes;
     }
     determineStageAbbr(typeValue, parsed) {
@@ -377,6 +534,12 @@ class IeeeBuilder {
             isoIteration = extractValue(draftData["draft_iso_iteration"]);
             month = extractValue(draftData["month"]);
             year = extractValue(draftData["year"]);
+            // The apostrophe-year catalogue convention ("P1484.20.1/D7,
+            // May 07"): the 2-digit year expands with the <30 pivot so the
+            // hash carries an unambiguous year (the reference's builder).
+            if (year !== undefined && /^\d{2}$/.test(year)) {
+                year = `${Number(year) < 30 ? 20 : 19}${year}`;
+            }
             day = extractValue(draftData["day"]);
             if (this.originalInput !== "" && month !== undefined) {
                 commaBeforeMonth = new RegExp(`,\\s+${month.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i")
@@ -390,6 +553,20 @@ class IeeeBuilder {
         else {
             version = extractValue(draftData);
         }
+        // A REV-carrying draft embeds its print date into the designator
+        // with the month canonicalized numeric (pubid ruling 2026-10-14):
+        // "P802.11-REVmc/D8.0, Aug 2016" renders ".../D8.0-2016-08".
+        // Drafts without a REV keep the comma face.
+        if ((attributes["revision"] !== undefined || attributes["rev_bare"] === true) &&
+            month !== undefined && year !== undefined && version !== undefined) {
+            const monthNumber = DRAFT_MONTH_NAMES[String(month).replace(/\.$/, "")];
+            if (monthNumber !== undefined) {
+                // The canonical face zero-pads ("D8.0-2016-08"), matching the
+                // reference's REV_MONTH_NUMBERS.
+                version = `${version}-${year}-${monthNumber.padStart(2, "0")}`;
+                month = year = day = undefined;
+            }
+        }
         if (version !== undefined || (isObj(draftData) && draftData["draft_iso_stage"] !== undefined)) {
             const draftObj = new IeeeDraft({
                 version,
@@ -409,7 +586,11 @@ class IeeeBuilder {
             return;
         if (typeValue !== "Draft Std")
             return;
-        attributes["draft"] = new IeeeDraft({ version: "1", year: attributes["year"] }).render();
+        // The reference stores the fabricated designator comma-joined with the
+        // identity year ("D1, 2012" — the gem's Draft#to_s), not space-joined.
+        attributes["draft"] = attributes["year"] === undefined
+            ? "D1"
+            : `D1, ${attributes["year"]}`;
     }
     handleKeyedHash(parsed, key, attributes, numberKey, yearKey) {
         if (isObj(parsed[key])) {
@@ -526,15 +707,17 @@ class IeeeBuilder {
             baseParts.push(extractValue(baseData["type"]) ?? "");
         }
         let numberStr = extractValue(baseData["number"]) ?? "";
+        const baseSep = extractValue(baseData["part_sep"]) ?? ".";
         if (baseData["part"] !== undefined) {
-            numberStr += `.${extractValue(baseData["part"]) ?? ""}`;
+            const pv = extractValue(baseData["part"]) ?? "";
+            numberStr += /^[._-]/.test(pv) ? pv : `${baseSep}${pv}`;
         }
         if (baseData["subpart"] !== undefined) {
             const subparts = Array.isArray(baseData["subpart"]) ? baseData["subpart"] : [baseData["subpart"]];
             for (const sp of subparts) {
                 const v = extractValue(sp);
                 if (v !== undefined)
-                    numberStr += `.${v}`;
+                    numberStr += /^[._-]/.test(v) ? v : `${baseSep}${v}`;
             }
         }
         if (baseData["year"] !== undefined) {
@@ -618,15 +801,33 @@ class IeeeBuilder {
             attributes["publisher"] = pubs[0];
             attributes["copublisher"] = pubs.slice(1);
         }
+        else if (parsed["publishers"] !== undefined) {
+            // Stage-bearing rows the artifact routes without a
+            // joint_publishers capture ("ISO/IEC/IEEE P26511/D8=DDIS.3"):
+            // the publishers hash carries the same information.
+            const pubData = asHash(parsed["publishers"]);
+            const lead = extractValue(pubData["publisher"]) ?? "";
+            const copubs = pubData["copublishers"] !== undefined
+                ? (Array.isArray(pubData["copublishers"])
+                    ? pubData["copublishers"]
+                    : [pubData["copublishers"]])
+                    .map((cp) => extractValue(asHash(cp)["copublisher"]))
+                    .filter((cp) => cp !== undefined)
+                : [];
+            attributes["publishers"] = [lead, ...copubs];
+            attributes["publisher"] = lead;
+            attributes["copublisher"] = copubs;
+        }
         const codeParts = [];
         if (parsed["part"] !== undefined)
             codeParts.push(extractValue(parsed["part"]) ?? "");
         let codeStr = extractValue(parsed["number"]);
         if (codeStr !== undefined && codeParts.length > 0) {
             // The ISO/IEC label's part may be dash-joined ("8802-9") - keep the
-            // printed separator.
+            // printed separator. Separator-carrying captures (the artifact's
+            // part binds ".2") join verbatim.
             const sep = parsed["iec_label_dash"] !== undefined ? "-" : ".";
-            codeStr += `${sep}${codeParts.join(sep)}`;
+            codeStr += codeParts.map((cp) => /^[._-]/.test(cp) ? cp : `${sep}${cp}`).join("");
         }
         // P = project (a draft): identity-bearing, preserved as spelled.
         if (parsed["project_marker"] !== undefined && codeStr !== undefined) {
@@ -665,8 +866,39 @@ class IeeeBuilder {
         }
         if (parsed["draft_version"] !== undefined) {
             const draftVer = (extractValue(parsed["draft_version"]) ?? "").replace(/^D/, "");
-            if (draftVer !== "")
-                attributes["ieee_draft"] = `D${draftVer}`;
+            if (draftVer !== "") {
+                // A date trailing the draft (", June 2010") belongs to the draft
+                // component (canonical month, comma form); the identity
+                // year/month the promotion filled from the same captures are
+                // vacated. Stage-first ISO rows are exempt: their canonical is
+                // the ISO face, which prints the date from the identity slots
+                // (", March 2017", pubid#216).
+                if (parsed["draft_month"] !== undefined && parsed["iso_stage"] === undefined) {
+                    const draftObj = new IeeeDraft({
+                        version: draftVer,
+                        month: extractValue(parsed["draft_month"]),
+                        year: extractValue(parsed["draft_year"]),
+                        comma_before_month: true,
+                    });
+                    attributes["draft"] = draftObj.render();
+                    if (parsed["year"] === undefined)
+                        delete attributes["year"];
+                    if (parsed["month"] === undefined)
+                        delete attributes["month"];
+                }
+                else if (parsed["draft_year"] !== undefined && parsed["iso_stage"] === undefined) {
+                    // The comma-year tail captures its separator (", 2013") —
+                    // strip it (the #471 separator-in-capture rule). The stored
+                    // form keeps the comma so it re-parses through the same tail.
+                    const draftYear = (extractValue(parsed["draft_year"]) ?? "").replace(/^[, ]+/, "");
+                    attributes["draft"] = `/D${draftVer}, ${draftYear}`;
+                    if (parsed["year"] === undefined)
+                        delete attributes["year"];
+                }
+                else {
+                    attributes["ieee_draft"] = `D${draftVer}`;
+                }
+            }
         }
         // The "(E)" edition marker of an ISO/IEC label rides on the joint
         // reference as parenthetical_content - either from the trailing
@@ -681,21 +913,37 @@ class IeeeBuilder {
         if (attributes["parenthetical_content"] === undefined && parsed["edition_marker"] !== undefined) {
             attributes["parenthetical_content"] = extractValue(parsed["edition_marker"]);
         }
+        // A joint ISO-print redline is a distinct document of the same standard
+        // (pubid#215) - same flag semantics as the generic path.
+        if (parsed["redline"] !== undefined)
+            attributes["redline"] = true;
         // The joint stage-draft clause (docs/IEEE-DRAFT-STAGES.md §1.3):
         // variant 1's compound tail composes onto the IEEE ordinal
         // ("D5=DIS.3"); variant 1b is the ordinal-less stage draft whose
         // date rides inside the designator ("D=CDV:2020"). The doubled-D
         // alias spelling echoes as spelled.
         if (parsed["draft_iso_stage"] !== undefined) {
-            const stageText = `${extractValue(parsed["draft_stage_d"]) ?? ""}${extractValue(parsed["draft_iso_stage"]) ?? ""}`;
-            let jointDraft = parsed["draft_version"] !== undefined
-                ? `D${(extractValue(parsed["draft_version"]) ?? "").replace(/^D/, "")}=${stageText}`
+            // The doubled-D alias ("=DDIS") is notation: the designator carries
+            // its own D-ordinal, the stage is the bare ISO/IEC token.
+            const rawStage = `${extractValue(parsed["draft_stage_d"]) ?? ""}${extractValue(parsed["draft_iso_stage"]) ?? ""}`;
+            const stageText = rawStage.startsWith("D") &&
+                ["PWI", "NP", "WD", "CD", "CDV", "DIS", "FDIS"].includes(rawStage.slice(1))
+                ? rawStage.slice(1)
+                : rawStage;
+            const jointVersion = extractValue(parsed["draft_version"]) ??
+                (parsed["draft"] !== undefined
+                    ? extractValue(asHash(parsed["draft"])["draft_version"])
+                    : undefined);
+            let jointDraft = jointVersion !== undefined
+                ? `D${jointVersion.replace(/^D/, "")}=${stageText}`
                 : `D=${stageText}`;
             if (parsed["draft_iso_iteration"] !== undefined) {
                 jointDraft += `.${extractValue(parsed["draft_iso_iteration"])}`;
             }
             if (parsed["draft_stage_year"] !== undefined) {
-                jointDraft += `:${extractValue(parsed["draft_stage_year"])}`;
+                // The capture carries its separator (":2020") — strip it (the
+                // #471 separator-in-capture rule).
+                jointDraft += `:${(extractValue(parsed["draft_stage_year"]) ?? "").replace(/^[\-:]/, "")}`;
             }
             attributes["ieee_draft"] = jointDraft;
         }
@@ -791,6 +1039,29 @@ class IeeeBuilder {
             if (record !== undefined)
                 attributes["typed_stage"] = new IeeeTypedStage(record);
         }
+        // A plain IEEE-designator draft on joint publishers ("/D8, June
+        // 2010") carries no ISO stage machinery: it builds as the project
+        // draft its bare-IEEE twin and the D= designator rows already pin
+        // (pubid#430) rather than the joint-development model.
+        if (attributes["draft"] !== undefined &&
+            parsed["iso_stage"] === undefined &&
+            parsed["iec_stage"] === undefined &&
+            parsed["amd_number"] === undefined) {
+            const pubs = (attributes["publishers"] ?? []);
+            const projectAttrs = {
+                code: attributes["code"],
+                draft: attributes["draft"],
+            };
+            if (pubs.length > 0) {
+                projectAttrs["publisher"] = pubs[0];
+                if (pubs.length > 1)
+                    projectAttrs["copublisher"] = pubs.slice(1);
+            }
+            if (attributes["draft_status"] !== undefined) {
+                projectAttrs["draft_status"] = attributes["draft_status"];
+            }
+            return new ProjectDraftIdentifierClass(projectAttrs);
+        }
         const joint = new JointDevelopmentClass(attributes);
         if (parsed["amd_number"] === undefined)
             return joint;
@@ -1046,7 +1317,12 @@ class IeeeBuilder {
         // nested name_first variant captures as a hash) and reaches Standard
         // via the code check; Edition is only the no-code fallback.
         let klass = NescEditionClass;
-        if (parsedHash["draft"] !== undefined) {
+        if (parsedHash["preprint"] !== undefined) {
+            // Preprint is a draft STAGE of the C2 code — checked before the
+            // Standard route: the c2-preprint tree carries :code "C2" too.
+            klass = NescPreprintClass;
+        }
+        else if (parsedHash["draft"] !== undefined) {
             klass = NescDraftClass;
         }
         else if (typeof parsedHash["variant"] === "string") {
@@ -1120,6 +1396,24 @@ function copublishedStructured(copublishedNumber) {
     return attrs;
 }
 // --- parse orchestration -------------------------------------------------------
+// The grammar runtime is the baked PARG artifact (pubid-grammar
+// artifacts/ieee.json via the parsanol engine) — the same artifact the
+// gem runs, so grammar changes land once and this port cannot drift.
+// Only the preprocessor, builder, model and the AIEE sub-grammar root
+// (parseAieeDirect) remain hand-written.
+let cachedArtifactRuntime;
+function parseSource(input) {
+    cachedArtifactRuntime ??= PubidRuntime.load("ieee");
+    try {
+        return artifactToBuilderTree(cachedArtifactRuntime.parseShape(input));
+    }
+    catch (e) {
+        // The engine throws its own error class; the reference's fallback
+        // logic keys on Parslet::ParseFailed, so normalize (the messageless
+        // wasm throws included).
+        throw new ParseFailed(e instanceof Error && e.message !== "" ? e.message : String(e), 0);
+    }
+}
 function ieeeParseSingle(input) {
     const normalized = applyUpdateCodes(input);
     // UpdateCodes may introduce the "; " double-label separator (the
@@ -1131,7 +1425,7 @@ function ieeeParseSingle(input) {
             return buildDual(re.parts);
     }
     const cleaned = preprocessIeee(normalized);
-    const tree = parseGrammar(ieeeGrammar, cleaned);
+    const tree = parseSource(cleaned);
     const builder = new IeeeBuilder();
     builder.originalInput = input;
     return builder.build(tree);
@@ -1141,7 +1435,7 @@ function ieeeParseSingle(input) {
 // update-codes rewrite (e.g. "AIEE Nos 72 and 73 - 1932") must not make
 // a line parse that the reference rejects.
 function ieeeParseSingleNoCodes(input) {
-    const tree = parseGrammar(ieeeGrammar, preprocessIeee(input));
+    const tree = parseSource(preprocessIeee(input));
     const builder = new IeeeBuilder();
     builder.originalInput = input;
     return builder.build(tree);

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

@@ -40,6 +40,7 @@ export declare class IeeeCode {
     static parse(codeStr: string): IeeeCode | undefined;
     render(): string;
 }
+export declare const DRAFT_MONTH_NAMES: Record<string, string>;
 export declare class IeeeDraft {
     readonly version: string;
     readonly revision: string | undefined;
@@ -83,10 +84,13 @@ export declare abstract class IeeeIdentifier extends BaseIdentifier {
     readonly draft_status: string | undefined;
     readonly draft: string | undefined;
     readonly revision: string | undefined;
+    readonly rev_sep: string | undefined;
+    readonly rev_bare: boolean | undefined;
     readonly edition: string | undefined;
     readonly month: string | undefined;
     readonly day: string | undefined;
     readonly redline: boolean | undefined;
+    readonly month_glued: boolean | undefined;
     readonly edition_month: string | undefined;
     readonly space_before_draft: boolean | undefined;
     readonly typed_stage: IeeeTypedStage | undefined;
@@ -142,3 +146,4 @@ export declare const NescHandbookClass: IdentifierStatic;
 export declare const NescRedlineClass: IdentifierStatic;
 export declare const NescStandardClass: IdentifierStatic;
 export declare const NescDraftClass: IdentifierStatic;
+export declare const NescPreprintClass: IdentifierStatic;