@openpresentation/opf 0.14.0 → 0.16.0

package/dist/{validation-types-zh03LeZy.d.ts → validation-types-HxIgJfKx.d.ts}

@@ -1,7 +1,7 @@
-import { C as CatalogKind } from './catalogs-D-yyQWCQ.js';
-import { T as TextMeasurement } from './composition-_WEwBe2a.js';
-import { f as FindingSeverity, e as FindingReport } from './finding-C_por275.js';
-import { J as JsonPrimitive } from './schemas-DDpqAgyS.js';
+import { C as Catalog } from './catalog-refs-_anZs-Qz.js';
+import { T as TextMeasurement } from './composition-D4ADF5c-.js';
+import { c as FindingSeverity, F as FindingReport } from './finding-CT_f_vbD.js';
+import { J as JsonPrimitive } from './json-BFSdESOE.js';
 
 /**
  * Template variables: typed, named values a deck declares once and uses in many
@@ -226,8 +226,8 @@ interface ValidateOptions {
         rule: string;
         path: string;
     }[];
-    /** Catalog records already loaded by the host, consulted after the document's own `catalogs`. Nothing is fetched. */
-    catalogs?: Partial<Record<CatalogKind, readonly unknown[]>>;
+    /** Catalogs the host registered, matched by source; the first is the host default for an omitted catalogs.default. Nothing is fetched. */
+    catalogs?: readonly Catalog[];
     /** Host policy (category `policy`). */
     contracts?: readonly Contract[];
     thresholds?: Partial<ValidationThresholds>;
@@ -244,7 +244,7 @@ interface ValidationChecks {
     /** `checked` for text input (JSON syntax and duplicate keys), `not-applicable` for a parsed document. */
     syntax: 'checked' | 'not-applicable';
     schema: 'checked' | 'not-run';
-    /** Catalog ids, assets, datasets and references, resolved against the document, supplied catalogs and the bundled ones. Nothing is fetched. */
+    /** Content references, assets, datasets and citations, resolved against the document's catalogs groups and the registered catalogs. Nothing is fetched. */
     references: 'checked' | 'not-run';
     policy: 'checked' | 'not-run';
     accessibility: 'checked' | 'not-run';

package/dist/validator.d.ts

@@ -1,11 +1,13 @@
-import { C as CatalogKind } from './catalogs-D-yyQWCQ.js';
-import { F as Finding } from './finding-C_por275.js';
-import { P as Presentation } from './presentation-C5eHkevA.js';
-import { i as ValidationThresholds, h as ValidationRuleInfo, a as ValidationReport, V as ValidateOptions } from './validation-types-zh03LeZy.js';
-export { C as Contract, d as ValidateFonts, e as ValidationCategory, f as ValidationChecks, g as ValidationRuleCost, z as validationCategories } from './validation-types-zh03LeZy.js';
-import './schemas-DDpqAgyS.js';
-import './composition-_WEwBe2a.js';
-import './chart-data-B_3z9VTb.js';
+import { a as CatalogRecordKind } from './catalog-schemas-BZCjgAxu.js';
+import { a as Finding } from './finding-CT_f_vbD.js';
+import { P as Presentation } from './presentation-COrFuj2g.js';
+import { i as ValidationThresholds, h as ValidationRuleInfo, a as ValidationReport, V as ValidateOptions } from './validation-types-HxIgJfKx.js';
+export { C as Contract, d as ValidateFonts, e as ValidationCategory, f as ValidationChecks, g as ValidationRuleCost, z as validationCategories } from './validation-types-HxIgJfKx.js';
+import './catalog-refs-_anZs-Qz.js';
+import './schemas.js';
+import './json-BFSdESOE.js';
+import './composition-D4ADF5c-.js';
+import './chart-data-BnNqgnC-.js';
 
 /**
  * The series palette opf-render and opf-pptx draw charts with (`CHART_COLORS`), in series order. A host with
@@ -51,10 +53,11 @@ declare function validate(input: unknown, options?: ValidateOptions): Validation
  */
 declare function assertValid(value: unknown, options?: ValidateOptions): asserts value is Presentation;
 /**
- * Check one catalog record (an audience, theme, layout, font scheme and so on) against its schema. The report has the same
- * shape as `validate`'s; every finding is `format` and a record that links to an unknown id warns.
+ * Check one published catalog record file (an audience, theme, layout, font scheme, chart type and so on) against its
+ * companion schema, `$schema` and `id` included. The report has the same shape as `validate`'s; every finding is `format`.
+ * A record a document embeds is checked by `validate`, keyed by its id and without `$schema`.
  */
-declare function validateCatalogRecord(kind: CatalogKind, value: unknown): ValidationReport;
-declare function assertValidCatalogRecord(kind: CatalogKind, value: unknown): void;
+declare function validateCatalogRecord(kind: CatalogRecordKind, value: unknown): ValidationReport;
+declare function assertValidCatalogRecord(kind: CatalogRecordKind, value: unknown): void;
 
 export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, ValidateOptions, ValidationReport, ValidationRuleInfo, ValidationThresholds, assertValid, assertValidCatalogRecord, findValidationRule, promotedRegionKeys, validate, validateCatalogRecord, validationRules };

