@pubid/pubid 0.1.3 → 0.1.4

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

@@ -0,0 +1,8 @@
+export interface PreParseResult {
+    dispatch: "standard" | "aiee_simple" | "iec_ieee_copublished" | "dual_semicolon" | "dual_reaffirmed" | "dual_ire" | "dual_space_separated" | "dual_and" | "dual_ampersand" | "aiee_asa_adoption" | "adopted";
+    input: string;
+    parts: string[];
+    metadata: Record<string, string>;
+}
+export declare function preParse(input: string): PreParseResult;
+export declare function preprocessIeee(input: string): string;

package/dist/flavors/ieee/preprocessor.js

@@ -0,0 +1,410 @@
+// IEEE pre-parser: regex/scan dispatch logic (Ruby: lib/pubid/ieee/pre_parser.rb)
+// and the Parser.parse string-cleaning stages (Ruby: lib/pubid/ieee/parser.rb
+// self.parse + normalize_* helpers), ported in the same order.
+const PUBLISHERS = [
+    "IEEE", "AIEE", "ANSI", "ASA", "IEC", "ISO", "ASTM", "NACE", "NSF",
+    "ASHRAE", "NCTA", "AESC",
+];
+const ADOPTION_PREFIXES = [
+    "ANSI", "ISO", "IEC", "IEEE", "AIEE", "IRE", "ASA", "ASTM", "CSA", "ASME",
+    "NACE", "NSF", "ASHRAE", "NCTA", "AESC",
+];
+const NON_ADOPTION_KEYWORDS = [
+    "Revision", "Revison", "Amendment", "Corrigendum", "Corrigenda",
+    "incorporates", "Incorporating", "Includes", "Incorporates", "Adoption",
+    "Supplement", "Draft Amendment", "DRAFT Amendment", "Draft Revision",
+    "Reaffirmation", "Redesignation", "redesignated as", "Supersedes",
+    "Supercedes", "Includes", "Previously designated as", "Notebooks",
+    "Standard Newspaper",
+];
+function findTopLevelPosition(input, marker) {
+    let parenDepth = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (char === "(")
+            parenDepth += 1;
+        if (char === ")")
+            parenDepth -= 1;
+        if (parenDepth === 0 &&
+            input.slice(i, i + marker.length) === marker) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function findTopLevel(input, marker) {
+    return findTopLevelPosition(input, marker) !== undefined;
+}
+function publisherPositions(input) {
+    const positions = [];
+    for (const pub of PUBLISHERS) {
+        const regex = new RegExp(`(?:^|\\s)(${pub.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(?:\\s|/)`, "g");
+        for (const m of input.matchAll(regex)) {
+            const matchPos = m.index + m[0].indexOf(m[1]);
+            const beforeMatch = input.slice(0, matchPos);
+            const open = (beforeMatch.match(/\(/g) ?? []).length;
+            const close = (beforeMatch.match(/\)/g) ?? []).length;
+            if (open > close)
+                continue;
+            positions.push({ pos: matchPos, publisher: pub });
+        }
+    }
+    return positions;
+}
+function nonAdoptionKeyword(adoptionPart) {
+    const alternation = NON_ADOPTION_KEYWORDS
+        .map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("|");
+    return new RegExp(`^\\s*(${alternation})`, "i").test(adoptionPart);
+}
+function adoptionPattern(input) {
+    if (!input.includes("(") || !input.includes(")"))
+        return false;
+    if (input.startsWith("IEC/IEEE "))
+        return false;
+    const mainPart = input.split("(")[0]?.trim();
+    const adoptionMatch = /\(([^)]+)\)/.exec(input);
+    const adoptionPart = adoptionMatch?.[1];
+    if (mainPart === undefined || mainPart === "" || adoptionPart === undefined)
+        return false;
+    if (nonAdoptionKeyword(adoptionPart))
+        return false;
+    const prefixes = ADOPTION_PREFIXES.join("|");
+    return (new RegExp(`\\b(${prefixes})\\s`).test(adoptionPart) ||
+        new RegExp(`^\\s*(${prefixes})\\b`).test(adoptionPart) ||
+        /\bStd\s+\d+/.test(adoptionPart));
+}
+function detectDispatch(input) {
+    if (input.startsWith("AIEE ") && !input.includes("("))
+        return "aiee_simple";
+    if (input.startsWith("IEC/IEEE "))
+        return "iec_ieee_copublished";
+    if (input.includes("; "))
+        return "dual_semicolon";
+    if (/\(R(\d{4})\)\s*\(Revision of ([^)]+)\)/.test(input) ||
+        /\(Reaffirmed\s+(\d{4})\)\s*\(Revision of ([^)]+)\)/.test(input)) {
+        return "dual_reaffirmed";
+    }
+    if (/\(R\d{4}\)\s*\((\d+\s+IRE[^)]+)\)/.test(input))
+        return "dual_ire";
+    {
+        const positions = publisherPositions(input).sort((a, b) => a.pos - b.pos);
+        if (positions.length >= 2) {
+            const between = input.slice(positions[0].pos, positions[1].pos);
+            if (!between.includes("/") && !between.includes(" and ") && !between.includes(" & ")) {
+                return "dual_space_separated";
+            }
+        }
+    }
+    if (input.includes(" and ") && findTopLevel(input, " and "))
+        return "dual_and";
+    if (input.includes(" & ") && findTopLevel(input, " & "))
+        return "dual_ampersand";
+    if (/^AIEE\s+/.test(input) && input.includes("(") && input.includes("ASA")) {
+        return "aiee_asa_adoption";
+    }
+    if (adoptionPattern(input))
+        return "adopted";
+    return undefined;
+}
+function buildDualSemicolon(input) {
+    const parts = input.split("; ");
+    if (parts.length !== 2 || parts[0] === undefined || parts[1] === undefined)
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    return {
+        dispatch: "dual_semicolon", input,
+        parts: [parts[0].trim(), parts[1].trim()], metadata: {},
+    };
+}
+function buildDualReaffirmed(input) {
+    const m = /\((?:R|Reaffirmed\s+)(\d{4})\)\s*\(Revision of ([^)]+)\)/.exec(input);
+    if (m === null)
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    const rewritten = input.replace(/\((?:R|Reaffirmed\s+)\d{4}\)\s*\(Revision of ([^)]+)\)/, "(Revision of $1)");
+    return { dispatch: "dual_reaffirmed", input: rewritten, parts: [], metadata: { reaffirmed: m[1] } };
+}
+function buildDualIre(input) {
+    const mainPart = input.split(" (R")[0]?.trim();
+    const reaffirmedMatch = /\(R(\d{4})\)/.exec(input);
+    const ireMatch = /\((\d+\s+IRE[^)]+)\)/.exec(input);
+    if (!mainPart || reaffirmedMatch === null || ireMatch === null) {
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    }
+    return {
+        dispatch: "dual_ire", input,
+        parts: [mainPart, ireMatch[1]], metadata: { reaffirmed: reaffirmedMatch[1] },
+    };
+}
+function buildDualSpaceSeparated(input) {
+    const positions = publisherPositions(input).sort((a, b) => a.pos - b.pos);
+    if (positions.length < 2)
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    const between = input.slice(positions[0].pos, positions[1].pos);
+    if (between.includes("/") || between.includes(" and ")) {
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    }
+    let splitPos = positions[1].pos;
+    while (splitPos > 0 && input[splitPos - 1] === " ")
+        splitPos -= 1;
+    return {
+        dispatch: "dual_space_separated", input,
+        parts: [input.slice(0, splitPos).trim(), input.slice(splitPos).trim()],
+        metadata: {},
+    };
+}
+function buildDualAnd(input) {
+    const position = findTopLevelPosition(input, " and ");
+    if (position === undefined)
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    return {
+        dispatch: "dual_and", input,
+        parts: [input.slice(0, position).trim(), input.slice(position + 5).trim()],
+        metadata: {},
+    };
+}
+function buildDualAmpersand(input) {
+    const parts = input.split(" & ");
+    if (parts.length !== 2 || parts[0] === undefined || parts[1] === undefined)
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    return {
+        dispatch: "dual_ampersand", input,
+        parts: [parts[0].trim(), parts[1].trim()], metadata: {},
+    };
+}
+function buildAieeAsaAdoption(input) {
+    const mainPart = input.split("(")[0]?.trim();
+    const adoptionMatch = /\((ASA[^)]+)\)/.exec(input);
+    if (!mainPart || adoptionMatch === null) {
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    }
+    return { dispatch: "aiee_asa_adoption", input, parts: [mainPart, adoptionMatch[1]], metadata: {} };
+}
+function buildAdopted(input) {
+    const mainPart = input.split("(")[0]?.trim();
+    const adoptionMatch = /\(([^)]+)\)/.exec(input);
+    const adoptionPart = adoptionMatch?.[1];
+    if (!mainPart || adoptionPart === undefined) {
+        return { dispatch: "standard", input, parts: [], metadata: {} };
+    }
+    return { dispatch: "adopted", input, parts: [mainPart, adoptionPart], metadata: {} };
+}
+export function preParse(input) {
+    const commaDual = input.replace(/(\d{4}),\s+Std\s/, "$1 and IEEE Std ");
+    switch (detectDispatch(commaDual)) {
+        case "aiee_simple": return { dispatch: "aiee_simple", input: commaDual, parts: [], metadata: {} };
+        case "iec_ieee_copublished": return { dispatch: "iec_ieee_copublished", input: commaDual, parts: [], metadata: {} };
+        case "dual_semicolon": return buildDualSemicolon(commaDual);
+        case "dual_reaffirmed": return buildDualReaffirmed(commaDual);
+        case "dual_ire": return buildDualIre(commaDual);
+        case "dual_space_separated": return buildDualSpaceSeparated(commaDual);
+        case "dual_and": return buildDualAnd(commaDual);
+        case "dual_ampersand": return buildDualAmpersand(commaDual);
+        case "aiee_asa_adoption": return buildAieeAsaAdoption(commaDual);
+        case "adopted": return buildAdopted(commaDual);
+        default: return { dispatch: "standard", input: commaDual, parts: [], metadata: {} };
+    }
+}
+// --- suffix / revision / joint-stage normalization (parser.rb) -------------
+function normalizeRelatonSuffixes(input) {
+    let cleaned = input;
+    // Combined draft + corrigendum: "…/D-N/CorM-YYYY[-MM]" → "…/Cor M-YYYY/DN".
+    // The month of the corrigendum is intentionally dropped (matches Ruby).
+    {
+        const re = /^(.*)\/D-([0-9A-Za-z][0-9A-Za-z.+]*?)\/Cor\.?[ ]?(\d+)(?:-((?:19|20)\d\d))?(?:-\d\d)?$/;
+        const m = re.exec(cleaned);
+        if (m !== null) {
+            cleaned = `${m[1]}/Cor ${m[3]}${m[4] !== undefined ? `-${m[4]}` : ""}/D${m[2]}`;
+        }
+    }
+    // Combined draft + revision and the empty-draft revision-only form.
+    {
+        const re = /^(.*?)\/D-([0-9A-Za-z.+]*)\/R-([0-9A-Za-z]+)(?:-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?)?$/;
+        const m = re.exec(cleaned);
+        if (m !== null) {
+            const date = m[4] !== undefined ? `-${m[4]}${m[5] !== undefined ? `-${m[5]}` : ""}` : "";
+            const draftPart = m[2] === "" ? "" : `/D${m[2]}`;
+            cleaned = `${m[1]}${date}${draftPart}/R-${m[3]}`;
+        }
+    }
+    // /D-N drafts with a trailing numeric date: reposition onto the number.
+    {
+        const re = /^(.*)\/D-([0-9A-Za-z][0-9A-Za-z.+]*?)-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?$/;
+        const m = re.exec(cleaned);
+        if (m !== null) {
+            cleaned = `${m[1]}-${m[3]}${m[4] !== undefined ? `-${m[4]}` : ""}/D${m[2]}`;
+        }
+    }
+    // /E-N editions: "/E-2-2023-02" → "Edition 2.0 2023-02".
+    {
+        const re = /^(.*?)\/E-(\d+)(?:-((?:19|20)\d\d)(?:-(0[1-9]|1[0-2]))?)?$/;
+        const m = re.exec(cleaned);
+        if (m !== null) {
+            const date = m[3] !== undefined ? ` ${m[3]}${m[4] !== undefined ? `-${m[4]}` : ""}` : "";
+            cleaned = `${m[1]} Edition ${m[2]}.0${date}`;
+        }
+    }
+    // /R-N revisions: reposition a trailing year onto the number, keep "/R-x".
+    {
+        const re = /^(.*?)\/R-([0-9A-Za-z]+)(?:-((?:19|20)\d\d))?$/;
+        const m = re.exec(cleaned);
+        if (m !== null) {
+            cleaned = `${m[3] !== undefined ? `${m[1]}-${m[3]}` : m[1]}/R-${m[2]}`;
+        }
+    }
+    return cleaned;
+}
+function normalizeRevisionNotation(input) {
+    let cleaned = input;
+    // Numbered revisions preserved, repositioned to "/R-<n>".
+    cleaned = cleaned.replace(/(\/D-?[0-9A-Za-z.]+)\s+[Rr][Ee][Vv]\s*(\d+)/, "$1/R-$2");
+    cleaned = cleaned.replace(/[-/_.]?\s?[Rr][Ee][Vv][-\s]?(\d+)(\/D-?[0-9A-Za-z.]+)/, "$2/R-$1");
+    cleaned = cleaned.replace(/(\d)[-._]?\s?[Rr][Ee][Vv]\s*(\d+)\s*$/, "$1/R-$2");
+    // Lettered inline revisions stripped.
+    cleaned = cleaned.replace(/[-/_.]?\s?[Rr][Ee][Vv][-\s]?[A-Za-z0-9]+(?=\/D-?[0-9A-Za-z])/, "");
+    cleaned = cleaned.replace(/(\d)[Rr][Ee][Vv][A-Za-z0-9]+\s*$/, "$1");
+    return cleaned;
+}
+function normalizeJointStageSpellings(input) {
+    let cleaned = input;
+    const pubs = "((?:ISO/IEC/IEEE|IEEE/ISO/IEC|IEEE/IEC/ISO|ISO/IEEE|IEC/IEEE|IEEE/IEC|ISO/IEC)(?:/ ?| ))";
+    const stage = "(FDIS|FCD|CDV|DIS\\d?|CD\\d?|WD|PWI|NP)";
+    const num = "(P?\\d+(?:[.-]\\d+)?)";
+    const tail = "(,? (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]* \\d{4}|$|-\\d{4}(?:-\\d\\d)?)";
+    cleaned = cleaned.replace(/(\d)_D(\d)/g, "$1/D$2");
+    cleaned = cleaned.replace(/,(?=[A-Za-z])/, ", ");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/(D[\\d.]+)/ ?${stage}\\b`), "$1$4 $2/$3");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/ ${stage}${tail}`), "$1$3 $2$4");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/${stage} (\\d{4})\\b`), "$1$3 $2-$4");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num} ${stage}${tail}`), "$1$3 $2$4");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num} ${stage} (D\\d+)\\b`), "$1$3 $2/$4");
+    // The dash-date must be a plausible year - a 4-digit monthcode (YYMM,
+    // e.g. "…/CD2-1410" = October 2014) is a DRAFT designator, not a
+    // dash-date, and rewriting it onto the number breaks the parse.
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${num}/ ?${stage}(-(?:19|20)\\d\\d(?:-\\d\\d)?)`), "$1$3 $2$4");
+    cleaned = cleaned.replace(new RegExp(`^${pubs}${stage} ${num}/? ?(D\\d+)\\b`), "$1$2 $3/$4");
+    return cleaned;
+}
+// The Parser.parse cleaning pipeline, in Ruby order.
+export function preprocessIeee(input) {
+    let cleaned = input.replace(/\.pdf$/i, "");
+    cleaned = cleaned.replace(/_(FDIS|CDV|CD|DIS|WD|PWI|NP)/g, "/$1");
+    cleaned = cleaned.replace(/\s+/g, " ");
+    cleaned = cleaned.replace(/\b(ISO\/IEC\/IEEE|IEEE\/ISO\/IEC|IEEE\/IEC\/ISO|ISO\/IEEE|IEC\/IEEE|IEEE\/IEC|ISO\/IEC)\/ ?(FDIS|FCD|CDV|DIS\d?|CD\d?|WD|PWI|NP)\b/g, "$1 $2");
+    cleaned = normalizeRevisionNotation(cleaned);
+    cleaned = normalizeRelatonSuffixes(cleaned);
+    cleaned = cleaned.replace(/(\d)\s+-(\d{4})\b/g, "$1-$2");
+    cleaned = cleaned.replace(/(\d)-\s+(\d{4})\b/g, "$1-$2");
+    cleaned = cleaned.replace(/&#x2013;(?!-)/g, "-");
+    cleaned = cleaned.replaceAll("&#x2013;-", "-");
+    cleaned = cleaned.replace(/^!IEEE /, "IEEE ");
+    cleaned = cleaned.replaceAll("IEEE/ ASTM", "IEEE/ASTM");
+    cleaned = cleaned.replaceAll("&#x2122;", "™");
+    cleaned = cleaned.replaceAll("&#x2019;", "'");
+    cleaned = cleaned.replaceAll("&amp;amp;", "&");
+    cleaned = cleaned.replaceAll("&amp;", "&");
+    cleaned = cleaned.replace(/\s+(P&V)\s*$/, " ($1)");
+    cleaned = cleaned.replace(/(\d+\.\d+)\s+(\d+\.)/g, "$1$2");
+    cleaned = cleaned.replace(/\b(1|2)\s+(\d{3})\b/g, "$1$2");
+    cleaned = cleaned.replace(/\b(January|February|March|April|May|June|July|August|September|October|November|December)(\d{4})\b/g, "$1 $2");
+    cleaned = cleaned.replace(/\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)(\d{4})\b/g, "$1 $2");
+    cleaned = normalizeJointStageSpellings(cleaned);
+    cleaned = cleaned.replace(/(IEC\s+\d+(?:-\d+)?(?::\d{4})?(?:\s+(?:First\s+)?[Ee]dition\s+\d+(?:\.\d+)?\s+\d{4}-\d{2})?)\s+(IEEE\s+Std\s+\S+|IEEE\s+\S+)/g, "$1; $2");
+    cleaned = cleaned.replace(/^(IEC\s+\d+(?:-\d+)?):\d{4}(\s+(?:First\s+)?[Ee]dition\s+\d+(?:\.\d+)?\s+\d{4}-\d{2})/, "$1$2");
+    cleaned = cleaned.replaceAll("™", "");
+    cleaned = cleaned.replace(/\b19969\b/g, "1969");
+    cleaned = cleaned.replace(/(\d{4}),(\d{3})/g, "$1, $2");
+    cleaned = cleaned.replaceAll("/lNT", "/INT");
+    cleaned = cleaned.replaceAll(".l/", ".1/");
+    cleaned = cleaned.replace(/\bI99O\b/g, "1990");
+    cleaned = cleaned.replace(/^EEE /, "IEEE ");
+    cleaned = cleaned.replace(/^I EEE /, "IEEE ");
+    cleaned = cleaned.replace(/^lEEE /, "IEEE ");
+    {
+        const openCount = (cleaned.match(/\(/g) ?? []).length;
+        const closeCount = (cleaned.match(/\)/g) ?? []).length;
+        if (openCount === closeCount + 1 && !cleaned.endsWith(")")) {
+            cleaned = `${cleaned})`;
+        }
+    }
+    cleaned = cleaned.replace(/,\s*Standard\s*$/, "");
+    cleaned = cleaned.replace(/[,:]\s*$/, "");
+    cleaned = cleaned.replace(/,\s+and\s+IEEE\s+Std\s/, " and ");
+    {
+        const openCount = (cleaned.match(/\(/g) ?? []).length;
+        const closeCount = (cleaned.match(/\)/g) ?? []).length;
+        if (openCount > closeCount) {
+            cleaned = cleaned + ")".repeat(openCount - closeCount);
+        }
+        else if (closeCount > openCount) {
+            const extra = closeCount - openCount;
+            cleaned = cleaned.replace(new RegExp(`\\){${extra}}$`), "");
+        }
+    }
+    cleaned = cleaned.replace(/(\d)\s+(\d{4})(?=\s*\(|\s*$)/g, "$1-$2");
+    cleaned = cleaned.replace(/\s+-\s+(\d{4})\b/g, "-$1");
+    cleaned = cleaned.replace(/^IEEE\s+(?!Std\b)(\d)/, "IEEE Std $1");
+    cleaned = cleaned.replace(/^IEEE\s+No\.\s*/, "IEEE Std ");
+    cleaned = cleaned.replace(/^IEEE\s+No\s/, "IEEE Std ");
+    cleaned = cleaned.replace(/\s+\//g, "/");
+    cleaned = cleaned.replace(/,\s+(\d{4})\s+Edition/, "-$1");
+    cleaned = cleaned.replace(/(ISO\/IEC)(\d)/g, "$1 $2");
+    cleaned = cleaned.replace(/^IEEE\s+Std\s+(ANSI\/IEEE)/, "$1 Std");
+    if (/;\s+[A-Z]{2,}/.test(cleaned)) {
+        cleaned = cleaned.replace(/;\s+([A-Z][^;]+)$/, " ($1)");
+    }
+    cleaned = cleaned.replace(/,\s+(\d{4})\s+Edn\.\s+\(Reaff\s+(\d{4})\)/g, "-$1 (R$2)");
+    cleaned = cleaned.replace(/(\d{4})\s+Edn\.\s+\(Reaff\s+(\d{4})\)/g, "$1 (R$2)");
+    cleaned = cleaned.replace(/\(Reaffirmed\s+(\d{4}),\s+(\d+\s+IRE[^)]+)\)/g, "(R$1) ($2)");
+    cleaned = cleaned.replace(/(\d{4})\/ANSI\s+([^(]+)(?=\s*\(|$)/g, "$1 (ANSI $2)");
+    cleaned = cleaned.replace(/(ISO\/IEC\s+TR)(\d)/g, "$1 $2");
+    cleaned = cleaned.replace(/\bStad\b/g, "Std");
+    cleaned = cleaned.replace(/\b(IEEE|ANSI|AIEE)\s+std\b/g, "$1 Std");
+    cleaned = cleaned.replaceAll("(TM)", "");
+    if (/^(\d+[-.]\d+)\/D\d+/.test(cleaned)) {
+        cleaned = `IEEE P${cleaned}`;
+    }
+    cleaned = cleaned.replace(/\/Preprint\b/g, "");
+    cleaned = cleaned.replaceAll("Proposed Revision of", "Revision of");
+    cleaned = cleaned.replace(/\bammended\b/gi, "amended");
+    cleaned = cleaned.replace(/(\/INT|\/Cor\s+\d+-\d{4})\./g, "$1");
+    cleaned = cleaned.replace(/(\/INT),\s+([A-Z][a-z]+)\s+(\d{4})\s+Edition/, "$1, $2 $3");
+    cleaned = cleaned.replace(/\s+Ed\.\s*$/, "");
+    cleaned = cleaned.replace(/\bStd\.\s+/g, "Std ");
+    cleaned = cleaned.replace(/(\d{4})(\s+\([^)]+\))?\s+-\s+IEEE\s+Standard\s+for.*$/, "$1$2");
+    cleaned = cleaned.replace(/^IEEE\s+PC(\d)/, "IEEE Std PC$1");
+    cleaned = cleaned.replace(/^IEEE\s+Unapproved\s+Draft\s+Std\s+PC(\d)/, "IEEE Unapproved Draft Std PC$1");
+    cleaned = cleaned.replace(/^IEEE\s+P(\d+)\s+and\s+ASHRAE/, "IEEE Std P$1 and ASHRAE");
+    cleaned = cleaned.replace(/^(ISO\/IEC \d+[-.]\d+-\d{4}):.*$/, "$1");
+    cleaned = cleaned.replace(/^(ISO\/IEC \d+-\d{4}):.*$/, "$1");
+    cleaned = cleaned.replace(/^(ISO\/IEC \d+[-.]\d*)\s*:\s*(\d{4})/, "$1:$2");
+    cleaned = cleaned.replace(/^(ISO\/IEC \d+)\s*:\s*(\d{4})/, "$1:$2");
+    cleaned = cleaned.replace(/^(IEC\/IEEE P[\w.-]+)_D/, "$1/D");
+    cleaned = cleaned.replace(/^IEEE\/ISO\/IEC\s+(P[\w.-]+)/, "ISO/IEC/IEEE $1");
+    cleaned = cleaned.replace(/^IEEE\/IEC\/ISO\s+(P[\w.-]+)/, "IEC/ISO/IEEE $1");
+    cleaned = cleaned.replace(/^(IEEE\/IEC P[\w.-]+)\s+D(\d)/, "$1/D$2");
+    cleaned = cleaned.replace(/^(IEEE\/IEC P[\w.-]+)\s+(CDV|FDIS|CD|DIS|ED\d)/, "$1/$2");
+    cleaned = cleaned.replace(/^ISO\s+\/IEC\/IEEE/, "ISO/IEC/IEEE");
+    cleaned = cleaned.replace(/^ISO\s+\/IEC/, "ISO/IEC");
+    cleaned = cleaned.replace(/^IS0\//, "ISO/");
+    cleaned = cleaned.replace(/^IEEE-P(\d+)-(\d+)-DIS-(.*)/, "ISO/IEC/IEEE P$1-$2/DIS, $3");
+    cleaned = cleaned.replace(/^IEEE\/CSA\s+(P[\d.]+)\/([\d.]+)\/D(\d+)/, "IEEE/CSA $1/D$3");
+    cleaned = cleaned.replace(/^IEEE\s+Approved\s+Draft\s+Std\s+(P\d)/, "IEEE Approved Draft Std $1");
+    cleaned = cleaned.replace(/^(IEEE Approved Draft Std P[\w.-]+)\s+\/\s*D/, "$1/D");
+    cleaned = cleaned.replace(/^AIEE\s+No\.\s*(\d)/, "AIEE No. $1");
+    cleaned = cleaned.replace(/^AIEE\s+no\s/, "AIEE No ");
+    cleaned = cleaned.replace(/^AIEE\s+Std\s+No\.\s*/, "AIEE Standard No ");
+    cleaned = cleaned.replace(/^IEEE\s+PSI\s+(\d)/, "IEEE/ASTM PSI $1");
+    cleaned = cleaned.replace(/^(IEEE\/IEC P[\d.-]+\/PC[\d.]+)_D/, "$1/D");
+    cleaned = cleaned.replace(/^IEC\s+(P[\d.-]+)\/IEEE\s+(PC[\d.]+)_D/, "IEC/IEEE $2/D");
+    cleaned = cleaned.replace(/^IEC\/IEC\s+(P\d)/, "IEC/IEEE $1");
+    cleaned = cleaned.replace(/^(NACE\s+SP\d+-\d+)\/(IEEE\s+Std\s+\d+-\d+)$/, "$1 ($2)");
+    cleaned = cleaned.replaceAll("Edn.", "Edition");
+    cleaned = cleaned.replaceAll("ASHARE", "ASHRAE");
+    cleaned = cleaned.replace(/^PC(\d)/, "P$1");
+    cleaned = cleaned.replace(/^IEEE\/ISO\/IEC\s+(8802[\w.-]+)/, "ISO/IEC/IEEE $1");
+    cleaned = cleaned.replace(/^(IEEE\s+C?\d[\d.]*\/D\d+)([A-Z][a-z]+\s+\d{4})/, "$1, $2");
+    cleaned = cleaned.replace(/^(ANSI\/IEEE Std):\s+.*$/, "$1");
+    cleaned = cleaned.replace(/^(IEEE\s+[\d.]+)\s+(IEC\s+\d+[-\d]*\s+.*edition\s+\d{4}-\d{2})$/i, "$1; $2");
+    cleaned = cleaned.replace(/^IEEE\s+No\s+(\d+-\d+)\s+\/\s+ASA\s+(.*)/, "IEEE Std $1 (ASA $2)");
+    return cleaned;
+}

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

@@ -0,0 +1,8 @@
+export interface UpdateCode {
+    plain?: string;
+    replacement: string;
+    pattern?: string;
+    flags?: string;
+}
+export declare const UPDATE_CODES: UpdateCode[];
+export declare function applyUpdateCodes(input: string): string;

package/dist/flavors/ieee/update_codes.js

@@ -0,0 +1,191 @@
+// Port of data/ieee/update_codes.yaml: pre-parse normalizations applied
+// BEFORE the Parser cleaning stages (parse_single order). Plain keys are
+// anchored full-string substitutions; /regex/[flags] literals map to JS.
+export const UPDATE_CODES = [
+    { plain: "IEEE Unapproved Draft Std PC37.110/D911Oct 07", replacement: "IEEE Unapproved Draft Std PC37.110/D711, Oct 07" },
+    { plain: "IEEE Unapproved Draft Std P15289, 06", replacement: "IEEE Unapproved Draft Std P15289/D6" },
+    { plain: "IEEE C57.139/D14June 2010", replacement: "IEEE C57.139/D14, June 2010" },
+    { plain: "IEEE P1653.5/D7d1 November, 2019", replacement: "IEEE P1653.5/D7.1 November, 2019" },
+    { plain: "IEEE P1017/D062012", replacement: "P1017/D062012, Jun 2012" },
+    { plain: "IEEP62.42.1/D3, October 2014", replacement: "IEEE P62.42.1/D3, October 2014" },
+    { plain: "IEEE P802.11ajD8.0, August 2017", replacement: "IEEE P802.11aj/D8.0, August 2017" },
+    { plain: "IEEE P802.11ajD9.0, November 2017", replacement: "IEEE P802.11aj/D9.0, November 2017" },
+    { plain: "IEC 62529:2012(E) (IEEE Std 1641-2010", replacement: "IEC 62529:2012(E) (IEEE Std 1641-2010)" },
+    { plain: "IEC 62529:2012(E) (IEEE Std 1641-2010 - Redline", replacement: "IEC 62529:2012(E) (IEEE Std 1641-2010) - Redline" },
+    { plain: "IEEE IEEE P1453/D3, June 2011", replacement: "IEEE P1453/D3, June 2011" },
+    { plain: "AIEE No 1E -1957", replacement: "AIEE No 1E-1957" },
+    { plain: "A.I.E.E. No. 15 May-1928", replacement: "AIEE No 15-192805" },
+    { plain: "AIEE No 45 -1951", replacement: "AIEE No 45-1951" },
+    { plain: "AIEE No. 2-June 1929", replacement: "AIEE No 2-192906" },
+    { plain: "AIEE No. 25-1952 (Supercedes AIEE No. 25-1945)", replacement: "AIEE No 25-1952 (Supercedes AIEE No. 25-1945)" },
+    { plain: "AIEE No.1-1962 (Supersedes June 1957 issue)", replacement: "AIEE No 1-1962 (Supersedes AIEE No 1-195706)" },
+    { plain: "AIEE Nos 72 and 73 - 1932", replacement: "AIEE No 72-1932 and AIEE No 73-1932" },
+    { plain: "EEE Std 1671.1-2017 (Revision of IEEE Std 1671.1‐2009)", replacement: "IEEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009)" },
+    { plain: "EEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009)", replacement: "IEEE Std 1671.1-2017 (Revision of IEEE Std 1671.1-2009)" },
+    { plain: "EEE Std 488.2-1992", replacement: "IEEE Std 488.2-1992" },
+    { plain: "EEE Std 802.3br-2016 (Amendment to IEEE Std 802.3-2015 as amended by IEEE St802.3bw-2015, IEEE Std 802.3by-2016, IEEE Std 802.3bq-2016, and IEEE Std 802.3bp-2016)", replacement: "IEEE Std 802.3br-2016 (Amendment to IEEE Std 802.3-2015 as amended by IEEE Std 802.3bw-2015, IEEE Std 802.3by-2016, IEEE Std 802.3bq-2016, and IEEE Std 802.3bp-2016)" },
+    { plain: "IEEE Std 336-2010 (Revision of EEE Std 336-2005)", replacement: "IEEE Std 336-2010 (Revision of IEEE Std 336-2005)" },
+    { plain: "IEEE Std 356-2020 (Revision of IEEE Std 356?2010)", replacement: "IEEE Std 356-2020 (Revision of IEEE Std 356-2010)" },
+    { plain: "IEEE Std 356-2020 (Revision of IEEE Std 356?2010) - Redline", replacement: "IEEE Std 356-2020 (Revision of IEEE Std 356-2010) - Redline" },
+    { plain: "IEEE Std Std 1139-2008", replacement: "IEEE Std 1139-2008" },
+    { plain: "IEEE/ ASTM SI 10-2010 (Revision of IEEE/ASTM SI 10-2002)", replacement: "IEEE/ASTM SI 10-2010 (Revision of IEEE/ASTM SI 10-2002)" },
+    { plain: "IEEE Std 24748-3:2012", replacement: "IEEE 24748-3:2012" },
+    { plain: "ISO/IEC/IEEE P24765/D3:2017", replacement: "ISO/IEC/IEEE P24765:2017/D3" },
+    { plain: "ISO/IEC/IEEE FDIS P24765 FDIS, October 2016", replacement: "ISO/IEC/IEEE FDIS P24765, October 2016" },
+    { plain: "ISO/IEC/IEEE P15289 FDIS, February 2019", replacement: "ISO/IEC/IEEE FDIS P15289, February 2019" },
+    { plain: "ISO/IEC/IEEE P26515 FDIS, May 2018", replacement: "ISO/IEC/IEEE FDIS P26515, May 2018" },
+    { plain: "IEC/IEEE P60214-2, FDIS 2018", replacement: "IEC/IEEE FDIS P60214-2-2018(E)" },
+    { plain: "IEC/IEEE P62582-6, FDIS 2018", replacement: "IEC/IEEE FDIS P62582-6-2018(E)" },
+    { plain: "ISO/IEC DIS P26511.2, May 2017", replacement: "ISO/IEC DIS 26511.2:2017" },
+    { plain: "ISO/IEC/IEEE P90003_FDIS, August 2018", replacement: "ISO/IEC/IEEE FDIS P90003, August 2018" },
+    { plain: "ISO/IEC/IEEE P29119-1/FDIS, September 2021", replacement: "ISO/IEC/IEEE FDIS P29119-1, September 2021" },
+    { plain: "ISO/IEC/IEEE/ P12207-2/D3_FDIS, July 2020", replacement: "ISO/IEC/IEEE FDIS P12207-2/D3, July 2020" },
+    { plain: "ISO/IEC/IEEE/ P21841/FDIS, April 2019", replacement: "ISO/IEC/IEEE FDIS P21841, April 2019" },
+    { plain: "ISO/IEC/IEEE/ P24748-3/DIS, August 2019", replacement: "ISO/IEC/IEEE DIS P24748-3, August 2019" },
+    { plain: "IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004)", replacement: "IEEE Std 1018-2013 (Revision of IEEE Std 1018-2004)" },
+    { plain: "IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004) - Redline", replacement: "IEEE Std 1018-2013 (Revision of IEEE Std 1018-2004) - Redline" },
+    { plain: "IEEE SId 342-1973 (ANSI C37.0731-1973)", replacement: "IEEE Std 342-1973 (ANSI C37.0731-1973)" },
+    { plain: "P1484.12.3/D1, September2019", replacement: "IEEE P1484.12.3/D1, September 2019" },
+    { plain: "P1073.1.3.4/D3.0", replacement: "IEEE P1073.1.3.4/D3.0" },
+    { plain: "P1936.1, 2020", replacement: "IEEE P1936.1, January 2020" },
+    { plain: "P20000-2, D1 December 2012", replacement: "IEEE P20000-2/D1, December 2012" },
+    { plain: "ISO/IEC/IEEE 8802-22.2:2015/Amd.2:2017(E)", replacement: "ISO/IEC/IEEE 8802-22:2015/Amd.2:2017(E)" },
+    { plain: "IEEE 1070-1995", replacement: "IEEE No 1070-1995" },
+    { plain: "IEEE 278-1967", replacement: "IEEE No 278-1967" },
+    { plain: "IEEE 730-1989", replacement: "IEEE No 730-1989" },
+    { plain: "IEEE 751-1991", replacement: "IEEE No 751-1991" },
+    { plain: "IEEE 1023-2020 (Revision of IEEE Std 1023-2004)", replacement: "IEEE No 1023-2020 (Revision of IEEE Std 1023-2004)" },
+    { plain: "IEEE P90003-2014, April 2015", replacement: "IEEE P90003, April 2015" },
+    { plain: "IEC/IEEE P61886-1_D2_May2020", replacement: "IEC/IEEE P61886-1_D2, May 2020" },
+    { plain: "IEEE Unapproved P1076.1/D-3.3-07-Feb20", replacement: "IEEE Unapproved P1076.1/D-3.3-2007-02" },
+    { plain: "IEEE Unapproved P11073.10407/D-09-08-Sep20", replacement: "IEEE Unapproved P11073.10407/D-09-2008-09" },
+    { plain: "IEEE Unapproved P1597.2/D-7.1-09-Oct20", replacement: "IEEE Unapproved P1597.2/D7.1-2009-10" },
+    { plain: "IEEE Unapproved P7.4.3.2/D-3-2010-01", replacement: "IEEE Unapproved P7-4.3.2/D-3-2010-01" },
+    { plain: "IEEE Unapproved P802.11k/D-13.0_Mar-08-20", replacement: "IEEE Unapproved P802.11k/D-13.0-2008-03" },
+    { plain: "IEEE Unapproved P802.16g/D-8-07-Feb20", replacement: "IEEE Unapproved P802.16g/D-8-2007-02" },
+    { plain: "IEEE Unapproved P802.1ah/D-4.-2008-02", replacement: "IEEE Unapproved P802.1ah/D-4-2008-02" },
+    { plain: "IEEE Unapproved P802.20.2/D-2.0-09-Oct20", replacement: "IEEE Unapproved P802.20.2/D-2.0-2009-10" },
+    { plain: "IEEE Unapproved P802.3/D-D1.1/Cor1-2009", replacement: "IEEE Unapproved P802.3/D1.1/Cor1-2009" },
+    { plain: "IEEE Unapproved Std PC57.129_D9, Mar07", replacement: "IEEE Unapproved Std PC57.129_D9, Mar 07" },
+    { plain: "IEEE Unapproved Draft Std PC62.21_D3, Sep07", replacement: "IEEE Unapproved Draft Std PC62.21_D3, Sep 07" },
+    { plain: "IEEE Unapproved Draft Std P2600.2/D41b, Jan09", replacement: "IEEE Unapproved Draft Std P2600.2/D41b, Jan 09" },
+    { plain: "IEEE Active Unapproved Draft Std IEEE PC37.06/D8.3, July 2007", replacement: "IEEE Active Unapproved Draft Std PC37.06/D8.3, July 2007" },
+    { plain: "IEEE Unapproved Draft Std PC57.21/D14, Dec. 2007", replacement: "IEEE Unapproved Draft Std PC57.21/D14, Dec 2007" },
+    { plain: "IEEE Unapproved Draft Std P802.1AB/REVD2.2, Dec 2007", replacement: "IEEE Unapproved Draft Std P802.1AB/D2.2, Dec 2007" },
+    { plain: "IEEE Unapproved Draft Std PC37.301/D3 R1, Feb 2008", replacement: "IEEE Unapproved Draft Std PC37.301/D3.1, Feb 2008" },
+    { plain: "IEEE Unapproved Draft Std PC37.27/D16_Dec 2007", replacement: "IEEE Unapproved Draft Std PC37.27/D16, Dec 2007" },
+    { plain: "IEEE Unapproved Draft Std PC37.13 / D21, Dec 2007", replacement: "IEEE Unapproved Draft Std PC37.13/D21, Dec 2007" },
+    { plain: "IEEE Unapproved Draft Std P802.1ah/D4., Feb 2008", replacement: "IEEE Unapproved Draft Std P802.1ah/D4, Feb 2008" },
+    { plain: "IEEE Unapproved Draft Std P802.11k_D13.0_Mar 2008", replacement: "IEEE Unapproved Draft Std P802.11k_D13.0, Mar 2008" },
+    { plain: "IEEE Unapproved Draft Std P1776/D9b, Feb. 2008", replacement: "IEEE Unapproved Draft Std P1776/D9b, Feb 2008" },
+    { plain: "IEEE Unapproved Draft Std PC62.21-2003-Cor_1/D5, Mar 2008", replacement: "IEEE Unapproved Draft Std PC62.21-2003-Cor1/D5, Mar 2008" },
+    { plain: "IEEE Unapproved Draft Std P1003.1 Draft 5.1, May 2008", replacement: "IEEE Unapproved Draft Std P1003.1/D5.1, May 2008" },
+    { plain: "IEEE Unapproved Draft Std P802-1Qay/D5-0, Jan 09", replacement: "IEEE Unapproved Draft Std P802-1Qay/D5.0, Jan 09" },
+    { plain: "IEEE Unapproved Draft Std P1775/1.9.7, Mar 2009", replacement: "IEEE Unapproved Draft Std P1775/D1.9.7, Mar 2009" },
+    { plain: "IEEE Unapproved Draft Std P1044/D00005, Aug-2009", replacement: "IEEE Unapproved Draft Std P1044/D5, Aug 2009" },
+    { plain: "IEEE Unapproved Draft Std P1584b/ D2, Jul 2009", replacement: "IEEE Unapproved Draft Std P1584b/D2, Jul 2009" },
+    { plain: "IEEE Unapproved Draft Std P11073-10421, D6, Oct 2009", replacement: "IEEE Unapproved Draft Std P11073-10421/D6, Oct 2009" },
+    { plain: "IEEE Unapproved Draft Std PC37.13.1a/D3. Nov 2009", replacement: "IEEE Unapproved Draft Std PC37.13.1a/D3, Nov 2009" },
+    { plain: "IEEE Unapproved Draft Std PC37.082_IEC62271-113/D2, Jan 2010", replacement: "IEEE Unapproved Draft Std PC37.082/D2, Jan 2010 (IEC 62271-113)" },
+    { plain: "IEEE Unapproved Draft Std PC37.20.7-2001 Cor 1/D3, Aug 2009", replacement: "IEEE Unapproved Draft Std PC37.20.7-2001/Cor 1/D3, Aug 2009" },
+    { plain: "IEEE Unapproved Draft Std PC37.20.7-2007 Cor 1/D4", replacement: "IEEE Unapproved Draft Std PC37.20.7-2007/Cor 1/D4" },
+    { plain: "IEEE Unapproved Draft Std P802.3-2008 (P802.3bb)/Cor 1/D1.1, Jan 2009", replacement: "IEEE Unapproved Draft Std P802.3-2008/Cor 1/D1.1, Jan 2009 (IEEE P802.3bb)" },
+    { plain: "IEEE Unapproved Draft Std P802.3-2008 (P802.3bb)/Cor 1/D2.0, Jul 2009", replacement: "IEEE Unapproved Draft Std P802.3-2008/Cor 1/D2.0, Jul 2009 (IEEE P802.3bb)" },
+    { plain: "IEEE Unapproved Draft Std P16326:2008/CD2, Sep 2008", replacement: "IEEE P16326:2008/CD2, Sep 2008" },
+    { plain: "IEEE Unapproved Draft Std 16326:2009", replacement: "IEEE 16326:2009" },
+    { plain: "Unapproved Draft Std ISO/IEC FDIS 15288:2007(E) IEEE P15288/D3", replacement: "IEEE Unapproved Draft Std P15288/D3 (ISO/IEC FDIS 15288:2007(E))" },
+    { plain: "IEEE Unapproved Draft Std P1635/ASHRAE 21_D4, Jan 2010", replacement: "IEEE Unapproved Draft Std P1635/D4, January 2010 (ASHRAE 21)" },
+    { plain: "IEC/IEEE 62582-1:2011 Edition 1.0 2011-08", replacement: "IEC/IEEE 62582-1-2011 Edition 1.0 2011-08" },
+    { plain: "ISO/IEC/IEEE CD P26513/D1, August 2015", replacement: "ISO/IEC/IEEE P26513/D1, August 2015" },
+    { plain: "IEEE Std P1073.1.3.4/D3.0", replacement: "IEEE Std P11073.00101" },
+    { plain: "IEEE P802.1Qbu/03.0, July 2015", replacement: "IEEE P802.1Qbu/D-3.0-2015" },
+    { plain: "IEEE P802.11aqTM/013.0 October 2017", replacement: "IEEE P802.11aqTM/D-13.0-2017" },
+    { plain: "IEC/IEEE P62271-37-013:2015 D13.4", replacement: "IEC/IEEE P62271.37-013/D-13.4-2015" },
+    { plain: "ISO/IEC/IEEE DIS P42020:201x(E), June 2017", replacement: "ISO/IEC/IEEE DIS P42020-2017-06" },
+    { 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: "IEC/IEEE P63195_CDV/V3, February 2020", replacement: "IEC/IEEE CDV P63195-2020-02" },
+    { 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" },
+    { plain: "International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition", replacement: "ISO/IEC/IEEE Std 802.9-1996" },
+    { plain: "ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991", replacement: "ISO/IEC/IEEE 13210-1994" },
+    { plain: "J-STD-016-1995", replacement: "IEEE 016-1995" },
+    { plain: "Nuclear EQ Sourcebook and Supplement", replacement: "IEEE 7438946" },
+    { plain: "PC37.30.2/D043 Rev 18, May 2015", replacement: "IEEE PC37.30-2/D-043/R-18-2015" },
+    { plain: "IEEE/IEC P62582 CD2 proposal, May 2017", replacement: "IEEE/IEC CD2 P62582-2017-05" },
+    { plain: "ISO/IEC/IEEE P16326:201x WD.4a, July 2017", replacement: "ISO/IEC/IEEE P16326/D-4a-2017-07" },
+    { plain: "ISO/IEC/IEEE CD.1 P21839, October 2017", replacement: "ISO/IEC/IEEE CD1 P21839-2017-10" },
+    { plain: "ISO/IEC/IEEE P16326:201x WD5, December 2017", replacement: "ISO/IEC/IEEE P16326/D-5-2017-12" },
+    { plain: "IEEE/ISO/IEC P42010.CD1-V1.0, April 2020", replacement: "IEEE/ISO/IEC CD1 P42010-2020-04" },
+    { plain: "Unapproved Draft Std ISO/IEC FDIS 15288:2007(E) IEEE P15288/D3,", replacement: "ISO/IEC/IEEE FDIS Std P15288/D-3-2007" },
+    { plain: "IS0/IEC/IEEE 8802-11:2012/Amd.5:2015(E) (Adoption of IEEE Std 802.11af-2014)", replacement: "ISO/IEC/IEEE 802.11/Amd5-2012" },
+    { plain: "IEEE Approved Std P1609.3/D-23.pdf-2007-02", replacement: "IEEE Approved Std P1609.3/D23, 02 2007" },
+    { plain: "IEEE P3004.5/D-6.2.", replacement: "IEEE P3004.5/D6.2" },
+    { plain: "IEEE P730/D-0.16.-2025", replacement: "IEEE P730/D0.16-2025" },
+    { plain: "IEEE PC37.107/D-4.-2023-11", replacement: "IEEE PC37.107/D4, 11 2023" },
+    { plain: "IEEE PC37.113/D-8.0.-2015-08", replacement: "IEEE PC37.113/D8.0, 08 2015" },
+    { plain: "IEEE PC37.98/D-5.1D-2013", replacement: "IEEE PC37.98/D5.1D-2013" },
+    { plain: "IEEE PC57.637/D-6.2.-2014-03", replacement: "IEEE PC57.637/D6.2, 03 2014" },
+    { plain: "IEEE Std P650/D-9.-2006", replacement: "IEEE Std P650/D9-2006" },
+    { plain: "IEC/IEEE P63198.2775/D-6.1_CDV_March-2022", replacement: "IEC/IEEE CDV P63198.2775/D6.1, March 2022" },
+    { plain: "IEEE 3.Rev.B/D-4.0-2023-01", replacement: "IEEE P3/D4.0, 01 2023" },
+    { plain: "IEEE 3.Rev.B/D-5.0-2023-03", replacement: "IEEE P3/D5.0, 03 2023" },
+    { plain: "IEEE P1003.1/D-5/Cor1-201x-2012-04", replacement: "IEEE P1003.1/Cor 1/D5, 04 2012" },
+    { plain: "IEEE P1003.1/D-5/Cor1-201x-2012-08", replacement: "IEEE P1003.1/Cor 1/D5, 08 2012" },
+    { plain: "IEEE P1127/D-4.1_July-2023", replacement: "IEEE P1127/D4.1, July 2023" },
+    { plain: "IEEE P2660_1/D-2-2020-06", replacement: "IEEE P2660.1/D2, 06 2020" },
+    { plain: "IEEE P802.1AE/D-1.0/R-/Cor1", replacement: "IEEE P802.1AE/Cor 1/D1.0" },
+    { plain: "IEEE P802.1AE_Rev/D-1.2-2018", replacement: "IEEE P802.1AE/D1.2-2018" },
+    { plain: "IEEE P802.1AE_Rev/D-1.3-2018", replacement: "IEEE P802.1AE/D1.3-2018" },
+    { plain: "IEEE Unapproved Std P802.16Rev2/D-9-2009-01", replacement: "IEEE Unapproved Std P802.16Rev2/D9-2009" },
+    { plain: "IEEE Unapproved Std P802.1X_REV/D-4.5-2009", replacement: "IEEE Unapproved Std P802.1X/D4.5-2009" },
+    { plain: "IEEE Unapproved Std PC37.91/D-8-2007-20", replacement: "IEEE Unapproved Std PC37.91/D8-2007" },
+    { plain: "IEEEE P1243/D-3-2023-02", replacement: "IEEE P1243/D3, 02 2023" },
+    { plain: "ISO/IEC/IEEE FDIS P15289./E-3/D-2-2016", replacement: "ISO/IEC/IEEE FDIS P15289-2016/D2" },
+    { plain: "ISO/IEC/IEEE P24641/D-2_CD-2020", replacement: "ISO/IEC/IEEE CD P24641-2020/D2" },
+    { plain: "ISO/IEC/IEEE P24641/D-3_CD2", replacement: "ISO/IEC/IEEE CD2 P24641/D3" },
+    { plain: "ISO/IEC/IEEE P24748.3/D-3_FDIS-2020", replacement: "ISO/IEC/IEEE FDIS P24748.3-2020/D3" },
+    { plain: "ISO/IEC/IEEE/ P12207.2/D-3_FDIS-2020", replacement: "ISO/IEC/IEEE FDIS P12207.2-2020/D3" },
+    { plain: "ISO/IEC/IEEE/ P24748.3/D-IS-2019", replacement: "ISO/IEC/IEEE DIS P24748.3-2019" },
+    { plain: "P1635/D10/ASHARE 21/D-10-2016", replacement: "IEEE P1635/D10-2016" },
+    { pattern: ", (\\w{3,4})(\\d{4,4})$", flags: "", replacement: ", \\1 \\2" },
+    { pattern: "C37.0I0d-1984", flags: "", replacement: "C37.010d-1984" },
+    { pattern: "\\bSept\\b", flags: "", replacement: "Sep" },
+    { pattern: "\\bFeburary\\b", flags: "", replacement: "Feb" },
+    { pattern: "\\bNovemer\\b", flags: "", replacement: "Nov" },
+    { pattern: "\\bOctobor\\b", flags: "", replacement: "Oct" },
+    { pattern: "\\bJanurary\\b", flags: "", replacement: "Jan" },
+    { pattern: "\\bjanuary\\b", flags: "", replacement: "January" },
+    { pattern: "\\bfebruary\\b", flags: "", replacement: "February" },
+    { pattern: "\\bmarch\\b", flags: "", replacement: "March" },
+    { pattern: "\\bapril\\b", flags: "", replacement: "April" },
+    { pattern: "\\bjune\\b", flags: "", replacement: "June" },
+    { pattern: "\\bjuly\\b", flags: "", replacement: "July" },
+    { pattern: "\\baugust\\b", flags: "", replacement: "August" },
+    { pattern: "\\bseptember\\b", flags: "", replacement: "September" },
+    { pattern: "\\boctober\\b", flags: "", replacement: "October" },
+    { pattern: "\\bnovember\\b", flags: "", replacement: "November" },
+    { pattern: "\\bdecember\\b", flags: "", replacement: "December" },
+];
+export function applyUpdateCodes(input) {
+    let code = input;
+    for (const entry of UPDATE_CODES) {
+        if (entry.plain !== undefined) {
+            const anchored = new RegExp(`^${entry.plain.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+            // Plain keys substitute LITERALLY (Ruby String#gsub with a String
+            // replacement treats it literally except backrefs, which plain keys
+            // never carry); the replacer function keeps "$" safe.
+            const literal = entry.replacement;
+            code = code.replace(anchored, () => literal);
+        }
+        else if (entry.pattern !== undefined) {
+            // Regex-literal keys may carry Ruby backrefs (\1) — map to $1.
+            const replacement = entry.replacement.replace(/\\(\d)/g, (_, d) => `$${d}`);
+            code = code.replace(new RegExp(entry.pattern, entry.flags), replacement);
+        }
+    }
+    return code;
+}