@pubid/pubid 0.1.33 → 0.1.34

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;

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+import { define } from "../index.js";
+export const amcaSchema = define("amca", (s) => {
+    s.atom("copublisher", "co");
+    s.atom("year", "year");
+    s.atom("revision", "rev");
+    s.atom("reaffirmed", "reaffirmed");
+    s.atom("interpretation_code", "interpcode");
+    s.type("pubid:amca:identifier", "id");
+    s.type("pubid:amca:interpretation", "interp");
+    s.type("pubid:amca:publication", "pub");
+    s.type("pubid:amca:standard", "std");
+});

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * The pubid-scheme URN schema of ANSI — 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 ansiSchema = define("ansi", (s) => {
+    s.atom("publisher.body", "pub");
+    s.atom("copublishers.*.body", "co");
+    s.atom("type.abbr", "type");
+    s.atom("part", "part");
+    s.atom("subpart", "subpart");
+    s.atom("year", "year");
+    s.atom("date.year", "dateyear");
+    s.atom("date.month", "datemonth");
+    s.atom("date.day", "dateday");
+    s.atom("date.undated", "undated", "bool");
+    s.atom("edition.number", "ed");
+    s.atom("stage.abbr", "stage");
+    s.atom("stage_iteration.number", "iter");
+    s.atom("languages.*.code", "lang");
+    s.atom("locality.value", "loc");
+    s.facet("languages.*.original_code", "langsrc");
+    s.facet("edition.original_text", "edsrc");
+    s.type("pubid:ansi:standard", "std");
+    s.type("pubid:ansi:american-national-standard", "ans");
+    s.type("pubid:ansi:identifier", "id");
+});

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * The pubid-scheme URN schema of API — 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 apiSchema = define("api", (s) => {
+    s.atom("part", "part");
+    s.atom("section", "section");
+    s.atom("subsection", "subsection");
+    s.atom("year", "year");
+    s.type("pubid:api:base", "base");
+    s.type("pubid:api:bulletin", "bulletin");
+    s.type("pubid:api:continuous-operations-standard", "cos");
+    s.type("pubid:api:identifier", "id");
+    s.type("pubid:api:mpms", "mpms");
+    s.type("pubid:api:publication", "pub");
+    s.type("pubid:api:recommended-practice", "rp");
+    s.type("pubid:api:specification", "spec");
+    s.type("pubid:api:standard", "std");
+    s.type("pubid:api:technical-report", "tr");
+    s.type("pubid:api:typeless-standard", "ts");
+});

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * The pubid-scheme URN schema of ASHRAE — 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 ashraeSchema = define("ashrae", (s) => {
+    s.atom("copublisher", "co");
+    s.atom("year", "year");
+    s.atom("date.day", "dateday");
+    s.atom("date.month", "datemonth");
+    s.atom("date.year", "dateyear");
+    s.atom("addendum_code", "addendumcode");
+    s.atom("addendum_codes", "addendumcodes");
+    s.atom("package_description", "packagedescription");
+    s.atom("reaffirmed", "reaffirmed");
+    s.atom("suffix", "suffix");
+    s.type("pubid:ashrae:addenda-package", "ap");
+    s.type("pubid:ashrae:addendum", "add");
+    s.type("pubid:ashrae:combined-addenda", "ca");
+    s.type("pubid:ashrae:errata", "err");
+    s.type("pubid:ashrae:guideline", "g");
+    s.type("pubid:ashrae:identifier", "id");
+    s.type("pubid:ashrae:interpretation", "interp");
+    s.type("pubid:ashrae:standard", "std");
+});

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

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

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

