@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/easc/index.js

@@ -0,0 +1,107 @@
+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";
+const CYRILLIC_SERIES = { PMG: "ПМГ", RMG: "РМГ" };
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("year_sep", () => space
+        .maybe()
+        .then(str("-").or(str("—")).or(str("–")))
+        .then(space.maybe()));
+    rule("series_word", () => str("ПМГ")
+        .or(str("РМГ"))
+        .or(str("PMG"))
+        .or(str("RMG"))
+        .as("series")
+        .then(space));
+    rule("variant_word", () => str("В").or(str("V")).as("variant").then(space));
+    rule("number", () => digits.then(str(".").then(digits).repeat(0, Infinity)).as("number"));
+    rule("year", () => match("[0-9]").repeat(4, 4).or(match("[0-9]").repeat(2, 2)).as("year"));
+    rule("identifier", () => rules["series_word"]
+        .then(rules["variant_word"].maybe())
+        .then(rules["number"])
+        .then(rules["year_sep"].then(rules["year"]).maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const eascGrammar = { rules: buildRules(), root: "root" };
+function eascClass(series) {
+    class EascSeriesIdentifier extends BaseIdentifier {
+        static polymorphicName = `pubid:easc:${series.toLowerCase()}`;
+        static attributes = extendAttributes(BaseIdentifier, {
+            series: { type: "string" },
+            variant: { type: "string" },
+            number: { type: "string" },
+            year: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "series", to: "series" }, { wire: "variant", to: "variant" }, { wire: "number", to: "number" }, { wire: "year", to: "year" });
+        render() {
+            let result = CYRILLIC_SERIES[series];
+            if (this.variant === "V")
+                result += " В";
+            result += ` ${this.number}`;
+            if (this.year !== undefined)
+                result += `-${this.year}`;
+            return result;
+        }
+    }
+    class EascUrnGenerator extends BaseUrnGenerator {
+        generate() {
+            const parts = ["urn", "easc", this.identifier.series.toLowerCase()];
+            if (this.identifier.variant !== undefined)
+                parts.push(this.identifier.variant.toLowerCase());
+            parts.push(this.identifier.number);
+            if (this.identifier.year !== undefined)
+                parts.push(this.identifier.year);
+            return parts.join(":");
+        }
+    }
+    EascSeriesIdentifier.urnGenerator = EascUrnGenerator;
+    registerType(EascSeriesIdentifier);
+    return EascSeriesIdentifier;
+}
+const SERIES_CLASSES = {
+    PMG: eascClass("PMG"),
+    RMG: eascClass("RMG"),
+};
+class EascBuilder extends BaseBuilder {
+    selectClass(data) {
+        const raw = String(data["series"]).toUpperCase();
+        if (raw !== "ПМГ" && raw !== "PMG" && raw !== "РМГ" && raw !== "RMG") {
+            throw new ParseFailed(`EASC: unknown series ${raw}`, 0);
+        }
+        return SERIES_CLASSES[raw === "ПМГ" || raw === "PMG" ? "PMG" : "RMG"];
+    }
+    defaultIdentifierClass() {
+        return SERIES_CLASSES["PMG"];
+    }
+    cast(key, value) {
+        if (key === "series") {
+            const raw = String(value).toUpperCase();
+            return { series: raw === "ПМГ" || raw === "PMG" ? "PMG" : "RMG" };
+        }
+        if (key === "variant")
+            return { variant: "V" };
+        return value;
+    }
+}
+export function eascGrammarImplementation() {
+    const builder = new EascBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(eascGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("EASC: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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

package/dist/flavors/ecma/index.js

@@ -0,0 +1,117 @@
+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";
+const KIND_PREFIXES = {
+    standard: undefined,
+    "technical-report": "TR",
+    memento: "MEM",
+};
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("prefix", () => str("ECMA"));
+    rule("tr", () => str(" TR/").then(digits.as("tr_number")));
+    rule("mem", () => str(" MEM/").then(digits.as("mem_number")));
+    rule("standard_separator", () => str("-").or(str(" ")));
+    rule("standard", () => rules["standard_separator"]
+        .then(digits.as("number"))
+        .then(str("-").then(digits.as("part")).maybe()));
+    rule("edition", () => str(" ed")
+        .then(digits.then(str(".").then(digits).repeat(0, Infinity)).as("edition")));
+    rule("volume", () => str(" vol").then(digits.as("volume")));
+    rule("identifier", () => rules["prefix"]
+        .then(rules["tr"].or(rules["mem"], rules["standard"]))
+        .then(rules["edition"].maybe())
+        .then(rules["volume"].maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ecmaGrammar = { rules: buildRules(), root: "root" };
+function ecmaClass(kind) {
+    const prefix = KIND_PREFIXES[kind];
+    class EcmaKindIdentifier extends BaseIdentifier {
+        static polymorphicName = `pubid:ecma:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "string" },
+            part: { type: "string" },
+            edition: { type: "string" },
+            volume: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "edition", to: "edition" }, { wire: "volume", to: "volume" });
+        render() {
+            let core;
+            if (prefix === undefined) {
+                core = `ECMA-${this.number}${this.part === undefined ? "" : `-${this.part}`}`;
+            }
+            else {
+                core = `ECMA ${prefix}/${this.number}`;
+            }
+            if (this.edition !== undefined)
+                core += ` ed${this.edition}`;
+            if (this.volume !== undefined)
+                core += ` vol${this.volume}`;
+            return core;
+        }
+    }
+    class EcmaUrnGenerator extends BaseUrnGenerator {
+        generate() {
+            const parts = ["urn", "ecma"];
+            if (prefix !== undefined)
+                parts.push(prefix.toLowerCase());
+            parts.push(this.identifier.number);
+            if (this.identifier.part !== undefined)
+                parts.push(`part-${this.identifier.part}`);
+            if (this.identifier.edition !== undefined)
+                parts.push(`ed-${this.identifier.edition}`);
+            if (this.identifier.volume !== undefined)
+                parts.push(`vol-${this.identifier.volume}`);
+            return parts.join(":");
+        }
+    }
+    EcmaKindIdentifier.urnGenerator = EcmaUrnGenerator;
+    registerType(EcmaKindIdentifier);
+    return EcmaKindIdentifier;
+}
+const KIND_CLASSES = {
+    standard: ecmaClass("standard"),
+    "technical-report": ecmaClass("technical-report"),
+    memento: ecmaClass("memento"),
+};
+class EcmaBuilder extends BaseBuilder {
+    selectClass(data) {
+        if (data["tr_number"] !== undefined && data["tr_number"] !== null) {
+            return KIND_CLASSES["technical-report"];
+        }
+        if (data["mem_number"] !== undefined && data["mem_number"] !== null) {
+            return KIND_CLASSES["memento"];
+        }
+        return KIND_CLASSES["standard"];
+    }
+    defaultIdentifierClass() {
+        return KIND_CLASSES["standard"];
+    }
+    cast(key, value) {
+        if (key === "tr_number" || key === "mem_number") {
+            return { number: String(value) };
+        }
+        return value;
+    }
+}
+export function ecmaGrammarImplementation() {
+    const builder = new EcmaBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ecmaGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("ECMA: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,14 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { Component } from "../../model/component.js";
+export declare const etsiGrammar: Grammar;
+/** ETSI Version component: "V1.2.3" or "ed.1". */
+export declare class EtsiVersion extends Component {
+    readonly version: string;
+    readonly is_edition: boolean;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+    toWire(): Record<string, unknown>;
+    protected fieldIsDefaulted(name: string, value: unknown): boolean;
+}
+export declare function etsiGrammarImplementation(): FlavorImplementation;

package/dist/flavors/etsi/index.js

@@ -0,0 +1,307 @@
+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 { Component, PubidDate } from "../../model/component.js";
+/**
+ * Port of lib/pubid/etsi/ on the unified model — the largest corpus
+ * (24,724 rows). "ETSI TYPE CODE[-parts][/A…/C…] [V…|ed.N] (YYYY-MM)".
+ * Compact serialization: number/parts/minor flat, Version flattens to a
+ * scalar + is_edition flag (omitted when false), Date to year/month.
+ * The publisher constant is never serialized. Supplements carry only
+ * their ordinal and the nested base; their URN is the BASE's URN —
+ * Ruby's generator string-matches "SupplementIdentifier" on the class
+ * NAME, which "Amendment" doesn't contain, so supplements fall through
+ * to the base branch (corpus-recorded behavior, mirrored exactly).
+ */
+const TYPES = ["I-ETS", "TCRTR", "GTS", "ETR", "ETS", "TBR", "NET", "EN", "ES", "EG", "TS", "GR", "GS", "SR", "TR"];
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const alnum = match("[A-Za-z0-9]");
+    const alnums = alnum.repeat(1, Infinity);
+    const dot = str(".");
+    rule("etsi_prefix", () => str("ETSI").then(space));
+    rule("type", () => TYPES.reduce((acc, t) => acc.or(str(t)), str(TYPES[0])).as("type"));
+    // parslet capture() converted to named captures; the builder composes
+    // the number string from whichever keys matched.
+    rule("gsm_with_space_number", () => str("GSM").as("gsm_prefix").then(space, digits.as("main"), dot, digits.as("sub")));
+    rule("dotted_number", () => digits.as("main").then(dot, digits.as("sub")));
+    rule("complex_number", () => alnums.as("prefix1")
+        .then(str("-").then(alnums.as("prefix2")).maybe())
+        .then(space, digits.as("num")));
+    rule("simple_number", () => digits.as("num"));
+    rule("number", () => rules["gsm_with_space_number"]
+        .or(rules["dotted_number"])
+        .or(rules["complex_number"])
+        .or(rules["simple_number"])
+        .as("number"));
+    rule("minor", () => space.then(digits.as("minor")));
+    rule("part", () => str("-").then(alnums.as("part")));
+    rule("parts", () => rules["part"].repeat(0, Infinity).as("parts"));
+    rule("version", () => str("V").then(match("[0-9.]").repeat(1, Infinity).as("version")));
+    rule("edition", () => str("ed.").then(digits.as("edition")));
+    rule("version_or_edition", () => rules["version"].or(rules["edition"]));
+    rule("date_part", () => str("(")
+        .then(match("[0-9]").repeat(4, 4).as("year"), str("-"), match("[0-9]").repeat(2, 2).as("month"), str(")")));
+    rule("amendment", () => str("/A").then(digits.as("number")));
+    rule("corrigendum", () => str("/C").then(digits.as("number")));
+    rule("supplements", () => rules["amendment"].as("amendment").or(rules["corrigendum"].as("corrigendum")).repeat(1, Infinity).as("supplements"));
+    rule("identifier", () => rules["etsi_prefix"]
+        .then(rules["type"], space, rules["number"])
+        .then(rules["minor"].maybe())
+        .then(rules["parts"])
+        .then(rules["supplements"].maybe())
+        .then(space.then(rules["version_or_edition"]).maybe())
+        .then(space.then(rules["date_part"]).maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const etsiGrammar = { rules: buildRules(), root: "root" };
+/** ETSI Version component: "V1.2.3" or "ed.1". */
+export class EtsiVersion extends Component {
+    version;
+    is_edition;
+    constructor(attrs) {
+        super();
+        this.version = attrs["version"];
+        this.is_edition = attrs["is_edition"] ?? false;
+    }
+    render() {
+        return this.is_edition ? `ed.${this.version}` : `V${this.version}`;
+    }
+    toWire() {
+        return { version: this.version, is_edition: this.is_edition };
+    }
+    fieldIsDefaulted(name, value) {
+        return name === "is_edition" && value === false;
+    }
+}
+class EtsiIdentifier extends BaseIdentifier {
+    /** Components::Code#to_s: number, minor after a space, parts dashed. */
+    code() {
+        if (this.number === undefined)
+            return undefined;
+        let result = this.number;
+        if (this.minor !== undefined)
+            result += ` ${this.minor}`;
+        if (this.parts !== undefined)
+            result += this.parts.map((p) => `-${p}`).join("");
+        return result;
+    }
+    supplementNotation() {
+        return "";
+    }
+    actualBase() {
+        let current = this.base ?? this;
+        while (current.base !== undefined)
+            current = current.base;
+        return current;
+    }
+}
+// Version and Date flatten through converter mappings (Ruby's with: hooks).
+const ETSI_MAPPINGS = keyValue({ wire: "type", to: "type" }, { wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "minor", to: "minor" }, {
+    wire: "version",
+    to: "version",
+    toWire: (m) => m["version"]?.version,
+    fromWire: (h) => h["version"] === undefined || h["version"] === null
+        ? undefined
+        : new EtsiVersion({ version: String(h["version"]), is_edition: h["is_edition"] === true }),
+}, {
+    wire: "is_edition",
+    to: "version",
+    toWire: (m) => (m["version"]?.is_edition ? true : undefined),
+    fromWire: () => undefined,
+}, {
+    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"] }),
+}, { wire: "month", to: "date", toWire: (m) => m["date"]?.month, fromWire: () => undefined });
+function etsiClass(kind) {
+    const isStandard = kind === "etsi-standard";
+    class EtsiKindIdentifier extends EtsiIdentifier {
+        static polymorphicName = `pubid:etsi:${kind}`;
+        static attributes = isStandard
+            ? extendAttributes(BaseIdentifier, {
+                type: { type: "string" },
+                number: { type: "string" },
+                minor: { type: "string" },
+                parts: { type: "string", collection: true, initializeEmpty: true },
+                version: { type: EtsiVersion },
+            })
+            : extendAttributes(BaseIdentifier, {
+                base: { type: EtsiIdentifier },
+                number: { type: "integer" },
+            });
+        static mappings = isStandard
+            ? ETSI_MAPPINGS
+            : keyValue({ wire: "number", to: "number" }, { wire: "base", to: "base" });
+        render() {
+            if (isStandard) {
+                let result = `ETSI ${this.type} ${this.code()}`;
+                if (this.version !== undefined)
+                    result += ` ${this.version.render()}`;
+                const d = this.date?.render();
+                if (d !== undefined && d !== "")
+                    result += ` (${d})`;
+                return result;
+            }
+            // render_supplement: the innermost base code plus the chain of
+            // notations ("/A1/C2"), innermost first.
+            const notations = [];
+            const collect = (id) => {
+                if (id.base !== undefined) {
+                    notations.unshift(`/${id.supplementNotation()}`);
+                    collect(id.base);
+                }
+            };
+            collect(this);
+            const actualBase = this.actualBase();
+            let result = `ETSI ${actualBase.type} ${actualBase.code()}${notations.join("")}`;
+            if (actualBase.version !== undefined)
+                result += ` ${actualBase.version.render()}`;
+            const d = actualBase.date?.render();
+            if (d !== undefined && d !== "")
+                result += ` (${d})`;
+            return result;
+        }
+        supplementNotation() {
+            const prefix = kind === "corrigendum" ? "C" : "A";
+            return `${prefix}${this.number ?? ""}`;
+        }
+    }
+    registerType(EtsiKindIdentifier);
+    return EtsiKindIdentifier;
+}
+const KIND_CLASSES = {
+    "etsi-standard": etsiClass("etsi-standard"),
+    amendment: etsiClass("amendment"),
+    corrigendum: etsiClass("corrigendum"),
+};
+class EtsiUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        // Ruby's generator string-matches "SupplementIdentifier" on the
+        // class NAME; "Amendment"/"Corrigendum" don't contain it, so every
+        // supplement produces the BASE urn — mirrored exactly. The base's
+        // type/code/version/date delegate transitively down a supplement
+        // chain, i.e. they are the innermost standard's.
+        const id = this.identifier.actualBase();
+        const parts = ["urn", "etsi"];
+        if (id.type !== undefined)
+            parts.push(id.type.toLowerCase());
+        const code = id.code();
+        if (code !== undefined)
+            parts.push(code);
+        if (id.version !== undefined)
+            parts.push(id.version.render().toLowerCase());
+        const d = id.date?.render();
+        if (d !== undefined && d !== "")
+            parts.push(d);
+        return parts.join(":");
+    }
+}
+for (const klass of Object.values(KIND_CLASSES)) {
+    klass.urnGenerator = EtsiUrnGenerator;
+}
+function isObj(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function composeNumber(numberData) {
+    if (isObj(numberData)) {
+        const main = numberData["main"];
+        const sub = numberData["sub"];
+        if (numberData["gsm_prefix"] !== undefined)
+            return `GSM ${String(main)}.${String(sub)}`;
+        if (main !== undefined && sub !== undefined)
+            return `${String(main)}.${String(sub)}`;
+        if (numberData["prefix1"] !== undefined) {
+            let prefix = String(numberData["prefix1"]);
+            if (numberData["prefix2"] !== undefined)
+                prefix += `-${String(numberData["prefix2"])}`;
+            return `${prefix} ${String(numberData["num"])}`;
+        }
+        return String(numberData["num"]);
+    }
+    return String(numberData);
+}
+function extractParts(partsData) {
+    if (Array.isArray(partsData)) {
+        return partsData.map((p) => (isObj(p) ? String(p["part"]) : String(p)));
+    }
+    if (isObj(partsData) && partsData["part"] !== undefined)
+        return [String(partsData["part"])];
+    return [];
+}
+class EtsiBuilder {
+    build(data) {
+        const tree = (Array.isArray(data) ? Object.assign({}, ...data) : data);
+        if (tree["supplements"] !== undefined)
+            return this.buildWithSupplements(tree);
+        return this.buildStandard(tree);
+    }
+    buildStandard(data) {
+        const attrs = {
+            type: String(data["type"]),
+            number: composeNumber(data["number"]),
+            parts: extractParts(data["parts"]),
+        };
+        if (data["minor"] !== undefined && data["minor"] !== null) {
+            attrs["minor"] = String(data["minor"]);
+        }
+        if (data["version"] !== undefined && data["version"] !== null) {
+            attrs["version"] = new EtsiVersion({ version: String(data["version"]), is_edition: false });
+        }
+        else if (data["edition"] !== undefined && data["edition"] !== null) {
+            attrs["version"] = new EtsiVersion({ version: String(data["edition"]), is_edition: true });
+        }
+        if (data["year"] !== undefined && data["year"] !== null) {
+            attrs["date"] = new PubidDate({ year: String(data["year"]), month: data["month"] === undefined || data["month"] === null ? undefined : String(data["month"]) });
+        }
+        return new KIND_CLASSES["etsi-standard"](attrs);
+    }
+    buildWithSupplements(data) {
+        const baseData = { ...data };
+        delete baseData["supplements"];
+        let base = this.buildStandard(baseData);
+        const supplements = Array.isArray(data["supplements"]) ? data["supplements"] : [data["supplements"]];
+        for (const supp of supplements) {
+            if (!isObj(supp))
+                continue;
+            if (supp["amendment"] !== undefined) {
+                const inner = isObj(supp["amendment"]) ? supp["amendment"] : undefined;
+                base = new KIND_CLASSES["amendment"]({
+                    base,
+                    number: Number(inner === undefined ? supp["amendment"] : inner["number"]),
+                });
+            }
+            else if (supp["corrigendum"] !== undefined) {
+                const inner = isObj(supp["corrigendum"]) ? supp["corrigendum"] : undefined;
+                base = new KIND_CLASSES["corrigendum"]({
+                    base,
+                    number: Number(inner === undefined ? supp["corrigendum"] : inner["number"]),
+                });
+            }
+        }
+        return base;
+    }
+}
+export function etsiGrammarImplementation() {
+    const builder = new EtsiBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(etsiGrammar, input);
+            if (typeof tree !== "object" || tree === null) {
+                throw new ParseFailed("ETSI: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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

package/dist/flavors/evs/grammar.js

@@ -0,0 +1,22 @@
+import { ref, str } from "../../grammar/engine.js";
+import { cenCenelecGrammar } from "../cen_cenelec/grammar.js";
+/**
+ * Port of lib/pubid/evs/parser.rb — "EVS" ("-" | " ") <CEN identifier>,
+ * with the CEN/CENELEC grammar's identifier rule embedded as an atom
+ * (the adopted subtree goes straight to the CEN builder as data, no
+ * string re-serialization).
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    rule("root", () => str("EVS")
+        .then(str("-").or(str(" ")).as("evs_separator"))
+        .then(ref(cenCenelecGrammar.rules, "identifier").as("adopted")));
+    return rules;
+}
+export const evsGrammar = {
+    rules: buildRules(),
+    root: "root",
+};

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

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

package/dist/flavors/evs/index.js

@@ -0,0 +1,24 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { evsGrammar } from "./grammar.js";
+import { buildCenIdentifier } from "../cen_cenelec/index.js";
+import { NationalAdoption } from "./model.js";
+/**
+ * Port of lib/pubid/evs/builder.rb — the :adopted subtree (from the
+ * embedded CEN grammar) goes to the CEN/CENELEC builder as data.
+ */
+function buildIdentifier(tree) {
+    const d = Array.isArray(tree)
+        ? Object.assign({}, ...tree)
+        : tree;
+    const separator = d["evs_separator"] !== undefined ? String(d["evs_separator"]) : "-";
+    const base = buildCenIdentifier(d["adopted"]);
+    return new NationalAdoption({ base, separator });
+}
+export function evsGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(evsGrammar, input);
+            return buildIdentifier(tree);
+        },
+    };
+}

package/dist/flavors/evs/model.d.ts

@@ -0,0 +1,19 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { CenIdentifier } from "../cen_cenelec/model.js";
+declare class EvsUrnGenerator extends BaseUrnGenerator<EvsIdentifier> {
+    generate(): string;
+}
+export declare abstract class EvsIdentifier extends BaseIdentifier {
+    readonly base: CenIdentifier | undefined;
+    readonly separator: string | undefined;
+}
+export declare class NationalAdoption extends EvsIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof EvsUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    render(): string;
+}
+export {};

package/dist/flavors/evs/model.js

@@ -0,0 +1,36 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { CenIdentifier } from "../cen_cenelec/model.js";
+/**
+ * Port of lib/pubid/evs: the national-adoption identifier wrapping a
+ * CEN/CENELEC base, the renderer ("EVS" + separator + adopted) and the
+ * URN generator (the adopted CEN URN with urn:cen: swapped for
+ * urn:evs:).
+ */
+const CEN_NAMESPACE = "urn:cen:";
+const EVS_NAMESPACE = "urn:evs:";
+class EvsUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const adoptedUrn = this.identifier.base?.toUrn() ?? "";
+        if (!adoptedUrn.startsWith(CEN_NAMESPACE)) {
+            throw new Error(`expected adopted CEN URN, got ${JSON.stringify(adoptedUrn)}`);
+        }
+        return EVS_NAMESPACE + adoptedUrn.slice(CEN_NAMESPACE.length);
+    }
+}
+export class EvsIdentifier extends BaseIdentifier {
+}
+export class NationalAdoption extends EvsIdentifier {
+    static polymorphicName = "pubid:evs:national-adoption";
+    static urnGenerator = EvsUrnGenerator;
+    static attributes = extendAttributes(EvsIdentifier, {
+        base: { type: CenIdentifier },
+        separator: { type: "string", default: "-" },
+    });
+    static mappings = keyValue({ wire: "base", to: "base" }, { wire: "separator", to: "separator" });
+    render() {
+        return `EVS${this.separator ?? "-"}${this.base?.toHuman() ?? ""}`;
+    }
+}
+registerType(NationalAdoption);