@pubid/pubid 0.1.3 → 0.1.4

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

@@ -0,0 +1,30 @@
+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 ietfGrammar: Grammar;
+declare abstract class IetfIdentifier extends BaseIdentifier {
+    readonly number: string | undefined;
+    /** Fail loudly on a nil number rather than keying the index under "". */
+    requireNumber(): string;
+}
+declare class IetfUrnGenerator extends BaseUrnGenerator<IetfIdentifier> {
+    generate(): string;
+}
+export declare class IetfRfc extends IetfIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof IetfUrnGenerator;
+    render(): string;
+}
+export declare class IetfInternetDraft extends IetfIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    static urnGenerator: typeof IetfUrnGenerator;
+    readonly version: string | undefined;
+    render(): string;
+}
+export declare function ietfGrammarImplementation(): FlavorImplementation;
+export {};

package/dist/flavors/ietf/index.js

@@ -0,0 +1,151 @@
+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";
+/**
+ * 1:1 port of lib/pubid/ietf/ on the unified model — 2,526 corpus rows.
+ * Three flat families keyed by leading token: RFC, the BCP/STD/FYI
+ * sub-series (series derived from the class, never stored — `_type`
+ * already carries it), and Internet-Drafts (slug including "draft-" in
+ * `number`, optional trailing two-digit `version`). URNs:
+ * urn:ietf:rfc:n / urn:ietf:{bcp|std|fyi}:n / urn:ietf:id:draft-slug[:v].
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const digits = match("[0-9]").repeat(1, Infinity);
+    // "RFC 2119" and the zero-padded space-less spelling rfc-index.xml
+    // emits ("RFC0001") — the Builder strips the pad.
+    rule("rfc", () => str("RFC").then(str(" ").maybe(), digits.as("number")));
+    // "BCP 3" / "STD 66" / "FYI 1", plus the padded "<is-also>STD0066"
+    // form relaton builds cross-references from, unnormalized.
+    rule("subseries", () => str("BCP")
+        .or(str("STD"), str("FYI"))
+        .as("series")
+        .then(str(" ").maybe(), digits.as("number")));
+    // Draft slug characters plus the two historical shapes the corpus
+    // carries: a dot inside a topic token and uppercase protocol names.
+    rule("draft_rest", () => match("[a-zA-Z0-9+_.\\-]").repeat(1, Infinity).as("draft_rest"));
+    rule("draft", () => str("draft-").then(rules["draft_rest"]));
+    rule("identifier", () => rules["rfc"].or(rules["subseries"], rules["draft"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ietfGrammar = { rules: buildRules(), root: "root" };
+class IetfIdentifier extends BaseIdentifier {
+    /** Fail loudly on a nil number rather than keying the index under "". */
+    requireNumber() {
+        if (this.number === undefined || this.number === "") {
+            throw new ParseFailed(`Cannot render ${this.constructor.polymorphicName} with an empty number`, 0);
+        }
+        return this.number;
+    }
+}
+class IetfUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        if (id instanceof IetfRfc)
+            return `urn:ietf:rfc:${id.requireNumber()}`;
+        if (id instanceof IetfInternetDraft) {
+            const base = `urn:ietf:id:${id.requireNumber()}`;
+            return id.version === undefined ? base : `${base}:${id.version}`;
+        }
+        if (id instanceof IetfSubseriesBase) {
+            return `urn:ietf:${id.seriesToken().toLowerCase()}:${id.requireNumber()}`;
+        }
+        throw new ParseFailed("IETF: not a concrete identifier", 0);
+    }
+}
+class IetfSubseriesBase extends IetfIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" });
+    static urnGenerator = IetfUrnGenerator;
+    render() {
+        return `${this.seriesToken()} ${this.requireNumber()}`;
+    }
+}
+export class IetfRfc extends IetfIdentifier {
+    static polymorphicName = "pubid:ietf:rfc";
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" });
+    static urnGenerator = IetfUrnGenerator;
+    render() {
+        return `RFC ${this.requireNumber()}`;
+    }
+}
+registerType(IetfRfc);
+function subseriesClass(kind, token) {
+    class IetfSubseriesKind extends IetfSubseriesBase {
+        static polymorphicName = `pubid:ietf:${kind}`;
+        seriesToken() {
+            return token;
+        }
+    }
+    registerType(IetfSubseriesKind);
+    return IetfSubseriesKind;
+}
+const SUBSERIES_CLASSES = {
+    bcp: subseriesClass("bcp", "BCP"),
+    std: subseriesClass("std", "STD"),
+    fyi: subseriesClass("fyi", "FYI"),
+};
+export class IetfInternetDraft extends IetfIdentifier {
+    static polymorphicName = "pubid:ietf:internet-draft";
+    static attributes = extendAttributes(BaseIdentifier, {
+        number: { type: "string" },
+        version: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "number", to: "number" }, { wire: "version", to: "version" });
+    static urnGenerator = IetfUrnGenerator;
+    render() {
+        const number = this.requireNumber();
+        return this.version === undefined ? number : `${number}-${this.version}`;
+    }
+}
+registerType(IetfInternetDraft);
+const SUBSERIES_TOKENS = {
+    BCP: "bcp",
+    STD: "std",
+    FYI: "fyi",
+};
+/** Strip the rfc-index.xml zero-pad ("STD0066" → "66"; "000" stays "0"). */
+function unpad(number) {
+    return number.replace(/^0+(?=\d)/, "");
+}
+/**
+ * A draft version is a trailing "-NN" of exactly two digits at the very
+ * end: a three-digit topic tail ("…-256") keeps its char-before-last-two
+ * a digit, not "-", so it stays in the slug.
+ */
+function splitDraftVersion(full) {
+    if (full.length > 3 && full.at(-3) === "-" && /^\d\d$/.test(full.slice(-2))) {
+        return [full.slice(0, -3), full.slice(-2)];
+    }
+    return [full, undefined];
+}
+export function ietfGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(ietfGrammar, input);
+            if (typeof tree !== "object" || tree === null) {
+                throw new ParseFailed("IETF: unexpected parse tree", 0);
+            }
+            if (tree["draft_rest"] !== undefined) {
+                const [slug, version] = splitDraftVersion(`draft-${String(tree["draft_rest"])}`);
+                return new IetfInternetDraft({ number: slug, ...(version !== undefined ? { version } : {}) });
+            }
+            if (tree["series"] !== undefined) {
+                const klass = SUBSERIES_CLASSES[SUBSERIES_TOKENS[String(tree["series"])]];
+                return new klass({ number: unpad(String(tree["number"])) });
+            }
+            return new IetfRfc({ number: unpad(String(tree["number"])) });
+        },
+    };
+}

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

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

