@pubid/pubid 0.1.3 → 0.1.5

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

@@ -0,0 +1,11 @@
+/**
+ * Port of lib/pubid/nist/preprocessor.rb + data/nist/update_codes.yaml.
+ * Every regex-based normalization applied before the grammar sees the
+ * string. Stage order is load-bearing — later stages match patterns
+ * produced by earlier ones (reordering requires the full corpus gate).
+ */
+export interface PreprocessorResult {
+    cleaned: string;
+    format: "mr" | "short";
+}
+export declare function preprocessNist(input: string): PreprocessorResult;

package/dist/flavors/nist/preprocessor.js

@@ -0,0 +1,281 @@
+/**
+ * Port of lib/pubid/nist/preprocessor.rb + data/nist/update_codes.yaml.
+ * Every regex-based normalization applied before the grammar sees the
+ * string. Stage order is load-bearing — later stages match patterns
+ * produced by earlier ones (reordering requires the full corpus gate).
+ */
+const UPDATE_CODE_LINES = {
+    "NBS MN": "NBS MONO",
+    "NIST MN": "NIST MONO",
+    "NIST MP": "NBS MP",
+    "NIST SP 260-162 2006ed.": "NIST SP 260-162e2006",
+    "NIST AI NIST AI 100-2e2023 ipd": "NIST AI 100-2e2023 ipd",
+    "NBS CIRC 154suprev": "NBS CIRC 154r1sup",
+    "NBS CIRC supJun1925-Jun1926": "NBS CIRC 24e7sup2",
+    "NBS CIRC supJun1925-Jun1927": "NBS CIRC 24e7sup3",
+    "NBS CIRC 25sup-1924": "NBS CIRC 25sup",
+    "NIST SP 260-126 rev 2013": "NIST SP 260-126r2013",
+    "NIST CSRC White Paper": "NIST CSWP",
+    "NIST SP 800-56ar": "NIST SP 800-56Ar1",
+    "NIST.LCIRC": "NIST.LC",
+    "NBS.LCIRC": "NBS.LC",
+    "NIST LCIRC": "NIST LC",
+    "NBS LCIRC": "NBS LC",
+    "NIST SP 800-57Pt3r1": "NIST SP 800-57pt3r1",
+    NISTIR: "NIST IR",
+    "NIST FIPS": "FIPS",
+    "NIST.CSWP.01162020pt": "NIST.CSWP.01162020(por)",
+    "NBS FIPS 11-1-Sep30": "NBS FIPS 11-1-Sep30/1977",
+    "NBS FIPS 89-Sep1": "NBS FIPS 89-Sep1981",
+    "FIPS PUB 54-1-Jan15": "FIPS 54-1",
+    "FIPS 54-1-Jan15": "FIPS 54-1",
+    "FIPS 54-1-Jan17": "FIPS 54-1-Jan17/1991",
+    "FIPS PUB": "FIPS",
+    "NBS CRPL c4-4": "NBS CRPL 4-4",
+    "NIST AMS 300-8r1 (February 2021 update)": "NIST AMS 300-8r1/Upd1-202102",
+    "NIST AMS 300-8r1/upd": "NIST AMS 300-8r1/Upd1-202102",
+    "NIST IR 8115r1-upd": "NIST IR 8115r1/Upd1-202103",
+    "NIST IR 8170-upd": "NIST IR 8170/Upd1-202003",
+    "NIST TN 2150-upd": "NIST TN 2150/Upd1-202102",
+    "NBS IR 73-197r": "NBS IR 73-197r1",
+    "NBS.HB.105-1r1990": "NIST.HB.105-1r1990",
+    "NBS.HB.28p11969": "NBS.HB.28-1969pt1",
+    "NIST HB 105-1-1990": "NIST HB 105-1r1990",
+    "NBS.FIPS.100-1-1991": "NIST.FIPS.100-1-1991",
+    "NBS.LC.1088sp": "NBS.LC.1088.spa",
+    "NBS LC 1088sp": "NBS LC 1088 spa",
+    "NIST SP 955 Suppl.": "NIST SP 955sup",
+    "NIST SP 800-38e": "NIST SP 800-38E",
+    "NBS.CIRC.supJun1925-Jun1926": "NBS CIRC 24e7sup2",
+    "NBS.CIRC.supJun1925-Jun1927": "NBS CIRC 24e7sup3",
+    "NIST.TN.2150-upd": "NIST.TN.2150-upd1-202102",
+    "NIST.SP.955.Suppl": "NIST.SP.955-S.uppl",
+    "NIST SP 782-1995-96": "NIST SP 782-1995",
+    "NIST FIPS 54-Jan15": "NIST FIPS 54",
+    "NBS report ;": "NBS RPT",
+    "NBS TN 467p1adde1": "NBS TN 467pt1-add",
+    "NIST SP 1011-II-1.0": "NIST SP 1011v2ver1.0",
+    "NIST SP 1011-II-1 0": "NIST SP 1011v2ver1.0",
+    "NIST SP 1011-I-2.0": "NIST SP 1011v1ver2.0",
+    "NIST SP 1011-I-2 0": "NIST SP 1011v1ver2.0",
+    "NIST SP 500-281-v1.0": "NIST SP 500-281v1.0",
+    "NIST IR 8259Aes": "NIST IR 8259A(spa)",
+    "NIST IR 8259Apt": "NIST IR 8259A(por)",
+    "NIST IR 8211-upd": "NIST IR 8211/Upd1-2021",
+    "NIST IR 8115r1/upd": "NIST IR 8115r1/Upd1-2021",
+    "NBS CS v": "NBS CSM v",
+    "NIST SP 800-57p1r2006": "NIST SP 800-57pt1r1",
+    "NIST SP 800-57p1r2007": "NIST SP 800-57pt1r2",
+    "NIST SP 500-268v1 1": "NIST SP 500-268v1.1",
+    "NIST SP 500-270v1 1": "NIST SP 500-270v1.1",
+    "NIST SP 500-280v2 1": "NIST SP 500-280v2.1",
+    "NIST SP 500-281-v1 0": "NIST SP 500-281v1.0",
+    "NIST SP 800-63v1 0 1": "NIST SP 800-63v1.0.1",
+    "NIST SP 800-63v1 0 2": "NIST SP 800-63v1.0.2",
+    "NIST SP 955 Suppl": "NIST SP 955sup",
+    "NIST SP 984 4": "NIST SP 984-4",
+    "NISTPUB 0413171251": "NIST TN 1648-2009",
+    "NIST HB 135e2022-upd1": "NIST HB 135e2022/Upd1-202205",
+    "NIST SP 1900-206-upd1": "NIST SP 1900-206/Upd1-202202",
+    "NIST TN 2207-upd1": "NIST TN 2207/Upd1-202205",
+    "NIST IR 8290-upd1": "NIST IR 8290/Upd1-202205",
+    "NIST IR 8413-upd1": "NIST IR 8413/Upd1-202207",
+    "NIST IR 85-3273-37-upd1": "NIST IR 85-3273-37/Upd1-202205",
+    "NIST.AMS.300-8r1/upd": "NIST.AMS.300-8r1-upd1",
+    "NIST.hb.150-1-2017": "NIST.HB.105-1r2017",
+    "nbs.tn.671": "NBS.TN.671",
+    "NIST.TN.1648_2009": "NIST.TN.1648e2009",
+    "NBS NSRDS": "NSRDS-NBS",
+    "nist ir": "NIST IR",
+};
+const UPDATE_CODE_REGEXES = [
+    [/\bMonograph\b/, "MONO"],
+    [/,\s+(Rev\.|Part\.|Vol\.|Revision|Volume|Part)(?=\s|\d)/, " $1"],
+    [/^NBS CIRC sup$/, "NBS CIRC 24e7sup"],
+    [/-draft$/, " (Draft)"],
+    [/-draft2$/, " 2pd"],
+    [/NBS CRPL-F-B(?=\d+)/, "NBS CRPL-F-B "],
+    [/(?<=\d)es/, "(spa)"],
+    [/(?<=\d)chi/, "(zho)"],
+    [/(?<=\d)viet/, "(vie)"],
+    [/(?<=\d)port/, "(por)"],
+    [/(?<=\d)(pt)(?!\d)/, "(por)"],
+    [/(?<=\d)id/, "(ind)"],
+];
+const ROMAN_TO_ARABIC = {
+    I: "1", II: "2", III: "3", IV: "4", V: "5", VI: "6",
+    VII: "7", VIII: "8", IX: "9", X: "10",
+};
+function romanToArabic(roman) {
+    return ROMAN_TO_ARABIC[roman] ?? roman;
+}
+export function preprocessNist(input) {
+    let cleaned = input.trim();
+    const line = UPDATE_CODE_LINES[cleaned];
+    if (line !== undefined) {
+        cleaned = line;
+    }
+    for (const [pattern, replacement] of UPDATE_CODE_REGEXES) {
+        cleaned = cleaned.replace(pattern, replacement);
+    }
+    // The format describes the string the parser will see: freeze it
+    // right after the update-codes remap, before the stages' cosmetic
+    // spacing (a dotted catalogue alias that remaps to the space form
+    // renders short; the dotted originals stay mr).
+    const format = cleaned.includes(".") && !/\s/.test(cleaned) ? "mr" : "short";
+    // Short-form "supprev" is the catalogue spelling of the plain
+    // supplement ("NBS CIRC 154supprev" is "NBS CIRC 154sup"); the
+    // revision-bearing identity stays the mr spelling. Must run before
+    // the digit+suprev typo fix below.
+    if (format === "short") {
+        cleaned = cleaned.replace(/supprev/g, "sup");
+    }
+    // normalize_spurious_u_suffix
+    cleaned = cleaned.replace(/(\d)U([a-z])/g, "$1$2");
+    // normalize_publisher_and_series
+    cleaned = cleaned.replace(/^nbs\b/i, "NBS");
+    cleaned = cleaned.replace(/^nist\b/i, "NIST");
+    cleaned = cleaned.replace(/^(NBS|NIST)(IR|FIPS|GCR|HB|MONO|MP|NCSTAR|NSRDS)/i, "$1 $2");
+    cleaned = cleaned.replace(/\b(ir|sp|tn|hb|fips|ams|vts)\b/i, (m) => m.toUpperCase());
+    cleaned = cleaned.replace(/\bLC\b(?!IRC)/g, "LCIRC");
+    // normalize_lcirc_supplement_contexts
+    cleaned = cleaned.replace(/\bNBS LCIRC\b(?=.*\b(?:supp?|sup\+|r\d+\/)\d)/, "NBS.LCIRC");
+    cleaned = cleaned.replace(/\bNBS\.LCIRC\.(\d+r\d+\/\d{4})/, "NBS LCIRC $1");
+    cleaned = cleaned.replace(/\bNBS\.LCIRC\.(\d+r\d+)\b/, "NBS LCIRC $1");
+    // normalize_revision_spacing
+    cleaned = cleaned.replace(/([-\d]+[IVX]+[-\d]+)\s+(\d+)/g, "$1.$2");
+    cleaned = cleaned.replace(/(?<!e)(\d)(rev\d{4})/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d+e\d+)\.([A-Za-z]{3,9}\d{4})/g, "$1rev$2");
+    // normalize_ir_slash_year_to_update
+    if (/\bIR\b/.test(cleaned) && !cleaned.includes("CIRC")) {
+        cleaned = cleaned.replace(/(\d)r(\d{1,2})\/(\d{2,4})/g, (_m, num, mon, yr) => {
+            const yyyy = yr.length === 2 ? `19${yr}` : yr;
+            return `${num}/Upd1-${yyyy}${mon.padStart(2, "0")}`;
+        });
+    }
+    if (!cleaned.includes("LCIRC") && !cleaned.includes("CIRC")) {
+        cleaned = cleaned.replace(/(\d)(r\d+\/\d{4})/g, "$1 $2");
+    }
+    cleaned = cleaned.replace(/\b(r(?!v)\d{4})\b/g, " $1");
+    cleaned = cleaned.replace(/(\d)(r[A-Z][a-z]{2,8}\d{4})/g, "$1 $2");
+    // normalize_letter_suffix_casing
+    cleaned = cleaned.replace(/(\d)-([a-z])$/, (_m, d, l) => `${d}-${l.toUpperCase()}`);
+    // Same letter when an addendum tail follows ("-add", " Add.");
+    // part digits ("800-85a-1") and update/translation codes never match.
+    cleaned = cleaned.replace(/(\d)-([a-z])(?=\s*[-.\s]\s*[aA]dd)/, (_m, d, l) => `${d}-${l.toUpperCase()}`);
+    cleaned = cleaned.replace(/(\d)([a-qs-z])(?=\s*[-.\s]\s*[aA]dd)/, (_m, d, l) => `${d}${l.toUpperCase()}`);
+    cleaned = cleaned.replace(/(\d)([a-qs-z])$/, (_m, d, l) => `${d}${l.toUpperCase()}`);
+    cleaned = cleaned.replace(/(\d)(r)(\d+)([a-z])$/, (_m, d, r, n, l) => `${d}${r}${n}${l.toUpperCase()}`);
+    cleaned = cleaned.replace(/(\d)([a-z])(r\d)/g, (_m, d, l, r) => `${d}${l.toUpperCase()}${r}`);
+    if (!cleaned.includes("NCSTAR")) {
+        cleaned = cleaned.replace(/(\d)([a-qs-z])(v\d+)/g, (_m, d, l, v) => `${d}${l.toUpperCase()}${v}`);
+    }
+    // normalize_draft_and_volume
+    cleaned = cleaned.replace(/(\d{2}-\d{4})\s+(\d)$/, "$1 v$2");
+    cleaned = cleaned.replace(/(\d)-draft(\d)/g, "$1 -draft $2");
+    cleaned = cleaned.replace(/(\d)draft(\d)/g, "$1 -draft $2");
+    cleaned = cleaned.replace(/(\d)suprev/g, "$1supprev");
+    cleaned = cleaned.replace(/(\d{2,})([A-Z])(r\d+)([-\s]draft\d*)/g, "$1$2 $3$4");
+    // convert_roman_volumes
+    cleaned = cleaned.replace(/(\d+)-([IVX]+)-(\d+(?:\.\d+)*)/g, (_m, n, roman, ver) => `${n} v${romanToArabic(roman)} ver${ver}`);
+    // normalize_supplement_and_part
+    cleaned = cleaned.replace(/(\d)(supp\d+\/\d{4})/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)Pt(\d+)(r\d+)/g, "$1 pt$2 $3");
+    // normalize_version_notation
+    cleaned = cleaned.replace(/(\d)ver(\d)/g, "$1 ver $2");
+    cleaned = cleaned.replace(/ver(\d+)e(\d{4})/g, "ver$1 e$2");
+    cleaned = cleaned.replace(/ver(\d+)v(\d+)/g, "ver$1 v$2");
+    cleaned = cleaned.replace(/(\d)(v\d+\.\d+)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)(v\d+\.\d+)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)(v\d+)\s+(\d+)$/g, "$1 $2.$3");
+    cleaned = cleaned.replace(/(\d)(v\d+)\s+(\d+)\s+(\d+)$/g, "$1 $2.$3.$4");
+    cleaned = cleaned.replace(/(\d)(v\d+[a-z]-[a-z])/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)(v\d+[A-Z])/g, "$1 $2");
+    cleaned = cleaned.replace(/(v\d+)([A-Z])-([A-Z])/g, (_m, v, a, b) => `${v}${a}-${b.toLowerCase()}`);
+    // normalize_edition_year_suffix
+    cleaned = cleaned.replace(/(\d{4})ed\./g, "e$1");
+    // normalize_revision_with_letter
+    cleaned = cleaned.replace(/(\d+)(r\d{1,2})([a-z])(?=-|[A-Z]|$)/g, (_m, n, r, l) => `${n}${r}${l.toUpperCase()}`);
+    cleaned = cleaned.replace(/(\d+)(r\d{1,2})(?![a-zA-Z])(?=[A-Z]|-(?=[A-Z])|\/(?:upd|errata|insert))/g, "$1 $2");
+    // normalize_version_dotted_spaces
+    cleaned = cleaned.replace(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)(?!(?:pd|wd|prd|PD|WD|PRD)\b)\s+(\d+)(?!(?:pd|wd|prd|PD|WD|PRD)\b)/g, "$1.$2.$3");
+    cleaned = cleaned.replace(/(\b(?:v|\d)[v\d]*)\s+(\d+)(?!(?:pd|wd|prd|PD|WD|PRD)\b)/g, "$1.$2");
+    // normalize_update_markers
+    cleaned = cleaned.replace(/(\d+)-upd(\d*)/g, "$1 -upd$2");
+    cleaned = cleaned.replace(/(\d+)\/upd(\d*)/g, "$1 /upd$2");
+    cleaned = cleaned.replace(/([a-z]\d+)-upd/g, "$1 -upd");
+    cleaned = cleaned.replace(/([a-z]\d+)\/upd/g, "$1 /upd");
+    cleaned = cleaned.replace(/(\d+[A-Z])-upd(\d*)/g, "$1 -upd$2");
+    cleaned = cleaned.replace(/(\d+[A-Z])\/upd(\d*)/g, "$1 /upd$2");
+    // normalize_supplement_variants
+    cleaned = cleaned.replace(/(\d)(sup\d)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)(sup+)(\d)/g, "$1 $2$3");
+    cleaned = cleaned.replace(/(\d)(sup\+)(\d)/g, "$1 $2$3");
+    cleaned = cleaned.replace(/(\d)(sup\d+)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d)(sup\d+\b)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d+[A-Z])sup(\b)/g, "$1supp$2");
+    cleaned = cleaned.replace(/(\d+)sup(\d+\/\d{4})/g, "$1supp$2");
+    cleaned = cleaned.replace(/(\d)(supp?)-(\d{4})(?![\d\/])/g, "$1supp$3");
+    // normalize_revision_language
+    cleaned = cleaned.replace(/(\d[a-z])r\b/g, "$1 r");
+    cleaned = cleaned.replace(/(\d)r\z/, "$1r1");
+    cleaned = cleaned.replace(/(r\d+)(es|pt|chi|viet|port|esp)\b/g, "$1 $2");
+    // normalize_mr_translation_codes
+    cleaned = cleaned.replace(/^([A-Z]+)\.SP\.(\d+)\.([a-z]{2,4})$/, "$1.SP.$2 $3");
+    cleaned = cleaned.replace(/^([A-Z]+)\.([A-Z]+)\.(\d+)\.([a-z]{2,4})$/, "$1.$2.$3 $4");
+    // convert_dashyear_to_edition
+    cleaned = cleaned.replace(/(?<!e\d)(?<![eE-])(\d(?:[A-DF-Za-df-z]?))-(\d{4})(?=\s|$)/g, (match, prefix, year) => {
+        const yearNum = Number(year);
+        return yearNum >= 1901 && yearNum <= 2099 ? `${prefix.toUpperCase()}e${year}` : match;
+    });
+    // revert_dashyear_for_series
+    if (cleaned.includes("CIRC")) {
+        cleaned = cleaned.replace(/(CIRC[ .])(supp?)(\d{4})e(\d{4})(?=\s|$)/g, "$1$2$3-$4");
+    }
+    cleaned = cleaned.replace(/\b(HB|HB\s+)[^:\s.]*?(\d+)e(\d{4})(?=\s|$)/g, "$1$2-$3");
+    cleaned = cleaned.replace(/\b(OWMWP|OWMWP\s*)[^:\s]*?(\d{2})-(\d{2})e(\d{4})(?=\s|$)/g, "$1$2-$3-$4");
+    cleaned = cleaned.replace(/\b(RPT|RPT\s*)([^:\s]*?)(\d{4})e(\d{4})(?=\s|$)/g, (match, prefix, sep, first, second) => Number(first) < Number(second) ? `${prefix}${sep}${first}-${second}` : match);
+    // normalize_version_verbose
+    cleaned = cleaned.replace(/-v(\d+\.\d+)/g, ".ver$1");
+    cleaned = cleaned.replace(/\bVer\.\s+(\d+(?:\.\d+)*)/g, "ver$1");
+    cleaned = cleaned.replace(/\bv(\d+\.\d+(?:\.\d+)*)/g, "ver$1");
+    // normalize_part_notation
+    cleaned = cleaned.replace(/(\d)P(\d)/g, "$1 p$2");
+    cleaned = cleaned.replace(/\b([pn])(\d+)(?!\d{4}\b)/g, "pt$2");
+    cleaned = cleaned.replace(/(\d)([pP]\d+)/g, "$1 $2");
+    // normalize_series_specific_spacing
+    cleaned = cleaned.replace(/(NBS CRPL-F-[AB])(\d)/g, "$1 $2");
+    cleaned = cleaned.replace(/(CRPL-F-[AB])(\d)/g, "$1 $2");
+    cleaned = cleaned.replace(/(\d+-\d+)(v\d+)(?![.\d])/g, "$1 $2");
+    // normalize_verbose_keywords
+    cleaned = cleaned.replace(/(\d+)\s+Suppl\b/g, "$1Suppl");
+    cleaned = cleaned.replace(/\s+Version\s+(\d+)/g, " ver $1");
+    cleaned = cleaned.replace(/\s+Revision\s+\(r\)/g, " r");
+    cleaned = cleaned.replace(/\s+Part\s+(\d+)/g, "pt$1");
+    cleaned = cleaned.replace(/(\d[a-z]?)\s+Add\b\.?/gi, (_m, d) => `${d.toUpperCase()} Add.`);
+    cleaned = cleaned.replace(/(\d+)\s+rev\s+(\d{4})/g, "$1r$2");
+    cleaned = cleaned.replace(/\breport\s*;\s*/g, "RPT ");
+    cleaned = cleaned.replace(/\breport\b/g, "RPT");
+    // normalize_legacy_corpus_spellings: catalogue forms the grammar and
+    // the renderers cannot round-trip on their own. Each rule mirrors an
+    // already-parseable spelling of the same document.
+    // The mr renderer prints the translation code with its own leading
+    // dot ("955-S..uppl"); the grammar wants one dot.
+    cleaned = cleaned.replace(/\.\./g, ".");
+    // Trailing-dot addendum spelling; the canonical render comes from
+    // the lowercase ".add" parse ("NBS.TN.467pt1.Add." -> ".add").
+    cleaned = cleaned.replace(/\.Add\.$/, ".add");
+    // Edition glued to the series in mr form ("NBS.CIRCe2" is
+    // "NBS.CIRC.e2"); digits before "e" are untouched ("24e7").
+    if (format === "mr") {
+        cleaned = cleaned.replace(/([A-Z])e(\d)/g, "$1.e$2");
+    }
+    // Update markers without a number render a phantom "1";
+    // "…-upd" is the numberless spelling of "…-upd1".
+    cleaned = cleaned.replace(/-upd$/, "-upd1");
+    // NIST-era handbook renumbering in the all-dash spelling ("NIST HB
+    // 150-1-2017" -> "NIST HB 1-2017"; NBS-era compound numbers keep
+    // their number).
+    cleaned = cleaned.replace(/\b(NIST HB\s+)(?:105|150)-(\d+)-(\d{4})(?=\s|$)/, "$1$2-$3");
+    return { cleaned, format };
+}

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

