@pubid/pubid 0.1.3 → 0.1.4

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

@@ -0,0 +1,14 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+export declare const omgGrammar: Grammar;
+export declare class OmgIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly acronym: string;
+    readonly version: string | undefined;
+    readonly part: string | undefined;
+    render(): string;
+}
+export declare function omgGrammarImplementation(): FlavorImplementation;

package/dist/flavors/omg/index.js

@@ -0,0 +1,73 @@
+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 { BaseBuilder } from "../../model/builder.js";
+/**
+ * 1:1 port of lib/pubid/omg/ on the unified model. The Ruby flavor has
+ * no urn_generator, so toUrn() resolves to the base template: only
+ * `part` hits a slot, deriving "urn:omg:-PDF" / bare "urn:omg".
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const acronymChar = match("[A-Za-z0-9+]");
+    const wordBoundary = match("[A-Za-z0-9]").absent();
+    const beta = str(" beta").then(wordBoundary, space.then(match("[0-9]").repeat(1, Infinity), wordBoundary).maybe());
+    const partSeparator = space.or(str("/"));
+    rule("acronym", () => match("[A-Za-z]")
+        .then(acronymChar.repeat(0, Infinity), match("[-/]")
+        .then(acronymChar.repeat(1, Infinity))
+        .repeat(0, Infinity))
+        .as("acronym"));
+    rule("version", () => match("[0-9]")
+        .repeat(1, Infinity)
+        .then(str(".").then(match("[0-9]").repeat(1, Infinity)).repeat(0, Infinity), beta.maybe())
+        .as("version"));
+    rule("part", () => match("[A-Za-z0-9]").repeat(1, Infinity).as("part"));
+    rule("identifier", () => str("OMG").then(space, rules["acronym"], space
+        .then(rules["version"], partSeparator.then(rules["part"]).maybe())
+        .or(space.then(rules["part"]))
+        .maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const omgGrammar = { rules: buildRules(), root: "root" };
+export class OmgIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:omg:specification";
+    static attributes = extendAttributes(BaseIdentifier, {
+        acronym: { type: "string" },
+        version: { type: "string" },
+        part: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "acronym", to: "acronym" }, { wire: "version", to: "version" }, { wire: "part", to: "part" });
+    render() {
+        let result = `OMG ${this.acronym}`;
+        if (this.version !== undefined)
+            result += ` ${this.version}`;
+        if (this.part !== undefined)
+            result += ` ${this.part}`;
+        return result;
+    }
+}
+registerType(OmgIdentifier);
+class OmgBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return OmgIdentifier;
+    }
+}
+export function omgGrammarImplementation() {
+    const builder = new OmgBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(omgGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("OMG: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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

package/dist/flavors/plateau/index.js

@@ -0,0 +1,97 @@
+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";
+const KIND_TYPES = {
+    handbook: "pubid:plateau:handbook",
+    "technical-report": "pubid:plateau:technical-report",
+};
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("doc_type", () => str("Handbook").or(str("Technical Report")).as("type"));
+    rule("number", () => str("#").then(digits.as("number")));
+    rule("annex", () => str("-").or(str("_")).then(digits.as("annex")));
+    rule("edition_part", () => str("第").then(digits.then(str("."), digits).as("edition"), str("版")));
+    rule("edition_latin", () => digits.then(str("."), digits).as("edition"));
+    rule("edition", () => space.then(rules["edition_part"].or(rules["edition_latin"])));
+    rule("annex_supplement", () => space.then(str("Annex")).then(space, match("[A-Z]").as("annex_letter")));
+    rule("handbook", () => str("PLATEAU")
+        .then(space, rules["doc_type"], space, rules["number"])
+        .then(rules["annex"].maybe())
+        .then(rules["edition"].maybe()));
+    rule("identifier", () => rules["handbook"]
+        .then(rules["annex_supplement"])
+        .as("base")
+        .or(rules["handbook"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const plateauGrammar = { rules: buildRules(), root: "root" };
+const pad2 = (n) => String(n).padStart(2, "0");
+function plateauClass(kind) {
+    const isHandbook = kind === "handbook";
+    class PlateauKindIdentifier extends BaseIdentifier {
+        static polymorphicName = KIND_TYPES[kind];
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "integer" },
+            annex: { type: "integer" },
+            edition: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "edition", to: "edition" }, { wire: "annex", to: "annex" });
+        render() {
+            let result = `PLATEAU ${isHandbook ? "Handbook" : "Technical Report"} #${pad2(this.number)}`;
+            if (this.annex !== undefined)
+                result += `-${this.annex}`;
+            if (isHandbook && this.edition !== undefined)
+                result += ` 第${this.edition}版`;
+            return result;
+        }
+    }
+    class PlateauUrnGenerator extends BaseUrnGenerator {
+        generate() {
+            const id = this.identifier;
+            const parts = ["urn", "plateau", isHandbook ? "handbook" : "tr", pad2(id.number)];
+            if (id.annex !== undefined)
+                parts.push(pad2(id.annex));
+            return parts.join(":");
+        }
+    }
+    PlateauKindIdentifier.urnGenerator = PlateauUrnGenerator;
+    registerType(PlateauKindIdentifier);
+    return PlateauKindIdentifier;
+}
+const KIND_CLASSES = {
+    handbook: plateauClass("handbook"),
+    "technical-report": plateauClass("technical-report"),
+};
+export function plateauGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(plateauGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("PLATEAU: unexpected parse tree", 0);
+            }
+            const data = tree;
+            if (data["base"] !== undefined) {
+                throw new ParseFailed("PLATEAU: Annex supplements are unsupported upstream", 0);
+            }
+            const kind = String(data["type"]) === "Handbook" ? "handbook" : "technical-report";
+            const attrs = { number: Number(data["number"]) };
+            if (data["annex"] !== undefined && data["annex"] !== null) {
+                attrs["annex"] = Number(data["annex"]);
+            }
+            // A legacy Latin TR edition is captured by the shared handbook
+            // rule and dropped for Technical Report (Ruby builder parity).
+            if (data["edition"] !== undefined && data["edition"] !== null && kind === "handbook") {
+                attrs["edition"] = String(data["edition"]);
+            }
+            return new KIND_CLASSES[kind](attrs);
+        },
+    };
+}

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

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

package/dist/flavors/tgpp/index.js

@@ -0,0 +1,122 @@
+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 = {
+    "technical-report": "TR",
+    "technical-specification": "TS",
+};
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const space = str(" ");
+    const any = match("[\\s\\S]");
+    rule("publisher_prefix", () => str("3GPP").then(space));
+    rule("type", () => str("TR").or(str("TS")).as("type"));
+    rule("number_core", () => digits.then(str("."), digits).as("number"));
+    rule("suffix", () => match("[A-Za-z]").repeat(1, Infinity).as("suffix"));
+    rule("part", () => str("-").then(digits.as("part")));
+    rule("parts", () => rules["part"].repeat(0, Infinity).as("parts"));
+    rule("version_core", () => digits.then(str("."), digits, str("."), digits));
+    rule("release", () => rules["version_core"]
+        .then(any.absent())
+        .absent()
+        .then(match("[^/:]").repeat(1, Infinity).as("release")));
+    rule("version", () => rules["version_core"].as("version"));
+    rule("identifier", () => rules["publisher_prefix"]
+        .maybe()
+        .then(rules["type"], space, rules["number_core"])
+        .then(rules["suffix"].maybe())
+        .then(rules["parts"])
+        .then(str(":").then(rules["release"]).maybe())
+        .then(str("/").then(rules["version"]).maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const tgppGrammar = { rules: buildRules(), root: "root" };
+function tgppClass(kind) {
+    const prefix = KIND_PREFIXES[kind];
+    class TgppKindIdentifier extends BaseIdentifier {
+        static polymorphicName = `pubid:3gpp:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "string" },
+            suffix: { type: "string" },
+            parts: { type: "string", collection: true, initializeEmpty: true },
+            release: { type: "string" },
+            version: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "suffix", to: "suffix" }, { wire: "parts", to: "parts" }, { wire: "release", to: "release" }, { wire: "version", to: "version" });
+        code() {
+            let result = this.number + (this.suffix ?? "");
+            if (this.parts.length > 0)
+                result += this.parts.map((p) => `-${p}`).join("");
+            return result;
+        }
+        render() {
+            let result = `${prefix} ${this.code()}`;
+            if (this.release !== undefined && this.release !== "")
+                result += `:${this.release}`;
+            if (this.version !== undefined && this.version !== "")
+                result += `/${this.version}`;
+            return result;
+        }
+    }
+    class TgppUrnGenerator extends BaseUrnGenerator {
+        generate() {
+            const id = this.identifier;
+            const tail = [id.release, id.version];
+            while (tail.length > 0 && (tail[tail.length - 1] === undefined || tail[tail.length - 1] === "")) {
+                tail.pop();
+            }
+            return ["urn", "3gpp", prefix.toLowerCase(), id.code(), ...tail.map((s) => s ?? "")].join(":");
+        }
+    }
+    TgppKindIdentifier.urnGenerator = TgppUrnGenerator;
+    registerType(TgppKindIdentifier);
+    return TgppKindIdentifier;
+}
+const KIND_CLASSES = {
+    "technical-report": tgppClass("technical-report"),
+    "technical-specification": tgppClass("technical-specification"),
+};
+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 TgppBuilder extends BaseBuilder {
+    selectClass(data) {
+        return KIND_CLASSES[String(data["type"]) === "TR" ? "technical-report" : "technical-specification"];
+    }
+    defaultIdentifierClass() {
+        return KIND_CLASSES["technical-specification"];
+    }
+    cast(key, value) {
+        if (key === "parts")
+            return { parts: extractParts(value) };
+        return value;
+    }
+}
+export function tgppGrammarImplementation() {
+    const builder = new TgppBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(tgppGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("3GPP: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,13 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+export declare const unGrammar: Grammar;
+export declare class UnIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly path: string[];
+    readonly number: string;
+    render(): string;
+}
+export declare function unGrammarImplementation(): FlavorImplementation;

package/dist/flavors/un/index.js

@@ -0,0 +1,90 @@
+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 { BaseBuilder } from "../../model/builder.js";
+import { PubidDate } from "../../model/component.js";
+/**
+ * 1:1 port of lib/pubid/un/ on the unified model. The builder derives a
+ * runtime `date` (a 4-digit path token) exactly like Ruby; un's key_value
+ * maps ONLY path/number, so the date never serializes (the mapping
+ * whitelist) while the base URN generator still reads it: the year-only
+ * render of a degenerate PubidDate yields "urn:un:<number>[:<year>]".
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const slash = str("/");
+    const token = match("[A-Z0-9.]").repeat(1, Infinity);
+    rule("un_prefix", () => str("UN").then(str(" ")).maybe());
+    rule("identifier", () => rules["un_prefix"]
+        .then(token.as("token"), slash.then(token.as("token")).repeat(1, Infinity)));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const unGrammar = { rules: buildRules(), root: "root" };
+export class UnIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:un:document";
+    static attributes = extendAttributes(BaseIdentifier, {
+        path: { type: "string", collection: true, default: [] },
+        number: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "path", to: "path" }, { wire: "number", to: "number" });
+    render() {
+        return [...this.path, this.number].join("/");
+    }
+}
+registerType(UnIdentifier);
+class UnBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return UnIdentifier;
+    }
+    cast(key, value) {
+        if (key !== "token")
+            return value;
+        void value;
+        return null; // handled in handleKey below (needs the full token list)
+    }
+    handleKey(_identifier, key, value) {
+        return key === "token";
+    }
+    build(data) {
+        // The parslet tree is a top-level ARRAY of {token: …} hashes (the
+        // repeat-of-captures shape); extract directly — merging would
+        // collide the repeated key (Ruby's builder iterates the array too).
+        const tokens = this.extractTokens(Array.isArray(data) ? data : data["token"]);
+        if (tokens.length === 0)
+            throw new ParseFailed("UN identifier has no tokens", 0);
+        const path = tokens.slice(0, -1);
+        // Only a PATH token is the date year ("TRADE/WP.4/1068" has none —
+        // a 4-digit NUMBER is not a year).
+        const yearToken = [...path].reverse().find((t) => /^\d{4}$/.test(t));
+        const attrs = {
+            number: tokens[tokens.length - 1],
+            path,
+        };
+        if (yearToken)
+            attrs["date"] = new PubidDate({ year: yearToken });
+        return new UnIdentifier(attrs);
+    }
+    extractTokens(raw) {
+        const toStrings = (v) => Array.isArray(v)
+            ? v.flatMap(toStrings)
+            : typeof v === "object" && v !== null
+                ? toStrings(v["token"])
+                : v === undefined || v === null
+                    ? []
+                    : [String(v)];
+        return toStrings(raw);
+    }
+}
+export function unGrammarImplementation() {
+    const builder = new UnBuilder();
+    return {
+        parse(input) {
+            return builder.build(parseGrammar(unGrammar, input));
+        },
+    };
+}

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

@@ -0,0 +1,14 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+/**
+ * 1:1 port of lib/pubid/w3c/ on the unified model. "W3C [TYPE-]slug[-date]";
+ * the grammar splits only the maturity token, the builder applies the
+ * fixed-width trailing-date split (8/6/4 digits — slugs like "url-1" or
+ * "DSIG-label-971024.html" never mis-split). Eleven kinds, one per W3C
+ * maturity level; `date` is a plain string in Ruby (never a PubidDate).
+ */
+declare const W3C_KINDS: readonly ["standard", "note", "draft-note", "working-draft", "candidate-recommendation", "candidate-recommendation-draft", "recommendation", "proposed-recommendation", "proposed-edited-recommendation", "superseded-recommendation", "obsolete-recommendation"];
+export type W3cKind = (typeof W3C_KINDS)[number];
+export declare const w3cGrammar: Grammar;
+export declare function w3cGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/w3c/index.js

