@pubid/pubid 0.1.33 → 0.1.35

package/dist/pubid-urn/index.js

@@ -0,0 +1,216 @@
+/**
+ * The pubid-scheme URN (pubid#656) — the TS mirror of
+ * Pubid::PubidUrn (lib/pubid/pubid_urn.rb). Pubid's own URN namespace,
+ * which carries the full typed model and always round-trips —
+ * `parsePubidUrn(generate(id.toHash())).toHash == id.toHash`.
+ *
+ * It is a different thing from the official URN (`toUrn()`, e.g.
+ * "urn:iso:std:…"), which follows the registered grammar of the
+ * organization and may be lossy. relaton uses the pubid-scheme URN as
+ * its HTTP path slug (relaton/relaton#441), so the form is also
+ * path-safe: no "/", "%", "?", "#" and no empty segment.
+ *
+ *   urn:pubid:iso:is:9001:year-2015:amd:1:year-2016
+ *
+ * The shape of each identifier type is declared in its flavor's schema
+ * (src/pubid-urn/schemas/<flavor>.ts), through {@linkcode define}. A
+ * flavor with no schema cannot emit one yet.
+ */
+import { FlavorSchema } from "./schema.js";
+import { InvalidInputError, UrnParseError } from "./errors.js";
+import { Encoder } from "./encoder.js";
+import { Decoder } from "./decoder.js";
+import { exactMatch } from "./escape.js";
+import { PUBID_URN_SCHEMAS } from "./schemas/index.js";
+import { resolveType } from "../model/identifier.js";
+import { toSlug, fromSlug } from "./slug.js";
+export { toSlug, fromSlug };
+export { Atom, Facet, FlavorSchema, TypeSchema } from "./schema.js";
+export { Encoder } from "./encoder.js";
+export { Decoder } from "./decoder.js";
+export { UrnParseError, InvalidInputError } from "./errors.js";
+export { encode, force, decode } from "./escape.js";
+export { take, put, blank } from "./paths.js";
+export const PREFIX = "urn:pubid:";
+/** An absent core value in the middle of the core, or an absent element
+ *  of a list. Distinct from an escape, which always has two hex digits. */
+export const NULL = "~";
+/** Pubid::MAX_INPUT_LENGTH (1000) — the printed-identifier guard. */
+export const MAX_INPUT_LENGTH = 1000;
+export const MAX_LENGTH = 16 * MAX_INPUT_LENGTH;
+const INPUT_NOT_A_STRING_MESSAGE = "input is not a String";
+/**
+ * A raw segment that reads as structure and not as a core value: a type
+ * token or the facet marker ("amd", "f"), an atom ("year-2015"), or a
+ * token of another flavor ("iec.is", "3gpp.ts").
+ *
+ * The rule depends on the SHAPE of the segment only, never on which
+ * schemas exist. So a published URN keeps its meaning when a flavor, a
+ * type token or an atom is added later. Type tokens, atom prefixes and
+ * facet names therefore start with a lower-case letter
+ * (FlavorSchema.NAME). Digit-led numbers ("9001", "802.11", "800-53")
+ * and upper-case ones ("G.711") never match; a core value that does
+ * match gets its first character escaped ("iec.is" -> "~69ec.is").
+ */
+const STRUCTURE_HEAD = /^[a-z][a-z0-9]*/;
+const STRUCTURE_FLAVOR_TOKEN = /^[a-z0-9]*[a-z][a-z0-9]*\.[a-z][a-z0-9]*$/;
+/** The schema registry: flavor segment => its FlavorSchema. Built lazily
+ *  from the declarative tables in ./schemas/ (no import side effects). */
+let registry;
+function schemas() {
+    if (registry === undefined) {
+        registry = new Map(PUBID_URN_SCHEMAS.map((schema) => [schema.flavor, schema]));
+    }
+    return registry;
+}
+/** Declare the schema of a flavor. `flavor` is the flavor segment of its
+ *  `_type` ("iso", "cencenelec", "3gpp"). The callback plays ruby's
+ *  instance_eval: it receives the schema and declares atoms/facets/types. */
+export function define(flavor, body) {
+    const schema = new FlavorSchema(flavor);
+    body(schema);
+    return schema;
+}
+/** The pubid-scheme URN of an identifier hash (ruby generate(identifier):
+ *  the hash is Identifier#to_hash's output). */
+export function generate(hash) {
+    const urn = PREFIX + new Encoder(hash).body();
+    if (urn.length > MAX_LENGTH) {
+        throw new InvalidInputError(`pubid URN exceeds ${MAX_LENGTH} characters`);
+    }
+    return urn;
+}
+/** Parse a pubid-scheme URN back into an identifier, through the
+ *  canonical gate: the decoded identifier must re-encode to exactly the
+ *  input, so one identifier has exactly one URN. */
+export function parse(urn) {
+    checkInput(urn);
+    const identifier = build(urn.slice(PREFIX.length));
+    checkCanonical(identifier, urn);
+    return identifier;
+}
+/** True for "urn:pubid:…" (the NID is case-insensitive, RFC 8141). */
+export function isPubidUrn(urn) {
+    return urn.slice(0, PREFIX.length).toLowerCase() === PREFIX;
+}
+/** "iso" in "pubid:iso:technical-report". */
+export function flavorSegment(type) {
+    return typeof type === "string" ? type.split(":")[1] : undefined;
+}
+export function flavorSchema(flavor) {
+    return schemas().get(flavor);
+}
+/** @raise InvalidInputError when no schema places `type`. */
+export function typeSchemaOrThrow(type) {
+    const flavor = flavorSegment(type);
+    const schema = flavor !== undefined ? flavorSchema(flavor)?.forType(type) : undefined;
+    if (schema !== undefined)
+        return schema;
+    throw new InvalidInputError(`no pubid URN schema for ${JSON.stringify(type)}`);
+}
+/** Does `token` (a raw, still escaped segment) read as structure? */
+export function structural(token) {
+    const head = STRUCTURE_HEAD.exec(token);
+    if (head !== null) {
+        const len = head[0].length;
+        if (len === token.length || token[len] === "-")
+            return true;
+    }
+    const flavorToken = STRUCTURE_FLAVOR_TOKEN.exec(token);
+    return flavorToken !== null && flavorToken[0].length === token.length;
+}
+/** A type token is "<token>" of the URN's own flavor, or
+ *  "<flavor>.<token>" for a node of another flavor. */
+export function splitToken(token, flavor) {
+    return token.includes(".") ? token.split(".", 2) : [flavor, token];
+}
+/** Split `body` at `separator` outside brackets. `allowEmpty` is true for
+ *  the items of a list, where an empty item is an empty String; a ":"
+ *  segment is never empty. */
+export function splitTop(body, separator, allowEmpty = false) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const char of body) {
+        if (char === "(")
+            depth += 1;
+        if (char === ")") {
+            depth -= 1;
+            if (depth < 0)
+                unbalanced(body);
+        }
+        if (char === separator && depth === 0) {
+            parts.push(current);
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (depth !== 0)
+        unbalanced(body);
+    parts.push(current);
+    if (!allowEmpty && parts.some((part) => part === "")) {
+        throw new UrnParseError(`empty segment in ${JSON.stringify(body)}`);
+    }
+    return parts;
+}
+function unbalanced(body) {
+    throw new UrnParseError(`unbalanced bracket in ${JSON.stringify(body)}`);
+}
+function checkInput(urn) {
+    if (typeof urn !== "string") {
+        throw new InvalidInputError(INPUT_NOT_A_STRING_MESSAGE);
+    }
+    if (urn.length > MAX_LENGTH) {
+        throw new InvalidInputError(`input exceeds ${MAX_LENGTH} characters`);
+    }
+    // ruby also rejects a String with invalid byte encoding; a JS string is
+    // always valid UTF-16, so that half of the check has no counterpart.
+    if (!isPubidUrn(urn)) {
+        throw new UrnParseError(`not a pubid-scheme URN: ${JSON.stringify(urn)}`);
+    }
+}
+/** The URN is untrusted input: a value that decodes but cannot be cast
+ *  into its attribute (a bad boolean, a String where a component goes)
+ *  is a bad URN, so every failure here is reported as UrnParseError,
+ *  with the original error as its cause. */
+function build(body) {
+    let hash;
+    let built;
+    try {
+        hash = new Decoder(body).toIdentifierHash();
+        const klass = resolveType(hash["_type"]);
+        if (klass === undefined) {
+            throw new InvalidInputError(`unknown identifier type ${JSON.stringify(hash["_type"])}`);
+        }
+        built = klass.fromHash(hash);
+    }
+    catch (e) {
+        if (e instanceof UrnParseError)
+            throw e;
+        throw new UrnParseError(`pubid URN ${JSON.stringify(body)} does not build: ${errorMessage(e)}`);
+    }
+    return built;
+}
+function checkCanonical(identifier, urn) {
+    let canonical;
+    try {
+        canonical = generate(identifier.toHash());
+    }
+    catch (e) {
+        if (e instanceof InvalidInputError) {
+            throw new UrnParseError(`${JSON.stringify(urn)} does not re-encode: ${errorMessage(e)}`);
+        }
+        throw e;
+    }
+    if (canonical.slice(PREFIX.length) !== urn.slice(PREFIX.length)) {
+        throw new UrnParseError(`${JSON.stringify(urn)} is not canonical; the canonical form is ${JSON.stringify(canonical)}`);
+    }
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+// exactMatch is re-exported for the schemas' own probes; the module
+// surface mirrors lib/pubid/pubid_urn.rb's helpers.
+export { exactMatch };

package/dist/pubid-urn/paths.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reads and writes a dotted key path ("edition.number",
+ * "languages.*.code") in an identifier hash — the TS mirror of
+ * Pubid::PubidUrn::Paths (lib/pubid/pubid_urn/paths.rb).
+ *
+ * `take` removes what it reads, so after every core path, atom and facet
+ * has been taken, anything left in the node is a key that the schema
+ * does not place — the encoder refuses it rather than drop it silently.
+ *
+ * A degenerate component may serialize as a bare scalar ("edition" =>
+ * "2" rather than {"number" => "2"}, see FLAT_SCALAR_FIELDS). Where a
+ * path expects a Hash and finds a scalar, the scalar IS the value of
+ * the path. `put` always writes the nested form, which fromHash reads
+ * as well, so the rebuilt identifier serializes alike.
+ *
+ * ruby nil is the JS null/undefined pair: the corpus wire form is JSON,
+ * where a nil attribute arrives as null; isNil() is the shared test.
+ */
+export declare function isNil(value: unknown): boolean;
+/** @return the value, or null (ruby nil) when the path is absent. */
+export declare function take(container: Record<string, unknown>, parts: string[]): unknown;
+/** Write `value` (null writes nothing). */
+export declare function put(container: Record<string, unknown>, parts: string[], value: unknown): void;
+/** True when nothing but empty containers is left. */
+export declare function blank(value: unknown): boolean;
+export declare function deepDup(value: unknown): unknown;

package/dist/pubid-urn/paths.js

@@ -0,0 +1,129 @@
+/**
+ * Reads and writes a dotted key path ("edition.number",
+ * "languages.*.code") in an identifier hash — the TS mirror of
+ * Pubid::PubidUrn::Paths (lib/pubid/pubid_urn/paths.rb).
+ *
+ * `take` removes what it reads, so after every core path, atom and facet
+ * has been taken, anything left in the node is a key that the schema
+ * does not place — the encoder refuses it rather than drop it silently.
+ *
+ * A degenerate component may serialize as a bare scalar ("edition" =>
+ * "2" rather than {"number" => "2"}, see FLAT_SCALAR_FIELDS). Where a
+ * path expects a Hash and finds a scalar, the scalar IS the value of
+ * the path. `put` always writes the nested form, which fromHash reads
+ * as well, so the rebuilt identifier serializes alike.
+ *
+ * ruby nil is the JS null/undefined pair: the corpus wire form is JSON,
+ * where a nil attribute arrives as null; isNil() is the shared test.
+ */
+export function isNil(value) {
+    return value === undefined || value === null;
+}
+/** @return the value, or null (ruby nil) when the path is absent. */
+export function take(container, parts) {
+    if (container === null || typeof container !== "object" || Array.isArray(container)) {
+        return null;
+    }
+    const key = parts[0];
+    if (!Object.hasOwn(container, key))
+        return null;
+    const rest = parts.slice(1);
+    const value = container[key];
+    if (rest.length === 0) {
+        delete container[key];
+        return value;
+    }
+    if (rest[0] === "*") {
+        return takeElements(container, key, value, rest.slice(1));
+    }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return take(value, rest);
+    }
+    if (rest.length === 1) {
+        delete container[key];
+        return value;
+    }
+    return null;
+}
+function takeElements(container, key, value, rest) {
+    if (!Array.isArray(value))
+        return null;
+    if (rest.length === 0) {
+        delete container[key];
+        return value;
+    }
+    const values = value.map((element, i) => {
+        if (element !== null && typeof element === "object" && !Array.isArray(element)) {
+            return take(element, rest);
+        }
+        if (rest.length === 1 && element !== null && element !== undefined) {
+            value[i] = {};
+            return element;
+        }
+        return null;
+    });
+    return values.every((v) => v === null) ? null : values;
+}
+/** Write `value` (null writes nothing). */
+export function put(container, parts, value) {
+    if (value === undefined || value === null)
+        return;
+    const key = parts[0];
+    const rest = parts.slice(1);
+    if (rest.length === 0) {
+        container[key] = value;
+    }
+    else if (rest[0] === "*") {
+        putElements(container, key, value, rest.slice(1));
+    }
+    else {
+        let nested = container[key];
+        if (nested === undefined || nested === null) {
+            nested = {};
+            container[key] = nested;
+        }
+        put(nested, rest, value);
+    }
+}
+function putElements(container, key, values, rest) {
+    if (rest.length === 0) {
+        container[key] = values;
+        return;
+    }
+    let elements = container[key];
+    if (elements === undefined || elements === null || !Array.isArray(elements)) {
+        elements = [];
+        container[key] = elements;
+    }
+    values.forEach((value, i) => {
+        if (value === undefined || value === null)
+            return;
+        let element = elements[i];
+        if (element === undefined || element === null || typeof element !== "object" || Array.isArray(element)) {
+            element = {};
+            elements[i] = element;
+        }
+        put(element, rest, value);
+    });
+}
+/** True when nothing but empty containers is left. */
+export function blank(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return Object.values(value).every((v) => blank(v));
+    }
+    if (Array.isArray(value)) {
+        return value.every((v) => blank(v));
+    }
+    return false;
+}
+export function deepDup(value) {
+    if (value !== null && typeof value === "object") {
+        if (Array.isArray(value))
+            return value.map((v) => deepDup(v));
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = deepDup(v);
+        return out;
+    }
+    return value;
+}

