@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/iso/grammar.js

@@ -0,0 +1,207 @@
+import { match, ref, str } from "../../grammar/engine.js";
+import { stageTokens } from "./model.js";
+/**
+ * Port of lib/pubid/iso/parser.rb. The identifier alternation order is
+ * load-bearing (PEG ordered choice): nsb_iso | tc_document |
+ * directives | jcgm | iso_r_supplement | iso_r | suppl³ | suppl² |
+ * suppl | joint | copublishers. Stage tokens come from the typed-stage
+ * registry (longest first), split into base (non-supplement) and
+ * supplement tables exactly like the Ruby TYPED_STAGES constants.
+ */
+const SUPPLEMENT_TYPE_KEYS = ["amd", "cor", "suppl", "ext", "add"];
+const BASE_STAGE_TOKENS = stageTokens().filter((t) => {
+    // Supplement tokens are excluded from the base table by type key, but
+    // stageTokens() is type-agnostic here; the split is done via the
+    // supplement table below (tokens unique to supplement types).
+    return true;
+});
+const DIRECTIVES_TOKENS = ["Directives Part", "Directives, Part", "Directives,", "Directives", "DIR"];
+const DIRECTIVES_SUPPLEMENT_TOKENS = ["DIR SUP", "Supplement", "SUP"];
+const ORGANIZATIONS = [
+    "ISO", "IEC", "IEEE", "CIW", "SAE", "CIE", "ASME", "ASTM", "OECD", "HL7", "CEI", "UNDP",
+];
+const TC_TYPES = [
+    "TC", "JTC", "PC", "IT", "CAB", "CASCO", "COPOLCO", "COUNCIL", "CPSG", "CS",
+    "DEVCO", "GA", "GAAB", "INFCO", "ITN", "ISOlutions", "REMCO", "TMB", "TMBG",
+    "WMO", "DMT", "JCG", "SGPM", "ATMG", "CCCC", "CCCC-TG", "JDMT", "JSAG",
+    "JSCTF-TF", "JTCG", "JTCG-TF", "SAG_Acc", "SAG_CRMI", "SAG_CRMI_CG",
+    "SAG_ESG", "SAG_ESG_CG", "SAG_MRS", "SAG_SF", "SAG_SF_CG", "SMCC", "STMG",
+    "MENA_STAR",
+];
+const WG_TYPES = [
+    "AG", "AhG", "WG", "JWG", "QC", "TF", "PPC", "CAG", "CSC", "ITSAG",
+    "CSC/FIN", "CSC/NOM", "CSC/OVE", "CSC/SP", "CSC", "SF", "ITSG", "JAG",
+    "JCTF", "JSG", "JTAG", "JTG",
+];
+function literalAlternation(tokens) {
+    const sorted = [...new Set(tokens)].sort((a, b) => b.length - a.length);
+    return sorted.map((t) => str(t)).reduce((a, b) => a.or(b));
+}
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digit = match("[0-9]");
+    const digits = digit.repeat(1, Infinity);
+    const yearDigits = digit.repeat(4, 4);
+    const monthDigits = digit.repeat(2, 2);
+    const dayDigits = digit.repeat(2, 2);
+    const dashChars = ["-", "‑", "‐"];
+    const dash = literalAlternation(dashChars);
+    rule("publisher", () => str("ISO").or(str("IEC")).as("publisher"));
+    rule("copublishers", () => str("/")
+        .then(space.maybe(), literalAlternation(ORGANIZATIONS).as("copublisher"))
+        .repeat(0, Infinity)
+        .as("copublishers"));
+    // (:|dash)(-- undated | Y[-M[-D]]), all optional after the separator.
+    rule("date", () => str(":")
+        .or(dash)
+        .then(str("--")
+        .or(str("—"))
+        .as("undated_marker")
+        .or(yearDigits
+        .then(dash.then(monthDigits).maybe(), dash.then(dayDigits).maybe())
+        .as("date"))
+        .maybe()));
+    rule("number", () => digit.repeat(1, 5));
+    // Modern "-A01", "-5-1-1" (space-tolerant) vs legacy "/6" (guarded
+    // against supplement type names).
+    rule("part_and_subpart", () => dash
+        .then(space.maybe(), match("\\w").repeat(1, Infinity), dash.then(match("\\w").repeat(1, Infinity)).repeat(0, Infinity).maybe())
+        .or(str("/").then(space.maybe(), ref(rules, "supplement_type_with_stage").absent(), match("\\w").repeat(1, Infinity))));
+    rule("number_with_part", () => rules["number"].then(rules["part_and_subpart"].maybe()).as("number_with_part"));
+    rule("all_parts", () => str("(all parts)").as("all_parts"));
+    const supplementTypeTokens = stageTokens(SUPPLEMENT_TYPE_KEYS);
+    const baseStageTokens = BASE_STAGE_TOKENS.filter((t) => !supplementTypeTokens.includes(t));
+    rule("type_with_stage", () => literalAlternation(baseStageTokens)
+        .as("type_with_stage")
+        .then(digit.as("stage_iteration").then(space).maybe()));
+    rule("supplement_type_with_stage", () => literalAlternation(supplementTypeTokens).as("type_with_stage"));
+    // (en,fr) or (E/F) — repeated captures joined.
+    rule("language", () => str("(").then(match("[a-z]")
+        .repeat(1, Infinity)
+        .then(str(",").maybe())
+        .or(match("[EFARDS]").then(str("/").or(str(",")).maybe()))
+        .repeat(0, Infinity)
+        .as("languages"), str(")")));
+    rule("edition", () => literalAlternation(["Edition", "Ed.", "ED", "Ed"])
+        .then(space.maybe(), digits.maybe())
+        .as("edition"));
+    rule("stage_iteration", () => str(".").then(digit.as("stage_iteration")));
+    rule("second_part", () => rules["number_with_part"]
+        .then(rules["stage_iteration"].maybe(), space.maybe(), rules["date"].maybe()));
+    rule("third_part_edition", () => space.maybe().then(rules["edition"].maybe()));
+    rule("third_part", () => rules["third_part_edition"]
+        .then(rules["language"].maybe(), space.maybe(), rules["all_parts"].maybe()));
+    rule("guide_prefix", () => str("Guide").or(str("GUIDE")));
+    rule("prefix_with_copublishers", () => str("ISO/R")
+        .as("iso_r_prefix")
+        .then(space)
+        .or(rules["publisher"]
+        .then(space.maybe(), rules["copublishers"].maybe())));
+    rule("identifier_copublishers_no_third", () => rules["guide_prefix"]
+        .as("type_with_stage_fr")
+        .then(space)
+        .maybe()
+        .then(rules["prefix_with_copublishers"].maybe(), space.maybe(), str("/").maybe(), rules["type_with_stage"].maybe(), space.maybe(), rules["second_part"], rules["third_part_edition"]));
+    rule("identifier_copublishers", () => rules["identifier_copublishers_no_third"].then(rules["third_part"]));
+    // NSB-prefixed: FprISO… / WD/ISO…
+    const nsbBody = () => rules["publisher"]
+        .then(space.maybe(), rules["copublishers"].maybe(), space.maybe(), rules["type_with_stage"].maybe(), space.maybe(), rules["second_part"], rules["third_part"]);
+    rule("nsb_iso_identifier", () => str("Fpr")
+        .as("nsb_stage")
+        .then(nsbBody())
+        .or(str("WD").as("nsb_stage").then(str("/"), nsbBody())));
+    // TC documents: ISO/TC 184/SC 4/WG 3 N 123[:year]
+    rule("tc_type", () => literalAlternation(TC_TYPES).as("tc_type"));
+    rule("sc_type", () => str("SC/QC").or(str("SC")).as("sc_type"));
+    rule("wg_type", () => literalAlternation(WG_TYPES).as("wg_type"));
+    rule("tc_subcommittee_part", () => str("/")
+        .then(rules["sc_type"], space, digits.as("sc_number"), str("/"), rules["wg_type"], space, digits.as("wg_number"))
+        .or(str("/").then(rules["sc_type"], space, digits.as("sc_number"))));
+    rule("tc_document", () => rules["publisher"]
+        .then(str("/").or(space), rules["tc_type"], space, digits.as("tc_number"), rules["tc_subcommittee_part"].maybe(), space, str("N"), space.maybe(), digits.as("number"), str(":").then(yearDigits.as("year")).maybe()));
+    // JCGM 200:2008(F)
+    rule("jcgm_identifier", () => str("JCGM")
+        .as("publisher")
+        .then(space, rules["second_part"], rules["third_part"]));
+    // Legacy ISO/R forms.
+    rule("iso_r_second_part", () => rules["number_with_part"]
+        .then(rules["stage_iteration"].maybe(), space.maybe(), rules["date"].maybe()));
+    rule("iso_r_identifier", () => str("ISO/R")
+        .as("iso_r_prefix")
+        .then(space, rules["iso_r_second_part"], rules["third_part"]));
+    rule("iso_r_supplement_separator", () => str("/").or(space.maybe().then(str("—"), space.maybe()), space.then(str("-"), space)));
+    rule("iso_r_supplement_identifier", () => str("ISO/R")
+        .as("iso_r_prefix")
+        .then(space, rules["iso_r_second_part"])
+        .as("base")
+        .then(rules["iso_r_supplement_separator"], rules["supplement_type_with_stage"], space.maybe(), rules["second_part"], rules["third_part"]));
+    // Supplements: base + "/" + stage + (second_part | .N | date)? [+ third]
+    rule("supplement_identifier_no_third", () => rules["identifier_copublishers_no_third"]
+        .as("base")
+        .then(str("/"), rules["supplement_type_with_stage"], space
+        .maybe()
+        .then(rules["second_part"])
+        .or(str(".").then(digits.as("number")), space.maybe().then(rules["date"]))
+        .maybe()));
+    rule("supplement_identifier", () => rules["supplement_identifier_no_third"].then(rules["third_part"]));
+    rule("supplement_supplement_identifier", () => rules["supplement_identifier_no_third"]
+        .as("base")
+        .then(str("/"), rules["supplement_type_with_stage"], space
+        .maybe()
+        .then(rules["second_part"], rules["third_part"])
+        .or(str(".").then(digits.as("number"), rules["third_part"]))));
+    rule("supplement_supplement_supplement_identifier", () => rules["supplement_supplement_identifier"]
+        .as("base")
+        .then(str("/"), rules["supplement_type_with_stage"], space
+        .maybe()
+        .then(rules["second_part"], rules["third_part"])
+        .or(str(".").then(digits.as("number"), rules["third_part"]))));
+    // Directives.
+    rule("directives_publisher_subgroup", () => str("JTC 1").as("subgroup"));
+    rule("directives_part_and_subpart", () => space.then(str("ISO").or(str("IEC")), str("/").absent(), space.then(str("SUP")).absent()));
+    rule("directives_number_with_part", () => rules["number"]
+        .then(rules["directives_part_and_subpart"].maybe())
+        .as("number_with_part"));
+    rule("directives_identifier_no_third", () => rules["prefix_with_copublishers"]
+        .then(space.maybe(), rules["directives_publisher_subgroup"].then(space).maybe(), literalAlternation(DIRECTIVES_TOKENS).as("type_with_stage"), space
+        .then(rules["directives_publisher_subgroup"], space.then(str("SUP")).absent())
+        .maybe(), space
+        .then(rules["directives_number_with_part"])
+        .maybe()
+        .then(str(":").then(rules["date"]).maybe())
+        .maybe()));
+    rule("directives_identifier", () => rules["directives_identifier_no_third"]
+        .then(rules["third_part"].maybe(), space.maybe(), rules["date"].maybe()));
+    rule("directives_supplement_part_no_third", () => space
+        .maybe()
+        .then(str("--"), space.maybe(), str("Consolidated"), space)
+        .maybe()
+        .then(str("ISO/IEC").or(str("ISO"), str("IEC"), str("JTC 1")).as("publisher"), space.then(literalAlternation(DIRECTIVES_SUPPLEMENT_TOKENS).as("type_with_stage")), rules["date"].maybe()));
+    rule("directives_supplement_part", () => rules["directives_supplement_part_no_third"].then(rules["third_part"].maybe()));
+    rule("directives_supplement_identifier", () => rules["directives_identifier_no_third"]
+        .as("base")
+        .then(space.maybe(), rules["directives_supplement_part"]));
+    rule("directives_bundled_identifier", () => rules["directives_identifier_no_third"]
+        .then(rules["third_part"].then(space.maybe()).maybe(), rules["date"].then(space.maybe()).maybe())
+        .as("base_document")
+        .then(str("+ ")
+        .then(rules["directives_supplement_part_no_third"].as("supplement"))
+        .repeat(1, Infinity)
+        .as("supplements")));
+    rule("directives_identifiers", () => rules["directives_bundled_identifier"].or(rules["directives_supplement_identifier"], rules["directives_identifier"]));
+    // Joint ISO|IDF — IDF side unreachable by the corpus (no rows); the
+    // twin is captured raw like ITU's common-text twin.
+    rule("idf_identifier", () => match("[^|]").repeat(1, Infinity).as("idf_raw"));
+    rule("joint_identifier", () => rules["identifier_copublishers_no_third"]
+        .as("base")
+        .then(space.maybe(), str("|"), space.maybe(), rules["idf_identifier"])
+        .as("joint_identifier"));
+    rule("identifier", () => rules["nsb_iso_identifier"].or(rules["tc_document"], rules["directives_identifiers"], rules["jcgm_identifier"], rules["iso_r_supplement_identifier"], rules["iso_r_identifier"], rules["supplement_supplement_supplement_identifier"], rules["supplement_supplement_identifier"], rules["supplement_identifier"], rules["joint_identifier"], rules["identifier_copublishers"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const isoGrammar = { rules: buildRules(), root: "root" };

package/dist/flavors/iso/index.d.ts

@@ -0,0 +1,2 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare function isoGrammarImplementation(): FlavorImplementation;

package/dist/flavors/iso/index.js

@@ -0,0 +1,343 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { PubidDate, Language, Iteration } from "../../model/component.js";
+import { isoGrammar } from "./grammar.js";
+import { IsoBundledIdentifier, IsoDirectives, IsoDirectivesSupplement, IsoEdition, IsoPublisher, IsoSupplementIdentifier, IsoTcDocument, isoClassForType, locateStage, } from "./model.js";
+/**
+ * Port of lib/pubid/iso/{builder,normalizer}.rb. Class dispatch follows
+ * the Ruby Builder: joint → Combined (unreachable by the corpus),
+ * supplements-bundle → BundledIdentifier, tc_type → TcDocument, else
+ * locate_type(typed_stage.type_code) with the DIR/SUP special cases.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const s = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const str = Array.isArray(v) ? v.join("") : String(v);
+    return str.length > 0 ? str : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+// --- Normalizer (lib/pubid/iso/normalizer.rb) --------------------------------
+const DAD_PATTERN = /^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/;
+const UPDATE_CODE_LINES = {
+    "ISO/R 657/IV": "ISO/R 657-4:1969",
+    "ISO/IEC/IEEE 8802-22.2:2015/Amd.2:2017(E)": "ISO/IEC/IEEE 8802-22:2015/Amd.2:2017(E)",
+    "ISO/TR 17716.2": "ISO/TR 17716",
+    "ISO/TR 17716.2(E)": "ISO/TR 17716(E)",
+};
+const UPDATE_CODE_REGEXES = [
+    [/^(ISO[\w/]*) DIS (TR|TS|PAS|ISP) /, "$1 D$2 "],
+    [/^(ISO[\w/]*) FDIS (TR|TS|PAS|ISP) /, "$1 FD$2 "],
+    [/DIS Amd /, "DAM "],
+    [/FDIS Amd /, "FDAM "],
+    [/DIS Cor /, "DCOR "],
+    [/FDIS Cor /, "FDCOR "],
+    [/DIS Suppl /, "DSuppl "],
+    [/DIS Add /, "DAD "],
+];
+const CYRILLIC_MAP = [
+    ["Руководства", "GUIDE"],
+    ["Руководство", "GUIDE"],
+    ["ИСО/МЭК", "ISO/IEC"],
+    ["ИСО/ОПМС", "ISO/FDIS"],
+    ["ИСО/ПМС", "ISO/DIS"],
+    ["ИСО/ТО", "ISO/TR"],
+    ["ИСО/ТС", "ISO/TS"],
+    ["ИСО", "ISO"],
+    ["МЭК", "IEC"],
+    ["ТО", "TR"],
+    ["ТС", "TS"],
+    ["ОПМС", "FDIS"],
+    ["ПМС", "DIS"],
+];
+function normalizeCyrillic(input) {
+    if (!/[а-яА-Я]/.test(input))
+        return input;
+    let normalized = input.replace(/\s*#\s*.*$/, "");
+    for (const [from, to] of CYRILLIC_MAP) {
+        normalized = normalized.split(from).join(to);
+    }
+    return normalized.trim();
+}
+function applyUpdateCodes(input) {
+    const line = UPDATE_CODE_LINES[input];
+    if (line !== undefined)
+        return line;
+    let out = input;
+    for (const [pattern, replacement] of UPDATE_CODE_REGEXES) {
+        // The Ruby table keys the supplement-position regexes with a "//"
+        // prefix marking "after the first /"; apply those only past a slash.
+        out = out.replace(pattern, replacement);
+    }
+    return out;
+}
+// --- Builder -------------------------------------------------------------------
+function parseLanguages(raw) {
+    const str = s(raw);
+    if (str === undefined)
+        return [];
+    return str
+        .split(",")
+        .flatMap((chunk) => chunk.split("/"))
+        .map((token) => token.trim())
+        .filter((token) => token !== "")
+        .map((original) => {
+        const code = original.length === 1 ? (Language.CHAR_MAP[original] ?? original.toLowerCase()) : original;
+        return new Language({ code, originalCode: original });
+    });
+}
+/**
+ * Builder#parse_number_with_part: em/en dashes, slashes and spaces
+ * normalize to "-", then number[-part[-subpart]]; a 4-digit 1900-2099
+ * part is a legacy year, not a part.
+ */
+function parseNumberWithPart(raw) {
+    const value = s(raw)?.replace(/[‑‐/]/g, "-").replace(/ /g, "-");
+    if (value === undefined)
+        return { number: undefined, part: undefined, subpart: undefined, date: undefined };
+    const segments = value.split("-").filter((seg) => seg !== "");
+    const [number, part, ...rest] = segments;
+    const result = { number, part, subpart: rest.length > 0 ? rest.join("-") : undefined, date: undefined };
+    if (part !== undefined && /^\d{4}$/.test(part)) {
+        const yearValue = Number(part);
+        if (yearValue >= 1900 && yearValue <= 2099 && rest.length === 0) {
+            result.part = undefined;
+            result.date = new PubidDate({ year: part });
+        }
+    }
+    return result;
+}
+function parseDate(tree) {
+    if (tree === undefined || !isObj(tree))
+        return undefined;
+    const flat = flatten(tree);
+    const year = s(flat["year"]);
+    if (year === undefined)
+        return undefined;
+    return new PubidDate({
+        year,
+        month: s(flat["month"]),
+        day: s(flat["day"]),
+    });
+}
+function parseEdition(raw) {
+    const text = s(raw);
+    if (text === undefined)
+        return undefined;
+    const number = /\d+/.exec(text)?.[0];
+    return new IsoEdition({ ...(number !== undefined ? { number } : {}), original_text: text });
+}
+function typeStateFromToken(token, fallbackTypeKey) {
+    const abbr = s(token);
+    if (abbr === undefined)
+        return undefined;
+    const entry = locateStage(abbr);
+    if (entry === undefined)
+        return undefined;
+    return { entry, originalAbbr: abbr };
+}
+class IsoBuilder {
+    build(data) {
+        const tree = flatten(data);
+        if (tree["joint_identifier"] !== undefined) {
+            // No corpus rows carry an IDF twin; fail rather than guess.
+            throw new ParseFailed("ISO: joint IDF identifiers are not ported", 0);
+        }
+        if (tree["supplements"] !== undefined)
+            return this.buildBundled(tree);
+        if (tree["tc_type"] !== undefined)
+            return this.buildTc(tree);
+        return this.buildStandard(tree);
+    }
+    publisherOf(tree) {
+        const primary = s(tree["publisher"]);
+        const copubTree = tree["copublishers"];
+        const copublishers = [];
+        if (Array.isArray(copubTree)) {
+            for (const entry of copubTree) {
+                if (isObj(entry)) {
+                    const cp = s(entry["copublisher"]);
+                    if (cp !== undefined)
+                        copublishers.push(cp);
+                }
+            }
+        }
+        else if (copubTree !== undefined) {
+            const cp = s(flatten(copubTree)["copublisher"]);
+            if (cp !== undefined)
+                copublishers.push(cp);
+        }
+        if (primary === undefined && copublishers.length === 0)
+            return undefined;
+        return new IsoPublisher({ publisher: primary ?? "ISO", copublisher: copublishers });
+    }
+    baseAttrs(tree) {
+        const attrs = {};
+        const numberWithPart = tree["number_with_part"] !== undefined ? flatten(tree["number_with_part"]) : {};
+        const rawNumber = s(numberWithPart["number"]) ?? s(tree["number"]);
+        const parsed = parseNumberWithPart(s(tree["number_with_part"]) ?? s(tree["number"]));
+        if (parsed.number !== undefined || rawNumber !== undefined) {
+            if (parsed.number !== undefined)
+                attrs["number"] = parsed.number;
+            if (parsed.part !== undefined)
+                attrs["part"] = parsed.part;
+            if (parsed.subpart !== undefined)
+                attrs["subpart"] = parsed.subpart;
+            if (parsed.date !== undefined)
+                attrs["date"] = parsed.date;
+        }
+        const date = parseDate(tree["date"]) ?? parseDate(tree["base"] !== undefined ? undefined : undefined);
+        if (tree["date"] !== undefined) {
+            if (isObj(tree["date"])) {
+                const flat = flatten(tree["date"]);
+                const year = s(flat["year"]);
+                if (year !== undefined) {
+                    attrs["date"] = new PubidDate({ year, month: s(flat["month"]), day: s(flat["day"]) });
+                }
+            }
+            else {
+                const dateStr = s(tree["date"]);
+                if (dateStr !== undefined) {
+                    const [year, month, day] = dateStr.split("-");
+                    if (year !== undefined && year !== "") {
+                        attrs["date"] = new PubidDate({ year, month, day });
+                    }
+                }
+            }
+        }
+        if (tree["undated_marker"] !== undefined) {
+            attrs["date"] = new PubidDate({ undated: true });
+        }
+        const edition = parseEdition(tree["edition"]);
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+        const languages = parseLanguages(tree["languages"]);
+        if (languages.length > 0)
+            attrs["languages"] = languages;
+        if (tree["all_parts"] !== undefined)
+            attrs["all_parts"] = true;
+        if (tree["stage_iteration"] !== undefined) {
+            attrs["stage_iteration"] = new Iteration({ string: s(tree["stage_iteration"]) });
+        }
+        return attrs;
+    }
+    buildStandard(treeIn) {
+        const tree = { ...treeIn };
+        // Legacy ISO/R: publisher ISO + type "R".
+        if (tree["iso_r_prefix"] !== undefined) {
+            tree["publisher"] = "ISO";
+            tree["type_with_stage"] = "R";
+        }
+        // NSB stage prefixes map onto typed stages.
+        if (tree["nsb_stage"] !== undefined) {
+            tree["type_with_stage"] = s(tree["nsb_stage"]) === "Fpr" ? "PRF" : "WD";
+        }
+        // French Guide/GUIDE prefix.
+        if (tree["type_with_stage_fr"] !== undefined) {
+            tree["type_with_stage"] = s(tree["type_with_stage_fr"]);
+        }
+        // Directive supplement without its own SUP keyword.
+        if (tree["type_with_stage"] === undefined && tree["base"] !== undefined && isObj(tree["base"])) {
+            const baseTree = flatten(tree["base"]);
+            const dirTokens = new Set(["DIR", "Directives Part", "Directives, Part", "Directives,", "Directives"]);
+            if (dirTokens.has(s(baseTree["type_with_stage"]) ?? "")) {
+                tree["type_with_stage"] = "SUP";
+            }
+        }
+        const state = typeStateFromToken(s(tree["type_with_stage"]), "is");
+        const typeKey = state?.entry.typeCode ?? "is";
+        if (typeKey === "dir-sup")
+            return this.buildDirectivesSupplement(tree, state);
+        if (typeKey === "dir")
+            return this.buildDirectives(tree, state ?? { entry: locateStage("DIR"), originalAbbr: "DIR" });
+        const klass = isoClassForType(typeKey);
+        if (klass === undefined) {
+            throw new ParseFailed(`ISO: unknown type key ${typeKey}`, 0);
+        }
+        const attrs = this.baseAttrs(tree);
+        const publisher = this.publisherOf(tree);
+        if (publisher !== undefined)
+            attrs["publisher"] = publisher;
+        if (state !== undefined)
+            attrs["typedStageState"] = state;
+        if ((tree["base"] !== undefined || klass.prototype instanceof IsoSupplementIdentifier) && tree["base"] !== undefined) {
+            attrs["base"] = this.build(tree["base"]);
+        }
+        const identifier = new klass(attrs);
+        return identifier;
+    }
+    buildDirectives(tree, state) {
+        const attrs = this.baseAttrs(tree);
+        const publisher = this.publisherOf(tree);
+        if (publisher !== undefined)
+            attrs["publisher"] = publisher;
+        attrs["typedStageState"] = state;
+        if (tree["subgroup"] !== undefined)
+            attrs["subgroup"] = s(tree["subgroup"]);
+        return new IsoDirectives(attrs);
+    }
+    buildDirectivesSupplement(tree, state) {
+        const attrs = this.baseAttrs(tree);
+        attrs["typedStageState"] = state;
+        if (tree["publisher"] !== undefined)
+            attrs["supplement_publisher"] = s(tree["publisher"]);
+        if (tree["base"] !== undefined)
+            attrs["base"] = this.build(tree["base"]);
+        return new IsoDirectivesSupplement(attrs);
+    }
+    buildTc(tree) {
+        const attrs = {};
+        const publisher = this.publisherOf(tree);
+        if (publisher !== undefined)
+            attrs["publisher"] = publisher;
+        for (const key of ["tc_type", "tc_number", "sc_type", "sc_number", "wg_type", "wg_number", "number"]) {
+            const value = s(tree[key]);
+            if (value !== undefined)
+                attrs[key] = value;
+        }
+        if (tree["year"] !== undefined) {
+            attrs["date"] = new PubidDate({ year: s(tree["year"]) });
+        }
+        return new IsoTcDocument(attrs);
+    }
+    buildBundled(tree) {
+        const baseDocument = this.build(tree["base_document"]);
+        const supplements = Array.isArray(tree["supplements"])
+            ? tree["supplements"].map((entry) => this.build(flatten(entry)["supplement"]))
+            : [];
+        return new IsoBundledIdentifier({ base_document: baseDocument, supplements });
+    }
+}
+// --- Entry points ----------------------------------------------------------------
+function parseHuman(input) {
+    const dad = DAD_PATTERN.exec(input);
+    if (dad !== null) {
+        // "ISO 2631/DAD 1[:1987]" — parsed manually; the grammar treats "/"
+        // as a copublisher separator.
+        const base = parseHuman(dad[1]);
+        const builder = new IsoBuilder();
+        const attrs = {
+            base,
+            number: dad[3],
+            typedStageState: { entry: locateStage(dad[2]), originalAbbr: dad[2] },
+        };
+        if (dad[4] !== undefined)
+            attrs["date"] = new PubidDate({ year: dad[4] });
+        const klass = isoClassForType("add");
+        return new klass(attrs);
+    }
+    const normalized = normalizeCyrillic(applyUpdateCodes(input));
+    const tree = parseGrammar(isoGrammar, normalized);
+    if (typeof tree !== "object" || tree === null) {
+        throw new ParseFailed("ISO: unexpected parse tree", 0);
+    }
+    return new IsoBuilder().build(tree);
+}
+export function isoGrammarImplementation() {
+    return {
+        parse(input) {
+            return parseHuman(input);
+        },
+    };
+}