@openpresentation/opf 0.15.1 → 0.16.0

package/dist/{chunk-VGAOJEY7.js → chunk-5TO6I3GB.js}

@@ -1,4 +1,4 @@
-import { validate } from './chunk-QDI75P2M.js';
+import { validate } from './chunk-PX5AWL7Y.js';
 
 // src/convert/shared.ts
 var CONTENT_KEYS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];

package/dist/{chunk-3RKB4RDJ.js → chunk-5UEUAW57.js}

@@ -1,6 +1,8 @@
-import { isRecord, same } from './chunk-VGAOJEY7.js';
+import { isRecord, same } from './chunk-5TO6I3GB.js';
 import { parseDocument, YAMLMap, Scalar, stringify } from 'yaml';
 
+// src/not-checked.ts
+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 splitLines(source) {
   const lines = [];
   let start = 0;
@@ -189,4 +191,4 @@ var OPFMarkdownError = class extends Error {
   }
 };
 
-export { Ctx, DECIMAL, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };
+export { Ctx, DECIMAL, NOT_CHECKED, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };

package/dist/{chunk-ZPU46TFA.js → chunk-6OR326EA.js}

@@ -1,4 +1,4 @@
-import { presentation } from './chunk-2CJPC4HI.js';
+import { presentation } from './chunk-WEDGVC5W.js';
 
 // src/format.ts
 var OPFFormatError = class extends Error {

package/dist/{chunk-UBFJ2QHH.js → chunk-BSYQDWT4.js}

@@ -1,5 +1,5 @@
-import { assertValid, resolveSlideContext } from './chunk-QDI75P2M.js';
-import { composeSlide, codeHighlightSlice, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-O744SXXA.js';
+import { assertValid, resolveSlideContext } from './chunk-PX5AWL7Y.js';
+import { composeSlide, codeHighlightSlice, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-5PDN7BN6.js';
 import { checkCatalogsOption } from './chunk-SPFV27O5.js';
 
 // src/pagination.ts
@@ -105,6 +105,16 @@ function paginateSlide(input, options = {}) {
   let evaluations = 0;
   const { fonts, minFontSize: _minFontSize, maxSlides: _maxSlides, reservedIds: _reservedIds, ...engineOptions } = options;
   const composeOptions = { ...engineOptions, ...fonts?.textMeasurement ? { textMeasurement: fonts.textMeasurement } : {} };
+  const readableLayout = (layout) => {
+    if (!isRecord(layout) || !Array.isArray(layout.placeholders) || !layout.placeholders.some((entry) => isRecord(entry) && entry.type === "group")) return layout;
+    const visit = (entries) => entries.map((entry) => {
+      if (!isRecord(entry) || entry.type !== "group") return entry;
+      const own = isRecord(entry.composition) ? entry.composition : {};
+      return { ...entry, composition: { ...own, ...typeof own.minFontSize === "number" ? { minFontSize: Math.max(minFontSize, own.minFontSize) } : {}, overflow: "warn" }, placeholders: Array.isArray(entry.placeholders) ? visit(entry.placeholders) : entry.placeholders };
+    });
+    return { ...layout, placeholders: visit(layout.placeholders) };
+  };
+  if (options.layout !== void 0) composeOptions.layout = readableLayout(options.layout);
   const geometry = (slide, pageIndex = 0) => {
     if (++evaluations > 2e4) throw new OPFPaginationError("Pagination exceeded its layout evaluation limit. Split the input into smaller sections.");
     return composeSlide(withReadability(slide, true), { ...composeOptions, slideNumber: (options.slideNumber ?? sourceIndex + 1) + pageIndex });

package/dist/{chunk-3JG4YXWF.js → chunk-FQSIIADJ.js}

@@ -1,7 +1,7 @@
-import { Ctx, splitLines, lineRange, readYamlMapping, OPFMarkdownError, writeYaml, readCsv, DECIMAL, csvField, scalarText } from './chunk-3RKB4RDJ.js';
-import { parseQuoteLines, levelsFromIndents, parseCodeFence, splitWhen, fenceCode } from './chunk-374R35TJ.js';
-import { same, isRecord, runText, isPlainRun, FORMATTING } from './chunk-VGAOJEY7.js';
-import { validate } from './chunk-QDI75P2M.js';
+import { Ctx, splitLines, lineRange, readYamlMapping, NOT_CHECKED, OPFMarkdownError, writeYaml, readCsv, DECIMAL, csvField, scalarText } from './chunk-5UEUAW57.js';
+import { parseQuoteLines, levelsFromIndents, parseCodeFence, splitWhen, fenceCode } from './chunk-NAWQR7MN.js';
+import { same, isRecord, runText, isPlainRun, FORMATTING } from './chunk-5TO6I3GB.js';
+import { validate } from './chunk-PX5AWL7Y.js';
 import { checkCatalogsOption } from './chunk-SPFV27O5.js';
 
 // src/markdown/canon.ts
@@ -1757,6 +1757,7 @@ function fromMarkdown(markdown, options = {}) {
   let lines = splitLines(source);
   if (lines[0]?.text.startsWith("\uFEFF")) lines = [{ ...lines[0], text: lines[0].text.slice(1), start: lines[0].start + 1 }, ...lines.slice(1)];
   const front = {};
+  let report = { schemaValid: null, checks: NOT_CHECKED };
   let body = lines;
   const matter = frontMatter(lines);
   if (matter === "unterminated") {
@@ -1792,6 +1793,12 @@ function fromMarkdown(markdown, options = {}) {
   if (!slides.length) ctx.error("no-slides", "The Markdown has no slides.", "Write at least one slide: a # title or any content, with --- between slides.", { start: 0, end: Math.min(1, source.length) }, "/slides");
   else if (options.validate !== false) {
     const checked = validate(document, options.validate === true || options.validate === void 0 ? { only: ["format", "references"], ...options.catalogs ? { catalogs: options.catalogs } : {} } : 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 range = ctx.rangeOf(found.path) ?? ctx.rangeOf("") ?? { start: 0, end: 0 };
       ctx.findings.push({ ...found, location: ctx.location(range) });
@@ -1800,7 +1807,7 @@ function fromMarkdown(markdown, options = {}) {
   const findings = [...ctx.findings].sort((a, b) => a.location.offset - b.location.offset);
   const counts = { error: 0, warning: 0, info: 0 };
   for (const entry of findings) counts[entry.severity]++;
-  return { presentation: document, valid: counts.error === 0, findings, counts };
+  return { presentation: document, valid: counts.error === 0, findings, counts, ...report };
 }
 function toMarkdown(document, options = {}) {
   const checked = validate(document, { only: ["format"] });

package/dist/chunk-K4DQQIT4.js

@@ -0,0 +1,319 @@
+import { NOT_CHECKED, Ctx } from './chunk-5UEUAW57.js';
+import { sortPresentationKeys } from './chunk-6OR326EA.js';
+import { same } from './chunk-5TO6I3GB.js';
+import { validate } from './chunk-PX5AWL7Y.js';
+import { checkCatalogsOption } from './chunk-SPFV27O5.js';
+import { presentation } from './chunk-WEDGVC5W.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;
+function fromYaml(yaml, options = {}) {
+  if (typeof yaml !== "string") throw new TypeError("fromYaml expects a string.");
+  checkCatalogsOption(options.catalogs, "fromYaml");
+  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.catalogs ? { catalogs: options.catalogs } : {} } : 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 };

package/dist/chunk-KINQFU6X.js

@@ -0,0 +1,51 @@
+import { fromMarkdown, toMarkdown } from './chunk-FQSIIADJ.js';
+import { fromYaml, toYaml } from './chunk-K4DQQIT4.js';
+import { NOT_CHECKED } from './chunk-5UEUAW57.js';
+import { parseSource, validate } from './chunk-PX5AWL7Y.js';
+import { checkCatalogsOption } from './chunk-SPFV27O5.js';
+
+// src/deck.ts
+var DECK_FORMATS = ["json", "yaml", "markdown"];
+function deckFormatOf(filename) {
+  if (filename === void 0) return "json";
+  if (/\.opf\.md$/i.test(filename)) return "markdown";
+  if (/\.ya?ml$/i.test(filename)) return "yaml";
+  return "json";
+}
+function resolveFormat(caller, options) {
+  if (options.format === void 0) return deckFormatOf(options.filename);
+  if (!DECK_FORMATS.includes(options.format)) throw new TypeError(`${caller}: unknown format ${JSON.stringify(options.format)}. Formats: ${DECK_FORMATS.join(", ")}.`);
+  return options.format;
+}
+function readDeck(text, options = {}) {
+  if (typeof text !== "string") throw new TypeError("readDeck expects a string.");
+  checkCatalogsOption(options.catalogs, "readDeck");
+  const format = resolveFormat("readDeck", options);
+  const { catalogs } = options;
+  const check = options.validate ?? true;
+  const validateOptions = typeof check === "object" ? { ...catalogs && check.catalogs === void 0 ? { catalogs } : {}, ...check } : { only: ["format", "references"], ...catalogs ? { catalogs } : {} };
+  const checked = check === false ? false : validateOptions;
+  if (format === "yaml") return { ...fromYaml(text, { validate: checked, catalogs }), format };
+  if (format === "markdown") return { ...fromMarkdown(text, { validate: checked, catalogs }), format };
+  if (checked === false) {
+    const parsed = parseSource(text);
+    return { ...report(parsed.syntax), presentation: parsed.syntax.length ? {} : parsed.value, format };
+  }
+  const result = validate(text, checked);
+  const broken = result.findings.some((found) => found.ruleId === "opf/json-syntax");
+  return { ...result, presentation: broken ? {} : JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text), format };
+}
+function report(findings) {
+  const counts = { error: 0, warning: 0, info: 0 };
+  for (const found of findings) counts[found.severity]++;
+  return { valid: counts.error === 0, schemaValid: null, findings, counts, checks: NOT_CHECKED };
+}
+function writeDeck(presentation, options = {}) {
+  const format = resolveFormat("writeDeck", options);
+  if (format === "yaml") return toYaml(presentation, { schemaComment: options.schemaComment === true }).yaml;
+  if (format === "markdown") return toMarkdown(presentation).markdown;
+  return `${JSON.stringify(presentation, null, 2)}
+`;
+}
+
+export { DECK_FORMATS, deckFormatOf, readDeck, writeDeck };

package/dist/{chunk-374R35TJ.js → chunk-NAWQR7MN.js}

@@ -1,4 +1,4 @@
-import { runText } from './chunk-VGAOJEY7.js';
+import { runText } from './chunk-5TO6I3GB.js';
 
 // src/convert/text-lines.ts
 var LIST_PREFIX = /^([ \t]*)(?:([-*•+]|\d{1,3}[.)])[ \t]+)?/;