package/dist/pubid-urn/schema.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The schema definition DSL of the pubid-scheme URN — the TS mirror of
+ * Pubid::PubidUrn::Atom/Facet/TypeSchema/FlavorSchema
+ * (lib/pubid/pubid_urn/schema.rb).
+ *
+ * One prefixed atom: an optional value, found by its prefix and not by
+ * its position ("part-1", "co-IEC,IEEE", "ids-(iso:is:9001)"). A facet
+ * is a spelling-only value, written in the trailing "f" group.
+ *
+ * The URN shape of one concrete identifier type is a TypeSchema: the
+ * positional core, the atoms in their canonical order, the facets. A
+ * flavor's FlavorSchema declares flavor-level atoms/facets that apply
+ * to every type, plus one TypeSchema per concrete type.
+ */
+export type AtomKind = "string" | "list" | "bool" | "bools" | "int" | "id" | "ids";
+export type FacetKind = "string" | "list" | "bool" | "bools";
+export type CoreKind = "string" | "int";
+export declare class Atom {
+    readonly path: string;
+    readonly prefix: string;
+    readonly kind: AtomKind;
+    readonly parts: readonly string[];
+    constructor(path: string, prefix: string, kind: AtomKind);
+    get list(): boolean;
+    /** The kind of one value (of one element of a list). */
+    get element(): "string" | "bool" | AtomKind;
+}
+export declare class Facet {
+    readonly path: string;
+    readonly name: string;
+    readonly kind: FacetKind;
+    readonly parts: readonly string[];
+    constructor(path: string, name: string, kind: FacetKind);
+    get list(): boolean;
+    get element(): "string" | "bool" | FacetKind;
+}
+export type CoreSpec = string | [path: string, kind: CoreKind];
+export type AtomSpec = [path: string, prefix: string, kind?: AtomKind];
+export type FacetSpec = [path: string, name: string, kind?: FacetKind];
+/** The URN shape of one concrete identifier type. */
+export declare class TypeSchema {
+    readonly flavor: string;
+    readonly type: string;
+    readonly token: string;
+    readonly core: readonly (readonly string[])[];
+    readonly coreKinds: readonly CoreKind[];
+    readonly atoms: readonly Atom[];
+    readonly facets: readonly Facet[];
+    private readonly atomIndex;
+    private readonly facetNames;
+    constructor(flavor: string, type: string, token: string, core: readonly CoreSpec[], atoms: readonly Atom[], facets: readonly Facet[]);
+    /** The canonical position of the atom whose prefix starts `token`,
+     *  or undefined when `token` is no atom of this type. */
+    atomPosition(token: string): number | undefined;
+    facet(name: string): Facet | undefined;
+}
+export interface TypeDeclaration {
+    /** The positional core paths; an entry is a path (a String value) or
+     *  [path, kind], kind "string" or "int". Default ["number"]. */
+    core?: CoreSpec[];
+    /** Extra atoms: [path, prefix, kind?]. */
+    atoms?: AtomSpec[];
+    /** Extra facets: [path, name, kind?]. */
+    facets?: FacetSpec[];
+}
+/**
+ * The pubid-scheme schema of one flavor: the canonical atom order, the
+ * facets, and one TypeSchema for each concrete type.
+ *
+ * Atoms and facets declared at flavor level apply to every type, in the
+ * order of declaration; a type adds its own after them. A type token, an
+ * atom prefix and a facet name are a lower-case letter followed by
+ * lower-case letters and digits, so none can contain the "-" that ends a
+ * prefix or the "." that qualifies a token of another flavor.
+ */
+export declare class FlavorSchema {
+    readonly flavor: string;
+    readonly types: Map<string, TypeSchema>;
+    private readonly tokens;
+    private atoms;
+    private facets;
+    constructor(flavor: string);
+    atom(path: string, prefix: string, kind?: AtomKind): void;
+    facet(path: string, name: string, kind?: FacetKind): void;
+    type(type: string, token: string, declaration?: TypeDeclaration): void;
+    forToken(token: string): TypeSchema | undefined;
+    forType(type: string): TypeSchema | undefined;
+}

