@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/bsi/index.js

@@ -0,0 +1,941 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { grammarImplementation } from "../index.js";
+import { bsiGrammar, preprocessBsi } from "./grammar.js";
+import { PubidDate, Publisher } from "../../model/component.js";
+import { AdoptedEuropeanNormClass as CenAdoptedEuropeanNormClass } from "../cen_cenelec/model.js";
+import { AddendumDocumentClass, AdoptedEuropeanNormClass, AdoptedInternationalStandardClass, AerospaceStandardClass, Amendment, BsiCode, BsiIdentifier, BundledIdentifierClass, BritishStandardClass, CommitteeDocumentClass, ConsolidatedIdentifierClass, Corrigendum, DetailedSpecificationClass, DiscClass, ExpertCommentaryClass, ExplanatorySupplementClass, FlexClass, IndexClass, MethodClass, NationalAnnexClass, SectionClass, SetClass, StandaloneAmendmentClass, SupplementDocumentClass, SupplementaryIndexClass, TestMethodClass, ValueAddedPublicationClass, locateStage, DEFAULT_TYPED_STAGE, TYPE_CLASSES, } from "./model.js";
+/**
+ * Port of lib/pubid/bsi/builder.rb — dispatch, attribute extraction,
+ * the specialized build paths, the adopted-identifier routing, and the
+ * supplement/consolidated wrapping.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+// Parse-tree numbers arrive as {number: "1000"} (the rule's own .as).
+const numv = (v) => {
+    if (isObj(v))
+        return strv(v["number"]);
+    return strv(v);
+};
+const strv = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return undefined;
+        const joined = v.flat(Infinity).map(String).join("");
+        return joined.length > 0 ? joined : undefined;
+    }
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+const ctor = (klass) => klass;
+function pub(body) {
+    return new Publisher({ body });
+}
+// The adopted routing mirrors the gem: a routed branch that fails to
+// parse RAISES through (build_adopted_identifier calls the foreign
+// parser directly), which is what rejects e.g. "BS HD 629.1 S3:2019".
+function tryForeign(flavor, raw) {
+    const impl = grammarImplementation(flavor);
+    if (impl === undefined)
+        return undefined;
+    return impl.parse(raw);
+}
+function extractSupplementsFromArray(supps) {
+    return supps.map((s) => {
+        const supp = isObj(s) && s["supplement"] !== undefined ? s["supplement"] : (isObj(s) ? s : {});
+        const separator = supp["amd_sep_slash"] !== undefined ? "/" : "+";
+        return {
+            type: supp["amd_number"] !== undefined ? "amendment" : "corrigendum",
+            number: strv(supp["amd_number"] ?? supp["cor_number"]),
+            year: strv(supp["amd_year"] ?? supp["cor_year"]),
+            separator,
+            amd_suffix_form: supp["amd_sep_plus"] === undefined && supp["amd_sep_slash"] === undefined,
+        };
+    });
+}
+function extractSupplements(data) {
+    const raw = data["supplements"];
+    if (raw === undefined)
+        return [];
+    const arr = (Array.isArray(raw) ? raw.flat(Infinity) : [raw])
+        .filter((x) => isObj(x) || (Array.isArray(x) && x.length > 0));
+    if (arr.length === 0)
+        return [];
+    return extractSupplementsFromArray(arr);
+}
+function expandYear(yearVal) {
+    if (yearVal === undefined)
+        return undefined;
+    if (yearVal.length === 2)
+        return String(2000 + Number(yearVal));
+    return yearVal;
+}
+function wrapWithConsolidated(base, supplementsData) {
+    const supplementIds = supplementsData.map((supp) => {
+        const yearVal = expandYear(supp.year);
+        if (supp.type === "amendment") {
+            return new Amendment({
+                base,
+                number: supp.number,
+                year: yearVal,
+                separator: supp.separator,
+                amd_suffix_form: supp.amd_suffix_form ? true : false,
+            });
+        }
+        return new Corrigendum({
+            base,
+            number: supp.number,
+            year: yearVal,
+            separator: supp.separator,
+        });
+    });
+    const wrapper = new (ctor(ConsolidatedIdentifierClass))({
+        identifiers: [base, ...supplementIds],
+    });
+    // The gem serializes the FIRST member's typed stage onto the
+    // consolidated wrapper itself.
+    wrapper["typedStage"] =
+        base["typedStage"];
+    return wrapper;
+}
+function wrapWithExpertCommentary(baseId, original) {
+    // The grammar nests the topic/full flags under an "expert_commentary"
+    // subtree.
+    const ec = isObj(original["expert_commentary"]) ? original["expert_commentary"] : {};
+    const flags = { ...ec, ...original };
+    let format = "abbr";
+    if (flags["expert_commentary_full"] !== undefined)
+        format = "full";
+    else if (flags["expert_commentary_topic"] !== undefined)
+        format = "abbr_with_topic";
+    const topic = strv(flags["expert_commentary_topic"]);
+    return new (ctor(ExpertCommentaryClass))({ base: baseId, format, topic });
+}
+// --- Attribute extraction ------------------------------------------------------------
+function partsToAttrs(partsVal) {
+    const arr = Array.isArray(partsVal) ? partsVal.flat(Infinity) : partsVal !== undefined ? [partsVal] : [];
+    if (arr.length === 0)
+        return {};
+    const first = isObj(arr[0]) ? arr[0] : undefined;
+    if (first === undefined)
+        return {};
+    const partStr = strv(first["part"]) ?? "";
+    if (first["subpart"] !== undefined) {
+        return { part: partStr, subpart: strv(first["subpart"]) };
+    }
+    const components = partStr.split("-");
+    if (components.length > 1) {
+        return { part: components[0], subpart: components[1] };
+    }
+    return { part: partStr };
+}
+function locateKlass(parsedHash) {
+    if (parsedHash["flex_type"] !== undefined)
+        return FlexClass;
+    if (parsedHash["na_prefix"] !== undefined)
+        return NationalAnnexClass;
+    if (parsedHash["prefix"] !== undefined)
+        return AerospaceStandardClass;
+    const adopted = strv(parsedHash["adopted_string"]);
+    if (adopted !== undefined && /^EN\s+\d/.test(adopted))
+        return AdoptedEuropeanNormClass;
+    if (adopted !== undefined)
+        return AdoptedInternationalStandardClass;
+    const typeStr = strv(parsedHash["type"]) ?? strv(parsedHash["stage"]) ?? "";
+    // Unknown abbreviations fall back to the DEFAULT_TYPED_STAGE (a
+    // published British Standard).
+    const stage = locateStage(typeStr.toUpperCase()) ?? DEFAULT_TYPED_STAGE;
+    return TYPE_CLASSES[stage.typeCode] ?? BritishStandardClass;
+}
+/** The registry entry the parse selected (stashed on the instance;
+ * the wire serializes it for non-default typed stages). */
+function selectedStage(parsedHash) {
+    const typeStr = strv(parsedHash["type"]) ?? strv(parsedHash["stage"]) ?? "";
+    return locateStage(typeStr.toUpperCase()) ?? DEFAULT_TYPED_STAGE;
+}
+function assignAttributes(data) {
+    const attrs = {};
+    if (data["publisher"] !== undefined)
+        attrs["publisher"] = pub(strv(data["publisher"]) ?? "BS");
+    if (data["prefix"] !== undefined)
+        attrs["prefix"] = strv(data["prefix"]);
+    if (data["flex_prefix"] !== undefined)
+        attrs["flex_prefix"] = strv(data["flex_prefix"]);
+    if (data["number"] !== undefined)
+        attrs["number"] = strv(data["number"]);
+    if (data["iteration"] !== undefined) {
+        const iterationObj = isObj(data["iteration"]) ? data["iteration"] : undefined;
+        const iterationVal = iterationObj !== undefined ? strv(iterationObj["iteration"]) : strv(data["iteration"]);
+        if (iterationVal !== undefined && iterationVal !== "")
+            attrs["iteration"] = iterationVal;
+    }
+    const partsAttr = partsToAttrs(data["parts"]);
+    if (partsAttr.part !== undefined)
+        attrs["part"] = partsAttr.part;
+    if (partsAttr.subpart !== undefined)
+        attrs["subpart"] = partsAttr.subpart;
+    if (data["year"] !== undefined) {
+        attrs["date"] = new PubidDate({ year: String(Number(strv(data["year"]))) });
+    }
+    if (data["month"] !== undefined)
+        attrs["month"] = Number(strv(data["month"]));
+    if (data["edition"] !== undefined)
+        attrs["edition"] = strv(data["edition"]);
+    if (data["second_number"] !== undefined) {
+        attrs["second_number"] = new BsiCode({ value: strv(data["second_number"]) ?? "" });
+    }
+    if (data["translation_lang"] !== undefined) {
+        const lang = strv(data["translation_lang"]) ?? "";
+        attrs["translation_lang"] = lang.charAt(0).toUpperCase() + lang.slice(1).toLowerCase();
+    }
+    if (data["translation_upper"] !== undefined) {
+        const lang = strv(data["translation_upper"]) ?? "";
+        attrs["translation_upper"] = lang.charAt(0).toUpperCase() + lang.slice(1).toLowerCase();
+    }
+    return attrs;
+}
+// --- The builder ---------------------------------------------------------------------
+export function buildBsiIdentifier(tree) {
+    return buildTree(flatten(tree));
+}
+function buildTree(data) {
+    const original = { ...data };
+    if (data["standalone_amendment"] !== undefined || data["parenthesized_amd"] !== undefined) {
+        return buildStandaloneAmendment(data);
+    }
+    if (data["committee_document"] !== undefined) {
+        return buildCommitteeDocument(flatten(data["committee_document"]));
+    }
+    if (data["index_identifier"] !== undefined) {
+        return buildIndex(flatten(data["index_identifier"]));
+    }
+    if (data["supplementary_index_identifier"] !== undefined) {
+        return buildSupplementaryIndex(flatten(data["supplementary_index_identifier"]));
+    }
+    if (data["explanatory_supplement_identifier"] !== undefined) {
+        return buildExplanatorySupplement(flatten(data["explanatory_supplement_identifier"]));
+    }
+    if (data["method_identifier"] !== undefined) {
+        return buildMethod(flatten(data["method_identifier"]));
+    }
+    if (data["test_method_identifier"] !== undefined) {
+        return buildTestMethod(flatten(data["test_method_identifier"]));
+    }
+    if (data["section_identifier"] !== undefined) {
+        return buildSection(flatten(data["section_identifier"]));
+    }
+    if (data["detailed_specification"] !== undefined) {
+        return buildDetailedSpecification(flatten(data["detailed_specification"]));
+    }
+    if (data["disc_identifier"] !== undefined) {
+        return buildDisc(flatten(data["disc_identifier"]));
+    }
+    if (data["aerospace_identifier"] !== undefined) {
+        return buildAerospaceIdentifier(flatten(data["aerospace_identifier"]));
+    }
+    if (data["supplement_document"] !== undefined) {
+        return buildSupplementDocument(flatten(data["supplement_document"]));
+    }
+    if (data["addendum_document"] !== undefined) {
+        return buildAddendumDocument(flatten(data["addendum_document"]));
+    }
+    if (data["bundled_parts"] !== undefined || data["bundled_list"] !== undefined) {
+        return buildBundledIdentifier(data);
+    }
+    if (data["set"] !== undefined) {
+        return buildSetData(data["set"]);
+    }
+    const supplementsData = extractSupplements(data);
+    if (data["pdf_format"] !== undefined || data["tc_format"] !== undefined || data["book_format"] !== undefined) {
+        return buildValueAddedPublication(data, supplementsData);
+    }
+    if (data["na_prefix"] !== undefined) {
+        return buildNationalAnnex(data, supplementsData);
+    }
+    if (data["adopted_string"] !== undefined) {
+        const adopted = buildAdoptedIdentifier(data, original);
+        if (adopted !== undefined)
+            return adopted;
+    }
+    const stageEntry = selectedStage(data);
+    let identifier = new (ctor(locateKlass(data)))(assignAttributes(data));
+    identifier["typedStage"] = stageEntry;
+    void identifier;
+    if (supplementsData.length > 0) {
+        identifier = wrapWithConsolidated(identifier, supplementsData);
+    }
+    if (data["expert_commentary"] !== undefined || data["expert_commentary_full"] !== undefined) {
+        identifier = wrapWithExpertCommentary(identifier, original);
+    }
+    return identifier;
+}
+// --- Specialized builders ------------------------------------------------------------
+function yearDate(v) {
+    const s = strv(v);
+    if (s === undefined)
+        return undefined;
+    return new PubidDate({ year: String(Number(s)) });
+}
+function buildIndex(data) {
+    const attrs = {
+        number: strv(data["number"]),
+    };
+    const suffix = isObj(data["index_suffix"]) ? data["index_suffix"] : {};
+    let format = "space";
+    let issueNumber;
+    if (suffix["colon_sep"] !== undefined)
+        format = "colon";
+    else if (suffix["issue_number"] !== undefined)
+        issueNumber = strv(suffix["issue_number"]);
+    attrs["issue_number"] = issueNumber;
+    attrs["index_format"] = format;
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(IndexClass))(attrs);
+}
+function buildSupplementaryIndex(data) {
+    const attrs = { number: strv(data["number"]) };
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(SupplementaryIndexClass))(attrs);
+}
+function buildExplanatorySupplement(data) {
+    const attrs = { number: strv(data["number"]) };
+    const parts = partsToAttrs(data["parts"]);
+    if (parts.part !== undefined)
+        attrs["part"] = parts.part;
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(ExplanatorySupplementClass))(attrs);
+}
+function buildMethod(data) {
+    const suffix = isObj(data["method_suffix"]) ? data["method_suffix"] : {};
+    const methodTo = strv(suffix["method_to"]);
+    const methodAnd = strv(suffix["method_and"]);
+    const attrs = {
+        number: strv(data["number"]),
+        method_code: strv(suffix["method_code"]),
+        method_to: methodTo,
+        method_and: methodAnd,
+        is_plural: methodTo !== undefined || methodAnd !== undefined,
+    };
+    const parts = partsToAttrs(data["parts"]);
+    if (parts.part !== undefined)
+        attrs["part"] = parts.part;
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(MethodClass))(attrs);
+}
+function buildTestMethod(data) {
+    const suffix = isObj(data["test_method_suffix"]) ? data["test_method_suffix"] : {};
+    const attrs = {
+        number: strv(data["number"]),
+        test_series: strv(suffix["test_series"]),
+        test_id: strv(suffix["test_id"]),
+    };
+    if (data["publisher"] !== undefined)
+        attrs["publisher"] = pub(strv(data["publisher"]) ?? "BS");
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(TestMethodClass))(attrs);
+}
+function buildSection(data) {
+    const suffix = isObj(data["section_suffix"]) ? data["section_suffix"] : {};
+    const publisherVal = strv(data["publisher"]) ?? strv(data["type"]);
+    const attrs = {
+        number: strv(data["number"]),
+        section_id: strv(suffix["section_id"]),
+        section_format: suffix["colon_sep"] !== undefined ? "colon" : "space",
+    };
+    if (publisherVal !== undefined)
+        attrs["publisher"] = pub(publisherVal);
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(SectionClass))(attrs);
+}
+function buildDetailedSpecification(data) {
+    const suffix = isObj(data["detailed_spec_suffix"]) ? data["detailed_spec_suffix"] : {};
+    const attrs = { number: strv(data["number"]) };
+    const specCode = strv(suffix["spec_code"]);
+    if (specCode !== undefined)
+        attrs["spec_code"] = new BsiCode({ value: specCode });
+    if (data["publisher"] !== undefined)
+        attrs["publisher"] = pub(strv(data["publisher"]) ?? "BS");
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(DetailedSpecificationClass))(attrs);
+}
+function buildDisc(data) {
+    const attrs = { number: strv(data["number"]) };
+    const parts = partsToAttrs(data["parts"]);
+    if (parts.part !== undefined)
+        attrs["part"] = parts.part;
+    attrs["publisher"] = pub("DISC");
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(DiscClass))(attrs);
+}
+function buildAerospaceIdentifier(data) {
+    const prefixRaw = data["prefix"];
+    const prefixVal = isObj(prefixRaw) ? strv(prefixRaw["prefix"]) : strv(prefixRaw);
+    const attrs = {
+        prefix: prefixVal,
+        number: numv(data["number"]),
+        publisher: pub("BS"),
+    };
+    // The part captures land flat at the aerospace_identifier level when
+    // the engine flattens embedded subrule labels (data[:part], with an
+    // optional sibling letter_edition).
+    if (data["part"] !== undefined) {
+        const partDirect = isObj(data["part"])
+            ? strv(data["part"]["part"])
+            : strv(data["part"]);
+        if (partDirect !== undefined)
+            attrs["part"] = partDirect;
+        const partLetter = isObj(data["part"])
+            ? strv(data["part"]["letter_edition"])
+            : undefined;
+        if (partLetter === undefined && data["letter_edition"] !== undefined) {
+            attrs["edition"] = isObj(data["letter_edition"])
+                ? strv(data["letter_edition"]["letter_edition"])
+                : strv(data["letter_edition"]);
+        }
+        if (partLetter !== undefined)
+            attrs["edition"] = partLetter;
+    }
+    const letterEditionPart = isObj(data["part_with_letter_edition"])
+        ? data["part_with_letter_edition"]
+        : undefined;
+    if (letterEditionPart !== undefined) {
+        const partVal = strv(letterEditionPart["part"]);
+        if (partVal !== undefined)
+            attrs["part"] = partVal;
+        const letterEdition = strv(letterEditionPart["letter_edition"]);
+        if (letterEdition !== undefined)
+            attrs["edition"] = letterEdition;
+    }
+    else {
+        const parts = partsToAttrs(data["parts"]);
+        if (parts.part !== undefined)
+            attrs["part"] = parts.part;
+        if (parts.subpart !== undefined)
+            attrs["subpart"] = parts.subpart;
+    }
+    if (attrs["edition"] === undefined && data["letter_edition"] !== undefined) {
+        const editionVal = isObj(data["letter_edition"])
+            ? strv(data["letter_edition"]["letter_edition"])
+            : strv(data["letter_edition"]);
+        if (editionVal !== undefined)
+            attrs["edition"] = editionVal;
+    }
+    const date = yearDate(data["year"]);
+    if (date !== undefined)
+        attrs["date"] = date;
+    return new (ctor(AerospaceStandardClass))(attrs);
+}
+function buildStandaloneAmendment(data) {
+    const amdRaw = data["standalone_amendment"] ?? data["parenthesized_amd"];
+    const amdData = flatten(amdRaw);
+    return new (ctor(StandaloneAmendmentClass))({
+        number: strv(amdData["amendment_number"]),
+        corrigendum: amdData["corrigendum"] !== undefined,
+        parenthesized: data["parenthesized_amd"] !== undefined,
+    });
+}
+function buildCommitteeDocument(data) {
+    const yearVal = strv(data["year"]);
+    const fullYear = yearVal !== undefined ? `20${yearVal}` : undefined;
+    const attrs = {
+        number: strv(data["document_number"]),
+    };
+    if (fullYear !== undefined)
+        attrs["date"] = new PubidDate({ year: String(Number(fullYear)) });
+    return new (ctor(CommitteeDocumentClass))(attrs);
+}
+function buildValueAddedPublication(data, _supplements) {
+    const format = data["pdf_format"] !== undefined
+        ? "PDF"
+        : data["tc_format"] !== undefined
+            ? "TC"
+            : data["book_format"] !== undefined
+                ? "BOOK"
+                : undefined;
+    const baseData = { ...data };
+    delete baseData["pdf_format"];
+    delete baseData["tc_format"];
+    delete baseData["book_format"];
+    const baseId = buildTree(baseData);
+    return new (ctor(ValueAddedPublicationClass))({
+        base: baseId,
+        format,
+    });
+}
+function buildNationalAnnex(data, _supplements) {
+    const baseData = { ...data };
+    delete baseData["na_prefix"];
+    delete baseData["na_supplements"];
+    const baseId = buildTree(baseData);
+    const naPrefix = isObj(data["na_prefix"]) ? data["na_prefix"] : undefined;
+    const naSuppRaw = naPrefix !== undefined && naPrefix["na_supplements"] !== undefined
+        ? naPrefix["na_supplements"]
+        : data["na_supplements"];
+    const naSuppData = naSuppRaw !== undefined
+        ? extractSupplementsFromArray(Array.isArray(naSuppRaw) ? naSuppRaw.flat(Infinity) : [naSuppRaw])
+        : [];
+    const naSupps = naSuppData.map((supp) => {
+        const yearVal = expandYear(supp.year);
+        if (supp.type === "amendment") {
+            return new Amendment({
+                number: supp.number,
+                year: yearVal,
+                separator: supp.separator,
+            });
+        }
+        return new Corrigendum({
+            number: supp.number,
+            year: yearVal,
+            separator: supp.separator,
+        });
+    });
+    return new (ctor(NationalAnnexClass))({
+        na_supplements: naSupps,
+        base: baseId,
+    });
+}
+function iterationOf(v) {
+    if (v === undefined)
+        return undefined;
+    const flat = (Array.isArray(v) ? v.flat(Infinity) : [v]);
+    for (const item of flat) {
+        if (isObj(item)) {
+            const raw = item["iteration"];
+            const inner = Array.isArray(raw)
+                ? iterationOf(raw)
+                : strv(raw);
+            if (inner !== undefined && inner !== "")
+                return inner;
+        }
+    }
+    return undefined;
+}
+function buildSupplementDocument(data) {
+    const publisherVal = strv(data["publisher"]);
+    // The grammar nests the parts under a "parts" key inside the parts
+    // subtree; unwrap before extracting part/subpart.
+    const suppPartsRaw = data["parts"];
+    const suppPartsVal = isObj(suppPartsRaw) && suppPartsRaw["parts"] !== undefined
+        ? suppPartsRaw["parts"]
+        : suppPartsRaw;
+    const baseData = {
+        ...(publisherVal !== undefined ? { publisher: publisherVal } : {}),
+        number: numv(data["number"]),
+        ...(iterationOf(data["iteration"]) !== undefined ? { iteration: iterationOf(data["iteration"]) } : {}),
+        ...(suppPartsVal !== undefined ? { parts: suppPartsVal } : {}),
+        ...(data["flex_prefix"] !== undefined ? { flex_prefix: strv(data["flex_prefix"]) } : {}),
+    };
+    const reverseFormat = data["supplement_number"] !== undefined
+        && data["supplement_year"] !== undefined
+        && data["publisher"] !== undefined
+        && data["number"] !== undefined
+        && data["base_year"] !== undefined;
+    if (reverseFormat) {
+        baseData["year"] = data["base_year"];
+    }
+    else if (data["year"] !== undefined) {
+        baseData["year"] = data["year"];
+    }
+    const baseId = buildTree(baseData);
+    const suppType = strv(data["supp_no_prefix"]) === "No."
+        ? "No."
+        : strv(data["supp_no_prefix"]) !== undefined
+            ? strv(data["supp_no_prefix"])
+            : "";
+    return new (ctor(SupplementDocumentClass))({
+        base: baseId,
+        supplement_number: strv(data["supplement_number"]),
+        supplement_year: data["supplement_year"] !== undefined ? Number(strv(data["supplement_year"])) : undefined,
+        supplement_type: suppType,
+        reverse_format: reverseFormat,
+        separator: strv(data["supp_sep"]) ?? ":",
+    });
+}
+function buildAddendumDocument(data) {
+    const publisherVal = strv(data["publisher"]);
+    // The grammar nests the parts under a "parts" key inside the
+    // "parts" subtree; unwrap before extracting part/subpart.
+    const partsRaw = data["parts"];
+    const partsVal = isObj(partsRaw) && partsRaw["parts"] !== undefined
+        ? partsRaw["parts"]
+        : partsRaw;
+    const baseData = {
+        ...(publisherVal !== undefined ? { publisher: publisherVal } : {}),
+        number: numv(data["number"]),
+        ...(iterationOf(data["iteration"]) !== undefined ? { iteration: iterationOf(data["iteration"]) } : {}),
+        ...(partsVal !== undefined ? { parts: partsVal } : {}),
+        ...(data["flex_prefix"] !== undefined ? { flex_prefix: strv(data["flex_prefix"]) } : {}),
+    };
+    if (data["base_year"] !== undefined)
+        baseData["year"] = data["base_year"];
+    const baseId = buildTree(baseData);
+    const addType = strv(data["add_no_prefix"]) === "No."
+        ? "No."
+        : strv(data["add_no_prefix"]) !== undefined
+            ? strv(data["add_no_prefix"])
+            : "";
+    // strv() trims, so a captured space separator must be read raw.
+    const sepRaw = data["add_sep"];
+    const separator = sepRaw === " " ? " " : strv(sepRaw) ?? ":";
+    return new (ctor(AddendumDocumentClass))({
+        base: baseId,
+        addendum_number: strv(data["addendum_number"]),
+        addendum_year: data["addendum_year"] !== undefined ? Number(strv(data["addendum_year"])) : undefined,
+        addendum_type: addType,
+        separator,
+    });
+}
+function buildBundleItem(itemData, defaultPublisher, defaultPrefix) {
+    if (isObj(itemData)) {
+        const d = itemData;
+        const hasExplicitPublisher = d["publisher"] !== undefined;
+        const hasExplicitPrefix = d["prefix"] !== undefined;
+        const publisherVal = strv(d["publisher"]) ?? defaultPublisher;
+        const prefixVal = strv(d["prefix"]) ?? defaultPrefix;
+        const id = new BsiIdentifier({
+            ...(publisherVal !== undefined ? { publisher: pub(publisherVal) } : {}),
+            ...(prefixVal !== undefined && prefixVal !== "" ? { prefix: prefixVal } : {}),
+            ...(strv(d["number"]) !== undefined ? { number: strv(d["number"]) } : {}),
+        });
+        const self = id;
+        self["explicit_prefix"] = hasExplicitPublisher || hasExplicitPrefix;
+        self["explicit_publisher"] = hasExplicitPublisher;
+        const partsVal = d["parts"];
+        if (isObj(partsVal) && Array.isArray(partsVal["parts"])) {
+            const partsArray = partsVal["parts"];
+            const partStr = strv(partsArray[0]?.["part"]);
+            if (partStr !== undefined)
+                self["part"] = partStr;
+        }
+        else if (d["part"] !== undefined) {
+            self["part"] = strv(d["part"]);
+            self["space_separated_part"] = true;
+        }
+        return id;
+    }
+    // Simple string (alphanumeric like "N001")
+    return new BsiIdentifier({ number: strv(itemData) });
+}
+function buildBundledIdentifier(data) {
+    if (data["bundled_parts"] !== undefined) {
+        const partsData = flatten(data["bundled_parts"]);
+        const baseNumber = strv(partsData["number"]) ?? "";
+        const bundleType = strv(partsData["bundle_type"]) ?? "";
+        const part1 = strv(partsData["part1"]) ?? "";
+        const part2 = strv(partsData["part2"]) ?? "";
+        const yearVal = strv(partsData["year"]);
+        const baseId = new BsiIdentifier({ publisher: pub("BS"), number: baseNumber });
+        const id1 = new BsiIdentifier({ publisher: pub("BS"), number: baseNumber, part: part1 });
+        const id2 = new BsiIdentifier({ publisher: pub("BS"), number: baseNumber, part: part2 });
+        return new (ctor(BundledIdentifierClass))({
+            identifiers: [baseId, id1, id2],
+            bundle_type: bundleType,
+            common_year: yearVal !== undefined ? new PubidDate({ year: String(Number(yearVal)) }) : undefined,
+        });
+    }
+    const listArray = (Array.isArray(data["bundled_list"]) ? data["bundled_list"] : [data["bundled_list"]]);
+    const firstElem = flatten(listArray[0]);
+    const publisherVal = strv(firstElem["publisher"]) ?? "BS";
+    const prefixVal = strv(firstElem["prefix"]);
+    const items = [];
+    const separators = [];
+    if (firstElem["bundle_item"] !== undefined) {
+        items.push(buildBundleItem(firstElem["bundle_item"], publisherVal, prefixVal));
+    }
+    for (const rawElem of listArray.slice(1)) {
+        const elem = flatten(rawElem);
+        if (elem["year"] !== undefined)
+            continue;
+        if (elem["bundle_item"] !== undefined) {
+            let sep = " and ";
+            if (elem["sep_and"] !== undefined)
+                sep = " and ";
+            else if (elem["sep_to"] !== undefined) {
+                const toCase = strv(elem["sep_to"]?.["to_case"]);
+                sep = toCase === "TO" ? " TO " : " to ";
+            }
+            else if (elem["sep_ampersand"] !== undefined)
+                sep = " & ";
+            else if (elem["sep_semicolon"] !== undefined)
+                sep = "; ";
+            else if (elem["sep_comma"] !== undefined)
+                sep = ",";
+            separators.push(sep);
+            items.push(buildBundleItem(elem["bundle_item"], publisherVal, prefixVal));
+        }
+    }
+    const yearElem = listArray.map((e) => flatten(e)).find((e) => e["year"] !== undefined);
+    const yearVal = yearElem !== undefined ? strv(yearElem["year"]) : undefined;
+    return new (ctor(BundledIdentifierClass))({
+        identifiers: items,
+        separators,
+        common_year: yearVal !== undefined ? new PubidDate({ year: String(Number(yearVal)) }) : undefined,
+    });
+}
+function buildSetData(setRaw) {
+    const itemsArray = Array.isArray(setRaw) ? setRaw.flat(Infinity) : [setRaw];
+    const identifiers = [];
+    for (const item of itemsArray) {
+        const itemData = isObj(item) && item["set_item"] !== undefined
+            ? (flatten(item["set_item"]))
+            : (isObj(item) ? item : {});
+        let idStr = "";
+        if (itemData["publisher"] !== undefined)
+            idStr += `${strv(itemData["publisher"])} `;
+        if (itemData["adopted_org"] !== undefined)
+            idStr += `${strv(itemData["adopted_org"])} `;
+        const numberVal = isObj(itemData["number"])
+            ? strv(itemData["number"]["number"])
+            : strv(itemData["number"]);
+        if (numberVal !== undefined)
+            idStr += numberVal;
+        if (isObj(itemData["parts"])) {
+            const partsInner = itemData["parts"]["parts"];
+            if (Array.isArray(partsInner) && partsInner.length > 0) {
+                const partVal = strv(partsInner[0]["part"]);
+                if (partVal !== undefined)
+                    idStr += `-${partVal}`;
+            }
+        }
+        if (itemData["year"] !== undefined)
+            idStr += `:${strv(itemData["year"])}`;
+        if (idStr.trim() === "")
+            continue;
+        const parsed = parseBsi(idStr);
+        if (parsed !== undefined)
+            identifiers.push(parsed);
+    }
+    return new (ctor(SetClass))({
+        identifiers,
+        separators: Array.from({ length: Math.max(0, identifiers.length - 1) }, () => " + "),
+    });
+}
+// --- Adopted identifiers ---------------------------------------------------------------
+function buildAdoptedIdentifier(dataIn, originalIn) {
+    const data = dataIn;
+    const original = originalIn;
+    const adoptedRaw = data["adopted_string"];
+    let adoptedStr = isObj(adoptedRaw)
+        ? strv(adoptedRaw["adopted_string"]) ?? strv(adoptedRaw["adopted_string_no_expert"])
+        : strv(adoptedRaw);
+    if (adoptedStr === undefined || adoptedStr === "")
+        return undefined;
+    adoptedStr = adoptedStr.trim();
+    const isBare = data["publisher"] === undefined && data["type"] === undefined
+        && data["na_prefix"] === undefined && data["flex_type"] === undefined && data["stage"] === undefined;
+    // Extract Expert Commentary suffixes (case-insensitive).
+    const setExComm = (topic) => {
+        data["expert_commentary_full"] = topic === undefined ? "Expert Commentary" : undefined;
+        if (topic === undefined && data["expert_commentary"] === undefined)
+            data["expert_commentary"] = true;
+        if (topic !== undefined) {
+            data["expert_commentary_topic"] = topic;
+            if (data["expert_commentary"] === undefined)
+                data["expert_commentary"] = true;
+        }
+        if (topic === undefined) {
+            original["expert_commentary_full"] = "Expert Commentary";
+            if (original["expert_commentary"] === undefined)
+                original["expert_commentary"] = true;
+        }
+        else {
+            original["expert_commentary_topic"] = topic;
+            if (original["expert_commentary"] === undefined)
+                original["expert_commentary"] = true;
+        }
+    };
+    if (/expert commentary$/i.test(adoptedStr)) {
+        adoptedStr = adoptedStr.replace(/expert commentary$/i, "");
+        setExComm();
+    }
+    else if (/excomm \($/i.test(adoptedStr)) {
+        adoptedStr = adoptedStr.replace(/excomm \(.*\)$/i, "");
+        setExComm();
+    }
+    else if (/excomm \(/i.test(adoptedStr)) {
+        const topicMatch = adoptedStr.match(/excomm\s*\(([^)]+)\)/i);
+        adoptedStr = adoptedStr.replace(/excomm\s*\(.*\)$/i, "");
+        setExComm(topicMatch?.[1]);
+    }
+    else if (/excomm\s*$/i.test(adoptedStr)) {
+        adoptedStr = adoptedStr.replace(/excomm\s*$/i, "");
+        if (data["expert_commentary"] === undefined)
+            data["expert_commentary"] = true;
+        if (original["expert_commentary"] === undefined)
+            original["expert_commentary"] = true;
+    }
+    // Extract translation suffixes.
+    const parenMatch = adoptedStr.match(/\s*\(([A-Za-z]+)(?:\s+(Translation|version))?\)\s*$/);
+    if (parenMatch !== null) {
+        data["translation_lang"] = parenMatch[1];
+        if (parenMatch[2] !== undefined)
+            data["translation_suffix_type"] = parenMatch[2];
+        adoptedStr = adoptedStr.replace(/\s*\([A-Za-z]+(?:\s+(?:Translation|version))?\)\s*$/, "");
+    }
+    else {
+        const upperMatch = adoptedStr.match(/\s+(SPANISH|FRENCH|GERMAN|ITALIAN)\s+TRANSLATION\s*$/);
+        if (upperMatch !== null) {
+            data["translation_upper"] = upperMatch[1];
+            data["translation_suffix_type"] = "Translation";
+            adoptedStr = adoptedStr.replace(/\s+(SPANISH|FRENCH|GERMAN|ITALIAN)\s+TRANSLATION\s*$/, "");
+        }
+    }
+    // Extract edition (only when NOT bare).
+    const editionMatch = isBare ? null : adoptedStr.match(/\s+ED(\d+)\s*$/);
+    const extractedEdition = editionMatch !== null ? editionMatch[1] : undefined;
+    if (editionMatch !== null) {
+        adoptedStr = adoptedStr.replace(/\s+ED\d+\s*$/, "");
+    }
+    const finalEdition = strv(data["edition"]) ?? extractedEdition;
+    // Extract reaffirmation "(R2004)".
+    const reaffirmationMatch = adoptedStr.match(/\s+\(R(\d{4})\)\s*$/);
+    if (reaffirmationMatch !== null) {
+        data["reaffirmation_year"] = reaffirmationMatch[1];
+        adoptedStr = adoptedStr.replace(/\s+\(R\d{4}\)\s*$/, "");
+    }
+    // Extract BSI-style supplements from the adopted string.
+    const extractedSupplements = [];
+    adoptedStr = adoptedStr.replace(/([+])(A(\d+)|AMD(\d+)|C(\d+)|COR(\d+))(?::(\d{4}))?(?:\s|$)/g, (match, sep, typeCode, _a, _amd, _c, _cor, year) => {
+        const suppType = typeCode.startsWith("A") ? "amendment" : "corrigendum";
+        const suppNumber = typeCode.startsWith("AMD")
+            ? typeCode.slice(3)
+            : typeCode.replace(/^[AC]/, "");
+        extractedSupplements.push({
+            type: suppType,
+            number: suppNumber,
+            year: year !== undefined ? year : undefined,
+            separator: sep,
+            amd_suffix_form: false,
+        });
+        return "";
+    }).trim();
+    adoptedStr = adoptedStr.replace(/\s+AMD\s*(AA|\d+)(?:\s|$)/gi, (match) => {
+        const amdNumber = match.trim().replace(/^AMD\s*/i, "");
+        extractedSupplements.push({
+            type: "amendment",
+            number: amdNumber,
+            year: undefined,
+            separator: undefined,
+            amd_suffix_form: true,
+        });
+        return "";
+    }).trim();
+    const bsiPrefix = strv(data["type"]) ?? strv(data["publisher"]) ?? "BS";
+    let adoptedId;
+    if (/^EN\s+(ISO\/IEC|IEC|ISO)/.test(adoptedStr)) {
+        const isoIecStr = adoptedStr.replace(/^EN\s+/, "");
+        let parsed;
+        if (isoIecStr.startsWith("ISO/IEC") || isoIecStr.includes("ISO/IEC")) {
+            parsed = tryForeign("iso", isoIecStr);
+        }
+        else if (isoIecStr.startsWith("ISO")) {
+            parsed = tryForeign("iso", isoIecStr);
+        }
+        else if (isoIecStr.startsWith("IEC")) {
+            parsed = tryForeign("iec", isoIecStr);
+        }
+        // Wrap the ISO/IEC identifier in a CEN EN adoption.
+        if (parsed !== undefined) {
+            adoptedId = new CenAdoptedEuropeanNormClass({
+                publisher: "EN",
+                adopted: parsed,
+            });
+        }
+        else {
+            adoptedId = tryForeign("cen_cenelec", adoptedStr);
+        }
+    }
+    else if (adoptedStr.startsWith("ISO/IEC") || adoptedStr.includes("ISO/IEC")) {
+        adoptedId = tryForeign("iso", adoptedStr);
+    }
+    else if (adoptedStr.startsWith("ISO")) {
+        adoptedId = tryForeign("iso", adoptedStr);
+    }
+    else if (adoptedStr.startsWith("IEC")) {
+        adoptedId = tryForeign("iec", adoptedStr);
+    }
+    else if (/^(EN|CEN|CLC|CR|ES|ENV|HD|CWA)/.test(adoptedStr)) {
+        adoptedId = tryForeign("cen_cenelec", adoptedStr);
+    }
+    else if (adoptedStr.startsWith("CISPR")) {
+        adoptedId = tryForeign("iec", adoptedStr);
+    }
+    if (isBare && adoptedId !== undefined)
+        return adoptedId;
+    if (adoptedId !== undefined) {
+        // AdoptedEuropeanNorm for CEN documents, else AdoptedInternational.
+        const adoptedWire = adoptedId.toHash();
+        const adoptedTypeStr = String(adoptedWire["_type"] ?? "");
+        const wrapperCtor = adoptedTypeStr.startsWith("pubid:cencenelec")
+            ? AdoptedEuropeanNormClass
+            : AdoptedInternationalStandardClass;
+        let identifier = new (ctor(wrapperCtor))({
+            publisher: pub(bsiPrefix),
+            base: adoptedId,
+            ...(finalEdition !== undefined ? { edition: finalEdition } : {}),
+            ...(strv(data["translation_lang"]) !== undefined ? { translation_lang: strv(data["translation_lang"]) } : {}),
+            ...(strv(data["translation_upper"]) !== undefined ? { translation_upper: strv(data["translation_upper"]) } : {}),
+            ...(strv(data["translation_suffix_type"]) !== undefined ? { translation_suffix_type: strv(data["translation_suffix_type"]) } : {}),
+            ...(strv(data["reaffirmation_year"]) !== undefined ? { reaffirmation_year: strv(data["reaffirmation_year"]) } : {}),
+        });
+        if (extractedSupplements.length > 0) {
+            identifier = wrapWithConsolidated(identifier, extractedSupplements);
+        }
+        if (data["expert_commentary"] !== undefined || data["expert_commentary_full"] !== undefined) {
+            identifier = wrapWithExpertCommentary(identifier, original);
+        }
+        return identifier;
+    }
+    return undefined;
+}
+// --- The parse entry -------------------------------------------------------------------
+function parseBsi(input) {
+    const cleaned = preprocessBsi(input);
+    try {
+        const tree = parseGrammar(bsiGrammar, cleaned);
+        return buildBsiIdentifier(tree);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function bsiGrammarImplementation() {
+    return {
+        parse(input) {
+            // Delegate to IEC for bare IEC identifiers with VAP suffixes or
+            // consolidated supplements (single_identifier.rb .parse).
+            if (/\bIEC\b/.test(input)
+                && (/\s+(CSV|CMV|RLV|SER|EXV|PAC|PRV)\b/.test(input)
+                    || /\+AMD\d+:/.test(input)
+                    || /\+COR\d+:/.test(input))) {
+                const iec = grammarImplementation("iec");
+                return iec.parse(input);
+            }
+            const parsed = parseBsi(input);
+            if (parsed === undefined) {
+                throw new Error("Failed to parse BSI identifier");
+            }
+            return parsed;
+        },
+    };
+}