@@ -0,0 +1,148 @@
+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/w3c/ on the unified model. "W3C [TYPE-]slug[-date]";
+ * the grammar splits only the maturity token, the builder applies the
+ * fixed-width trailing-date split (8/6/4 digits — slugs like "url-1" or
+ * "DSIG-label-971024.html" never mis-split). Eleven kinds, one per W3C
+ * maturity level; `date` is a plain string in Ruby (never a PubidDate).
+ */
+const W3C_KINDS = [
+    "standard",
+    "note",
+    "draft-note",
+    "working-draft",
+    "candidate-recommendation",
+    "candidate-recommendation-draft",
+    "recommendation",
+    "proposed-recommendation",
+    "proposed-edited-recommendation",
+    "superseded-recommendation",
+    "obsolete-recommendation",
+];
+// Printed token -> kind; DNOTE before NOTE, CRD before CR, PER before PR.
+const TOKEN_KINDS = [
+    ["DNOTE", "draft-note"],
+    ["NOTE", "note"],
+    ["WD", "working-draft"],
+    ["CRD", "candidate-recommendation-draft"],
+    ["CR", "candidate-recommendation"],
+    ["REC", "recommendation"],
+    ["PER", "proposed-edited-recommendation"],
+    ["PR", "proposed-recommendation"],
+    ["SPSD", "superseded-recommendation"],
+    ["OBSL", "obsolete-recommendation"],
+];
+const KIND_TOKENS = {
+    standard: undefined,
+    note: "NOTE",
+    "draft-note": "DNOTE",
+    "working-draft": "WD",
+    "candidate-recommendation": "CR",
+    "candidate-recommendation-draft": "CRD",
+    recommendation: "REC",
+    "proposed-recommendation": "PR",
+    "proposed-edited-recommendation": "PER",
+    "superseded-recommendation": "SPSD",
+    "obsolete-recommendation": "OBSL",
+};
+function buildRules() {
+    const rules = {};
+    const [first, ...others] = TOKEN_KINDS;
+    const typeToken = others.reduce((acc, [token]) => acc.or(str(token)), str(first[0]));
+    ruleInit(rules, "prefix", () => str("W3C").then(str(" ")));
+    // A leading token is only a type when immediately followed by "-".
+    ruleInit(rules, "type_part", () => typeToken.as("type").then(str("-")));
+    ruleInit(rules, "rest", () => match("[\\s\\S]").repeat(1, Infinity).as("rest"));
+    ruleInit(rules, "identifier", () => rules["prefix"]
+        .then(rules["type_part"].maybe())
+        .then(rules["rest"]));
+    ruleInit(rules, "root", () => rules["identifier"]);
+    return rules;
+}
+function ruleInit(rules, name, build) {
+    rules[name] = build();
+}
+export const w3cGrammar = { rules: buildRules(), root: "root" };
+const KIND_CLASSES = {};
+function w3cClass(kind) {
+    const token = KIND_TOKENS[kind];
+    class W3cKindIdentifier extends BaseIdentifier {
+        static polymorphicName = `pubid:w3c:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "string" },
+            date: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "date", to: "date" });
+        render() {
+            let body = token === undefined ? "" : `${token}-`;
+            body += this.number;
+            if (this.date !== undefined)
+                body += `-${this.date}`;
+            return `W3C ${body}`;
+        }
+    }
+    registerType(W3cKindIdentifier);
+    return W3cKindIdentifier;
+}
+for (const kind of W3C_KINDS) {
+    KIND_CLASSES[kind] = w3cClass(kind);
+}
+class W3cUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const kind = (this.identifier.constructor.polymorphicName.slice("pubid:w3c:".length));
+        const parts = ["urn", "w3c"];
+        const token = KIND_TOKENS[kind];
+        if (token !== undefined)
+            parts.push(token.toLowerCase());
+        parts.push(id.number);
+        if (id.date !== undefined)
+            parts.push(id.date);
+        return parts.join(":");
+    }
+}
+for (const kind of W3C_KINDS) {
+    KIND_CLASSES[kind].urnGenerator = W3cUrnGenerator;
+}
+const DATE_RE = /^(.+)-(\d{8}|\d{6}|\d{4})$/;
+function kindForToken(token) {
+    if (token === undefined)
+        return "standard";
+    const entry = TOKEN_KINDS.find(([t]) => t === token);
+    if (!entry)
+        throw new ParseFailed(`W3C: unknown type token ${token}`, 0);
+    return entry[1];
+}
+class W3cBuilder extends BaseBuilder {
+    selectClass(data) {
+        const type = data["type"];
+        return KIND_CLASSES[kindForToken(type === undefined || type === null ? undefined : String(type))];
+    }
+    defaultIdentifierClass() {
+        return KIND_CLASSES["standard"];
+    }
+    cast(key, value) {
+        if (key !== "rest")
+            return value;
+        const rest = String(value);
+        const m = DATE_RE.exec(rest);
+        return m ? { number: m[1], date: m[2] } : { number: rest };
+    }
+}
+export function w3cGrammarImplementation() {
+    const builder = new W3cBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(w3cGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("W3C: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+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 xsfGrammar: Grammar;
+declare class XsfUrnGenerator extends BaseUrnGenerator<XsfIdentifier> {
+    generate(): string;
+}
+export declare class XsfIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof XsfUrnGenerator;
+    readonly number: string;
+    render(): string;
+}
+export declare function xsfGrammarImplementation(): FlavorImplementation;
+export {};