package/dist/pubid-urn/schema.js

@@ -0,0 +1,186 @@
+/**
+ * The schema definition DSL of the pubid-scheme URN — the TS mirror of
+ * Pubid::PubidUrn::Atom/Facet/TypeSchema/FlavorSchema
+ * (lib/pubid/pubid_urn/schema.rb).
+ *
+ * One prefixed atom: an optional value, found by its prefix and not by
+ * its position ("part-1", "co-IEC,IEEE", "ids-(iso:is:9001)"). A facet
+ * is a spelling-only value, written in the trailing "f" group.
+ *
+ * The URN shape of one concrete identifier type is a TypeSchema: the
+ * positional core, the atoms in their canonical order, the facets. A
+ * flavor's FlavorSchema declares flavor-level atoms/facets that apply
+ * to every type, plus one TypeSchema per concrete type.
+ */
+/** A list kind => the kind of its elements. */
+const LIST_KINDS = {
+    list: "string",
+    bools: "bool",
+};
+export class Atom {
+    path;
+    prefix;
+    kind;
+    parts;
+    constructor(path, prefix, kind) {
+        this.path = path;
+        this.prefix = prefix;
+        this.kind = kind;
+        this.parts = path.split(".");
+    }
+    get list() {
+        return LIST_KINDS[this.kind] !== undefined;
+    }
+    /** The kind of one value (of one element of a list). */
+    get element() {
+        return LIST_KINDS[this.kind] ?? this.kind;
+    }
+}
+export class Facet {
+    path;
+    name;
+    kind;
+    parts;
+    constructor(path, name, kind) {
+        this.path = path;
+        this.name = name;
+        this.kind = kind;
+        this.parts = path.split(".");
+    }
+    get list() {
+        return LIST_KINDS[this.kind] !== undefined;
+    }
+    get element() {
+        return LIST_KINDS[this.kind] ?? this.kind;
+    }
+}
+/** The URN shape of one concrete identifier type. */
+export class TypeSchema {
+    flavor;
+    type;
+    token;
+    core;
+    coreKinds;
+    atoms;
+    facets;
+    atomIndex;
+    facetNames;
+    constructor(flavor, type, token, core, atoms, facets) {
+        this.flavor = flavor;
+        this.type = type;
+        this.token = token;
+        this.core = core.map((spec) => (typeof spec === "string" ? spec : spec[0]).split("."));
+        this.coreKinds = core.map((spec) => (typeof spec === "string" ? "string" : spec[1]));
+        this.atoms = atoms;
+        this.facets = facets;
+        this.atomIndex = new Map(atoms.map((atom, i) => [atom.prefix, i]));
+        this.facetNames = new Map(facets.map((facet) => [facet.name, facet]));
+    }
+    /** The canonical position of the atom whose prefix starts `token`,
+     *  or undefined when `token` is no atom of this type. */
+    atomPosition(token) {
+        const m = /^([a-z0-9]+)-/.exec(token);
+        if (m === null)
+            return undefined;
+        return this.atomIndex.get(m[1]);
+    }
+    facet(name) {
+        return this.facetNames.get(name);
+    }
+}
+const NAME = /^[a-z][a-z0-9]*$/;
+const RESERVED_TOKENS = new Set(["f", "type"]);
+/**
+ * The pubid-scheme schema of one flavor: the canonical atom order, the
+ * facets, and one TypeSchema for each concrete type.
+ *
+ * Atoms and facets declared at flavor level apply to every type, in the
+ * order of declaration; a type adds its own after them. A type token, an
+ * atom prefix and a facet name are a lower-case letter followed by
+ * lower-case letters and digits, so none can contain the "-" that ends a
+ * prefix or the "." that qualifies a token of another flavor.
+ */
+export class FlavorSchema {
+    flavor;
+    types = new Map();
+    tokens = new Map();
+    atoms = [];
+    facets = [];
+    constructor(flavor) {
+        this.flavor = flavor;
+    }
+    atom(path, prefix, kind) {
+        this.atoms.push(buildAtom(path, prefix, kind));
+    }
+    facet(path, name, kind) {
+        this.facets.push(buildFacet(path, name, kind));
+    }
+    type(type, token, declaration = {}) {
+        checkName(token, "type token");
+        if (RESERVED_TOKENS.has(token) || this.tokens.has(token)) {
+            throw new Error(`type token ${JSON.stringify(token)} is reserved or taken`);
+        }
+        const core = (declaration.core ?? ["number"]).map(buildCore);
+        const allAtoms = [...this.atoms, ...(declaration.atoms ?? []).map((spec) => buildAtom(...spec))];
+        checkUnique(allAtoms.map((atom) => atom.prefix), "atom prefix", type);
+        const allFacets = [
+            ...this.facets,
+            ...(declaration.facets ?? []).map((spec) => buildFacet(...spec)),
+        ];
+        checkUnique(allFacets.map((facet) => facet.name), "facet name", type);
+        const schema = new TypeSchema(this.flavor, type, token, core, allAtoms, allFacets);
+        this.types.set(type, schema);
+        this.tokens.set(token, schema);
+    }
+    forToken(token) {
+        return this.tokens.get(token);
+    }
+    forType(type) {
+        return this.types.get(type);
+    }
+}
+function buildCore(spec) {
+    const kind = typeof spec === "string" ? "string" : spec[1];
+    if (kind !== "string" && kind !== "int") {
+        throw new Error(`unknown core kind ${JSON.stringify(kind)}`);
+    }
+    return spec;
+}
+function buildAtom(path, prefix, kind) {
+    checkName(prefix, "atom prefix");
+    return new Atom(path, prefix, checkKind(path, kind, ATOM_KINDS, "atom"));
+}
+function buildFacet(path, name, kind) {
+    checkName(name, "facet name");
+    return new Facet(path, name, checkKind(path, kind, FACET_KINDS, "facet"));
+}
+const ATOM_KINDS = ["string", "list", "bool", "bools", "int", "id", "ids"];
+const FACET_KINDS = ["string", "list", "bool", "bools"];
+/** A path with "*" reads a list, so its kind must be a list kind. */
+function checkKind(path, kind, kinds, what) {
+    const listed = path.split(".").includes("*");
+    const resolved = kind ?? (listed ? "list" : "string");
+    if (!kinds.includes(resolved)) {
+        throw new Error(`unknown ${what} kind ${JSON.stringify(resolved)}`);
+    }
+    if (listed && LIST_KINDS[resolved] === undefined) {
+        throw new Error(`${what} ${JSON.stringify(path)} reads a list, so its kind must be one of list, bools`);
+    }
+    return resolved;
+}
+function checkName(name, what) {
+    const m = NAME.exec(name);
+    if (m === null || m[0].length !== name.length) {
+        throw new Error(`${what} ${JSON.stringify(name)} must match ${NAME.source}`);
+    }
+}
+function checkUnique(names, what, type) {
+    const counts = new Map();
+    for (const name of names)
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    for (const [name, count] of counts) {
+        if (count > 1) {
+            throw new Error(`${what} ${JSON.stringify(name)} repeats in ${type}`);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * The pubid-scheme URN schema of ADOBE — 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 adobeSchema: import("../schema.js").FlavorSchema;

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

@@ -0,0 +1,15 @@
+/**
+ * The pubid-scheme URN schema of ADOBE — 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 adobeSchema = define("adobe", (s) => {
+    s.atom("slug", "slug");
+    s.atom("version", "v");
+    s.type("pubid:adobe:identifier", "id", { core: [] });
+    s.type("pubid:adobe:publication", "pub", { core: [] });
+    s.type("pubid:adobe:tech-note", "technote");
+});

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

@@ -0,0 +1,8 @@
+/**
+ * The pubid-scheme URN schema of AMCA — 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 amcaSchema: import("../schema.js").FlavorSchema;