@@ -0,0 +1,26 @@
+/**
+ * The pubid-scheme URN schema of ASME — 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 asmeSchema = define("asme", (s) => {
+    s.atom("publisher", "pub");
+    s.atom("year", "year");
+    s.atom("language", "lang");
+    s.atom("csa_number", "csanumber");
+    s.atom("draft_year", "draftyear");
+    s.atom("first_code", "firstcode");
+    s.atom("first_publisher", "firstpublisher");
+    s.atom("handbook", "handbook", "bool");
+    s.atom("joint_publisher", "jointpublisher");
+    s.atom("parenthetical_revision", "parentheticalrevision");
+    s.atom("ptc_suffix", "ptcsuffix");
+    s.atom("revision_note", "revisionnote");
+    s.atom("second_publisher", "secondpublisher");
+    s.type("pubid:asme:base", "base");
+    s.type("pubid:asme:identifier", "id");
+    s.type("pubid:asme:standard", "std");
+});

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

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

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

@@ -0,0 +1,38 @@
+/**
+ * The pubid-scheme URN schema of ASTM — 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 astmSchema = define("astm", (s) => {
+    s.atom("publisher", "pub");
+    s.atom("committee", "committee");
+    s.atom("letter", "letter");
+    s.atom("subseries", "subseries");
+    s.atom("suffix", "suffix");
+    s.atom("dual_m", "metric", "bool");
+    s.atom("year", "year");
+    s.atom("sub_year", "subyear");
+    s.atom("reapproval", "reapproval");
+    s.atom("edition", "ed");
+    s.atom("supplement", "sup", "bool");
+    s.atom("tp_designation", "tp");
+    s.atom("format_suffix", "format");
+    s.atom("ea_suffix", "ea", "bool");
+    s.atom("dvd_suffix", "dvd", "bool");
+    s.atom("hol_suffix", "hol", "bool");
+    s.type("pubid:astm:identifier", "id");
+    s.type("pubid:astm:single-identifier", "single");
+    s.type("pubid:astm:base", "base");
+    s.type("pubid:astm:standard", "std");
+    s.type("pubid:astm:iso-dual-published", "isodual");
+    s.type("pubid:astm:adjunct", "adj");
+    s.type("pubid:astm:data-series", "ds");
+    s.type("pubid:astm:manual", "mnl");
+    s.type("pubid:astm:monograph", "mono");
+    s.type("pubid:astm:research-report", "rr");
+    s.type("pubid:astm:technical-report", "tr");
+    s.type("pubid:astm:work-in-progress", "wk");
+});

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * The pubid-scheme URN schema of BIPM — 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 bipmSchema = define("bipm", (s) => {
+    s.atom("part", "part");
+    s.atom("issue", "issue");
+    s.atom("year", "year", "int");
+    s.atom("edition", "ed");
+    s.atom("version", "v");
+    s.atom("appendix", "appendix");
+    s.atom("annex", "annex");
+    s.atom("language", "lang");
+    s.atom("article", "article");
+    s.atom("form", "form");
+    s.atom("group", "group");
+    s.atom("guide_kind", "guidekind");
+    s.atom("mep_code", "mepcode");
+    s.atom("report_code", "reportcode");
+    s.atom("type_code", "typecode");
+    s.atom("variant", "variant");
+    s.atom("years", "years");
+    s.type("pubid:bipm:committee-document", "cd");
+    s.type("pubid:bipm:guide", "guide");
+    s.type("pubid:bipm:identifier", "id");
+    s.type("pubid:bipm:meeting", "meeting");
+    s.type("pubid:bipm:mep", "mep");
+    s.type("pubid:bipm:metrologia-article", "ma");
+    s.type("pubid:bipm:si-brochure", "sb");
+});

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

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

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

@@ -0,0 +1,98 @@
+/**
+ * The pubid-scheme URN schema of BSI — 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 bsiSchema = define("bsi", (s) => {
+    s.atom("publisher.body", "pubbody");
+    s.atom("copublishers", "co", "list");
+    s.atom("prefix", "prefix");
+    s.atom("flex_prefix", "flexprefix");
+    s.atom("part", "part");
+    s.atom("subpart", "subpart");
+    s.atom("year", "year");
+    s.atom("month", "month", "int");
+    s.atom("edition", "ed");
+    s.atom("type.abbr", "typeabbr");
+    s.atom("type.name", "typename");
+    s.atom("type.type_code", "typetypecode");
+    s.atom("stage.abbr", "stageabbr");
+    s.atom("stage.name", "stagename");
+    s.atom("stage.stage_code", "stagecode");
+    s.atom("stage.harmonized_stages", "stagehs", "list");
+    s.atom("typed_stage.abbr", "tsabbr", "list");
+    s.atom("typed_stage.name", "tsname");
+    s.atom("typed_stage.code", "tscode");
+    s.atom("typed_stage.stage_code", "tsstagecode");
+    s.atom("typed_stage.type_code", "tstypecode");
+    s.atom("typed_stage.harmonized_stages", "tshs", "list");
+    s.atom("format", "format");
+    s.atom("topic", "topic");
+    s.atom("separators", "seps", "list");
+    s.atom("separator", "sep");
+    s.atom("reverse_format", "revfmt", "bool");
+    s.atom("common_year.year", "cyear");
+    s.atom("supplement_number", "sup");
+    s.atom("supplement_year", "supyear", "int");
+    s.atom("addendum_number", "addn");
+    s.atom("addendum_year", "addy", "int");
+    s.atom("method_code", "mcode");
+    s.atom("method_to", "mto");
+    s.atom("method_and", "mand");
+    s.atom("is_plural", "isplural", "bool");
+    s.atom("section_id", "secid");
+    s.atom("section_format", "secfmt");
+    s.atom("second_number.value", "snd");
+    s.atom("spec_code.value", "spc");
+    s.atom("index_format", "idxfmt");
+    s.atom("issue_number", "issue");
+    s.atom("translation_lang", "translang");
+    s.atom("test_id", "testid");
+    s.atom("test_series", "testseries");
+    s.atom("iteration", "iter");
+    s.atom("fragment_number", "frag");
+    s.atom("explicit_prefix", "expprefix", "bool");
+    s.atom("explicit_publisher", "exppub", "bool");
+    s.atom("space_separated_part", "sspart", "bool");
+    s.atom("amd_suffix_form", "amdsuffix", "bool");
+    s.atom("bundle_type", "btype");
+    s.atom("identifiers", "ids", "ids");
+    s.atom("na_supplements", "nasup", "ids");
+    s.type("pubid:bsi:addendum-document", "ad");
+    s.type("pubid:bsi:adopted-european-norm", "aen", { core: [] });
+    s.type("pubid:bsi:adopted-international-standard", "ais", { core: [] });
+    s.type("pubid:bsi:aerospace-standard", "as");
+    s.type("pubid:bsi:amendment", "amd");
+    s.type("pubid:bsi:british-industrial-practice", "bip");
+    s.type("pubid:bsi:british-standard", "bs");
+    s.type("pubid:bsi:bundled-identifier", "bundle", { core: [] });
+    s.type("pubid:bsi:committee-document", "cd");
+    s.type("pubid:bsi:consolidated-identifier", "consol", { core: [] });
+    s.type("pubid:bsi:corrigendum", "cor");
+    s.type("pubid:bsi:detailed-specification", "ds");
+    s.type("pubid:bsi:disc", "disc");
+    s.type("pubid:bsi:draft-document", "dd");
+    s.type("pubid:bsi:electronic-book", "eb");
+    s.type("pubid:bsi:expert-commentary", "ec", { core: [] });
+    s.type("pubid:bsi:explanatory-supplement", "es");
+    s.type("pubid:bsi:flex", "flex");
+    s.type("pubid:bsi:handbook", "hb");
+    s.type("pubid:bsi:identifier", "id");
+    s.type("pubid:bsi:index", "index");
+    s.type("pubid:bsi:method", "method");
+    s.type("pubid:bsi:national-annex", "na");
+    s.type("pubid:bsi:practice-guide", "pg");
+    s.type("pubid:bsi:publicly-available-specification", "pas");
+    s.type("pubid:bsi:published-document", "pd");
+    s.type("pubid:bsi:section", "section");
+    s.type("pubid:bsi:set", "set", { core: [] });
+    s.type("pubid:bsi:standalone-amendment", "sa");
+    s.type("pubid:bsi:supplement-document", "sd");
+    s.type("pubid:bsi:supplementary-index", "si");
+    s.type("pubid:bsi:technical-specification", "ts");
+    s.type("pubid:bsi:test-method", "tm");
+    s.type("pubid:bsi:value-added-publication", "vap");
+});

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * The pubid-scheme URN schema of CALCONNECT — 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 calconnectSchema = define("calconnect", (s) => {
+    s.atom("series", "series");
+    s.atom("year", "year");
+    s.atom("month", "month");
+    s.atom("day", "day");
+    s.type("pubid:calconnect:identifier", "id");
+    s.type("pubid:calconnect:standard", "std");
+});

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * The pubid-scheme URN schema of CCSDS — 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 ccsdsSchema = define("ccsds", (s) => {
+    s.atom("type", "type");
+    s.atom("part", "part");
+    s.atom("edition", "ed");
+    s.atom("language", "lang");
+    s.atom("suffix", "suffix");
+    s.type("pubid:ccsds:base", "base");
+    s.type("pubid:ccsds:corrigendum", "cor");
+    s.type("pubid:ccsds:identifier", "id");
+});