@pubid/pubid 0.1.31 → 0.1.32

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

@@ -36,9 +36,27 @@ export declare class IeeeCode {
     readonly number: string;
     readonly parts: string[];
     readonly originalSeparator: string | undefined;
+    /** The separator BEFORE each part, when the source mixed them
+     * ("7.4-3-2" — dot after the number, dashes before the subparts).
+     * Runtime-only: the serialized columns keep the single
+     * original_separator, and only a fresh parse knows the per-part
+     * spelling (the reference's Components::Code#original_separators). */
+    readonly originalSeparators: string[] | undefined;
     constructor(attrs: Record<string, unknown>);
     static parse(codeStr: string): IeeeCode | undefined;
+    /** The printed face. The reference's Components::Code#to_s keeps the
+     * separator each part was printed with ("7.4-3-2"), and the corpus
+     * canonically pins the printed spelling (the project-draft rows freeze
+     * "IEEE P7-4.3.2/D2" with the dashed spelling as the input alias), so
+     * this face renders per-part like the Ruby reference. */
     render(): string;
+    /** The canonical face: one uniform separator across every part
+     * boundary (the first distinct one the source printed) — the face the
+     * URN segment, the joint IEEE/ISO faces and the reassembled PSI code
+     * render, so spellings that differ only in part separators share one
+     * identity. */
+    canonicalRender(): string;
+    private renderCode;
 }
 export declare const DRAFT_MONTH_NAMES: Record<string, string>;
 export declare class IeeeDraft {

package/dist/flavors/ieee/model.js

@@ -64,11 +64,20 @@ export class IeeeCode {
     number;
     parts;
     originalSeparator;
+    /** The separator BEFORE each part, when the source mixed them
+     * ("7.4-3-2" — dot after the number, dashes before the subparts).
+     * Runtime-only: the serialized columns keep the single
+     * original_separator, and only a fresh parse knows the per-part
+     * spelling (the reference's Components::Code#original_separators). */
+    originalSeparators;
     constructor(attrs) {
         this.prefix = attrs["prefix"];
         this.number = String(attrs["number"] ?? "");
         this.parts = Array.isArray(attrs["parts"]) ? attrs["parts"] : [];
         this.originalSeparator = attrs["original_separator"];
+        this.originalSeparators = Array.isArray(attrs["original_separators"])
+            ? attrs["original_separators"]
+            : undefined;
     }
     static parse(codeStr) {
         if (codeStr === "")
@@ -83,14 +92,37 @@ export class IeeeCode {
             separator = "-";
         const components = remainder.split(/[.-]/);
         const number = components.shift() ?? "";
+        // The separators AS PRINTED, one per part boundary — a code may mix
+        // them ("7.4-3-2": dot after the number, dashes before the
+        // subparts), and to_s re-joins with these instead of the uniform
+        // original_separator when they were captured.
+        const separators = remainder.match(/[.-]/g) ?? [];
+        const perPart = separators.length === components.length ? separators : undefined;
         return new IeeeCode({
             prefix,
             number,
             parts: components,
             original_separator: separator,
+            original_separators: perPart,
         });
     }
+    /** The printed face. The reference's Components::Code#to_s keeps the
+     * separator each part was printed with ("7.4-3-2"), and the corpus
+     * canonically pins the printed spelling (the project-draft rows freeze
+     * "IEEE P7-4.3.2/D2" with the dashed spelling as the input alias), so
+     * this face renders per-part like the Ruby reference. */
     render() {
+        return this.renderCode(true);
+    }
+    /** The canonical face: one uniform separator across every part
+     * boundary (the first distinct one the source printed) — the face the
+     * URN segment, the joint IEEE/ISO faces and the reassembled PSI code
+     * render, so spellings that differ only in part separators share one
+     * identity. */
+    canonicalRender() {
+        return this.renderCode(false);
+    }
+    renderCode(perPart) {
         let result = "";
         if (this.prefix !== undefined)
             result += this.prefix;
@@ -111,8 +143,14 @@ export class IeeeCode {
                     separator = ".";
                 }
             }
-            for (const part of this.parts)
-                result += separator + part;
+            for (const [idx, part] of this.parts.entries()) {
+                // A fresh parse of mixed-separator codes ("7.4-3-2") carries the
+                // separator each part was printed with; the canonical face (and
+                // an unknown per-part spelling — the serialized column shape)
+                // falls back to the uniform original separator.
+                const sep = (perPart && this.originalSeparators?.[idx]) || separator;
+                result += sep + part;
+            }
         }
         return result;
     }
@@ -764,7 +802,10 @@ class IeeeUrnGenerator extends BaseUrnGenerator {
             ? ["ieee_identifier", "primary_identifier", "first_identifier", "base"]
             : ["ieee_identifier", "primary_identifier", "first_identifier"];
         const wrapped = fallbacks.map((k) => self[k]).find((v) => v instanceof IeeeIdentifier);
-        return (wrapped ?? this.identifier).codeObj?.render();
+        // The URN is spelling-stable: codes printed with mixed part
+        // separators ("7.4-3-2") share one identity with their uniform
+        // spelling, so the segment renders canonically, not as printed.
+        return (wrapped ?? this.identifier).codeObj?.canonicalRender();
     }
     yearComponent() {
         const id = this.identifier;
@@ -858,12 +899,19 @@ function ieeeClass(spec, opts = {}) {
             return (opts.render ?? renderIeeeBase)(this);
         }
         get codeObj() {
+            // The parse path carries the freshly parsed Code (with its per-part
+            // separator spelling — the reference's `code:` string →
+            // Components::Code.parse in base #initialize); only the from_hash
+            // rebuild falls back to the split columns (uniform separator).
+            const self = this;
+            const runtime = self["__code_obj"];
+            if (runtime instanceof IeeeCode)
+                return runtime;
             // Only CodeNumber leaves carry code columns; on a supplement the
             // `number` attribute is the ORDINAL (Ruby SupplementIdentifier#code
             // delegates to base, code_obj stays nil).
             if (opts.codeColumns !== true)
                 return undefined;
-            const self = this;
             const number = self["number"];
             if (typeof number !== "string" || number === "")
                 return undefined;
@@ -927,7 +975,9 @@ export const SiStandardClass = ieeeClass({ kind: "si-standard" }, {
         const isPsi = (id.typed_stage?.abbr ?? []).includes("PSI");
         parts.push(isPsi ? "PSI" : "SI");
         const codeObj = id.codeObj;
-        let codePart = codeObj?.render() ?? "";
+        // Canonical code: the PSI code is reassembled from parse-tree
+        // captures (synthetic separators), so the face spells uniformly.
+        let codePart = codeObj?.canonicalRender() ?? "";
         const draftObj = id.draftObject();
         if (draftObj !== undefined)
             codePart += `/D${draftObj.version}`;
@@ -1166,7 +1216,10 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
                 parts.push(publishers.join("/"));
             if (stageWord !== "")
                 parts.push(stageWord);
-            let codeStr = codeObj?.render() ?? "";
+            // Canonical (uniform-separator) code: a joint document parses
+            // from both the dotted IEEE face and the dashed IEC face, and
+            // both spellings must render — and URN — identically.
+            let codeStr = codeObj?.canonicalRender() ?? "";
             // A P-prefixed joint project prints its parts dot-joined on the
             // ISO face ("ISO/IEEE DIS P15500.1"), whatever separator the
             // parse captured ("IEC/IEEE FDIS P60214-2-2018(E)" aliases in).
@@ -1214,8 +1267,9 @@ export const JointDevelopmentClass = ieeeClass({ kind: "joint-development" }, {
         if (draftStatus !== undefined)
             parts.push(draftStatus);
         // The P-state prints as spelled (P = project draft; no P =
-        // standard). Never added or stripped.
-        let codeStr = codeObj?.render() ?? "";
+        // standard). Never added or stripped. Canonical code for the same
+        // both-faces reason as the ISO face above.
+        let codeStr = codeObj?.canonicalRender() ?? "";
         let designatorCarriesYear = false;
         if (ieeeDraft !== undefined && ieeeDraft.startsWith("D=") && id.year !== undefined) {
             // The ordinal-less stage draft's canonical face (the

package/dist/flavors/ieee/preprocessor.js

@@ -503,6 +503,9 @@ export function preprocessIeee(input) {
     cleaned = cleaned.replaceAll("Edn.", "Edition");
     cleaned = cleaned.replaceAll("ASHARE", "ASHRAE");
     cleaned = cleaned.replace(/^PC(\d)/, "P$1");
+    // A two-digit draft designator spelled without its D ("IEEE P1052/08,
+    // September 2018"): the corpus face is the D ordinal ("…/D08").
+    cleaned = cleaned.replace(/^IEEE\s+(P[\d.-]+)\/(\d{2}),\s+([A-Za-z]+)\s+(\d{4})$/, "IEEE $1/D$2, $3 $4");
     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");

package/dist/flavors/ieee/update_codes.js

@@ -112,7 +112,7 @@ export const UPDATE_CODES = [
     { plain: "ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991", replacement: "ISO/IEC 13210:1994 (E); ANSI/IEEE Std 1003.3-1991" },
     { 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: "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:2017/D=WD.4a" },
     { plain: "ISO/IEC/IEEE CD.1 P21839, October 2017", replacement: "ISO/IEC/IEEE CD1 P21839-2017-10" },

package/dist/flavors/iho/index.js

@@ -20,54 +20,150 @@ function buildRules() {
     const dash = str("-");
     const dot = str(".");
     const digits = match("[0-9]").repeat(1, Infinity);
-    rule("series", () => str("S").or(str("P"), str("M"), str("B"), str("C")).as("type"));
-    rule("number_suffix", () => str(":").then(digits).or(str("/").then(digits)).or(dash.then(digits)).or(match("[A-Z]")));
+    const letters = match("[A-Za-z]").repeat(0, Infinity);
+    const seriesLetter = str("S").or(str("P"), str("M"), str("B"), str("C"));
+    const year4 = str("19").or(str("20")).then(match("[0-9]").repeat(2));
+    rule("series", () => seriesLetter.as("type"));
+    rule("number_suffix", () => str(":").then(digits));
     rule("number", () => digits.then(rules["number_suffix"].maybe()).as("number"));
+    // The compact part face, hyphenated onto the code: S-5-B (lettered),
+    // S-100-1 (numbered) and S-158-S-102 (series reference).
+    rule("compact_part", () => dash.then(seriesLetter
+        .then(dash, digits)
+        .or(digits.then(letters), match("[A-Z]"))
+        .as("part")));
+    // LEGACY glued lettered bases (S-5A): parse-only alias, rendered as
+    // "Part A".
+    rule("glued", () => match("[A-Z]").as("part"));
+    rule("edition", () => space.then(digits.then(dot, digits, dot, digits).as("edition")));
+    rule("v_edition", () => space.then(str("v").then(digits.then(str(".").then(digits).maybe()).as("edition_shorthand"))));
+    rule("year_qualifier", () => space.then(str("(").then(year4.as("year"), str(")"))));
+    rule("part_series_ref", () => seriesLetter.then(dash, digits));
+    rule("part_value", () => rules["part_series_ref"].or(digits.then(letters), match("[A-Z]")).as("part"));
+    rule("part_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("part_edition")));
+    rule("part_year_rule", () => space.then(str("(").then(year4.as("part_year"), str(")"))));
+    rule("part_dated", () => rules["part_edition_rule"].then(rules["part_year_rule"].maybe()));
+    rule("part", () => space.then(str("Part")).then(space, rules["part_value"], rules["part_dated"].maybe()));
+    rule("supplement_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("supplement_edition")));
+    rule("supplement_year_rule", () => space.then(str("(").then(year4.as("supplement_year"), str(")"))));
+    rule("supplement_dated", () => rules["supplement_edition_rule"].then(rules["supplement_year_rule"].maybe()));
+    rule("supplement", () => space
+        .then(str("Suppl").or(str("Sup")))
+        .then(space, digits.as("supplement"), rules["supplement_dated"].maybe()));
+    rule("annex_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("annex_edition")));
+    rule("annex_year_rule", () => space.then(str("(").then(year4.as("annex_year"), str(")"))));
+    rule("annex_dated", () => rules["annex_edition_rule"].then(rules["annex_year_rule"].maybe()));
+    rule("annex", () => space.then(str("Annex")).then(space, match("[A-Z]").as("annex"), rules["annex_dated"].maybe()));
+    rule("appendix_value", () => match("[A-Z]").or(digits).as("appendix"));
+    rule("appendix_subnumber", () => dash.then(digits.as("appendix_subnumber")));
+    rule("appendix_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("appendix_edition")));
+    rule("appendix_year_rule", () => space.then(str("(").then(year4.as("appendix_year"), str(")"))));
+    rule("appendix_dated", () => rules["appendix_edition_rule"].then(rules["appendix_year_rule"].maybe()));
     rule("appendix", () => space
-        .then(str("Appendix").or(str("Ap.")))
-        .then(space, match("[A-Z]").then(dash, digits).or(digits).or(match("[A-Z]")).as("appendix")));
-    rule("part", () => space.then(str("Part")).then(space, digits.then(match("[a-zA-Z]").repeat(0, Infinity)).as("part").or(match("[A-Z]").as("part"))));
-    rule("annex", () => space.then(str("Annex")).then(space, match("[A-Z]").as("annex")));
-    rule("supplement", () => space.then(str("Suppl")).then(space, digits.as("supplement")));
-    rule("version", () => space.then(digits.then(dot, digits, dot, digits).as("version")));
+        .then(str("Appendix").or(str("App"), str("Ap.")))
+        .then(space, rules["appendix_value"], rules["appendix_subnumber"].maybe(), rules["appendix_dated"].maybe()));
+    rule("volume_issue", () => space
+        .then(str("Issue"))
+        .then(space, digits.as("issue"))
+        .or(space.then(str("("), digits.as("issue"), str(")"))));
+    rule("volume_edition_rule", () => space.then(digits.then(dot, digits, dot, digits).as("volume_edition")));
+    rule("volume_year_rule", () => space.then(str("(").then(year4.as("volume_year"), str(")"))));
+    rule("volume_dated", () => rules["volume_edition_rule"].then(rules["volume_year_rule"].maybe()));
+    rule("volume", () => space.then(str("Vol.")).then(space, digits.as("volume"), rules["volume_issue"].maybe()));
+    // The volume's short face — the slash chain ("IHO P-1/21").
+    rule("volume_short", () => str("/").then(digits.as("volume"), rules["volume_dated"].maybe()));
+    // LEGACY bare year ("IHO P-5 2024"): the yearbook year IS a volume.
+    rule("volume_bare_year", () => space.then(year4.as("volume")));
+    rule("serial", () => rules["volume"].or(rules["volume_bare_year"]).then(rules["volume_dated"].maybe()));
+    rule("dated", () => rules["edition"].or(rules["v_edition"]).then(rules["year_qualifier"].maybe()));
     rule("identifier", () => str("IHO")
         .then(space)
         .maybe()
-        .then(rules["series"], dash, rules["number"])
-        .then(rules["appendix"].maybe())
-        .then(rules["part"].maybe())
-        .then(rules["annex"].maybe())
-        .then(rules["supplement"].maybe())
-        .then(rules["version"].maybe()));
+        .then(rules["series"], dash, rules["number"], rules["compact_part"].maybe(), rules["glued"].maybe(), rules["volume_short"].maybe(), rules["dated"].maybe(), rules["supplement"].maybe(), rules["part"].maybe(), rules["annex"].maybe(), rules["appendix"].maybe(), rules["serial"].maybe(), rules["year_qualifier"].maybe()));
     rule("root", () => rules["identifier"]);
     return rules;
 }
 export const ihoGrammar = { rules: buildRules(), root: "root" };
+function padEditionShorthand(value) {
+    const segments = value.split(".");
+    while (segments.length < 3)
+        segments.push("0");
+    return segments.join(".");
+}
 function ihoClass(kind) {
     const letter = KIND_LETTERS[kind];
     class IhoKindIdentifier extends BaseIdentifier {
         static polymorphicName = `pubid:iho:${kind}`;
         static attributes = extendAttributes(BaseIdentifier, {
             number: { type: "string" },
-            appendix: { type: "string" },
             part: { type: "string" },
+            part_edition: { type: "string" },
+            part_year: { type: "string" },
             annex: { type: "string" },
+            annex_edition: { type: "string" },
+            annex_year: { type: "string" },
+            appendix: { type: "string" },
+            appendix_subnumber: { type: "string" },
+            appendix_edition: { type: "string" },
+            appendix_year: { type: "string" },
             supplement: { type: "string" },
-            version: { type: "string" },
+            supplement_edition: { type: "string" },
+            supplement_year: { type: "string" },
+            edition: { type: "string" },
+            year: { type: "string" },
+            volume: { type: "string" },
+            volume_edition: { type: "string" },
+            volume_year: { type: "string" },
+            issue: { type: "string" },
         });
-        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "appendix", to: "appendix" }, { wire: "part", to: "part" }, { wire: "annex", to: "annex" }, { wire: "supplement", to: "supplement" }, { wire: "version", to: "version" });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "part_edition", to: "part_edition" }, { wire: "part_year", to: "part_year" }, { wire: "annex", to: "annex" }, { wire: "annex_edition", to: "annex_edition" }, { wire: "annex_year", to: "annex_year" }, { wire: "appendix", to: "appendix" }, { wire: "appendix_subnumber", to: "appendix_subnumber" }, { wire: "appendix_edition", to: "appendix_edition" }, { wire: "appendix_year", to: "appendix_year" }, { wire: "supplement", to: "supplement" }, { wire: "supplement_edition", to: "supplement_edition" }, { wire: "supplement_year", to: "supplement_year" }, { wire: "edition", to: "edition" }, { wire: "year", to: "year" }, { wire: "volume", to: "volume" }, { wire: "volume_edition", to: "volume_edition" }, { wire: "volume_year", to: "volume_year" }, { wire: "issue", to: "issue" });
         render() {
             let result = `IHO ${letter}-${this.number}`;
-            if (this.appendix !== undefined)
-                result += ` Ap. ${this.appendix}`;
-            if (this.part !== undefined)
+            if (this.edition !== undefined)
+                result += ` ${this.edition}`;
+            if (this.supplement !== undefined) {
+                result += ` Sup ${this.supplement}`;
+                if (this.supplement_edition !== undefined)
+                    result += ` ${this.supplement_edition}`;
+                if (this.supplement_year !== undefined)
+                    result += ` (${this.supplement_year})`;
+            }
+            if (this.part !== undefined) {
                 result += ` Part ${this.part}`;
-            if (this.annex !== undefined)
+                if (this.part_edition !== undefined)
+                    result += ` ${this.part_edition}`;
+                if (this.part_year !== undefined)
+                    result += ` (${this.part_year})`;
+            }
+            if (this.annex !== undefined) {
                 result += ` Annex ${this.annex}`;
-            if (this.supplement !== undefined)
-                result += ` Suppl ${this.supplement}`;
-            if (this.version !== undefined)
-                result += ` ${this.version}`;
+                if (this.annex_edition !== undefined)
+                    result += ` ${this.annex_edition}`;
+                if (this.annex_year !== undefined)
+                    result += ` (${this.annex_year})`;
+            }
+            if (this.appendix !== undefined) {
+                result += ` Appendix ${this.appendix}`;
+                if (this.appendix_subnumber !== undefined)
+                    result += `-${this.appendix_subnumber}`;
+                if (this.appendix_edition !== undefined)
+                    result += ` ${this.appendix_edition}`;
+                if (this.appendix_year !== undefined)
+                    result += ` (${this.appendix_year})`;
+            }
+            if (this.volume !== undefined) {
+                result += ` Vol. ${this.volume}`;
+                if (this.issue !== undefined)
+                    result += ` (${this.issue})`;
+                if (this.volume_edition !== undefined)
+                    result += ` ${this.volume_edition}`;
+                if (this.volume_year !== undefined)
+                    result += ` (${this.volume_year})`;
+            }
+            // The base year qualifier prints last, parenthesized ("IHO
+            // S-100 1.0.0 Part A (2024)").
+            if (this.year !== undefined)
+                result += ` (${this.year})`;
             return result;
         }
     }
@@ -75,16 +171,54 @@ function ihoClass(kind) {
         generate() {
             const id = this.identifier;
             const parts = ["urn", "iho", letter.toLowerCase(), id.number];
-            if (id.appendix !== undefined)
-                parts.push(`ap.${id.appendix}`);
-            if (id.part !== undefined)
-                parts.push(`part.${id.part}`);
-            if (id.annex !== undefined)
-                parts.push(`annex.${id.annex}`);
-            if (id.supplement !== undefined)
-                parts.push(`suppl.${id.supplement}`);
-            if (id.version !== undefined)
-                parts.push(id.version);
+            // Each component is a marker-prefixed segment; its own edition
+            // (ed-) and year (year-) follow it directly. The base edition
+            // and year come first (they attach to the base node).
+            if (id.edition !== undefined)
+                parts.push(`ed-${id.edition}`);
+            if (id.year !== undefined)
+                parts.push(`year-${id.year}`);
+            if (id.supplement !== undefined) {
+                parts.push(`sup-${id.supplement}`);
+                if (id.supplement_edition !== undefined)
+                    parts.push(`ed-${id.supplement_edition}`);
+                if (id.supplement_year !== undefined)
+                    parts.push(`year-${id.supplement_year}`);
+            }
+            if (id.part !== undefined) {
+                parts.push(`part-${id.part}`);
+                if (id.part_edition !== undefined)
+                    parts.push(`ed-${id.part_edition}`);
+                if (id.part_year !== undefined)
+                    parts.push(`year-${id.part_year}`);
+            }
+            if (id.annex !== undefined) {
+                parts.push(`annex-${id.annex}`);
+                if (id.annex_edition !== undefined)
+                    parts.push(`ed-${id.annex_edition}`);
+                if (id.annex_year !== undefined)
+                    parts.push(`year-${id.annex_year}`);
+            }
+            if (id.appendix !== undefined) {
+                parts.push(`appendix-${id.appendix}`);
+                // The subnumber is a bare child segment directly after the
+                // appendix ("appendix-D:2").
+                if (id.appendix_subnumber !== undefined)
+                    parts.push(id.appendix_subnumber);
+                if (id.appendix_edition !== undefined)
+                    parts.push(`ed-${id.appendix_edition}`);
+                if (id.appendix_year !== undefined)
+                    parts.push(`year-${id.appendix_year}`);
+            }
+            if (id.volume !== undefined) {
+                parts.push(`vol-${id.volume}`);
+                if (id.issue !== undefined)
+                    parts.push(`issue-${id.issue}`);
+                if (id.volume_edition !== undefined)
+                    parts.push(`ed-${id.volume_edition}`);
+                if (id.volume_year !== undefined)
+                    parts.push(`year-${id.volume_year}`);
+            }
             return parts.join(":");
         }
     }
@@ -111,6 +245,35 @@ class IhoBuilder extends BaseBuilder {
     defaultIdentifierClass() {
         return KIND_CLASSES["standard"];
     }
+    build(data) {
+        const flat = Array.isArray(data)
+            ? Object.assign({}, ...data)
+            : { ...data };
+        // A component year without its component edition attaches to the
+        // nearest preceding edition node — the base ("IHO S-100 1.0.0
+        // Part A (2024)" binds the base year, never part_year). With the
+        // component's own edition present it stays component-scoped
+        // ("IHO S-98 Part A 1.0.0 (2024)" keeps part_year).
+        for (const component of ["part", "supplement", "annex", "appendix", "volume"]) {
+            const yearKey = `${component}_year`;
+            if (flat[yearKey] !== undefined &&
+                flat[`${component}_edition`] === undefined &&
+                flat["edition"] !== undefined) {
+                if (flat["year"] === undefined)
+                    flat["year"] = flat[yearKey];
+                delete flat[yearKey];
+            }
+        }
+        return super.build(flat);
+    }
+    cast(key, value) {
+        if (key === "type")
+            return null; // the kind is encoded in _type
+        if (key === "edition_shorthand") {
+            return { edition: padEditionShorthand(String(value)) };
+        }
+        return value;
+    }
 }
 export function ihoGrammarImplementation() {
     const builder = new IhoBuilder();

package/dist/flavors/jis/index.js

@@ -11,6 +11,10 @@ import { BaseUrnGenerator } from "../../model/urn-generator.js";
  * code ("B 0205-1") lives in the series/number/parts columns and is
  * composed on demand. URN: urn:jis:<code>[:year][:lang]["all"]? with a
  * supplement notation appended lowercased.
+ *
+ * WES (welding-engineering-standard, pubid#638) rides the same flavor:
+ * "WES <number>[-parts][:year[R]]…" with no series letter and no JIS
+ * prefix — the code itself carries the "WES" root.
  */
 function buildRules() {
     const rules = {};
@@ -55,7 +59,19 @@ function buildRules() {
         .then(rules["all_parts"].maybe())
         .then(rules["supplement"].maybe())
         .then(rules["symbol_clause"].maybe()));
-    rule("root", () => rules["identifier"]);
+    // WES (Japan Welding Engineering Society) rides the JIS flavor with the
+    // same tail but no prefix and no series letter; the root tries it first,
+    // as the reference grammar does.
+    rule("wes_identifier", () => str("WES").as("wes")
+        .then(space)
+        .then(rules["number"])
+        .then(rules["parts"])
+        .then(rules["year"].maybe())
+        .then(rules["language"].maybe())
+        .then(rules["all_parts"].maybe())
+        .then(rules["supplement"].maybe())
+        .then(rules["symbol_clause"].maybe()));
+    rule("root", () => rules["wes_identifier"].or(rules["identifier"]));
     return rules;
 }
 export const jisGrammar = { rules: buildRules(), root: "root" };
@@ -151,6 +167,45 @@ const KIND_CLASSES = {
     corrigendum: jisClass("corrigendum"),
     explanation: jisClass("explanation"),
 };
+// WES 7700-1:2019 — JSA sells Welding Engineering Standards next to JIS,
+// so they parse through the JIS flavor, but the id carries no series
+// letter and no JIS prefix ("WES" is the root of the designation).
+function wesClass() {
+    class JisWesIdentifier extends JisIdentifier {
+        static polymorphicName = "pubid:jis:welding-engineering-standard";
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "string" },
+            parts: { type: "string", collection: true },
+            year: { type: "integer" },
+            language: { type: "string" },
+            all_parts: { type: "boolean", default: false },
+            reaffirmed: { type: "boolean" },
+            symbol: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
+        code() {
+            if (this.base !== undefined)
+                return this.base.code();
+            let result = `WES ${this.number}`;
+            if (this.parts !== undefined)
+                result += this.parts.map((p) => `-${p}`).join("");
+            return result;
+        }
+        render() {
+            let result = this.code() ?? "";
+            if (this.year !== undefined)
+                result += `:${this.yearWithReaffirmation()}`;
+            if (this.language !== undefined)
+                result += `(${this.language})`;
+            if (this.all_parts === true)
+                result += "（規格群）";
+            return result + this.symbolSuffix();
+        }
+    }
+    registerType(JisWesIdentifier);
+    return JisWesIdentifier;
+}
+const WES_CLASS = wesClass();
 class JisUrnGenerator extends BaseUrnGenerator {
     generate() {
         const id = this.identifier;
@@ -171,7 +226,7 @@ class JisUrnGenerator extends BaseUrnGenerator {
         return parts.join(":");
     }
 }
-for (const klass of Object.values(KIND_CLASSES)) {
+for (const klass of [...Object.values(KIND_CLASSES), WES_CLASS]) {
     klass.urnGenerator = JisUrnGenerator;
 }
 function isObj(v) {
@@ -213,6 +268,8 @@ class JisBuilder {
         return out;
     }
     buildSingle(tree) {
+        if (tree["wes"] !== undefined)
+            return this.buildWes(tree);
         const type = tree["type"] === undefined || tree["type"] === null ? undefined : String(tree["type"]);
         const kind = type === "TR" ? "technical-report" : type === "TS" ? "technical-specification" : "japanese-industrial-standard";
         const attrs = {
@@ -230,6 +287,21 @@ class JisBuilder {
             attrs["reaffirmed"] = true;
         return new KIND_CLASSES[kind](attrs);
     }
+    buildWes(tree) {
+        const attrs = {
+            number: String(tree["number"]),
+            parts: extractParts(tree["parts"]),
+        };
+        if (tree["year"] !== undefined && tree["year"] !== null)
+            attrs["year"] = Number(tree["year"]);
+        if (tree["language"] !== undefined && tree["language"] !== null)
+            attrs["language"] = String(tree["language"]);
+        if (tree["all_parts"] !== undefined)
+            attrs["all_parts"] = true;
+        if (tree["reaffirmed"] !== undefined && tree["reaffirmed"] !== null)
+            attrs["reaffirmed"] = true;
+        return new WES_CLASS(attrs);
+    }
     buildSupplement(tree, kind, key, prefix) {
         const supp = isObj(tree[key]) ? tree[key] : {};
         const base = this.buildSingle(this.baseData(tree, key));