@pubid/pubid 0.1.38 → 0.1.40

package/dist/conformance/implementation.d.ts

@@ -24,5 +24,8 @@ export interface Identifier {
     toUrn(): string | undefined;
     /** Deserialize the canonical hash; the idempotency gate relies on it. */
     fromHash(hash: Record<string, unknown>): Identifier;
+    /** Ruby ==: canonical equality skipping equalityIgnored attributes
+     *  (the (E) position is spelling, the language itself is not). */
+    equals?(other: Identifier): boolean;
 }
 export type ImplementationRegistry = Map<string, FlavorImplementation>;

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

@@ -0,0 +1,35 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+/**
+ * The PFS-compiled doi flavor (pubid/pubid#706 §2.2) — one definition
+ * file, both engines: the grammar runtime is the SAME baked artifact the
+ * Ruby flavor runs (pubid-grammar artifacts/doi_pfs.json, compiled from
+ * definitions/doi.pfs), loaded through the artifact runtime, so grammar
+ * changes land once and this side cannot drift. Nothing is hand-rolled:
+ * the model is declared attributes (serialization derives from
+ * BaseIdentifier), the builder is the shared one, and the render body is
+ * the definition's canonical template. The parity gate
+ * (test/doi-pfs-parity.test.ts) pins byte-identity with the coded
+ * {@linkcode import("../doi").DoiIdentifier} over the shared conformance
+ * set.
+ */
+export declare class DoiPfsIdentifier extends BaseIdentifier {
+    /**
+     * The SCHEME-canonical wire tag (declared in the definition): to_hash
+     * is byte-identical with the coded flavor. Deliberately NOT registered
+     * in the global type map — one scheme, one `_type`, one global
+     * resolution (the coded class); {@linkcode fromHash} routes the tag
+     * back here flavor-locally, mirroring Ruby's DOI_TYPE_MAP.
+     */
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    render(): string;
+    readonly prefix: string;
+    readonly suffix: string;
+    /** The alias's own from_hash: the scheme tag routes HERE, while the
+     *  global resolution keeps answering the coded class (coexistence, not
+     *  cutover). */
+    static fromHash(hash: Record<string, unknown>): BaseIdentifier;
+}
+export declare function doiPfsGrammarImplementation(): FlavorImplementation;

package/dist/flavors/doi_pfs/index.js

