@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/jcgm/index.js

@@ -0,0 +1,300 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { BaseBuilder } from "../../model/builder.js";
+import { PubidDate, Language } from "../../model/component.js";
+/**
+ * Port of lib/pubid/jcgm/ on the unified model. Five concrete classes
+ * (guide, gum-guide, meeting, amendment, corrigendum); the date
+ * serializes FLAT as year/month/day through the converter mapping trio
+ * (Ruby's year_to_kv pattern); the ordinal suffix ("11st") is computed
+ * from the number at render time; supplements hold a nested base. The
+ * typed_stage is runtime-derived from the class (never serialized).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    // CommonParseRules year_digits: 19xx/20xx not followed by a digit.
+    const yearDigits = str("19").or(str("20")).then(match("\\d").repeat(2, 2), digits.absent());
+    const monthDigits = match("[0-9]").repeat(2, 2);
+    const dayDigits = match("[0-9]").repeat(2, 2);
+    const fullDate = yearDigits.then(str("-"), monthDigits, str("-"), dayDigits).as("date");
+    const datePortion = str(":").then(fullDate.or(yearDigits.as("date")));
+    rule("publisher", () => str("JCGM").as("publisher"));
+    rule("number_portion", () => str("GUM-").then(digits.as("gum_number")).or(digits.as("number")));
+    rule("language_portion", () => str("(")
+        .then((str("E/F").or(str("F/E")).or(match("[A-Z]"))).as("languages"), str(")")));
+    rule("base", () => rules["publisher"]
+        .then(space, rules["number_portion"])
+        .then(datePortion.maybe())
+        .then(rules["language_portion"].maybe()));
+    rule("ordinal_suffix", () => str("st").or(str("nd"), str("rd"), str("th")));
+    rule("meeting_identifier", () => rules["publisher"]
+        .then(space, digits.as("number"), rules["ordinal_suffix"])
+        .then(space, str("Meeting").as("type_with_stage"))
+        .then(space.then(str("("), yearDigits.as("date"), str(")")).maybe()));
+    rule("corrigendum_identifier", () => rules["base"].as("base").then(space, str("Corrigendum").as("type_with_stage")));
+    rule("numbered_corrigendum_identifier", () => rules["base"]
+        .as("base")
+        .then(str("/"), str("Cor").as("type_with_stage"))
+        .then(space, digits.as("number"))
+        .then(datePortion.maybe()));
+    rule("amendment_identifier", () => rules["base"]
+        .as("base")
+        .then(str("/"), str("Amd").as("type_with_stage"))
+        .then(space, digits.as("number"))
+        .then(datePortion.maybe()));
+    rule("named_number", () => (str("GUM").or(str("VIM").then(str("-").then(digits).maybe()))).as("number"));
+    rule("named_guide_identifier", () => rules["publisher"].then(space, rules["named_number"]));
+    rule("identifier", () => rules["meeting_identifier"]
+        .or(rules["amendment_identifier"])
+        .or(rules["corrigendum_identifier"])
+        .or(rules["numbered_corrigendum_identifier"])
+        .or(rules["base"])
+        .or(rules["named_guide_identifier"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const jcgmGrammar = { rules: buildRules(), root: "root" };
+const JCGM_ATTRS = {
+    number: { type: "string" },
+    part: { type: "string" },
+    subpart: { type: "string" },
+    date: { type: PubidDate },
+    languages: { type: Language, collection: true, initializeEmpty: true },
+};
+// The calconnect-style converter trio: the date serializes FLAT as
+// year/month/day.
+const DATE_MAPPINGS = keyValue({
+    wire: "year",
+    to: "date",
+    toWire: (m) => m["date"]?.year,
+    fromWire: (h) => h["year"] === undefined || h["year"] === null
+        ? undefined
+        : new PubidDate({
+            year: String(h["year"]),
+            month: h["month"],
+            day: h["day"],
+        }),
+}, { wire: "month", to: "date", toWire: (m) => m["date"]?.month, fromWire: () => undefined }, { wire: "day", to: "date", toWire: (m) => m["date"]?.day, fromWire: () => undefined });
+class JcgmIdentifier extends BaseIdentifier {
+    /** generate_base_urn shape: urn:jcgm:<number>[:part...]:date... */
+    baseUrnParts() {
+        const parts = ["urn", "jcgm"];
+        if (this.number !== undefined)
+            parts.push(this.number);
+        if (this.part !== undefined)
+            parts.push(`-${this.part}`);
+        if (this.subpart !== undefined)
+            parts.push(`-${this.subpart}`);
+        const rendered = this.date?.render("urn");
+        if (rendered !== undefined && rendered !== "")
+            parts.push(rendered);
+        return parts;
+    }
+    /** The date as printed (PubidDate#to_s): "2008" / "2022-11-28". */
+    dateToS() {
+        return this.date?.render() ?? "";
+    }
+    languagePortion() {
+        return this.languages.length === 0
+            ? ""
+            : `(${this.languages.map((l) => l.originalCode ?? l.code).join("/")})`;
+    }
+    /** English ordinal suffix computed from the number (11st, 12nd, 13rd…). */
+    ordinalSuffix() {
+        if (this.number === undefined)
+            return "th";
+        const mod = Number(this.number) % 10;
+        return mod === 1 ? "st" : mod === 2 ? "nd" : mod === 3 ? "rd" : "th";
+    }
+}
+function jcgmClass(kind, attrs, mappings) {
+    class JcgmKindIdentifier extends JcgmIdentifier {
+        static polymorphicName = `pubid:jcgm:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, attrs);
+        static mappings = mappings;
+        render() {
+            const id = this;
+            switch (kind) {
+                case "meeting": {
+                    const base = `JCGM ${id.number}${this.ordinalSuffix()} Meeting`;
+                    const year = id.date?.year;
+                    return year === undefined ? base : `${base} (${year})`;
+                }
+                case "amendment": {
+                    let result = `${id.base?.render() ?? ""}/Amd`;
+                    if (id.number !== undefined)
+                        result += ` ${id.number}`;
+                    const d = this.dateToS();
+                    if (d !== "")
+                        result += `:${d}`;
+                    return result;
+                }
+                case "corrigendum": {
+                    if (id.number !== undefined) {
+                        const d = this.dateToS();
+                        return `${id.base?.render() ?? ""}/Cor ${id.number}${d === "" ? "" : `:${d}`}`;
+                    }
+                    return `${id.base?.render() ?? ""} Corrigendum`;
+                }
+                case "gum-guide": {
+                    let result = `JCGM GUM-${id.number}`;
+                    const d = this.dateToS();
+                    if (d !== "")
+                        result += `:${d}`;
+                    result += this.languagePortion();
+                    return result;
+                }
+                default: {
+                    let result = "JCGM";
+                    let portion = id.number ?? "";
+                    const d = this.dateToS();
+                    if (portion !== "" && d !== "")
+                        portion += `:${d}`;
+                    if (portion !== "")
+                        result += ` ${portion}`;
+                    result += this.languagePortion();
+                    return result;
+                }
+            }
+        }
+    }
+    registerType(JcgmKindIdentifier);
+    return JcgmKindIdentifier;
+}
+const KIND_CLASSES = {
+    guide: jcgmClass("guide", JCGM_ATTRS, keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "subpart", to: "subpart" }, ...DATE_MAPPINGS, { wire: "languages", to: "languages" })),
+    "gum-guide": jcgmClass("gum-guide", JCGM_ATTRS, keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "subpart", to: "subpart" }, ...DATE_MAPPINGS, { wire: "languages", to: "languages" })),
+    meeting: jcgmClass("meeting", JCGM_ATTRS, keyValue({ wire: "number", to: "number" }, ...DATE_MAPPINGS)),
+    amendment: jcgmClass("amendment", { ...JCGM_ATTRS, base: { type: undefined } }, keyValue({ wire: "number", to: "number" }, ...DATE_MAPPINGS, { wire: "base", to: "base" })),
+    corrigendum: jcgmClass("corrigendum", { ...JCGM_ATTRS, base: { type: undefined } }, keyValue({ wire: "number", to: "number" }, ...DATE_MAPPINGS, { wire: "base", to: "base" })),
+};
+// base attr needs the abstract self-type for polymorphic coercion.
+KIND_CLASSES["amendment"].attributes["base"] = { type: JcgmIdentifier };
+KIND_CLASSES["corrigendum"].attributes["base"] = { type: JcgmIdentifier };
+class JcgmUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const kind = this.identifier.constructor.polymorphicName.slice("pubid:jcgm:".length);
+        if (kind === "meeting") {
+            const parts = ["urn", "jcgm", "meeting"];
+            if (this.identifier.number)
+                parts.push(this.identifier.number);
+            const year = this.identifier.date?.year;
+            if (year !== undefined)
+                parts.push(year);
+            return parts.join(":");
+        }
+        if (kind === "amendment" || kind === "corrigendum") {
+            const base = this.identifier.base;
+            if (!base)
+                return "urn:jcgm:unknown";
+            const parts = [...base.baseUrnParts()];
+            parts.push(kind);
+            if (this.identifier.number)
+                parts.push(this.identifier.number);
+            const rendered = this.identifier.date?.render("urn");
+            if (rendered !== undefined && rendered !== "")
+                parts.push(rendered);
+            return parts.join(":");
+        }
+        // generate_base_urn: GUM guides carry the "gum.N" number form;
+        // guide/gum_guide type codes are implied and never appended.
+        if (kind === "gum-guide" && this.identifier.number !== undefined) {
+            const parts = ["urn", "jcgm", `gum.${this.identifier.number}`];
+            const rendered = this.identifier.date?.render("urn");
+            if (rendered !== undefined && rendered !== "")
+                parts.push(rendered);
+            if (this.identifier.languages.length > 0) {
+                parts.push(this.identifier.languages.map((l) => l.code).join(","));
+            }
+            return parts.join(":");
+        }
+        const parts = [...this.identifier.baseUrnParts()];
+        if (this.identifier.languages.length > 0) {
+            parts.push(this.identifier.languages.map((l) => l.code).join(","));
+        }
+        return parts.join(":");
+    }
+}
+for (const klass of Object.values(KIND_CLASSES)) {
+    klass.urnGenerator = JcgmUrnGenerator;
+}
+function isObj(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseLanguages(value) {
+    const raw = String(value);
+    return raw.split("/").map((code) => {
+        const original = code.trim();
+        const mapped = Language.CHAR_MAP[original] ?? original.toLowerCase();
+        return new Language({ code: mapped, originalCode: original });
+    });
+}
+function buildDate(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const dateStr = String(value);
+    const parts = dateStr.split("-");
+    return new PubidDate({ year: parts[0], month: parts[1], day: parts[2] });
+}
+class JcgmBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return KIND_CLASSES["guide"];
+    }
+    selectClass(data) {
+        const hasBase = data["base"] !== undefined;
+        const typeWithStage = data["type_with_stage"] === undefined || data["type_with_stage"] === null
+            ? undefined
+            : String(data["type_with_stage"]);
+        if (hasBase) {
+            if (typeWithStage === undefined)
+                return KIND_CLASSES["amendment"];
+            return typeWithStage === "Amd" ? KIND_CLASSES["amendment"] : KIND_CLASSES["corrigendum"];
+        }
+        if (data["gum_number"] !== undefined)
+            return KIND_CLASSES["gum-guide"];
+        if (typeWithStage === "Meeting")
+            return KIND_CLASSES["meeting"];
+        return KIND_CLASSES["guide"];
+    }
+    build(data) {
+        const flat = Array.isArray(data) ? Object.assign({}, ...data) : data;
+        const klass = this.selectClass(flat);
+        const attrs = {};
+        if (flat["base"] !== undefined) {
+            attrs["base"] = this.build(flat["base"]);
+        }
+        if (flat["gum_number"] !== undefined)
+            attrs["number"] = String(flat["gum_number"]);
+        else if (flat["number"] !== undefined)
+            attrs["number"] = String(flat["number"]);
+        if (flat["date"] !== undefined) {
+            const date = buildDate(flat["date"]);
+            if (date)
+                attrs["date"] = date;
+        }
+        if (flat["languages"] !== undefined)
+            attrs["languages"] = parseLanguages(flat["languages"]);
+        return new klass(attrs);
+    }
+}
+export function jcgmGrammarImplementation() {
+    const builder = new JcgmBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(jcgmGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("JCGM: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}
+export { isObj };

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

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare const jisGrammar: Grammar;
+export declare function jisGrammarImplementation(): FlavorImplementation;

package/dist/flavors/jis/index.js

@@ -0,0 +1,267 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/jis/ on the unified model — 10,555 corpus rows.
+ * "JIS[ TR|TS] <series> <number>[-parts][:year[R]][(E|J)][（規格群）]
+ * [/AMD|EXPL|CORRIGENDUM …] [SYMBOL <value>]". Full-width Japanese
+ * separators parse and normalize; year is an INTEGER in the hash; the
+ * code ("B 0205-1") lives in the series/number/parts columns and is
+ * composed on demand. URN: urn:jis:<code>[:year][:lang]["all"]? with a
+ * supplement notation appended lowercased.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const jpDash = str("ｰ");
+    const jpSpace = str("　");
+    const jpColon = str("：");
+    const jpLparen = str("（");
+    const jpRparen = str("）");
+    const space = str(" ").or(jpSpace);
+    const dash = str("-").or(jpDash);
+    const colon = str(":").or(jpColon);
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("jis_prefix", () => str("JIS").then(space.or(str("/")).maybe()));
+    rule("type_prefix", () => (str("TR").or(str("TS"))).as("type").then(space.or(str("/"))));
+    rule("series", () => match("[A-Z]").as("series"));
+    rule("number", () => digits.as("number"));
+    rule("part", () => dash.then(digits.as("part")));
+    rule("parts", () => rules["part"].repeat(0, Infinity).as("parts"));
+    rule("reaffirmed", () => str("R").maybe().as("reaffirmed"));
+    rule("year", () => colon.then(digits.as("year"), rules["reaffirmed"]));
+    rule("language", () => jpLparen.or(str("(")).then(match("[EJ]").as("language"), jpRparen.or(str(")"))));
+    rule("all_parts", () => jpLparen.then(str("規格群"), jpRparen)
+        .or(str("(").then(str("規格群"), str(")")))
+        .as("all_parts"));
+    rule("amendment", () => str("/").then((str("AMENDMENT").or(str("AMD"))).as("amd_type"), space, digits.as("amd_number"), colon, digits.as("amd_year"), str("R").maybe().as("amd_reaffirmed")));
+    rule("explanation", () => str("/").then((str("EXPLANATION").or(str("EXPL"))).as("expl_type"), space.then(digits.as("expl_number")).maybe()));
+    rule("corrigendum", () => str("/").then((str("CORRIGENDUM").or(str("CORR"))).as("corr_type"), space, digits.as("corr_number"), colon, digits.as("corr_year"), str("R").maybe().as("corr_reaffirmed")));
+    rule("supplement", () => rules["amendment"].as("amendment")
+        .or(rules["explanation"].as("explanation"))
+        .or(rules["corrigendum"].as("corrigendum")));
+    rule("symbol_clause", () => space.then(str("SYMBOL").as("symbol_present"), space.then(match("[^\\n]").repeat(1, Infinity).as("symbol_value")).maybe()));
+    rule("identifier", () => rules["jis_prefix"]
+        .maybe()
+        .then(rules["type_prefix"].maybe())
+        .then(space.maybe(), rules["series"], space.maybe(), rules["number"])
+        .then(rules["parts"])
+        .then(rules["year"].maybe())
+        .then(rules["language"].maybe())
+        .then(rules["all_parts"].maybe())
+        .then(rules["supplement"].maybe())
+        .then(rules["symbol_clause"].maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const jisGrammar = { rules: buildRules(), root: "root" };
+const KIND_PREFIXES = {
+    "japanese-industrial-standard": undefined,
+    "technical-report": "TR",
+    "technical-specification": "TS",
+};
+class JisIdentifier extends BaseIdentifier {
+    /** The rendered document code, e.g. "B 0205-1". */
+    code() {
+        if (this.base !== undefined)
+            return this.base.code();
+        if (this.series === undefined || this.number === undefined)
+            return undefined;
+        let result = `${this.series} ${this.number}`;
+        if (this.parts !== undefined)
+            result += this.parts.map((p) => `-${p}`).join("");
+        return result;
+    }
+    yearWithReaffirmation() {
+        return `${this.year}${this.reaffirmed === true ? "R" : ""}`;
+    }
+    symbolSuffix() {
+        if (this.symbol === undefined)
+            return "";
+        return this.symbol === "" ? " SYMBOL" : ` SYMBOL ${this.symbol}`;
+    }
+    supplementNotation() {
+        return "";
+    }
+}
+const JIS_MAPPINGS = keyValue({ wire: "series", to: "series" }, { wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
+function jisClass(kind) {
+    const isSupplement = kind === "amendment" || kind === "corrigendum" || kind === "explanation";
+    class JisKindIdentifier extends JisIdentifier {
+        static polymorphicName = `pubid:jis:${kind}`;
+        static attributes = isSupplement
+            ? extendAttributes(BaseIdentifier, {
+                base: { type: JisIdentifier },
+                number: { type: "integer" },
+                year: { type: "integer" },
+                reaffirmed: { type: "boolean" },
+            })
+            : extendAttributes(BaseIdentifier, {
+                series: { type: "string" },
+                number: { type: "string" },
+                parts: { type: "string", collection: true },
+                year: { type: "integer" },
+                language: { type: "string" },
+                all_parts: { type: "boolean", default: false },
+                reaffirmed: { type: "boolean" },
+                symbol: { type: "string" },
+            });
+        static mappings = isSupplement
+            ? keyValue({ wire: "number", to: "number" }, { wire: "year", to: "year" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "base", to: "base" })
+            : JIS_MAPPINGS;
+        render() {
+            if (isSupplement) {
+                const result = `${this.base?.render() ?? ""}/${this.supplementNotation()}`;
+                return result + this.symbolSuffix();
+            }
+            const typePrefix = KIND_PREFIXES[kind];
+            let result = typePrefix === undefined ? "JIS" : `JIS ${typePrefix}`;
+            result += ` ${this.code()}`;
+            if (this.year !== undefined)
+                result += `:${this.yearWithReaffirmation()}`;
+            if (this.language !== undefined)
+                result += `(${this.language})`;
+            if (this.all_parts === true)
+                result += "（規格群）";
+            return result + this.symbolSuffix();
+        }
+        supplementNotation() {
+            if (kind === "amendment")
+                return `AMD ${this.number}:${this.yearWithReaffirmation()}`;
+            if (kind === "corrigendum")
+                return `CORRIGENDUM ${this.number}:${this.yearWithReaffirmation()}`;
+            if (kind === "explanation") {
+                return this.number === undefined ? "EXPL" : `EXPL ${this.number}`;
+            }
+            return "";
+        }
+    }
+    registerType(JisKindIdentifier);
+    return JisKindIdentifier;
+}
+const KIND_CLASSES = {
+    "japanese-industrial-standard": jisClass("japanese-industrial-standard"),
+    "technical-report": jisClass("technical-report"),
+    "technical-specification": jisClass("technical-specification"),
+    amendment: jisClass("amendment"),
+    corrigendum: jisClass("corrigendum"),
+    explanation: jisClass("explanation"),
+};
+class JisUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "jis"];
+        const code = id.code();
+        if (code !== undefined)
+            parts.push(code);
+        if (id.year !== undefined)
+            parts.push(String(id.year));
+        if (id.language !== undefined)
+            parts.push(id.language.toLowerCase());
+        if (id.all_parts === true)
+            parts.push("all");
+        const notation = id.supplementNotation();
+        if (id.base !== undefined && notation !== "") {
+            parts.push(notation.toLowerCase());
+        }
+        return parts.join(":");
+    }
+}
+for (const klass of Object.values(KIND_CLASSES)) {
+    klass.urnGenerator = JisUrnGenerator;
+}
+function isObj(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function extractParts(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((p) => (isObj(p) ? String(p["part"]) : String(p)));
+    }
+    if (isObj(raw) && raw["part"] !== undefined)
+        return [String(raw["part"])];
+    return [];
+}
+class JisBuilder {
+    build(data) {
+        const tree = (Array.isArray(data) ? Object.assign({}, ...data) : data);
+        const identifier = this.dispatch(tree);
+        // The SYMBOL clause attaches to the outermost identifier.
+        if (tree["symbol_present"] !== undefined) {
+            identifier["symbol"] =
+                tree["symbol_value"] === undefined || tree["symbol_value"] === null
+                    ? ""
+                    : String(tree["symbol_value"]);
+        }
+        return identifier;
+    }
+    dispatch(tree) {
+        if (tree["amendment"] !== undefined)
+            return this.buildSupplement(tree, "amendment", "amendment", "amd");
+        if (tree["corrigendum"] !== undefined)
+            return this.buildSupplement(tree, "corrigendum", "corrigendum", "corr");
+        if (tree["explanation"] !== undefined)
+            return this.buildExplanation(tree);
+        return this.buildSingle(tree);
+    }
+    baseData(tree, key) {
+        const out = { ...tree };
+        delete out[key];
+        return out;
+    }
+    buildSingle(tree) {
+        const type = tree["type"] === undefined || tree["type"] === null ? undefined : String(tree["type"]);
+        const kind = type === "TR" ? "technical-report" : type === "TS" ? "technical-specification" : "japanese-industrial-standard";
+        const attrs = {
+            series: String(tree["series"]),
+            number: String(tree["number"]),
+            parts: extractParts(tree["parts"]),
+        };
+        if (tree["year"] !== undefined && tree["year"] !== null)
+            attrs["year"] = Number(tree["year"]);
+        if (tree["language"] !== undefined && tree["language"] !== null)
+            attrs["language"] = String(tree["language"]);
+        if (tree["all_parts"] !== undefined)
+            attrs["all_parts"] = true;
+        if (tree["reaffirmed"] !== undefined && tree["reaffirmed"] !== null)
+            attrs["reaffirmed"] = true;
+        return new KIND_CLASSES[kind](attrs);
+    }
+    buildSupplement(tree, kind, key, prefix) {
+        const supp = isObj(tree[key]) ? tree[key] : {};
+        const base = this.buildSingle(this.baseData(tree, key));
+        const attrs = {
+            base,
+            number: Number(supp[`${prefix}_number`]),
+            year: Number(supp[`${prefix}_year`]),
+        };
+        if (supp[`${prefix}_reaffirmed`] !== undefined && supp[`${prefix}_reaffirmed`] !== null) {
+            attrs["reaffirmed"] = true;
+        }
+        return new KIND_CLASSES[kind](attrs);
+    }
+    buildExplanation(tree) {
+        const supp = isObj(tree["explanation"]) ? tree["explanation"] : {};
+        const base = this.buildSingle(this.baseData(tree, "explanation"));
+        const attrs = { base, year: base.year };
+        if (supp["expl_number"] !== undefined && supp["expl_number"] !== null) {
+            attrs["number"] = Number(supp["expl_number"]);
+        }
+        return new KIND_CLASSES["explanation"](attrs);
+    }
+}
+export function jisGrammarImplementation() {
+    const builder = new JisBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(jisGrammar, input);
+            if (typeof tree !== "object" || tree === null) {
+                throw new ParseFailed("JIS: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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