package/dist/validator.js

@@ -1,5 +1,5 @@
-export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-JDJBDYSR.js';
-export { promotedRegionKeys } from './chunk-6OXY2CP3.js';
-import './chunk-S5W34SIJ.js';
-import './chunk-XOZ4KMSR.js';
-import './chunk-LS2FMPI5.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-PX5AWL7Y.js';
+export { promotedRegionKeys } from './chunk-5PDN7BN6.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-WEDGVC5W.js';

package/dist/yaml.d.ts

@@ -1,10 +1,10 @@
-import { P as Presentation } from './presentation-C5eHkevA.js';
-import { V as ValidateOptions, a as ValidationReport } from './validation-types-zh03LeZy.js';
-import { F as Finding, d as FindingLocation } from './finding-C_por275.js';
-import './catalogs-D-yyQWCQ.js';
-import './schemas-DDpqAgyS.js';
-import './composition-_WEwBe2a.js';
-import './chart-data-B_3z9VTb.js';
+import { C as Catalog } from './catalog-refs-_anZs-Qz.js';
+import { P as Presentation } from './presentation-COrFuj2g.js';
+import { V as ValidateOptions, a as ValidationReport } from './validation-types-HxIgJfKx.js';
+import { a as Finding, b as FindingLocation } from './finding-CT_f_vbD.js';
+import './composition-D4ADF5c-.js';
+import './chart-data-BnNqgnC-.js';
+import './json-BFSdESOE.js';
 
 /** A finding located in the YAML source: `yaml/<rule>` syntax and dialect errors (category `format`) and the OPF findings of the parsed deck. */
 type YamlFinding = Finding & {
@@ -19,6 +19,19 @@ interface YamlComments {
 /** Find the comments of a YAML text (they are lost when a command rewrites the file) and its editor modeline. */
 declare function scanYamlComments(source: string): YamlComments;
 
+/**
+ * OPF as YAML (RR-56): read a deck written as YAML and write any valid deck as YAML, with no renderer, fonts, network
+ * or model. JSON stays the canonical form; `.opf.yaml` is an authoring serialization of the same data.
+ *
+ * The reader accepts one dialect, strict by default: JSON-compatible YAML 1.2 (core schema) with exactly one document
+ * whose root is a mapping, no duplicate keys, no custom tags, no anchors, aliases or merge keys (opt in with
+ * `aliases: true`) and only finite numbers. Errors carry the offset, line and column of the YAML that caused them,
+ * including the OPF validation findings mapped back to the YAML of the field they name. The writer emits canonical schema key
+ * order, 2-space block style and quoted ambiguous strings, and reads its own output back before returning it.
+ *
+ * The same input always gives the same output.
+ */
+
 /** The canonical schema URL (`$id` of the presentation schema), used by `schemaComment`. */
 declare const YAML_SCHEMA_URL: string;
 interface FromYamlOptions {
@@ -27,6 +40,8 @@ interface FromYamlOptions {
      * and `references`; options pick other rules or categories (`{}` runs every rule); `false` skips the check.
      */
     validate?: boolean | ValidateOptions;
+    /** Catalogs the host registered, for the references check of `validate: true` (the default). Nothing is fetched. */
+    catalogs?: readonly Catalog[];
     /**
      * Expand anchors, aliases and `<<` merge keys (default false: they are an error). The expansion is capped at 100 aliases
      * and an alias inside its own anchor is rejected, so the result is always finite JSON-compatible data.

package/dist/yaml.js

@@ -1,321 +1,9 @@
-import { Ctx } from './chunk-4LDGKLUC.js';
-import { sortPresentationKeys } from './chunk-5ZU6JAPP.js';
-import { same } from './chunk-CSQHPVGL.js';
-import { validate } from './chunk-JDJBDYSR.js';
-import './chunk-6OXY2CP3.js';
-import './chunk-S5W34SIJ.js';
-import './chunk-XOZ4KMSR.js';
-import { presentation } from './chunk-LS2FMPI5.js';
-import { Parser, parseDocument, isMap, Document, visit, isScalar, isAlias, isSeq } from 'yaml';
-
-var MAX_ALIAS_COUNT = 100;
-var CORE_TAGS = new Set(["map", "seq", "str", "int", "float", "bool", "null"].map((name) => `tag:yaml.org,2002:${name}`));
-var ALIAS_HELP = "Write each value out instead of using anchors (&name), aliases (*name) and merge keys (<<). Pass aliases: true (CLI: --aliases) to expand them.";
-var TAG_HELP = "Custom tags are not accepted. Remove the tag; quote a value to keep it as text.";
-var CYCLE_HELP = "An alias must not appear inside its own anchor. Write the nested value out.";
-var decode = (part) => part.replaceAll("~1", "/").replaceAll("~0", "~");
-var encode = (part) => part.replaceAll("~", "~0").replaceAll("/", "~1");
-var pointerOf = (parts) => parts.length ? `/${parts.map(encode).join("/")}` : "";
-function rangeOfPointer(doc, pointer) {
-  const root = doc?.contents;
-  if (!root?.range) return void 0;
-  const parts = pointer === "" ? [] : pointer.slice(1).split("/").map(decode);
-  let node = root;
-  let key;
-  for (const part of parts) {
-    if (isAlias(node)) break;
-    let child;
-    let childKey;
-    if (isMap(node)) {
-      const pairs = node.items;
-      const pair = pairs.find((item) => isScalar(item.key) && String(item.key.value) === part) ?? pairs.find((item) => isMergeKey(item.key) && item.value);
-      if (pair) {
-        childKey = pair.key;
-        child = pair.value ?? childKey;
-      }
-    } else if (isSeq(node)) child = node.items[/^(?:0|[1-9]\d*)$/.test(part) ? Number(part) : -1];
-    if (!child?.range) break;
-    node = child;
-    key = childKey;
-  }
-  const [start, end] = node.range;
-  if (key?.range && (isMap(node) || isSeq(node) || isAlias(node))) return { start: key.range[0], end };
-  return { start, end: Math.max(start, end) };
-}
-function isMergeKey(key) {
-  return isScalar(key) && (typeof key.value === "symbol" || key.value === "<<" && key.type === "PLAIN");
-}
-function describeError(error) {
-  const text = error.message.split("\n")[0] ?? error.message;
-  switch (error.code) {
-    case "DUPLICATE_KEY":
-      return { rule: "duplicate-key", message: `YAML: ${text}`, help: "Remove or rename one of the repeated keys. JSON-compatible YAML needs every key once in each mapping." };
-    case "MULTIPLE_DOCS":
-      return { rule: "multiple-documents", message: "The input holds more than one YAML document.", help: "An OPF file is exactly one document: remove the extra --- separators, or put each deck in its own file." };
-    case "TAG_RESOLVE_FAILED":
-      return { rule: "tag", message: `YAML: ${text}`, help: TAG_HELP };
-    case "BAD_ALIAS":
-      return { rule: "alias", message: `YAML: ${text}`, help: ALIAS_HELP };
-    default:
-      return { rule: "syntax", message: `YAML: ${text}`, help: "Fix the YAML syntax at this position. An OPF file holds JSON-compatible YAML 1.2: mappings, sequences and scalars." };
-  }
-}
-function keyRangeAt(doc, start) {
-  let found;
-  visit(doc, {
-    Pair(_key, pair) {
-      const key = pair.key;
-      if (!found && key?.range && key.range[0] === start) found = { start, end: key.range[1] };
-    }
-  });
-  return found;
-}
-function readYamlDocument(source, aliases, rootKind = "mapping") {
-  const bom = source.startsWith("\uFEFF") ? 1 : 0;
-  const text = source.slice(bom);
-  const ctx = new Ctx(text);
-  const findings = [];
-  const locate = (range) => {
-    const location = ctx.location(range);
-    return { ...location, offset: location.offset + bom };
-  };
-  const add = (rule, message, help, range, path = "") => {
-    findings.push({ ruleId: `yaml/${rule}`, severity: "error", category: "format", scope: "document", path, message, help, location: locate(range) });
-  };
-  const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: aliases, prettyErrors: false });
-  const finish = (value2) => ({
-    value: value2,
-    locatePointer: (pointer) => {
-      const range = rangeOfPointer(doc, pointer);
-      return range ? locate(range) : void 0;
-    },
-    findings,
-    errors: findings.length
-  });
-  for (const error of [...doc.errors, ...doc.warnings.filter((warning) => warning.code === "TAG_RESOLVE_FAILED")]) {
-    const described = describeError(error);
-    const [start, end] = error.pos;
-    add(described.rule, described.message, described.help, (error.code === "DUPLICATE_KEY" ? keyRangeAt(doc, start) : void 0) ?? { start, end: Math.max(start, end) });
-  }
-  if (findings.length) return finish({});
-  const root = doc.contents;
-  if (root === null || !root.range) {
-    add("empty", "The input holds no YAML document.", "An OPF file is one YAML mapping: write the deck properties (name, slides, ...) as key: value lines.", { start: 0, end: Math.min(1, text.length) });
-    return finish({});
-  }
-  const rootRange = { start: root.range[0], end: root.range[1] };
-  if (rootKind === "mapping" && !isMap(root)) {
-    add("not-mapping", "The document is not a mapping.", "An OPF deck is a YAML mapping of keys and values (name:, slides:, ...), not a list or a single value.", rootRange);
-    return finish({});
-  }
-  checkTree({ doc, text, aliases, add }, root, [], []);
-  if (findings.length) return finish({});
-  let value;
-  try {
-    value = doc.toJS({ maxAliasCount: aliases ? MAX_ALIAS_COUNT : 0 });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (/excessive alias/i.test(message)) add("alias-limit", `The anchors and aliases expand beyond the limit of ${MAX_ALIAS_COUNT} aliases.`, "Aliases that contain aliases grow exponentially. Write the repeated values out, or reduce the aliasing.", rootRange);
-    else add("alias", `YAML: ${message}`, ALIAS_HELP, rootRange);
-    return finish({});
-  }
-  if (isCircular(value)) {
-    add("alias-cycle", "An alias refers to the value that contains it, so the document is infinitely deep.", CYCLE_HELP, rootRange);
-    return finish({});
-  }
-  const bad = nonJson(value);
-  if (bad) {
-    add("number", `The YAML holds ${bad}, which JSON cannot carry.`, "Quote it to keep it as text, or write a finite number.", rootRange);
-    return finish({});
-  }
-  return finish(value);
-}
-function propertyRange(text, nodeStart, token, fallback) {
-  const found = text.lastIndexOf(token, nodeStart);
-  return found >= 0 && found < nodeStart ? { start: found, end: found + token.length } : fallback;
-}
-function checkTree(env, node, trail, ancestors) {
-  const { doc, text, aliases, add } = env;
-  const path = pointerOf(trail);
-  const range = (target) => ({ start: target.range?.[0] ?? 0, end: Math.max(target.range?.[0] ?? 0, target.range?.[1] ?? 0) });
-  if (isAlias(node)) {
-    const name = node.source;
-    if (!aliases) add("alias", `The alias *${name} is not allowed.`, ALIAS_HELP, range(node), path);
-    else {
-      const target = node.resolve(doc);
-      if (target && ancestors.includes(target)) add("alias-cycle", `The alias *${name} refers to a value that contains it.`, CYCLE_HELP, range(node), path);
-    }
-    return;
-  }
-  const anchor = node.anchor;
-  if (anchor !== void 0 && !aliases) add("alias", `The anchor &${anchor} is not allowed.`, ALIAS_HELP, propertyRange(text, node.range?.[0] ?? 0, `&${anchor}`, range(node)), path);
-  const tag = node.tag;
-  if (tag !== void 0 && !CORE_TAGS.has(tag)) {
-    let start = text.lastIndexOf("!", node.range?.[0] ?? 0);
-    while (start > 0 && text[start - 1] === "!") start--;
-    const written = start >= 0 ? /^!\S*/.exec(text.slice(start))?.[0] : void 0;
-    add("tag", `The tag ${written ?? tag} is not allowed.`, TAG_HELP, written && start < (node.range?.[0] ?? 0) ? { start, end: start + written.length } : range(node), path);
-  }
-  if (isScalar(node)) {
-    const value = node.value;
-    if (typeof value === "number" && !Number.isFinite(value)) add("number", `${String(node.source ?? value)} is not a finite number, and JSON cannot carry it.`, 'Quote it (".inf", ".nan") to keep it as text, or write a finite number.', range(node), path);
-    return;
-  }
-  const inside = [...ancestors, node];
-  if (isMap(node)) {
-    for (const pair of node.items) {
-      const key = pair.key;
-      if (key && isMergeKey(key)) {
-        if (!aliases) add("alias", "The merge key << is not allowed.", ALIAS_HELP, range(key), path);
-        else {
-          const source = pair.value;
-          if (source && isSeq(source)) for (const item of source.items) checkTree(env, item, [...trail, "<<"], inside);
-          else if (source) checkTree(env, source, [...trail, "<<"], inside);
-        }
-        continue;
-      }
-      const resolved = key && isAlias(key) ? key.resolve(doc) : key;
-      const name = resolved && isScalar(resolved) && typeof resolved.value === "string" ? resolved.value : void 0;
-      if (key) checkTree(env, key, trail, inside);
-      if (name === void 0) {
-        add("key", "A mapping key is not a string.", 'JSON keys are always strings. Quote the key, for example "1": value.', key ? range(key) : range(node), path);
-        continue;
-      }
-      if (pair.value) checkTree(env, pair.value, [...trail, name], inside);
-    }
-    return;
-  }
-  if (isSeq(node)) {
-    const items = node.items;
-    for (let index = 0; index < items.length; index++) checkTree(env, items[index], [...trail, String(index)], inside);
-  }
-}
-function nonJson(value) {
-  if (typeof value === "number") return Number.isFinite(value) ? void 0 : "a number that is not finite";
-  if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
-  if (Array.isArray(value)) return value.map(nonJson).find(Boolean);
-  if (typeof value === "object") {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) return `a ${value.constructor?.name ?? "non-JSON"} value`;
-    return Object.values(value).map(nonJson).find(Boolean);
-  }
-  return `a ${typeof value}`;
-}
-function isCircular(value, stack = /* @__PURE__ */ new Set()) {
-  if (typeof value !== "object" || value === null) return false;
-  if (stack.has(value)) return true;
-  stack.add(value);
-  const found = Object.values(value).some((child) => isCircular(child, stack));
-  stack.delete(value);
-  return found;
-}
-function scanYamlComments(source) {
-  const text = source.startsWith("\uFEFF") ? source.slice(1) : source;
-  let count = 0;
-  let modeline;
-  const visit3 = (value) => {
-    if (Array.isArray(value)) value.forEach(visit3);
-    else if (value && typeof value === "object") {
-      const token = value;
-      if (token.type === "comment" && typeof token.source === "string") {
-        if (modeline === void 0 && token.offset === 0 && /^#\s*yaml-language-server:/.test(token.source)) modeline = token.source;
-        else count++;
-      } else for (const child of Object.values(value)) visit3(child);
-    }
-  };
-  for (const token of new Parser().parse(text)) visit3(token);
-  return { count, ...modeline === void 0 ? {} : { modeline } };
-}
-var AMBIGUOUS = [
-  /^(?:y|n|yes|no|on|off|true|false|null|~|=|<<)$/i,
-  /^[-+]?(?:0[0-7_]+|0b[01_]+|0x[0-9a-f_]+|[0-9][0-9_]*(?:\.[0-9_]*)?(?:e[-+]?[0-9]+)?|\.[0-9_]+(?:e[-+]?[0-9]+)?|\.inf)$/i,
-  /^\.nan$/i,
-  /^\d{4}-\d{1,2}-\d{1,2}(?:[Tt ].*)?$/,
-  /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$/
-];
-var isAmbiguous = (text) => AMBIGUOUS.some((pattern) => pattern.test(text));
-function writeCanonicalYaml(value, reads) {
-  const expected = JSON.stringify(value);
-  for (const blockQuote of [true, false]) {
-    const doc = new Document(value, { schema: "core" });
-    visit(doc, {
-      Scalar(_key, node) {
-        if (isScalar(node) && typeof node.value === "string" && isAmbiguous(node.value)) node.type = "QUOTE_DOUBLE";
-      }
-    });
-    const text = doc.toString({ indent: 2, lineWidth: 0, minContentWidth: 0, blockQuote, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
-    const out = text.endsWith("\n") ? text : `${text}
-`;
-    let back;
-    try {
-      back = reads(out);
-    } catch {
-      continue;
-    }
-    if (JSON.stringify(back) === expected) return out;
-  }
-  return void 0;
-}
-
-// src/yaml.ts
-var YAML_SCHEMA_URL = presentation.$id;
-var NOT_CHECKED = { syntax: "checked", schema: "not-run", references: "not-run", policy: "not-run", accessibility: "not-run", content: "not-run", layout: "not-run", backgroundPixels: "not-read", imageBytes: "embedded-only", nativeExport: "not-checked" };
-function fromYaml(yaml, options = {}) {
-  if (typeof yaml !== "string") throw new TypeError("fromYaml expects a string.");
-  const parsed = readYamlDocument(yaml, options.aliases === true);
-  const findings = [...parsed.findings];
-  let report = { schemaValid: null, checks: NOT_CHECKED };
-  if (!parsed.errors && options.validate !== false) {
-    const checked = validate(parsed.value, options.validate === true || options.validate === void 0 ? { only: ["format", "references"] } : options.validate);
-    report = {
-      schemaValid: checked.schemaValid,
-      checks: { ...checked.checks, syntax: "checked" },
-      ...checked.template === void 0 ? {} : { template: checked.template },
-      ...checked.unfilledVariables === void 0 ? {} : { unfilledVariables: checked.unfilledVariables }
-    };
-    for (const found of checked.findings) {
-      const location = parsed.locatePointer(found.path) ?? parsed.locatePointer("") ?? { offset: 0, length: 0, line: 1, column: 1 };
-      findings.push({ ...found, location });
-    }
-  }
-  findings.sort((a, b) => a.location.offset - b.location.offset);
-  const counts = { error: 0, warning: 0, info: 0 };
-  for (const found of findings) counts[found.severity]++;
-  return { presentation: parsed.value, valid: counts.error === 0, findings, counts, ...report };
-}
-var OPFYamlError = class extends Error {
-  code;
-  details;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "OPFYamlError";
-    this.code = code;
-    this.details = details;
-  }
-};
-function toYaml(document, options = {}) {
-  const checked = validate(document, { only: ["format"] });
-  if (!checked.valid) {
-    const errors = checked.findings.filter((found) => found.severity === "error");
-    const first = errors[0];
-    throw new OPFYamlError("invalid-document", `The document is not valid OPF: ${first?.message ?? "unknown error"}${first?.path ? ` (${first.path})` : ""}.`, { findings: errors });
-  }
-  const sorted = sortPresentationKeys(document);
-  const text = writeCanonicalYaml(sorted, (out) => {
-    const back = readYamlDocument(out, false);
-    if (back.errors) throw new Error("The YAML does not read back.");
-    return back.value;
-  });
-  if (text === void 0) throw new OPFYamlError("not-representable", "The document holds a value that YAML cannot carry exactly.");
-  if (!same(JSON.parse(JSON.stringify(sorted)), readYamlDocument(text, false).value)) throw new OPFYamlError("not-representable", "The document does not read back from its YAML.");
-  const schema = typeof sorted.$schema === "string" && !/[\r\n]/.test(sorted.$schema) ? sorted.$schema : YAML_SCHEMA_URL;
-  return { yaml: options.schemaComment ? `# yaml-language-server: $schema=${schema}
-${text}` : text };
-}
-function parseYamlData(yaml, options = {}) {
-  if (typeof yaml !== "string") throw new TypeError("parseYamlData expects a string.");
-  const parsed = readYamlDocument(yaml, options.aliases === true, "any");
-  return { value: parsed.errors ? null : parsed.value, valid: parsed.errors === 0, findings: parsed.findings };
-}
-
-export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml };
+export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml } from './chunk-K4DQQIT4.js';
+import './chunk-5UEUAW57.js';
+import './chunk-6OR326EA.js';
+import './chunk-5TO6I3GB.js';
+import './chunk-PX5AWL7Y.js';
+import './chunk-5PDN7BN6.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-WEDGVC5W.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openpresentation/opf",
-  "version": "0.14.0",
-  "description": "Canonical Open Presentation Format schemas, catalogs, TypeScript types, and local validation.",
+  "version": "0.16.0",
+  "description": "Canonical Open Presentation Format schemas, TypeScript types, local validation and composition; the pinned default catalog ships as the opt-in @openpresentation/opf/catalog.",
   "license": "MIT",
   "author": "Open Presentation",
   "homepage": "https://openpresentation.org",
@@ -38,9 +38,9 @@
       "types": "./dist/schemas.d.ts",
       "import": "./dist/schemas.js"
     },
-    "./catalogs": {
-      "types": "./dist/catalogs.d.ts",
-      "import": "./dist/catalogs.js"
+    "./catalog": {
+      "types": "./dist/catalog.d.ts",
+      "import": "./dist/catalog.js"
     },
     "./validator": {
       "types": "./dist/validator.d.ts",
@@ -54,10 +54,6 @@
       "types": "./dist/spec-files.d.ts",
       "import": "./dist/spec-files.js"
     },
-    "./previews": {
-      "types": "./dist/previews.d.ts",
-      "import": "./dist/previews.js"
-    },
     "./examples": {
       "types": "./dist/examples.d.ts",
       "import": "./dist/examples.js"
@@ -92,6 +88,10 @@
       "types": "./dist/symbol-font-encodings.d.ts",
       "import": "./dist/symbol-font-encodings.js"
     },
+    "./deck": {
+      "types": "./dist/deck.d.ts",
+      "import": "./dist/deck.js"
+    },
     "./markdown": {
       "types": "./dist/markdown.d.ts",
       "import": "./dist/markdown.js"