@pubid/pubid 0.1.3 → 0.1.5

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 {};

package/dist/flavors/xsf/index.js

@@ -0,0 +1,65 @@
+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/xsf/ on the unified model. XEP numbers, plus the
+ * two named documents ("XEP README", "XEP xxxx") kept verbatim. URN:
+ * urn:xsf:xep:<number> (the Ruby flavor's own generator).
+ */
+// The editor README and the xep-xxxx template reach pubid as real
+// primary docids.
+const SPECIAL_NUMBERS = ["README", "xxxx"];
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const specialNumber = SPECIAL_NUMBERS.map((name) => str(name)).reduce((a, b) => a.or(b));
+    rule("special_number", () => specialNumber);
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("digits", () => digits);
+    rule("identifier", () => str("XEP").then(str(" "), digits.or(specialNumber).as("number")));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const xsfGrammar = {
+    rules: buildRules(),
+    root: "root",
+};
+class XsfUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        return ["urn", "xsf", "xep", this.identifier.number].join(":");
+    }
+}
+export class XsfIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:xsf:xep";
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" });
+    static urnGenerator = XsfUrnGenerator;
+    render() {
+        return `XEP ${this.number}`;
+    }
+}
+registerType(XsfIdentifier);
+class XsfBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return XsfIdentifier;
+    }
+}
+export function xsfGrammarImplementation() {
+    const builder = new XsfBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(xsfGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("XSF: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

package/dist/grammar/engine.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A parslet-compatible parser-combinator engine.
+ *
+ * The Ruby pubid grammars are declarative parslet rule trees; porting a
+ * flavor 1:1 requires the TypeScript engine to reproduce parslet's tree
+ * semantics exactly, because the Ruby builders read those trees. The
+ * semantics below were pinned empirically against parslet 2.0 (see the
+ * porting guide in docs/PORTING.md):
+ *
+ * - atoms produce a string, a capture hash, an array, or nil
+ * - sequences fold with `combine`: string+string concat; a plain string
+ *   is DISCARDED when combined with a capture; hash+hash merges and a
+ *   duplicate key raises; nil is transparent
+ * - `.as(key)` wraps the result: {key: result}
+ * - `.repeat` is greedy and does NOT backtrack a successful iteration to
+ *   satisfy an outer minimum (parslet: "Expected at least N of ...");
+ *   results are an array when any iteration captured, else a concat string
+ * - `.maybe` is special-cased like parslet's Maybe: one attempt, nil on
+ *   failure (not an empty array)
+ * - `absent?`/`present?` are zero-width lookaheads
+ * - full input consumption is enforced the way parslet 2.0 does it: a
+ *   `consumeAll` flag is threaded down the parse spine — the root starts
+ *   with it, a Sequence hands it ONLY to its last child, Alternatives
+ *   pass it to every branch, and Repetition iterations never get it. An
+ *   atom that succeeds while unconsumed input remains FAILS (parslet
+ *   Base#apply's "Don't know what to do with ..." check). Because that
+ *   failure is an ordinary match failure, an enclosing Alternative
+ *   retries its next branch — so `a | b` DOES re-try `b` when `a`
+ *   matched but left trailing input (pinned against parslet: bare
+ *   "080442957X" reaches ISBN's second body alternative this way).
+ */
+export declare class ParseFailed extends Error {
+    readonly pos: number;
+    constructor(message: string, pos: number);
+}
+export type Tree = string | number | TreeObject | Tree[] | null | undefined;
+export interface TreeObject {
+    [key: string]: Tree;
+}
+/** Context threaded through every match attempt. */
+declare class Ctx {
+    input: string;
+    pos: number;
+    constructor(input: string);
+}
+export interface Atom {
+    /** Attempt a match at ctx.pos; failure throws Fail. */
+    _match(ctx: Ctx, consumeAll: boolean): Tree | undefined;
+}
+/** Builder-side sugar: chainable wrapper. */
+export declare class P {
+    readonly atom: Atom;
+    constructor(atom: Atom);
+    then(...next: (P | Atom)[]): P;
+    or(...others: (P | Atom)[]): P;
+    repeat(min?: number, max?: number): P;
+    maybe(): P;
+    as(key: string): P;
+    absent(): P;
+    present(): P;
+}
+export declare function unwrap(p: P | Atom): Atom;
+export declare function str(s: string): P;
+/** parslet's match: a single-character regex match, e.g. match("[a-z]"). */
+export declare function match(pattern: string): P;
+/** A named rule reference (lazily resolved — grammars are recursive). */
+export declare function ref(rules: Record<string, P | Atom>, name: string): P;
+export interface Grammar {
+    rules: Record<string, P | Atom>;
+    root: string;
+}
+/**
+ * Parse the whole input with the grammar's root rule, parslet-style:
+ * full consumption is enforced by the root's consumeAll flag, so an
+ * Alternative at the spine retries a branch that left trailing input.
+ */
+export declare function parseGrammar(grammar: Grammar, input: string): Tree;
+export {};