package/dist/flavors/iho/index.js

@@ -0,0 +1,126 @@
+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_LETTERS = {
+    standard: "S",
+    publication: "P",
+    miscellaneous: "M",
+    bibliographic: "B",
+    "circular-letter": "C",
+};
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const dash = str("-");
+    const dot = str(".");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    rule("series", () => str("S").or(str("P"), str("M"), str("B"), str("C")).as("type"));
+    rule("number_suffix", () => str(":").then(digits).or(str("/").then(digits)).or(dash.then(digits)).or(match("[A-Z]")));
+    rule("number", () => digits.then(rules["number_suffix"].maybe()).as("number"));
+    rule("appendix", () => space
+        .then(str("Appendix").or(str("Ap.")))
+        .then(space, match("[A-Z]").then(dash, digits).or(digits).or(match("[A-Z]")).as("appendix")));
+    rule("part", () => space.then(str("Part")).then(space, digits.then(match("[a-zA-Z]").repeat(0, Infinity)).as("part").or(match("[A-Z]").as("part"))));
+    rule("annex", () => space.then(str("Annex")).then(space, match("[A-Z]").as("annex")));
+    rule("supplement", () => space.then(str("Suppl")).then(space, digits.as("supplement")));
+    rule("version", () => space.then(digits.then(dot, digits, dot, digits).as("version")));
+    rule("identifier", () => str("IHO")
+        .then(space)
+        .maybe()
+        .then(rules["series"], dash, rules["number"])
+        .then(rules["appendix"].maybe())
+        .then(rules["part"].maybe())
+        .then(rules["annex"].maybe())
+        .then(rules["supplement"].maybe())
+        .then(rules["version"].maybe()));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const ihoGrammar = { rules: buildRules(), root: "root" };
+function ihoClass(kind) {
+    const letter = KIND_LETTERS[kind];
+    class IhoKindIdentifier extends BaseIdentifier {
+        static polymorphicName = `pubid:iho:${kind}`;
+        static attributes = extendAttributes(BaseIdentifier, {
+            number: { type: "string" },
+            appendix: { type: "string" },
+            part: { type: "string" },
+            annex: { type: "string" },
+            supplement: { type: "string" },
+            version: { type: "string" },
+        });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "appendix", to: "appendix" }, { wire: "part", to: "part" }, { wire: "annex", to: "annex" }, { wire: "supplement", to: "supplement" }, { wire: "version", to: "version" });
+        render() {
+            let result = `IHO ${letter}-${this.number}`;
+            if (this.appendix !== undefined)
+                result += ` Ap. ${this.appendix}`;
+            if (this.part !== undefined)
+                result += ` Part ${this.part}`;
+            if (this.annex !== undefined)
+                result += ` Annex ${this.annex}`;
+            if (this.supplement !== undefined)
+                result += ` Suppl ${this.supplement}`;
+            if (this.version !== undefined)
+                result += ` ${this.version}`;
+            return result;
+        }
+    }
+    class IhoUrnGenerator extends BaseUrnGenerator {
+        generate() {
+            const id = this.identifier;
+            const parts = ["urn", "iho", letter.toLowerCase(), id.number];
+            if (id.appendix !== undefined)
+                parts.push(`ap.${id.appendix}`);
+            if (id.part !== undefined)
+                parts.push(`part.${id.part}`);
+            if (id.annex !== undefined)
+                parts.push(`annex.${id.annex}`);
+            if (id.supplement !== undefined)
+                parts.push(`suppl.${id.supplement}`);
+            if (id.version !== undefined)
+                parts.push(id.version);
+            return parts.join(":");
+        }
+    }
+    IhoKindIdentifier.urnGenerator = IhoUrnGenerator;
+    registerType(IhoKindIdentifier);
+    return IhoKindIdentifier;
+}
+const KIND_CLASSES = {
+    standard: ihoClass("standard"),
+    publication: ihoClass("publication"),
+    miscellaneous: ihoClass("miscellaneous"),
+    bibliographic: ihoClass("bibliographic"),
+    "circular-letter": ihoClass("circular-letter"),
+};
+const LETTER_TO_CLASS = new Map(Object.keys(KIND_LETTERS).map((kind) => [KIND_LETTERS[kind], KIND_CLASSES[kind]]));
+class IhoBuilder extends BaseBuilder {
+    selectClass(data) {
+        const kind = LETTER_TO_CLASS.get(String(data["type"]));
+        if (kind === undefined) {
+            throw new ParseFailed(`IHO: unknown series ${String(data["type"])}`, 0);
+        }
+        return kind;
+    }
+    defaultIdentifierClass() {
+        return KIND_CLASSES["standard"];
+    }
+}
+export function ihoGrammarImplementation() {
+    const builder = new IhoBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ihoGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("IHO: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

package/dist/flavors/index.d.ts

@@ -0,0 +1,9 @@
+import type { FlavorImplementation } from "../conformance/implementation.js";
+/**
+ * The grammar-wave registry: flavors whose Ruby grammar has been ported
+ * to a TypeScript implementation. A flavor listed here parses
+ * open-endedly (real-world spellings beyond the corpus); the
+ * conformance gate enforces parity with the corpus floor for it. Every
+ * flavor NOT listed falls back to corpus mode.
+ */
+export declare function grammarImplementation(flavor: string): FlavorImplementation | undefined;

package/dist/flavors/index.js

@@ -0,0 +1,136 @@
+import { oimlGrammarImplementation } from "./oiml/implementation.js";
+import { xsfGrammarImplementation } from "./xsf/index.js";
+import { doiGrammarImplementation } from "./doi/index.js";
+import { ianaGrammarImplementation } from "./iana/index.js";
+import { unGrammarImplementation } from "./un/index.js";
+import { plateauGrammarImplementation } from "./plateau/index.js";
+import { w3cGrammarImplementation } from "./w3c/index.js";
+import { omgGrammarImplementation } from "./omg/index.js";
+import { ogcGrammarImplementation } from "./ogc/index.js";
+import { isbnGrammarImplementation } from "./isbn/index.js";
+import { eascGrammarImplementation } from "./easc/index.js";
+import { ecmaGrammarImplementation } from "./ecma/index.js";
+import { tgppGrammarImplementation } from "./tgpp/index.js";
+import { ansiGrammarImplementation } from "./ansi/index.js";
+import { oasisGrammarImplementation } from "./oasis/index.js";
+import { ihoGrammarImplementation } from "./iho/index.js";
+import { calconnectGrammarImplementation } from "./calconnect/index.js";
+import { gbGrammarImplementation } from "./gb/index.js";
+import { jcgmGrammarImplementation } from "./jcgm/index.js";
+import { etsiGrammarImplementation } from "./etsi/index.js";
+import { jisGrammarImplementation } from "./jis/index.js";
+import { iecGrammarImplementation } from "./iec/index.js";
+import { cieGrammarImplementation } from "./cie/index.js";
+import { bipmGrammarImplementation } from "./bipm/index.js";
+import { isoGrammarImplementation } from "./iso/index.js";
+import { nistGrammarImplementation } from "./nist/index.js";
+import { ieeeGrammarImplementation } from "./ieee/index.js";
+import { cenCenelecGrammarImplementation } from "./cen_cenelec/index.js";
+import { astmGrammarImplementation } from "./astm/index.js";
+import { idfGrammarImplementation } from "./idf/index.js";
+import { gostGrammarImplementation } from "./gost/index.js";
+import { evsGrammarImplementation } from "./evs/index.js";
+import { ashraeGrammarImplementation } from "./ashrae/index.js";
+import { bsiGrammarImplementation } from "./bsi/index.js";
+import { csaGrammarImplementation } from "./csa/index.js";
+import { asmeGrammarImplementation } from "./asme/index.js";
+import { amcaGrammarImplementation } from "./amca/index.js";
+import { apiGrammarImplementation } from "./api/index.js";
+import { ituGrammarImplementation } from "./itu/index.js";
+import { ietfGrammarImplementation } from "./ietf/index.js";
+import { ialaGrammarImplementation } from "./iala/index.js";
+/**
+ * The grammar-wave registry: flavors whose Ruby grammar has been ported
+ * to a TypeScript implementation. A flavor listed here parses
+ * open-endedly (real-world spellings beyond the corpus); the
+ * conformance gate enforces parity with the corpus floor for it. Every
+ * flavor NOT listed falls back to corpus mode.
+ */
+export function grammarImplementation(flavor) {
+    switch (flavor) {
+        case "oiml":
+            return oimlGrammarImplementation();
+        case "xsf":
+            return xsfGrammarImplementation();
+        case "doi":
+            return doiGrammarImplementation();
+        case "iana":
+            return ianaGrammarImplementation();
+        case "un":
+            return unGrammarImplementation();
+        case "plateau":
+            return plateauGrammarImplementation();
+        case "w3c":
+            return w3cGrammarImplementation();
+        case "omg":
+            return omgGrammarImplementation();
+        case "ogc":
+            return ogcGrammarImplementation();
+        case "isbn":
+            return isbnGrammarImplementation();
+        case "easc":
+            return eascGrammarImplementation();
+        case "ecma":
+            return ecmaGrammarImplementation();
+        case "tgpp":
+            return tgppGrammarImplementation();
+        case "ansi":
+            return ansiGrammarImplementation();
+        case "oasis":
+            return oasisGrammarImplementation();
+        case "iho":
+            return ihoGrammarImplementation();
+        case "calconnect":
+            return calconnectGrammarImplementation();
+        case "gb":
+            return gbGrammarImplementation();
+        case "jcgm":
+            return jcgmGrammarImplementation();
+        case "etsi":
+            return etsiGrammarImplementation();
+        case "jis":
+            return jisGrammarImplementation();
+        case "iec":
+            return iecGrammarImplementation();
+        case "cie":
+            return cieGrammarImplementation();
+        case "bipm":
+            return bipmGrammarImplementation();
+        case "iso":
+            return isoGrammarImplementation();
+        case "nist":
+            return nistGrammarImplementation();
+        case "ieee":
+            return ieeeGrammarImplementation();
+        case "cen_cenelec":
+            return cenCenelecGrammarImplementation();
+        case "astm":
+            return astmGrammarImplementation();
+        case "idf":
+            return idfGrammarImplementation();
+        case "gost":
+            return gostGrammarImplementation();
+        case "evs":
+            return evsGrammarImplementation();
+        case "ashrae":
+            return ashraeGrammarImplementation();
+        case "bsi":
+            return bsiGrammarImplementation();
+        case "csa":
+            return csaGrammarImplementation();
+        case "asme":
+            return asmeGrammarImplementation();
+        case "amca":
+            return amcaGrammarImplementation();
+        case "api":
+            return apiGrammarImplementation();
+        case "itu":
+            return ituGrammarImplementation();
+        case "ietf":
+            return ietfGrammarImplementation();
+        case "iala":
+            return ialaGrammarImplementation();
+        default:
+            return undefined;
+    }
+}

package/dist/flavors/isbn/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 isbnGrammar: Grammar;
+export declare class IsbnIdentifier extends BaseIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly raw: string;
+    readonly hyphenated: string | undefined;
+    render(): string;
+}
+export declare function isbnGrammarImplementation(): FlavorImplementation;

package/dist/flavors/isbn/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 { BaseBuilder } from "../../model/builder.js";
+/**
+ * 1:1 port of lib/pubid/isbn/ on the unified model. ISBN-10/13 per ISO
+ * 2108; the builder validates length and the ISO 2108 check digit and
+ * surfaces failures as parse errors (Ruby Builder parity). The Ruby
+ * flavor has no urn_generator → the base template emits "urn:isbn".
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const colon = str(":");
+    const hyphen = str("-");
+    const digit = match("[0-9]");
+    const xDigit = digit.or(str("X"));
+    const digitGroup = digit.repeat(1, Infinity);
+    rule("isbn_prefix", () => str("ISBN")
+        .then(space.or(space.maybe().then(colon, space.maybe())))
+        .maybe());
+    rule("isbn_body", () => digitGroup
+        .then(hyphen.then(digitGroup).repeat(0, Infinity))
+        .then(hyphen.then(xDigit).maybe())
+        .as("body")
+        .or(digit.repeat(9, 12).then(xDigit.maybe()).as("body")));
+    rule("identifier", () => rules["isbn_prefix"].then(rules["isbn_body"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const isbnGrammar = { rules: buildRules(), root: "root" };
+export class IsbnIdentifier extends BaseIdentifier {
+    static polymorphicName = "pubid:isbn:book";
+    static attributes = extendAttributes(BaseIdentifier, {
+        raw: { type: "string" },
+        hyphenated: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "raw", to: "raw" }, { wire: "hyphenated", to: "hyphenated" });
+    render() {
+        return `ISBN ${this.hyphenated ?? this.raw}`;
+    }
+}
+registerType(IsbnIdentifier);
+const VALID_LENGTH = /^(?:\d{9}[\dX]|\d{13})$/;
+function validCheckDigit(full) {
+    // ISBN-10: weights 10..1 mod 11, 10 renders as "X".
+    // ISBN-13: alternating weights 1/3 mod 10.
+    const digits = full.toUpperCase().replace(/[^0-9X]/g, "");
+    if (digits.length === 10) {
+        let sum = 0;
+        for (let i = 0; i < 9; i++)
+            sum += Number(digits[i]) * (10 - i);
+        const computed = (11 - (sum % 11)) % 11;
+        return (computed === 10 ? "X" : String(computed)) === digits[9];
+    }
+    if (digits.length === 13) {
+        let sum = 0;
+        for (let i = 0; i < 12; i++)
+            sum += Number(digits[i]) * (i % 2 === 0 ? 1 : 3);
+        return String((10 - (sum % 10)) % 10) === digits[12];
+    }
+    return false;
+}
+class IsbnBuilder extends BaseBuilder {
+    defaultIdentifierClass() {
+        return IsbnIdentifier;
+    }
+    cast(key, value) {
+        if (key !== "body")
+            return value;
+        const hyphenatedInput = String(value);
+        const raw = hyphenatedInput.replaceAll("-", "");
+        if (!VALID_LENGTH.test(raw)) {
+            throw new ParseFailed(`ISBN must be 10 or 13 digits (got ${raw.length})`, 0);
+        }
+        if (!validCheckDigit(raw)) {
+            throw new ParseFailed(`ISBN check digit invalid for ${raw}`, 0);
+        }
+        return hyphenatedInput.includes("-") ? { raw, hyphenated: hyphenatedInput } : { raw };
+    }
+}
+export function isbnGrammarImplementation() {
+    const builder = new IsbnBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(isbnGrammar, input);
+            if (typeof tree !== "object" || tree === null || Array.isArray(tree)) {
+                throw new ParseFailed("ISBN: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

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