@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/ashrae/model.js

@@ -0,0 +1,335 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { PubidDate } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/ashrae: the two single-document leaves (Standard,
+ * Guideline), the five supplement types (Addendum, CombinedAddenda,
+ * AddendaPackage, Errata, Interpretation), the renderer and the URN
+ * generator.
+ */
+const MONTH_NAMES = [
+    "January", "February", "March", "April", "May", "June", "July",
+    "August", "September", "October", "November", "December",
+];
+// The document number lives on the two leaves only (never on the
+// shared base, mirroring the gem's deliberate leaf-only declaration);
+// the renderer and URN reach it through this accessor or #root.
+function numberOf(id) {
+    return id.number;
+}
+// Addendum/CombinedAddenda/AddendaPackage override #copublisher to
+// delegate to base (Errata/Interpretation do not).
+function copublisherOf(id) {
+    if (id instanceof Addendum || id instanceof CombinedAddenda || id instanceof AddendaPackage) {
+        return id.base?.copublisher;
+    }
+    return id.copublisher;
+}
+/** mr_sanitize: lowercase, fold out-of-charset runs to "-", trim the
+ * edges; an all-out-of-charset value collapses to undefined. */
+function mrSanitize(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    const sanitized = value.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "");
+    return sanitized === "" ? undefined : sanitized;
+}
+/** The supplement marker segment (mr_supplement_suffix): the same
+ * marker the MR slug uses, appended to the base's URN. */
+function mrSupplementMarker(id) {
+    const rec = id;
+    const has = (k) => rec[k] !== undefined;
+    if (has("addendum_code")) {
+        const code = rec["addendum_code"];
+        const lower = code.toLowerCase();
+        return lower === "" ? "add" : `add.${lower}`;
+    }
+    if (id instanceof CombinedAddenda)
+        return ["adds", mrSanitize(rec["addendum_codes"])].filter(Boolean).join(".");
+    if (has("package_description"))
+        return ["pkg", mrSanitize(rec["package_description"])].filter(Boolean).join(".");
+    if (id instanceof Interpretation)
+        return "interp";
+    if (id instanceof Errata) {
+        const d = rec["date"];
+        const slug = d === undefined ? undefined : [d.year, d.month, d.day].filter(Boolean).join("-");
+        return ["errata", mrSanitize(slug)].filter(Boolean).join(".");
+    }
+    return undefined;
+}
+class AshraeUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        // A supplement's URN is the URN of its base plus the one marker
+        // segment naming the supplement (the same marker the MR slug uses).
+        if (id instanceof SupplementIdentifier && id.base !== undefined) {
+            const marker = mrSupplementMarker(id);
+            return marker === undefined || marker === ""
+                ? id.base.toUrn()
+                : `${id.base.toUrn()}:${marker}`;
+        }
+        // A supplement carries no number of its own — the two leaves declare
+        // one — so reach it through #root, which walks `base`.
+        const number = numberOf(id) ?? numberOf(id.root());
+        const parts = ["urn", "ashrae"];
+        if (number !== undefined && number !== "")
+            parts.push(number);
+        if (id.year !== undefined)
+            parts.push(id.year);
+        if (id.type !== undefined)
+            parts.push(id.type.toLowerCase());
+        if (id.suffix !== undefined)
+            parts.push(id.suffix.toLowerCase());
+        if (id.amendment !== undefined)
+            parts.push(`amd.${id.amendment}`);
+        if (id.reaffirmed !== undefined)
+            parts.push(`reaff.${id.reaffirmed}`);
+        // The copublisher segment lowercases but keeps its slashes
+        // ("copub.ansi/ashrae").
+        const copublisher = copublisherOf(id);
+        if (copublisher !== undefined)
+            parts.push(`copub.${copublisher.toLowerCase()}`);
+        if (id.publisher !== undefined)
+            parts[1] = id.publisher.toLowerCase();
+        const addendum = id.addendum;
+        if (addendum !== undefined)
+            parts.push(`add.${addendum}`);
+        return parts.join(":");
+    }
+}
+export class AshraeIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        publisher: { type: "string", default: "ASHRAE" },
+        year: { type: "string" },
+        type: { type: "string" },
+        suffix: { type: "string" },
+        amendment: { type: "string" },
+        reaffirmed: { type: "string" },
+        copublisher: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "publisher", to: "publisher" }, { wire: "copublisher", to: "copublisher" }, { wire: "type", to: "type" }, { wire: "suffix", to: "suffix" }, { wire: "amendment", to: "amendment" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "year", to: "year" });
+    // The supplement types reach the document through #root (base walk).
+    root() {
+        return this;
+    }
+}
+function renderSingle(id) {
+    let result = [id.publisher ?? "", id.type ?? ""].filter((s) => s !== "").join(" ");
+    if (result.length > 0)
+        result += " ";
+    result += id.number !== undefined ? id.number : "";
+    if (id.year !== undefined)
+        result += `-${id.year}`;
+    if (id.amendment !== undefined)
+        result += ` (${id.amendment})`;
+    if (id.suffix !== undefined)
+        result += id.suffix;
+    if (id.reaffirmed !== undefined)
+        result += ` (RA${id.reaffirmed})`;
+    return result;
+}
+export class Standard extends AshraeIdentifier {
+    static polymorphicName = "pubid:ashrae:standard";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(AshraeIdentifier, {
+        number: { type: "string" },
+        type: { type: "string", default: "Standard" },
+    });
+    static mappings = [
+        ...AshraeIdentifier.mappings,
+        { wire: "number", to: "number" },
+    ];
+    constructor(attrs = {}) {
+        super(attrs);
+        const self = this;
+        if (self["publisher"] === undefined)
+            self["publisher"] = "ASHRAE";
+        if (self["type"] === undefined)
+            self["type"] = "Standard";
+    }
+    render() {
+        return renderSingle(this);
+    }
+}
+export class Guideline extends AshraeIdentifier {
+    static polymorphicName = "pubid:ashrae:guideline";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(AshraeIdentifier, {
+        number: { type: "string" },
+        type: { type: "string", default: "Guideline" },
+    });
+    static mappings = [
+        ...AshraeIdentifier.mappings,
+        { wire: "number", to: "number" },
+    ];
+    constructor(attrs = {}) {
+        super(attrs);
+        const self = this;
+        if (self["publisher"] === undefined)
+            self["publisher"] = "ASHRAE";
+        if (self["type"] === undefined)
+            self["type"] = "Guideline";
+    }
+    render() {
+        return renderSingle(this);
+    }
+}
+export class SupplementIdentifier extends AshraeIdentifier {
+    static attributes = extendAttributes(AshraeIdentifier, {
+        base: { type: AshraeIdentifier },
+    });
+    static mappings = [
+        ...AshraeIdentifier.mappings,
+        { wire: "base", to: "base" },
+    ];
+    root() {
+        return this.base?.root() ?? this;
+    }
+}
+// The delegated base copublisher rides the wrapper's wire through the
+// compactHash hook (Ruby serializes through the overridden getter).
+function delegatedCopublisher(model, hash) {
+    const base = model.base;
+    if (base?.copublisher !== undefined)
+        hash["copublisher"] = base.copublisher;
+}
+export class Addendum extends SupplementIdentifier {
+    static polymorphicName = "pubid:ashrae:addendum";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(SupplementIdentifier, {
+        addendum_code: { type: "string" },
+        addendum_date: { type: "string" },
+    });
+    static mappings = [
+        ...SupplementIdentifier.mappings,
+        { wire: "addendum_code", to: "addendum_code" },
+        { wire: "addendum_date", to: "addendum_date" },
+    ];
+    static compactHash = delegatedCopublisher;
+    render() {
+        if (this.base === undefined)
+            return "";
+        const copublisher = this.base.copublisher;
+        let result;
+        if (copublisher !== undefined) {
+            result = `${copublisher} Addendum ${this.addendum_code ?? ""} to ${this.base.toHuman()}`;
+        }
+        else {
+            const baseType = this.base.type ?? "Standard";
+            result = `ASHRAE Addendum ${this.addendum_code ?? ""} to ${baseType} ${numberOf(this.base) ?? ""}`;
+            if (this.base.year !== undefined)
+                result += `-${this.base.year}`;
+        }
+        if (this.addendum_date !== undefined)
+            result += ` (${this.addendum_date})`;
+        return result;
+    }
+}
+export class CombinedAddenda extends SupplementIdentifier {
+    static polymorphicName = "pubid:ashrae:combined-addenda";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(SupplementIdentifier, {
+        addendum_codes: { type: "string" },
+        connector: { type: "string" },
+    });
+    static mappings = [
+        ...SupplementIdentifier.mappings,
+        { wire: "addendum_codes", to: "addendum_codes" },
+        { wire: "connector", to: "connector" },
+    ];
+    static compactHash = delegatedCopublisher;
+    render() {
+        if (this.base === undefined)
+            return "";
+        const baseType = this.base.type ?? "Standard";
+        let result;
+        if (this.addendum_codes !== undefined) {
+            result = `ASHRAE Addenda ${this.addendum_codes} to ${baseType} ${numberOf(this.base) ?? ""}`;
+        }
+        else {
+            result = `ASHRAE Addenda to ${baseType} ${numberOf(this.base) ?? ""}`;
+        }
+        if (this.base.year !== undefined)
+            result += `-${this.base.year}`;
+        return result;
+    }
+}
+export class AddendaPackage extends SupplementIdentifier {
+    static polymorphicName = "pubid:ashrae:addenda-package";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(SupplementIdentifier, {
+        package_description: { type: "string" },
+    });
+    static mappings = [
+        ...SupplementIdentifier.mappings,
+        { wire: "package_description", to: "package_description" },
+    ];
+    static compactHash = delegatedCopublisher;
+    render() {
+        if (this.base === undefined)
+            return "";
+        let result = `ASHRAE ${this.base.type ?? "Standard"} ${numberOf(this.base) ?? ""}`;
+        if (this.base.year !== undefined)
+            result += `-${this.base.year}`;
+        if (this.package_description !== undefined)
+            result += `: Addenda ${this.package_description}`;
+        return result;
+    }
+}
+export class Errata extends SupplementIdentifier {
+    static polymorphicName = "pubid:ashrae:errata";
+    static urnGenerator = AshraeUrnGenerator;
+    static attributes = extendAttributes(SupplementIdentifier, {
+        date: { type: PubidDate },
+    });
+    static mappings = [
+        ...SupplementIdentifier.mappings,
+        { wire: "date", to: "date" },
+    ];
+    render() {
+        if (this.base === undefined)
+            return "";
+        let result = `${this.base.toHuman()} Errata`;
+        const date = longDate(this.date);
+        if (date !== undefined)
+            result += ` (${date})`;
+        return result;
+    }
+}
+export class Interpretation extends SupplementIdentifier {
+    static polymorphicName = "pubid:ashrae:interpretation";
+    static urnGenerator = AshraeUrnGenerator;
+    render() {
+        if (this.base === undefined)
+            return "";
+        const baseType = this.base.type ?? "Standard";
+        let result = `Interpretations for ${baseType} ${numberOf(this.base) ?? ""}`;
+        if (this.base.year !== undefined)
+            result += `-${this.base.year}`;
+        return result;
+    }
+}
+function longDate(date) {
+    if (date === undefined)
+        return undefined;
+    if (date.month === undefined)
+        return date.year?.toString();
+    const month = MONTH_NAMES[Number(date.month) - 1];
+    if (month === undefined)
+        return date.render();
+    if (date.day === undefined)
+        return `${month} ${date.year ?? ""}`.trim();
+    const day = `${month} ${Number(date.day)}`;
+    return date.year !== undefined ? `${day}, ${date.year}` : day;
+}
+for (const klass of [
+    Standard,
+    Guideline,
+    Addendum,
+    CombinedAddenda,
+    AddendaPackage,
+    Errata,
+    Interpretation,
+]) {
+    registerType(klass);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Port of the ashrae parser's self.parse normalization — strip, the
+ * !original!canonical fixture format, whitespace/RA/dash normalization,
+ * trailing punctuation cleanup, paren balancing, and the "and"-in-
+ * addenda-code-list preprocessing.
+ */
+export declare function preprocessAshrae(input: string): string;

package/dist/flavors/ashrae/preprocessor.js

@@ -0,0 +1,44 @@
+/**
+ * Port of the ashrae parser's self.parse normalization — strip, the
+ * !original!canonical fixture format, whitespace/RA/dash normalization,
+ * trailing punctuation cleanup, paren balancing, and the "and"-in-
+ * addenda-code-list preprocessing.
+ */
+export function preprocessAshrae(input) {
+    let cleaned = input.trim();
+    if (cleaned.startsWith("!")) {
+        const parts = cleaned.split("!");
+        if (parts.length >= 3)
+            cleaned = parts[1];
+    }
+    cleaned = cleaned.replaceAll(/\s+/g, " ");
+    cleaned = cleaned.replaceAll(/\(RA\s+(\d{4})\)/g, "(RA $1)");
+    cleaned = cleaned.replaceAll(/RA\s+(\d{4})/g, "RA $1");
+    cleaned = cleaned.replace(/[,.]$/, "");
+    cleaned = cleaned.replaceAll("))", ")");
+    const open = (cleaned.match(/\(/g) ?? []).length;
+    const close = (cleaned.match(/\)/g) ?? []).length;
+    if (open > close)
+        cleaned = cleaned + ")".repeat(open - close);
+    cleaned = cleaned.replaceAll(/-\s+/g, "-");
+    cleaned = cleaned.replaceAll(/\s+/g, " ");
+    if (/\bAddenda\s+/.test(cleaned) || /\bAddendum\s+/.test(cleaned)) {
+        const boundary = /\s+(?:to|for|\()/;
+        const match = cleaned.match(boundary);
+        if (match !== null && match.index !== undefined) {
+            const pos = cleaned.indexOf(match[0]);
+            const before = cleaned.slice(0, pos);
+            const after = cleaned.slice(pos);
+            cleaned =
+                before.replaceAll(/,\s+and\s+/gi, ", ").replaceAll(/\s+and\s+/gi, ", ") +
+                    after;
+        }
+        else {
+            cleaned = cleaned
+                .replaceAll(/,\s+and\s+/gi, ", ")
+                .replaceAll(/\s+and\s+/gi, ", ");
+        }
+        cleaned = cleaned.replaceAll(/\bAddendum\s+([a-z]+)\s*,\s*/gi, (_m, code) => `Addenda ${code}, `);
+    }
+    return cleaned;
+}

package/dist/flavors/asme/grammar.d.ts

@@ -0,0 +1,2 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const asmeGrammar: Grammar;

package/dist/flavors/asme/grammar.js

@@ -0,0 +1,200 @@
+import { match, ref, str } from "../../grammar/engine.js";
+/**
+ * Port of lib/pubid/asme/parser.rb — 1:1. Root: identifier.
+ *
+ * Branch order: CSA/ASME, API/ASME, ISO/ASME, ASME/ANS, standard.
+ */
+const alt = (tokens) => tokens.map((t) => str(t)).reduce((a, b) => a.or(b));
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    rule("space", () => str(" "));
+    rule("dash", () => str("-").or(str("–")).or(str("—")));
+    rule("slash", () => str("/"));
+    rule("dot", () => str("."));
+    rule("digit", () => match("[0-9]"));
+    rule("digits", () => ref(rules, "digit").repeat(1, Infinity));
+    rule("letter", () => match("[A-Z]"));
+    rule("letters", () => ref(rules, "letter").repeat(1, Infinity));
+    rule("underscore", () => str("_"));
+    rule("roman_numeral", () => alt(["XIII", "XII", "XI", "VIII", "VII", "VI", "IV", "IX", "X", "III", "II", "V", "I"]));
+    rule("bpvc_letter_code", () => alt(["NCA", "NCD", "SSC", "BPV", "NUC", "NB", "NC", "ND", "NE", "NF", "NG"])
+        .or(ref(rules, "letter")));
+    rule("bpvc_subdivision", () => str("BPVC")
+        .then((ref(rules, "space").then(str("COMPLETE CODE BIND")).as("special")
+        .or(ref(rules, "dash").then(str("CC")).then(ref(rules, "dash"))
+        .then(ref(rules, "bpvc_letter_code").as("case_code")))
+        .or(ref(rules, "dot").then(
+    // SSC with complex subdivision: BPVC.SSC.XI.II.V.IX,
+    // or the bare catalogue form BPVC.SSC.
+    str("SSC")
+        .then((ref(rules, "dot")
+        .then(ref(rules, "roman_numeral")
+        .then((ref(rules, "dot").then(ref(rules, "roman_numeral"))).repeat(0, Infinity))
+        .as("ssc_sections"))).maybe())
+        .then(ref(rules, "dot").maybe())
+        .as("ssc_code")
+        // CC = Case Code: BPVC.CC.BPV or BPVC.CC.NC.XI; the
+        // catalogue prints the sub-code with its own leading
+        // dot (BPVC.CC.BPV..I)
+        .or(str("CC").then(ref(rules, "dot"))
+        .then(ref(rules, "bpvc_letter_code").as("case_code"))
+        .then((ref(rules, "dot").then(ref(rules, "dot").maybe())
+        .then(ref(rules, "roman_numeral").or(ref(rules, "bpvc_letter_code")).as("case_sub"))).maybe()))
+        .or(ref(rules, "roman_numeral").as("section")
+        .then((ref(rules, "dot")
+        .then((ref(rules, "digits").or(ref(rules, "bpvc_letter_code"))).as("subsection"))).maybe())
+        .then((ref(rules, "dot").then(ref(rules, "bpvc_letter_code").as("sub_subsection"))).maybe())
+        .then((ref(rules, "underscore").then(ref(rules, "letters").as("lang_suffix"))).maybe()))).as("subdivision"))).as("bpvc_code")));
+    rule("multi_char_code", () => alt([
+        "PVHO", "PASE", "PTC", "PTB", "PDS", "PCC",
+        "V&V", "V V", "VVUQ",
+        "TDP", "RTP", "RT",
+        "RA-S", "RA",
+        "QME", "QAI", "QEI",
+        "NUM", "NQA", "NML",
+        "OM",
+        "HST", "HRT",
+        "FFS",
+        "TES",
+        "TR",
+        "STS",
+        "CSD", "CA",
+        "BTH", "BPE",
+        "ANDE", "AED",
+        "AG",
+        "NM",
+        "EA",
+    ]));
+    rule("asme_publisher", () => str("ASME"));
+    rule("csa_publisher", () => str("CSA"));
+    rule("api_publisher", () => str("API"));
+    rule("iso_publisher", () => str("ISO"));
+    rule("ans_publisher", () => str("ANS"));
+    rule("iso_asme_publisher", () => str("ISO/ASME").as("joint_publisher").then(ref(rules, "space").maybe()));
+    rule("asme_ans_publisher", () => str("ASME/ANS").as("joint_publisher").then(ref(rules, "space")));
+    rule("csa_asme_publisher", () => ref(rules, "csa_publisher").as("first_publisher")
+        .then(ref(rules, "space"))
+        .then(match("[A-Z0-9.]").repeat(1, Infinity).as("first_code"))
+        .then(ref(rules, "space").maybe())
+        .then(ref(rules, "slash"))
+        .then(ref(rules, "asme_publisher").as("second_publisher"))
+        .then(ref(rules, "space")));
+    rule("api_asme_publisher", () => ref(rules, "api_publisher").as("first_publisher")
+        .then(ref(rules, "space"))
+        .then(match("[0-9-]").repeat(1, Infinity).as("first_code"))
+        .then(ref(rules, "space").maybe())
+        .then(ref(rules, "slash"))
+        .then(ref(rules, "asme_publisher").as("second_publisher"))
+        .then(ref(rules, "space")));
+    rule("publisher", () => ref(rules, "asme_publisher").then(ref(rules, "space")));
+    rule("designator", () => (ref(rules, "bpvc_subdivision")
+        .or(ref(rules, "multi_char_code"))
+        .or(str("ISO"))
+        .or(str("CSA"))
+        .or(str("API"))
+        .or(str("ANS"))
+        .or(ref(rules, "letters"))).as("designator"));
+    // A trailing edition year ("-2021", "-20XX") and nothing after it.
+    // `number_part` must not read it as a dash-separated number: a
+    // designator with no number ("BPVC.I-2021", "BPE-2012") then stored
+    // the year as its number, and the year itself was lost.
+    rule("trailing_year", () => ref(rules, "dash")
+        .then(str("20XX").or(str("202X"))
+        .or(str("20").then(ref(rules, "digit")).then(str("X")))
+        .or(ref(rules, "digit").repeat(4, 4)))
+        .then(match("[0-9A-Z.]").absent()));
+    // Number part - can start with dot (NM.1), be dotted (16.5), OR dash-separated (BTH-1)
+    rule("number_part", () => ((ref(rules, "dot").then(match("[0-9A-Z]").repeat(1, Infinity))
+        .then((ref(rules, "dot").then(match("[0-9A-Z]").repeat(1, Infinity))).repeat(0, Infinity)))
+        .or(ref(rules, "trailing_year").absent()
+        .then(ref(rules, "dash")).then(match("[0-9A-Z]").repeat(1, Infinity))
+        .then((ref(rules, "dot").then(match("[0-9A-Z]").repeat(1, Infinity))).repeat(0, Infinity)))
+        .or(match("[0-9A-Z]").repeat(1, Infinity)
+        .then((ref(rules, "dot").then(match("[0-9A-Z]").repeat(1, Infinity))).repeat(0, Infinity)))).as("number"));
+    // PTC special: space-separated number with optional suffix; the
+    // renderer glues the designator to the number (PTC 19.3 TW and
+    // PTC19.3 TW are the same document)
+    rule("ptc_number", () => ref(rules, "space").maybe()
+        .then(match("[0-9]").repeat(1, Infinity)
+        .then((ref(rules, "dot").then(match("[0-9]").repeat(1, Infinity))).repeat(0, Infinity))
+        .as("number"))
+        .then((ref(rules, "space").then(ref(rules, "letters").as("ptc_suffix"))).maybe()));
+    // TR special: space-separated number (like "ASME TR A17.1-8.4-2013");
+    // the rendered form glues the designator (TRA17.1-8.4)
+    rule("tr_number", () => ref(rules, "space").maybe()
+        .then(match("[A-Z0-9]").repeat(1, Infinity)
+        .then((ref(rules, "dot").then(match("[0-9A-Z]").repeat(1, Infinity))).repeat(0, Infinity))
+        .then((ref(rules, "dash").then(match("[0-9]").repeat(1, Infinity))
+        .then((ref(rules, "dot").then(match("[0-9]").repeat(1, Infinity))).repeat(0, Infinity))).maybe())
+        .as("number")));
+    rule("spaced_number_part", () => ref(rules, "space").maybe().then(ref(rules, "number_part")));
+    rule("year_4digit", () => ref(rules, "digit").repeat(4, 4).as("year"));
+    rule("draft_year", () => str("20XX").or(str("202X"))
+        .or(str("20").then(ref(rules, "digit")).then(str("X")))
+        .as("draft_year"));
+    rule("reaffirmation", () => ref(rules, "space").then(str("(R")).then(ref(rules, "year_4digit").as("reaffirmation")).then(str(")")));
+    rule("csa_portion", () => ref(rules, "slash").then(str("CSA")).then(ref(rules, "space"))
+        .then((ref(rules, "letter").then(match("[0-9.]").repeat(1, Infinity))).as("csa_number")));
+    rule("parenthetical_revision", () => ref(rules, "space").then(str("("))
+        .then(str("Proposed revision of").or(str("Revision of")))
+        .then(ref(rules, "space"))
+        .then(match("[^)]").repeat(1, Infinity).as("ref_standard"))
+        .then(str(")")));
+    rule("revision_note", () => ref(rules, "space").then(str("["))
+        .then(match("[^\\]]").repeat(1, Infinity).as("revision_note"))
+        .then(str("]")));
+    rule("language", () => ref(rules, "space").then(str("(")).then(ref(rules, "letters").as("language")).then(str(")")));
+    rule("handbook_keyword", () => (ref(rules, "space").then(str("Handbook"))).as("handbook"));
+    const yearSuffix = () => (ref(rules, "dash").then(ref(rules, "draft_year").or(ref(rules, "year_4digit")))).maybe();
+    const trailingTails = () => ref(rules, "language").maybe()
+        .then(ref(rules, "reaffirmation").maybe());
+    rule("csa_asme_identifier", () => ref(rules, "csa_asme_publisher")
+        .then(ref(rules, "designator"))
+        .then(ref(rules, "number_part").maybe())
+        .then(yearSuffix())
+        .then(trailingTails()));
+    rule("api_asme_identifier", () => ref(rules, "api_asme_publisher")
+        .then(ref(rules, "designator"))
+        .then(ref(rules, "number_part").maybe())
+        .then(yearSuffix())
+        .then(trailingTails()));
+    rule("iso_asme_identifier", () => ref(rules, "iso_asme_publisher")
+        .then(ref(rules, "number_part").maybe())
+        .then(yearSuffix())
+        .then(trailingTails()));
+    rule("asme_ans_identifier", () => ref(rules, "asme_ans_publisher")
+        .then(ref(rules, "designator"))
+        .then(ref(rules, "number_part").maybe())
+        .then(yearSuffix())
+        .then(trailingTails()));
+    rule("standard", () => ref(rules, "publisher")
+        .then(str("PTC").as("designator")
+        .then(ref(rules, "ptc_number"))
+        .then(yearSuffix())
+        .or(str("TR").as("designator")
+        .then(ref(rules, "tr_number"))
+        .then(yearSuffix()))
+        .or(ref(rules, "designator")
+        .then(ref(rules, "spaced_number_part").maybe())
+        .then((ref(rules, "csa_portion").then(ref(rules, "handbook_keyword").maybe())
+        .or(ref(rules, "handbook_keyword"))).maybe())
+        .then(ref(rules, "language").maybe())
+        .then(yearSuffix())
+        .then(ref(rules, "language").maybe())))
+        .then(ref(rules, "parenthetical_revision").maybe())
+        .then(ref(rules, "reaffirmation").maybe())
+        .then(ref(rules, "revision_note").maybe()));
+    rule("identifier", () => ref(rules, "csa_asme_identifier")
+        .or(ref(rules, "api_asme_identifier"))
+        .or(ref(rules, "iso_asme_identifier"))
+        .or(ref(rules, "asme_ans_identifier"))
+        .or(ref(rules, "standard")));
+    return rules;
+}
+export const asmeGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

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

@@ -0,0 +1,4 @@
+import type { Tree } from "../../grammar/engine.js";
+import type { FlavorImplementation, Identifier } from "../../conformance/implementation.js";
+export declare function buildAsmeIdentifier(tree: Tree): Identifier;
+export declare function asmeGrammarImplementation(): FlavorImplementation;