@@ -0,0 +1,23 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+export declare const oasisGrammar: Grammar;
+declare class OasisUrnGenerator extends BaseUrnGenerator<OasisIdentifier> {
+    generate(): string;
+}
+export declare class OasisIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof OasisUrnGenerator;
+    readonly original: string;
+    readonly number: string | undefined;
+    readonly version: string | undefined;
+    readonly stage: string | undefined;
+    readonly part: string | undefined;
+    readonly label: string | undefined;
+    render(): string;
+}
+export declare function oasisGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/oasis/index.js

@@ -0,0 +1,110 @@
+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";
+/**
+ * 1:1 port of lib/pubid/oasis/ on the unified model. The grammar strips
+ * "OASIS " and captures the slug verbatim; the builder decomposes it
+ * order-independently by classifying WHOLE dash-fragments (stage tokens
+ * are case-sensitive). `original` alone drives the human form; the URN
+ * percent-encodes only the space and stray "]" of malformed records.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    rule("prefix", () => str("OASIS").then(str(" ")));
+    rule("slug", () => match("[\\s\\S]").repeat(1, Infinity).as("original"));
+    rule("identifier", () => rules["prefix"].then(rules["slug"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const oasisGrammar = { rules: buildRules(), root: "root" };
+class OasisUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const slug = this.identifier.original.replace(/[ \]]/g, (c) => (c === " " ? "%20" : "%5D"));
+        return `urn:oasis:${slug}`;
+    }
+}
+export class OasisIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:oasis:standard";
+    static attributes = extendAttributes(BaseIdentifier, {
+        original: { type: "string" },
+        number: { type: "string" },
+        version: { type: "string" },
+        stage: { type: "string" },
+        part: { type: "string" },
+        label: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "original", to: "original" }, { wire: "number", to: "number" }, { wire: "version", to: "version" }, { wire: "stage", to: "stage" }, { wire: "part", to: "part" }, { wire: "label", to: "label" });
+    static urnGenerator = OasisUrnGenerator;
+    render() {
+        return `OASIS ${this.original}`;
+    }
+}
+registerType(OasisIdentifier);
+// v?N(.N)+ (bare integers deliberately NOT versions); stage tokens are
+// CASE-SENSITIVE; part spellings incl. bare "Pt"/"P".
+const VERSION_RE = /^v?\d+(?:\.\d+)+$/i;
+const STAGE_RE = /^(?:CSPRD|CSD|COS|CS|WD|OS|PS|PRD|CD|Errata)\d*$/;
+const PART_RE = /^(?:Part|Pt|part|P)\d*$/;
+function classify(fragment) {
+    if (VERSION_RE.test(fragment))
+        return "version";
+    if (STAGE_RE.test(fragment))
+        return "stage";
+    if (PART_RE.test(fragment))
+        return "part";
+    return undefined;
+}
+class OasisBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return OasisIdentifier;
+    }
+    cast(key, value) {
+        if (key !== "original")
+            return value;
+        const original = String(value);
+        const attrs = { original };
+        const pairs = original.split("-").map((f) => [f, classify(f)]);
+        const leadEnd = pairs.findIndex(([, kind]) => kind !== undefined);
+        const lead = leadEnd === -1 ? pairs : pairs.slice(0, leadEnd);
+        const rest = leadEnd === -1 ? [] : pairs.slice(leadEnd);
+        const names = (ps) => {
+            const fragments = ps.filter(([, kind]) => kind === undefined).map(([f]) => f);
+            return fragments.length === 0 ? undefined : fragments.join("-");
+        };
+        const firstOf = (kind) => rest.find(([, k]) => k === kind)?.[0];
+        const number = names(lead);
+        if (number !== undefined)
+            attrs["number"] = number;
+        const version = firstOf("version");
+        if (version !== undefined)
+            attrs["version"] = version;
+        const stage = firstOf("stage");
+        if (stage !== undefined)
+            attrs["stage"] = stage;
+        const part = firstOf("part");
+        if (part !== undefined)
+            attrs["part"] = part;
+        const label = names(rest);
+        if (label !== undefined)
+            attrs["label"] = label;
+        return attrs;
+    }
+}
+export function oasisGrammarImplementation() {
+    const builder = new OasisBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(oasisGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("OASIS: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,20 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+export declare const ogcGrammar: Grammar;
+declare class OgcUrnGenerator extends BaseUrnGenerator<OgcIdentifier> {
+    generate(): string;
+}
+export declare class OgcIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof OgcUrnGenerator;
+    readonly year: string;
+    readonly number: string;
+    readonly revision: string | undefined;
+    render(): string;
+}
+export declare function ogcGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/ogc/index.js

@@ -0,0 +1,75 @@
+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";
+/**
+ * 1:1 port of lib/pubid/ogc/ on the unified model. "<yy>-<nnn>[<revision>]"
+ * with no publisher token in the printed form; strings preserve zero
+ * padding; the revision normalizes to lower case. URN:
+ * urn:ogc:<year>:<number>[:<revision>] (the Ruby flavor's generator).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = match("[\\s]").repeat(1, Infinity);
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const revision = match("[A-Za-z0-9]").repeat(1, Infinity).as("revision");
+    rule("publisher", () => str("OGC").then(space).maybe());
+    rule("identifier", () => rules["publisher"]
+        .then(digits.as("year"), str("-"), digits.as("number"))
+        .then(revision.maybe())
+        .then(space.maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ogcGrammar = { rules: buildRules(), root: "root" };
+class OgcUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const parts = ["urn", "ogc", this.identifier.year, this.identifier.number];
+        if (this.identifier.revision !== undefined)
+            parts.push(this.identifier.revision);
+        return parts.join(":");
+    }
+}
+export class OgcIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:ogc:document";
+    static attributes = extendAttributes(BaseIdentifier, {
+        year: { type: "string" },
+        number: { type: "string" },
+        revision: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "year", to: "year" }, { wire: "number", to: "number" }, { wire: "revision", to: "revision" });
+    static urnGenerator = OgcUrnGenerator;
+    render() {
+        return `${this.year}-${this.number}${this.revision ?? ""}`;
+    }
+}
+registerType(OgcIdentifier);
+class OgcBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return OgcIdentifier;
+    }
+    cast(key, value) {
+        if (key === "revision") {
+            const normalized = String(value).trim().toLowerCase();
+            return normalized === "" ? null : { revision: normalized };
+        }
+        return value;
+    }
+}
+export function ogcGrammarImplementation() {
+    const builder = new OgcBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ogcGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("OGC: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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