@@ -0,0 +1,61 @@
+import { ParseFailed } from "../../grammar/engine.js";
+import { PubidRuntime } from "../../parg/runtime.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+/**
+ * The PFS-compiled doi flavor (pubid/pubid#706 §2.2) — one definition
+ * file, both engines: the grammar runtime is the SAME baked artifact the
+ * Ruby flavor runs (pubid-grammar artifacts/doi_pfs.json, compiled from
+ * definitions/doi.pfs), loaded through the artifact runtime, so grammar
+ * changes land once and this side cannot drift. Nothing is hand-rolled:
+ * the model is declared attributes (serialization derives from
+ * BaseIdentifier), the builder is the shared one, and the render body is
+ * the definition's canonical template. The parity gate
+ * (test/doi-pfs-parity.test.ts) pins byte-identity with the coded
+ * {@linkcode import("../doi").DoiIdentifier} over the shared conformance
+ * set.
+ */
+export class DoiPfsIdentifier extends BaseIdentifier {
+    /**
+     * The SCHEME-canonical wire tag (declared in the definition): to_hash
+     * is byte-identical with the coded flavor. Deliberately NOT registered
+     * in the global type map — one scheme, one `_type`, one global
+     * resolution (the coded class); {@linkcode fromHash} routes the tag
+     * back here flavor-locally, mirroring Ruby's DOI_TYPE_MAP.
+     */
+    static polymorphicName = "pubid:doi:resource";
+    static attributes = extendAttributes(BaseIdentifier, {
+        prefix: { type: "string" },
+        suffix: { type: "string" },
+    });
+    static mappings = keyValue({ wire: "prefix", to: "prefix" }, { wire: "suffix", to: "suffix" });
+    render() {
+        return `doi:${this.prefix}/${this.suffix}`;
+    }
+    /** The alias's own from_hash: the scheme tag routes HERE, while the
+     *  global resolution keeps answering the coded class (coexistence, not
+     *  cutover). */
+    static fromHash(hash) {
+        return new DoiPfsIdentifier(this.applyMappings(this.inflateScalarComponents(hash)));
+    }
+}
+/**
+ * The artifact's declared bindings (prefix -> prefix, suffix -> suffix)
+ * carry the whole printed prefix face ("10.1000") — the doi.pfs pattern
+ * captures the "10." face the coded grammar re-assembles — so the bound
+ * map lands on the model fields directly, no builder cast.
+ */
+let cachedRuntime;
+export function doiPfsGrammarImplementation() {
+    return {
+        parse(input) {
+            cachedRuntime ??= PubidRuntime.load("doi_pfs");
+            const bound = cachedRuntime.parseAndBind(input);
+            if (bound === null || typeof bound !== "object") {
+                throw new ParseFailed("doi_pfs: the artifact rejected the input", 0);
+            }
+            const identifier = new DoiPfsIdentifier(bound);
+            return identifier;
+        },
+    };
+}

package/dist/flavors/index.js

@@ -2,6 +2,7 @@ import { lookupUrnParser, parseUrnFor } from "../urn/parsers.js";
 import { oimlGrammarImplementation } from "./oiml/implementation.js";
 import { xsfGrammarImplementation } from "./xsf/index.js";
 import { doiGrammarImplementation } from "./doi/index.js";
+import { doiPfsGrammarImplementation } from "./doi_pfs/index.js";
 import { ianaGrammarImplementation } from "./iana/index.js";
 import { unGrammarImplementation } from "./un/index.js";
 import { plateauGrammarImplementation } from "./plateau/index.js";
@@ -81,6 +82,8 @@ function grammarImplementationSwitch(flavor) {
             return xsfGrammarImplementation();
         case "doi":
             return doiGrammarImplementation();
+        case "doi_pfs":
+            return doiPfsGrammarImplementation();
         case "iana":
             return ianaGrammarImplementation();
         case "un":

package/dist/flavors/jis/index.js

@@ -14,7 +14,12 @@ import { BaseUrnGenerator } from "../../model/urn-generator.js";
  *
  * WES (welding-engineering-standard, pubid#638) rides the same flavor:
  * "WES <number>[-parts][:year[R]]…" with no series letter and no JIS
- * prefix — the code itself carries the "WES" root.
+ * prefix — the code itself carries the "WES" root. A WES id may also
+ * carry a TR/TS type after the root ("WES TR 2032:2024", its own
+ * welding-engineering-technical-report/-specification classes,
+ * pubid#716) and a language before the year ("WES 1112(E):2022",
+ * bound only when a colon follows; recorded as language_before_year,
+ * which equality ignores — the two (E) positions are one document).
  */
 function buildRules() {
     const rules = {};
@@ -61,11 +66,18 @@ function buildRules() {
         .then(rules["symbol_clause"].maybe()));
     // WES (Japan Welding Engineering Society) rides the JIS flavor with the
     // same tail but no prefix and no series letter; the root tries it first,
-    // as the reference grammar does.
+    // as the reference grammar does. A WES id may also carry a TR/TS type
+    // after the root ("WES TR 2032:2024") and a language before the year
+    // ("WES 1112(E):2022" — bound only when a colon follows, so
+    // "WES 1112(E)" with no year still reads as no language).
+    rule("wes_type", () => (str("TR").or(str("TS"))).as("wes_type").then(space));
+    rule("wes_language", () => jpLparen.or(str("(")).then(match("[EJ]").as("wes_language"), jpRparen.or(str(")"))).then(colon.present()));
     rule("wes_identifier", () => str("WES").as("wes")
         .then(space)
+        .then(rules["wes_type"].maybe())
         .then(rules["number"])
         .then(rules["parts"])
+        .then(rules["wes_language"].maybe())
         .then(rules["year"].maybe())
         .then(rules["language"].maybe())
         .then(rules["all_parts"].maybe())
@@ -95,6 +107,13 @@ class JisIdentifier extends BaseIdentifier {
     yearWithReaffirmation() {
         return `${this.year}${this.reaffirmed === true ? "R" : ""}`;
     }
+    /** The ":year[R]" and "(lang)" tail, in the order the source used
+     *  (ruby year_and_language). */
+    yearAndLanguage() {
+        const yearPart = this.year !== undefined ? `:${this.yearWithReaffirmation()}` : "";
+        const langPart = this.language !== undefined ? `(${this.language})` : "";
+        return this.language_before_year === true ? langPart + yearPart : yearPart + langPart;
+    }
     symbolSuffix() {
         if (this.symbol === undefined)
             return "";
@@ -104,7 +123,7 @@ class JisIdentifier extends BaseIdentifier {
         return "";
     }
 }
-const JIS_MAPPINGS = keyValue({ wire: "series", to: "series" }, { wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
+const JIS_MAPPINGS = keyValue({ wire: "series", to: "series" }, { wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "language_before_year", to: "language_before_year" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
 function jisClass(kind) {
     const isSupplement = kind === "amendment" || kind === "corrigendum" || kind === "explanation";
     class JisKindIdentifier extends JisIdentifier {
@@ -122,6 +141,7 @@ function jisClass(kind) {
                 parts: { type: "string", collection: true },
                 year: { type: "integer" },
                 language: { type: "string" },
+                language_before_year: { type: "boolean", equalityIgnored: true },
                 all_parts: { type: "boolean", default: false },
                 reaffirmed: { type: "boolean" },
                 symbol: { type: "string" },
@@ -137,10 +157,7 @@ function jisClass(kind) {
             const typePrefix = KIND_PREFIXES[kind];
             let result = typePrefix === undefined ? "JIS" : `JIS ${typePrefix}`;
             result += ` ${this.code()}`;
-            if (this.year !== undefined)
-                result += `:${this.yearWithReaffirmation()}`;
-            if (this.language !== undefined)
-                result += `(${this.language})`;
+            result += this.yearAndLanguage();
             if (this.all_parts === true)
                 result += "（規格群）";
             return result + this.symbolSuffix();
@@ -167,36 +184,43 @@ const KIND_CLASSES = {
     corrigendum: jisClass("corrigendum"),
     explanation: jisClass("explanation"),
 };
+const WES_TYPE_PREFIXES = {
+    "welding-engineering-standard": undefined,
+    "welding-engineering-technical-report": "TR",
+    "welding-engineering-technical-specification": "TS",
+};
 // WES 7700-1:2019 — JSA sells Welding Engineering Standards next to JIS,
 // so they parse through the JIS flavor, but the id carries no series
-// letter and no JIS prefix ("WES" is the root of the designation).
-function wesClass() {
+// letter and no JIS prefix ("WES" is the root of the designation). The
+// TR/TS type token after the root picks the WES TR / WES TS classes
+// (pubid#716): "WES TR 2032" is not "WES 2032" and not "TR Z 2032".
+function wesClass(kind) {
     class JisWesIdentifier extends JisIdentifier {
-        static polymorphicName = "pubid:jis:welding-engineering-standard";
+        static polymorphicName = `pubid:jis:${kind}`;
         static attributes = extendAttributes(BaseIdentifier, {
             number: { type: "string" },
             parts: { type: "string", collection: true },
             year: { type: "integer" },
             language: { type: "string" },
+            language_before_year: { type: "boolean", equalityIgnored: true },
             all_parts: { type: "boolean", default: false },
             reaffirmed: { type: "boolean" },
             symbol: { type: "string" },
         });
-        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
+        static mappings = keyValue({ wire: "number", to: "number" }, { wire: "parts", to: "parts" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "language_before_year", to: "language_before_year" }, { wire: "all_parts", to: "all_parts" }, { wire: "reaffirmed", to: "reaffirmed" }, { wire: "symbol", to: "symbol" });
         code() {
             if (this.base !== undefined)
                 return this.base.code();
-            let result = `WES ${this.number}`;
+            const prefix = WES_TYPE_PREFIXES[kind];
+            const root = prefix === undefined ? "WES" : `WES ${prefix}`;
+            let result = `${root} ${this.number}`;
             if (this.parts !== undefined)
                 result += this.parts.map((p) => `-${p}`).join("");
             return result;
         }
         render() {
             let result = this.code() ?? "";
-            if (this.year !== undefined)
-                result += `:${this.yearWithReaffirmation()}`;
-            if (this.language !== undefined)
-                result += `(${this.language})`;
+            result += this.yearAndLanguage();
             if (this.all_parts === true)
                 result += "（規格群）";
             return result + this.symbolSuffix();
@@ -205,7 +229,11 @@ function wesClass() {
     registerType(JisWesIdentifier);
     return JisWesIdentifier;
 }
-const WES_CLASS = wesClass();
+const WES_CLASSES = {
+    "welding-engineering-standard": wesClass("welding-engineering-standard"),
+    "welding-engineering-technical-report": wesClass("welding-engineering-technical-report"),
+    "welding-engineering-technical-specification": wesClass("welding-engineering-technical-specification"),
+};
 class JisUrnGenerator extends BaseUrnGenerator {
     generate() {
         const id = this.identifier;
@@ -226,7 +254,7 @@ class JisUrnGenerator extends BaseUrnGenerator {
         return parts.join(":");
     }
 }
-for (const klass of [...Object.values(KIND_CLASSES), WES_CLASS]) {
+for (const klass of [...Object.values(KIND_CLASSES), ...Object.values(WES_CLASSES)]) {
     klass.urnGenerator = JisUrnGenerator;
 }
 function isObj(v) {
@@ -294,13 +322,29 @@ class JisBuilder {
         };
         if (tree["year"] !== undefined && tree["year"] !== null)
             attrs["year"] = Number(tree["year"]);
-        if (tree["language"] !== undefined && tree["language"] !== null)
+        const wesType = tree["wes_type"] === undefined || tree["wes_type"] === null ? undefined : String(tree["wes_type"]);
+        const kind = wesType === "TR"
+            ? "welding-engineering-technical-report"
+            : wesType === "TS"
+                ? "welding-engineering-technical-specification"
+                : "welding-engineering-standard";
+        // "wes_language" is a language printed before the year
+        // ("WES 1112(E):2022"); an id carries one language, not two.
+        if (tree["wes_language"] !== undefined && tree["wes_language"] !== null) {
+            if (tree["language"] !== undefined && tree["language"] !== null) {
+                throw new ParseFailed("JIS: a WES id carries one language, not two", 0);
+            }
+            attrs["language"] = String(tree["wes_language"]);
+            attrs["language_before_year"] = true;
+        }
+        else if (tree["language"] !== undefined && tree["language"] !== null) {
             attrs["language"] = String(tree["language"]);
+        }
         if (tree["all_parts"] !== undefined)
             attrs["all_parts"] = true;
         if (tree["reaffirmed"] !== undefined && tree["reaffirmed"] !== null)
             attrs["reaffirmed"] = true;
-        return new WES_CLASS(attrs);
+        return new WES_CLASSES[kind](attrs);
     }
     buildSupplement(tree, kind, key, prefix) {
         const supp = isObj(tree[key]) ? tree[key] : {};

package/dist/flavors/nist/index.js

@@ -180,6 +180,18 @@ function locateIdentifierKlass(h) {
         return classForKind("dated-document");
     }
     let series = s(h["series"]);
+    // The default-series plain-number branch (pubid#711): the grammar's
+    // trailing alternatives accept a bare report number ("800-90B") and
+    // its publisher-led spelling ("NIST 800-90B") with NO series token.
+    // The SP series is the default: the docid-derived citation of
+    // NIST.SP.800-90B is exactly the bare docnumber "800-90B", and the
+    // Builder fills the same SP series the spelled form carries, so the
+    // two spellings are one identity to a lookup. No other branch can
+    // arrive here series-less (dated shapes returned above; every
+    // series-bearing branch captures :series).
+    if (series === undefined) {
+        return classForKind("special-publication");
+    }
     if (series?.startsWith("NBS ") === true || series?.startsWith("NBS.") === true || series?.startsWith("NIST.") === true) {
         const separator = series.startsWith("NBS ") ? "NBS " : series.startsWith("NBS.") ? "NBS." : "NIST.";
         let simple = series.slice(separator.length);
@@ -857,6 +869,21 @@ class NistBuilder {
         const klass = locateIdentifierKlass(h);
         const policy = seriesPolicy(s(h["series"]));
         const identifier = new klass();
+        // The default-series plain-number branch (pubid#711): the grammar's
+        // trailing alternatives carry no series token ("800-90B" /
+        // "NIST 800-90B"), so the identity gains the class's default series
+        // and parses == to the spelled "NIST SP 800-90B" form. The bare
+        // publisher rides the series-default-publisher fill at the tail
+        // (the #704 shape: filled after publisher_was_parsed is recorded,
+        // so the bare face keeps rendering bare). The policy stays the
+        // series-less Base one — Ruby's Series.for reads parsed_hash, not
+        // the filled attribute (SP's own policy is Base anyway).
+        if (h["series"] === undefined) {
+            const defaultSeries = klass.nistDefaultSeries;
+            if (defaultSeries !== undefined) {
+                identifier["series"] = new NistCode({ value: defaultSeries });
+            }
+        }
         const attrs = {};
         const toEdition = (v) => {
             if (isObj(v)) {
@@ -1123,16 +1150,19 @@ class NistBuilder {
                 self["supplement"] = NistSupplement.fromRaw(supp.value, supp.hasRevision);
             }
         }
-        // Default publisher for series-less renders.
+        // apply_series_default_publisher (the #704 rule): a series that
+        // implies its publisher (bare "FIPS 197" is "NIST FIPS 197"; bare
+        // "800-90B" is "NIST SP 800-90B" — pubid#712) gets it now, after the
+        // publisher_was_parsed: false above, so the two spellings are ==
+        // while the bare face keeps rendering bare (the printed-publisher
+        // views read the flag, not the filled value). Runs only when the
+        // publisher is absent AND unspelled — at this point that is exactly
+        // `publisher === undefined` (the flag was recorded false above iff
+        // no publisher was parsed).
         if (self["publisher"] === undefined) {
             const defaultPublisher = identifier.constructor.nistDefaultPublisher;
             if (defaultPublisher !== undefined && defaultPublisher !== "") {
                 self["publisher"] = defaultPublisher;
-                if (self["publisher_was_parsed"] === false) {
-                    // Circular/RPT/MP render "NBS <series>" through the default even
-                    // when not parsed — keep the flag false (Ruby publisher_was_parsed
-                    // stays false but to_short_style uses default only via series).
-                }
             }
         }
         return identifier;

package/dist/flavors/nist/model.js

@@ -680,6 +680,11 @@ function nistClass(spec) {
     class NistConcrete extends (spec.supplementSeam === true ? NistSupplementIdentifier : NistIdentifier) {
         static polymorphicName = `pubid:nist:${spec.kind}`;
         static urnGenerator = NistUrnGenerator;
+        /** Ruby `self.default_series` (pubid#711) — read by the Builder. */
+        static nistDefaultSeries = spec.defaultSeries;
+        /** Ruby `self.series_default_publisher` (#704/#712) — read by the
+         *  Builder's series-default-publisher fill. */
+        static nistDefaultPublisher = spec.seriesDefaultPublisher;
         seriesCode() {
             return spec.seriesCode;
         }
@@ -819,7 +824,17 @@ export class NistSupplementIdentifier extends NistIdentifier {
     }
 }
 const TYPE_SPECS = [
-    { kind: "special-publication", seriesCode: "SP" },
+    {
+        kind: "special-publication", seriesCode: "SP",
+        // The default-series plain-number branch (pubid#711): a citation
+        // shaped like the docnumber ("800-90B", publisher-led
+        // "NIST 800-90B") names an SP document — the docid-derived
+        // citation of NIST.SP.800-90B is exactly "800-90B" — and a bare
+        // plain-number parse carries the series' NIST publisher (the #704
+        // shape), so it is == to the spelled "NIST SP 800-90B" form a
+        // lookup compares against.
+        defaultSeries: "SP", seriesDefaultPublisher: "NIST",
+    },
     { kind: "federal-information-processing-standards", seriesCode: "FIPS", defaultPublisher: "", style: "fips" },
     { kind: "interagency-report", seriesCode: "IR", forceShort: true },
     { kind: "handbook", seriesCode: "HB" },

package/dist/model/attribute.d.ts

@@ -18,6 +18,9 @@ export interface AttributeSpec {
     collection?: boolean;
     /** Materialize [] when the input hash omits the key (tgpp parts). */
     initializeEmpty?: boolean;
+    /** Ruby `equality_ignored`: the attribute serializes, but `==` skips it
+     *  (jis language_before_year — where the source printed "(E)" is spelling). */
+    equalityIgnored?: boolean;
 }
 export type AttributeTable = Record<string, AttributeSpec>;
 /**

package/dist/model/identifier.d.ts

@@ -62,6 +62,13 @@ export declare abstract class BaseIdentifier {
      *  `PubidUrn.parse(this.toPubidUrn()).toHash == this.toHash`. */
     toPubidUrn(): string;
     fromHash(hash: Record<string, unknown>): BaseIdentifier;
+    /** Ruby == (lutaml equality with `equality_ignored`): canonical-hash
+     *  equality that skips the attributes a flavor declares
+     *  equalityIgnored. The skipped keys stay in to_hash — it is ==, not
+     *  serialization, that reads the flag. */
+    equals(other: BaseIdentifier): boolean;
+    /** The canonical hash minus every equalityIgnored attribute's wire key. */
+    protected equalityHash(): Record<string, unknown>;
     /** SubsetMatch: an all-parts reference skips the part attributes. */
     subsetAllPartsWildcard(): boolean;
     protected classAttributes(): AttributeTable;

package/dist/model/identifier.js

@@ -116,6 +116,23 @@ export class BaseIdentifier {
     fromHash(hash) {
         return this.constructor.fromHash(hash);
     }
+    /** Ruby == (lutaml equality with `equality_ignored`): canonical-hash
+     *  equality that skips the attributes a flavor declares
+     *  equalityIgnored. The skipped keys stay in to_hash — it is ==, not
+     *  serialization, that reads the flag. */
+    equals(other) {
+        return canonicalKey(this.equalityHash()) === canonicalKey(other.equalityHash());
+    }
+    /** The canonical hash minus every equalityIgnored attribute's wire key. */
+    equalityHash() {
+        const hash = { ...this.toHash() };
+        for (const [name, spec] of Object.entries(this.classAttributes())) {
+            if (spec.equalityIgnored !== true)
+                continue;
+            delete hash[this.wireKeyFor(name).wire];
+        }
+        return hash;
+    }
     /** SubsetMatch: an all-parts reference skips the part attributes. */
     subsetAllPartsWildcard() {
         return Boolean(this["all_parts"]);

package/dist/pubid-urn/schemas/doi_pfs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The pubid-scheme URN schema of DOI_PFS — the transcription
+ * of lib/pubid/<flavor>/pubid_urn_schema.rb (pubid#656, completed by
+ * #670; design in docs/URN-SCHEMES.adoc). GENERATED by
+ * scripts/port-urn-schemas.rb from the ruby declaration: edit the ruby
+ * schema and regenerate, never this table by hand.
+ */
+export declare const doiPfsSchema: import("../schema.js").FlavorSchema;

package/dist/pubid-urn/schemas/doi_pfs.js

@@ -0,0 +1,14 @@
+/**
+ * The pubid-scheme URN schema of DOI_PFS — the transcription
+ * of lib/pubid/<flavor>/pubid_urn_schema.rb (pubid#656, completed by
+ * #670; design in docs/URN-SCHEMES.adoc). GENERATED by
+ * scripts/port-urn-schemas.rb from the ruby declaration: edit the ruby
+ * schema and regenerate, never this table by hand.
+ */
+import { define } from "../index.js";
+export const doiPfsSchema = define("doi_pfs", (s) => {
+    s.atom("prefix", "prefix");
+    s.atom("suffix", "suffix");
+    s.type("pubid:doi_pfs:identifier", "id", { core: [] });
+    s.type("pubid:doi_pfs:resource", "resource", { core: [] });
+});

package/dist/pubid-urn/schemas/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * The registry of all 44 flavor pubid-urn schema tables — the TS mirror
+ * The registry of all 45 flavor pubid-urn schema tables — the TS mirror
  * of lib/pubid.rb's autoloaded Pubid::<Flavor>::PubidUrnSchema chain.
  * Declared tables only: importing this module has no side effects; the
  * pubid-urn module builds its flavor lookup lazily from this array.

package/dist/pubid-urn/schemas/index.js

@@ -1,5 +1,5 @@
 /**
- * The registry of all 44 flavor pubid-urn schema tables — the TS mirror
+ * The registry of all 45 flavor pubid-urn schema tables — the TS mirror
  * of lib/pubid.rb's autoloaded Pubid::<Flavor>::PubidUrnSchema chain.
  * Declared tables only: importing this module has no side effects; the
  * pubid-urn module builds its flavor lookup lazily from this array.
@@ -19,6 +19,7 @@ import { cencenelecSchema } from "./cencenelec.js";
 import { cieSchema } from "./cie.js";
 import { csaSchema } from "./csa.js";
 import { doiSchema } from "./doi.js";
+import { doiPfsSchema } from "./doi_pfs.js";
 import { eascSchema } from "./easc.js";
 import { ecmaSchema } from "./ecma.js";
 import { etsiSchema } from "./etsi.js";
@@ -65,6 +66,7 @@ export const PUBID_URN_SCHEMAS = [
     cieSchema,
     csaSchema,
     doiSchema,
+    doiPfsSchema,
     eascSchema,
     ecmaSchema,
     etsiSchema,

package/dist/pubid-urn/schemas/jis.js

@@ -11,14 +11,21 @@ export const jisSchema = define("jis", (s) => {
     s.atom("parts", "part", "list");
     s.atom("year", "year", "int");
     s.atom("reaffirmed", "reaffirmed", "bool");
+    s.atom("language", "lang");
+    s.facet("language_before_year", "langfirst", "bool");
     s.type("pubid:jis:all-parts", "all");
-    s.type("pubid:jis:amendment", "amd");
-    s.type("pubid:jis:corrigendum", "cor");
-    s.type("pubid:jis:explanation", "e");
+    s.type("pubid:jis:amendment", "amd", { core: [["number", "int"]] });
+    s.type("pubid:jis:corrigendum", "cor", { core: [["number", "int"]] });
+    s.type("pubid:jis:explanation", "e", {
+        core: [],
+        atoms: [["number", "n", "int"]],
+    });
     s.type("pubid:jis:identifier", "id");
     s.type("pubid:jis:japanese-industrial-standard", "jis");
     s.type("pubid:jis:standard", "std");
     s.type("pubid:jis:technical-report", "tr");
     s.type("pubid:jis:technical-specification", "ts");
     s.type("pubid:jis:welding-engineering-standard", "wes");
+    s.type("pubid:jis:welding-engineering-technical-report", "westr");
+    s.type("pubid:jis:welding-engineering-technical-specification", "wests");
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "description": "TypeScript PubID identifiers: resolution, normalization and canonical hashes for every identifier in the pubid-testsuite corpus (41 standards bodies), with a conformance runner mirroring the Ruby reference",
   "type": "module",
   "license": "MIT",

package/vendor/parg/calconnect_pfs.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidCalconnectPfs","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"CC"}},{"Str":{"pattern":"/"}},{"Entity":{"atom":8}},{"Entity":{"atom":6}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Alternative":{"atoms":[4,5]}},{"Repetition":{"atom":3,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"series","atom":7}},{"Sequence":{"atoms":[1,2]}},{"Repetition":{"atom":9,"min":0,"max":1,"tag":"Maybe"}},{"Str":{"pattern":" "}},{"Entity":{"atom":24}},{"Entity":{"atom":14}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":13,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Str":{"pattern":"-"}},{"Alternative":{"atoms":[16,17]}},{"Entity":{"atom":14}},{"Repetition":{"atom":19,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[18,20]}},{"Repetition":{"atom":21,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[15,22]}},{"Named":{"name":"number","atom":23}},{"Str":{"pattern":":"}},{"Entity":{"atom":29}},{"Entity":{"atom":14}},{"Repetition":{"atom":27,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"year","atom":28}},{"Str":{"pattern":"-"}},{"Entity":{"atom":34}},{"Entity":{"atom":14}},{"Repetition":{"atom":32,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"month","atom":33}},{"Str":{"pattern":"-"}},{"Entity":{"atom":39}},{"Entity":{"atom":14}},{"Repetition":{"atom":37,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"day","atom":38}},{"Sequence":{"atoms":[30,31,35,36]}},{"Repetition":{"atom":40,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[25,26,41]}},{"Repetition":{"atom":42,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[0,10,11,12,43]}}],"root":44},"bindings":[{"capture":"series","path":"series","type":"string","card":null,"preprocess":null},{"capture":"number","path":"number","type":"string","card":null,"preprocess":null},{"capture":"year","path":"year","type":"string","card":null,"preprocess":null},{"capture":"month","path":"month","type":"string","card":null,"preprocess":null},{"capture":"day","path":"day","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"CC 18011","expect":{}},{"entry":"identifier","kind":"accept","input":"CC 18011:2018","expect":{}},{"entry":"identifier","kind":"accept","input":"CC 11001:2024","expect":{}},{"entry":"identifier","kind":"accept","input":"CC/DIR 10006:2019","expect":{}},{"entry":"identifier","kind":"accept","input":"CC/Adv 0707.1:2007","expect":{}},{"entry":"identifier","kind":"accept","input":"CC/A 0812-1:2008","expect":{}},{"entry":"identifier","kind":"accept","input":"CC/WD 51017:2024-07-23","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}},{"entry":"identifier","kind":"reject","input":"CC","expect":{}},{"entry":"identifier","kind":"reject","input":"CC/WD","expect":{}},{"entry":"identifier","kind":"reject","input":"CC 18011:","expect":{}},{"entry":"identifier","kind":"reject","input":"CC 18011:2024-","expect":{}},{"entry":"identifier","kind":"example","input":"CC 18011","expect":{"number":"18011"}},{"entry":"identifier","kind":"example","input":"CC 18011:2018","expect":{"number":"18011","year":"2018"}},{"entry":"identifier","kind":"example","input":"CC 11001:2024","expect":{"number":"11001","year":"2024"}},{"entry":"identifier","kind":"example","input":"CC/DIR 10006:2019","expect":{"series":"DIR","number":"10006","year":"2019"}},{"entry":"identifier","kind":"example","input":"CC/Adv 0707.1:2007","expect":{"series":"Adv","number":"0707.1","year":"2007"}},{"entry":"identifier","kind":"example","input":"CC/A 0812-1:2008","expect":{"series":"A","number":"0812-1","year":"2008"}},{"entry":"identifier","kind":"example","input":"CC/WD 51017:2024-07-23","expect":{"series":"WD","number":"51017","year":"2024","month":"07","day":"23"}}],"docs":{},"source":"# PFS-generated grammar — DO NOT EDIT BY HAND.\n# Source: definitions/calconnect.pfs (pfs:1) sha256:2e864f0185a1a2f18a392f2f401ad3c9d65d1f32a9ec3f3f04f7dfca9b2226c4\n# Compiler: pubid/grammar/pfs 0.1.0\n# Flavor key: calconnect_pfs (grammar PubidCalconnectPfs)\n# Regenerate: ruby scripts/pfs compile definitions/calconnect.pfs --as calconnect_pfs\n\ngrammar PubidCalconnectPfs version \"0.1.0\" edition 2 {\n\n  # Grammar fragments: named lexical terms declared under `grammar:`.\n  digit = %x30-39\n  letter = %x41-5A / %x61-7A\n  space = \" \"\n  slash = \"/\"\n  colon = \":\"\n  dash = \"-\"\n\n  # Fields: one capture rule per declared field; the whole pattern\n  # is the capture.\n  calconnect_series = (1*letter) as series\n  calconnect_number = (1*digit [(\".\" / \"-\") 1*digit]) as number\n  calconnect_year = (1*digit) as year\n  calconnect_month = (1*digit) as month\n  calconnect_day = (1*digit) as day\n\n  # Identifier rule: the canonical template first, then the\n  # declared alternates (parse-in spellings; they normalize to the\n  # canonical render face).\n  identifier = \"CC\" [\"/\" calconnect_series] \" \" calconnect_number [\":\" calconnect_year [\"-\" calconnect_month \"-\" calconnect_day]]\n  entry identifier: identifier\n\n  # Typed model bindings: every bound capture lands on the\n  # consumer model's field of the same name.\n  bindings identifier {\n    series -> series (string)\n    number -> number (string)\n    year -> year (string)\n    month -> month (string)\n    day -> day (string)\n  }\n\n  # REQUIRED examples from the definition — accepts, rejects, and\n  # the capture expectations the compiler replayed at compile time.\n  test {\n    accept \"CC 18011\"\n    accept \"CC 18011:2018\"\n    accept \"CC 11001:2024\"\n    accept \"CC/DIR 10006:2019\"\n    accept \"CC/Adv 0707.1:2007\"\n    accept \"CC/A 0812-1:2008\"\n    accept \"CC/WD 51017:2024-07-23\"\n    reject \"nonsense\"\n    reject \"CC\"\n    reject \"CC/WD\"\n    reject \"CC 18011:\"\n    reject \"CC 18011:2024-\"\n    example \"CC 18011\" { number: \"18011\" }\n    example \"CC 18011:2018\" { number: \"18011\" year: \"2018\" }\n    example \"CC 11001:2024\" { number: \"11001\" year: \"2024\" }\n    example \"CC/DIR 10006:2019\" { series: \"DIR\" number: \"10006\" year: \"2019\" }\n    example \"CC/Adv 0707.1:2007\" { series: \"Adv\" number: \"0707.1\" year: \"2007\" }\n    example \"CC/A 0812-1:2008\" { series: \"A\" number: \"0812-1\" year: \"2008\" }\n    example \"CC/WD 51017:2024-07-23\" { series: \"WD\" number: \"51017\" year: \"2024\" month: \"07\" day: \"23\" }\n  }\n}\n","source_hash":"35a33d659c86202186a5e6beb8c7df58af7bd6667dd55b6cb3cecb8855713b85","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.126","edition":2,"semantics_hash":"sha256:9fbceffd1828c207a9ec854699d0801fad9e52521a972e39dc1838fb80440dc8","checksum":"sha256:6557fd4360e2deab7ca4062b72e5cd6e60b6e3cd0252cb5b1e30d66f3905f467"}

package/vendor/parg/cen_pfs.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidCenPfs","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"EN"}},{"Str":{"pattern":" "}},{"Entity":{"atom":8}},{"Re":{"pattern":"[\\x31-\\x39]"}},{"Entity":{"atom":5}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":4,"min":0,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[3,6]}},{"Named":{"name":"number","atom":7}},{"Str":{"pattern":"-"}},{"Entity":{"atom":13}},{"Entity":{"atom":5}},{"Repetition":{"atom":11,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"part","atom":12}},{"Sequence":{"atoms":[9,10]}},{"Repetition":{"atom":14,"min":0,"max":1,"tag":"Maybe"}},{"Str":{"pattern":":"}},{"Entity":{"atom":20}},{"Entity":{"atom":5}},{"Repetition":{"atom":18,"min":4,"max":null,"tag":"Repetition"}},{"Named":{"name":"year","atom":19}},{"Sequence":{"atoms":[16,17]}},{"Repetition":{"atom":21,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[0,1,2,15,22]}}],"root":23},"bindings":[{"capture":"number","path":"number","type":"string","card":null,"preprocess":null},{"capture":"part","path":"part","type":"string","card":null,"preprocess":null},{"capture":"year","path":"year","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"EN 1325","expect":{}},{"entry":"identifier","kind":"accept","input":"EN 12464-1:2011","expect":{}},{"entry":"identifier","kind":"accept","input":"EN 1177:2018","expect":{}},{"entry":"identifier","kind":"reject","input":"EN","expect":{}},{"entry":"identifier","kind":"reject","input":"EN ISO 9001:2015","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}},{"entry":"identifier","kind":"reject","input":"CEN/TS 12345","expect":{}},{"entry":"identifier","kind":"example","input":"EN 1325","expect":{"number":"1325"}},{"entry":"identifier","kind":"example","input":"EN 12464-1:2011","expect":{"number":"12464","part":"1","year":"2011"}},{"entry":"identifier","kind":"example","input":"EN 1177:2018","expect":{"number":"1177","year":"2018"}}],"docs":{},"source":"# PFS-generated grammar — DO NOT EDIT BY HAND.\n# Source: definitions/cen.pfs (pfs:1) sha256:bc1edd5874f8938b5f946416a2b052d9d9b9df3d99f6c20a3d88fcab9ae1d70c\n# Compiler: pubid/grammar/pfs 0.1.0\n# Flavor key: cen_pfs (grammar PubidCenPfs)\n# Regenerate: ruby scripts/pfs compile definitions/cen.pfs --as cen_pfs\n# Module: iso.inner v1 (sha256:6f04cf475f1c...)\n# Module: en.overlay v1 (sha256:851af8c5f31b...)\n# Module: national.prefix v1 (sha256:c7aa2f2442e8...)\n# Module: supplements.core v1 (sha256:9fa9656375c7...)\n\ngrammar PubidCenPfs version \"0.1.0\" edition 2 {\n\n  # Grammar fragments: named lexical terms declared under `grammar:`.\n  iso_space = \" \"\n  iso_colon = \":\"\n  iso_dash = \"-\"\n  iso_year = 4*digit\n  iso_part = 1*digit [\"-\" 1*digit]\n  iso_number = 1*(\"0\" %x31-39) *digit [iso_dash iso_part]\n  iso_document = \"ISO\" iso_space iso_number [iso_colon iso_year]\n  en_space = \" \"\n  en_draft = (\"pr\" / \"Fpr\")\n  en_face = [en_draft] \"EN\"\n  en_adoption = en_face en_space iso_document\n  supplement_number = 1*digit\n  supplement_year = 4*digit\n  supplement_month = 2*digit\n  digit = %x30-39\n  space = \" \"\n  slash = \"/\"\n  colon = \":\"\n  dash = \"-\"\n\n  # Fields: one capture rule per declared field; the whole pattern\n  # is the capture.\n  cen_cenelec_number = ((%x31-39) *digit) as number\n  cen_cenelec_part = (1*digit) as part\n  cen_cenelec_year = (4*digit) as year\n\n  # Identifier rule: the canonical template first, then the\n  # declared alternates (parse-in spellings; they normalize to the\n  # canonical render face).\n  identifier = \"EN\" \" \" cen_cenelec_number [\"-\" cen_cenelec_part] [\":\" cen_cenelec_year]\n  entry identifier: identifier\n\n  # Typed model bindings: every bound capture lands on the\n  # consumer model's field of the same name.\n  bindings identifier {\n    number -> number (string)\n    part -> part (string)\n    year -> year (string)\n  }\n\n  # REQUIRED examples from the definition — accepts, rejects, and\n  # the capture expectations the compiler replayed at compile time.\n  test {\n    accept \"EN 1325\"\n    accept \"EN 12464-1:2011\"\n    accept \"EN 1177:2018\"\n    reject \"EN\"\n    reject \"EN ISO 9001:2015\"\n    reject \"nonsense\"\n    reject \"CEN/TS 12345\"\n    example \"EN 1325\" { number: \"1325\" }\n    example \"EN 12464-1:2011\" { number: \"12464\" part: \"1\" year: \"2011\" }\n    example \"EN 1177:2018\" { number: \"1177\" year: \"2018\" }\n  }\n}\n","source_hash":"4b84b6acda6f62fbbff60e0ff603d72e3ff00b71906914855633b6f0404869db","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.126","edition":2,"semantics_hash":"sha256:4363f170082d3242a35648e8b019037e9670c804d4ea951a51487697eb0c4cee","checksum":"sha256:e19eae585ed8ee560c88d97c8289d827384d21214db02634bc3eeff5a0296ac9"}

package/vendor/parg/doi_pfs.json

@@ -0,0 +1 @@
+{"bindings":null,"version":"0.1.0","grammar":"PubidDoiPfs","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"doi:"}},{"Entity":{"atom":8}},{"Str":{"pattern":"10"}},{"Str":{"pattern":"."}},{"Entity":{"atom":5}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":4,"min":2,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[2,3,6]}},{"Named":{"name":"prefix","atom":7}},{"Str":{"pattern":"/"}},{"Entity":{"atom":23}},{"Entity":{"atom":21}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Re":{"pattern":"[.]"}},{"Re":{"pattern":"[_]"}},{"Re":{"pattern":"[\\-]"}},{"Re":{"pattern":"[/]"}},{"Re":{"pattern":"[(]"}},{"Re":{"pattern":"[)]"}},{"Alternative":{"atoms":[12,13,14,15,16,17,18,19,20]}},{"Repetition":{"atom":11,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"suffix","atom":22}},{"Sequence":{"atoms":[0,1,9,10]}},{"Entity":{"atom":33}},{"Str":{"pattern":"https://"}},{"Str":{"pattern":"http://"}},{"Alternative":{"atoms":[26,27]}},{"Repetition":{"atom":28,"min":0,"max":1,"tag":"Maybe"}},{"Str":{"pattern":"doi.org"}},{"Repetition":{"atom":30,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[29,31]}},{"Repetition":{"atom":32,"min":0,"max":1,"tag":"Maybe"}},{"Named":{"name":"url_prefix","atom":25}},{"Repetition":{"atom":34,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":41}},{"Str":{"pattern":"doi:"}},{"Str":{"pattern":"DOI:"}},{"Str":{"pattern":"Doi:"}},{"Alternative":{"atoms":[37,38,39]}},{"Repetition":{"atom":40,"min":0,"max":1,"tag":"Maybe"}},{"Named":{"name":"scheme_prefix","atom":36}},{"Repetition":{"atom":42,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":45}},{"Str":{"pattern":"/"}},{"Named":{"name":"slash","atom":44}},{"Repetition":{"atom":46,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":8}},{"Str":{"pattern":"/"}},{"Entity":{"atom":23}},{"Sequence":{"atoms":[35,43,47,48,49,50]}},{"Alternative":{"atoms":[24,51]}}],"root":52},"bindings":[{"capture":"prefix","path":"prefix","type":"string","card":null,"preprocess":null},{"capture":"suffix","path":"suffix","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":["rule identifier: branches 1 and 2 are order-dependent (shared first bytes; ordered choice is decisive)"]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"doi:10.1000/182","expect":{}},{"entry":"identifier","kind":"accept","input":"10.1006/jmbi.1998.2354","expect":{}},{"entry":"identifier","kind":"accept","input":"DOI:10.6028/NIST.2022-04-15.001","expect":{}},{"entry":"identifier","kind":"accept","input":"https://doi.org/10.1000/182","expect":{}},{"entry":"identifier","kind":"reject","input":"doi:","expect":{}},{"entry":"identifier","kind":"reject","input":"doi:10","expect":{}},{"entry":"identifier","kind":"reject","input":"doi:10.X/abc","expect":{}},{"entry":"identifier","kind":"reject","input":"doi:10.1000/","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}},{"entry":"identifier","kind":"example","input":"doi:10.1000/182","expect":{"prefix":"10.1000","suffix":"182"}},{"entry":"identifier","kind":"example","input":"10.1006/jmbi.1998.2354","expect":{"prefix":"10.1006","suffix":"jmbi.1998.2354"}},{"entry":"identifier","kind":"example","input":"DOI:10.6028/NIST.2022-04-15.001","expect":{"prefix":"10.6028","suffix":"NIST.2022-04-15.001"}},{"entry":"identifier","kind":"example","input":"https://doi.org/10.1000/182","expect":{"prefix":"10.1000","suffix":"182"}}],"docs":{},"source":"# PFS-generated grammar — DO NOT EDIT BY HAND.\n# Source: definitions/doi.pfs (pfs:1) sha256:60abc3c403c61019d727ee44d9a72591c1549672451e6609a72d36189cae6340\n# Compiler: pubid/grammar/pfs 0.1.0\n# Flavor key: doi_pfs (grammar PubidDoiPfs)\n# Regenerate: ruby scripts/pfs compile definitions/doi.pfs --as doi_pfs\n\ngrammar PubidDoiPfs version \"0.1.0\" edition 2 {\n\n  # Grammar fragments: named lexical terms declared under `grammar:`.\n  digit = %x30-39\n  suffix_char = %x30-39 / %x41-5A / %x61-7A / %x2E / %x5F / %x2D / %x2F / %x28 / %x29\n  slash = \"/\"\n  url_prefix = [[\"https://\" / \"http://\"] [\"doi.org\"]]\n  scheme_prefix = [\"doi:\" / \"DOI:\" / \"Doi:\"]\n\n  # Fields: one capture rule per declared field; the whole pattern\n  # is the capture.\n  doi_prefix = (\"10\" \".\" 2*digit) as prefix\n  doi_suffix = (1*suffix_char) as suffix\n\n  # Identifier rule: the canonical template first, then the\n  # declared alternates (parse-in spellings; they normalize to the\n  # canonical render face).\n  identifier = {\n    \"doi:\" doi_prefix \"/\" doi_suffix\n    / [url_prefix] [scheme_prefix] [slash] doi_prefix \"/\" doi_suffix\n  }\n  entry identifier: identifier\n\n  # Typed model bindings: every bound capture lands on the\n  # consumer model's field of the same name.\n  bindings identifier {\n    prefix -> prefix (string)\n    suffix -> suffix (string)\n  }\n\n  # REQUIRED examples from the definition — accepts, rejects, and\n  # the capture expectations the compiler replayed at compile time.\n  test {\n    accept \"doi:10.1000/182\"\n    accept \"10.1006/jmbi.1998.2354\"\n    accept \"DOI:10.6028/NIST.2022-04-15.001\"\n    accept \"https://doi.org/10.1000/182\"\n    reject \"doi:\"\n    reject \"doi:10\"\n    reject \"doi:10.X/abc\"\n    reject \"doi:10.1000/\"\n    reject \"nonsense\"\n    example \"doi:10.1000/182\" { prefix: \"10.1000\" suffix: \"182\" }\n    example \"10.1006/jmbi.1998.2354\" { prefix: \"10.1006\" suffix: \"jmbi.1998.2354\" }\n    example \"DOI:10.6028/NIST.2022-04-15.001\" { prefix: \"10.6028\" suffix: \"NIST.2022-04-15.001\" }\n    example \"https://doi.org/10.1000/182\" { prefix: \"10.1000\" suffix: \"182\" }\n  }\n}\n","source_hash":"c872de21dfa95b1add4eed4785182c6e661fc79a0a8c15c07eb6209621a20f2c","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.126","edition":2,"semantics_hash":"sha256:06d0039460d751282b122dd5834bd505046c2cb32605c051ac296f2c29f964b3","checksum":"sha256:25f3643ce0fe181ae16b91a87a43177d495079ed590c6eee3c3cf36825e1fc05"}