@openpresentation/opf 0.26.3 → 0.26.5

package/dist/source.js

@@ -1,12 +1,379 @@
-import { createLocator, parsePointer } from './chunk-NJWI6MPT.js';
-export { analyzeJsonSyntax, applyTextEdits } from './chunk-NJWI6MPT.js';
+export { explain } from './chunk-MD3CJ5YJ.js';
+import { readMarkdown, frontMatter, splitSegments, isOutline, NOTES, fenceStart, fenceClose, COMMENT } from './chunk-MLH5LIGF.js';
+import './chunk-DXTPLVAK.js';
+import { splitLines } from './chunk-KPALXWX3.js';
+export { analyzeYamlSyntax } from './chunk-KPALXWX3.js';
+import './chunk-HPEZCAYC.js';
+import { rememberByText, SLIDE_OPTION_KEYS, FENCE_KINDS, createLocator, parsePointer } from './chunk-CIWC7DRZ.js';
+export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, PATTERN_PHRASES, SLIDE_OPTION_KEYS, SPAN_FLAGS, SPAN_VALUES, analyzeJsonSyntax, applyTextEdits, describeFinding, distance, nearest, segmentsOf as pointerSegments, starterValue } from './chunk-CIWC7DRZ.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';
 import { findNodeAtOffset, getNodePath, parseTree } from 'jsonc-parser';
+import { parseDocument, isMap, isSeq, isScalar, isAlias } from 'yaml';
 
+var read = rememberByText(readText);
+function readText(text) {
+  const bom = text.startsWith("\uFEFF") ? 1 : 0;
+  const body = bom ? text.slice(1) : text;
+  const document = parseDocument(body, { prettyErrors: false, uniqueKeys: false, merge: false, strict: false });
+  return { text: body, root: document.contents ?? null, shift: bom };
+}
+var isBlank = (char) => char === " " || char === "	" || char === "\n" || char === "\r";
+function endOf(text, node) {
+  let end = node.range[1];
+  const start = node.range[0];
+  while (end > start && isBlank(text[end - 1])) end--;
+  return end;
+}
+var startOf = (node) => node.range[0];
+var keyName = (key) => isScalar(key) ? String(key.value) : isAlias(key) ? void 0 : key !== null && typeof key === "object" && "toString" in key ? String(key.toString()) : void 0;
+var hasText = (text, node) => !!node && node.range[0] < endOf(text, node);
+var pairKey = (pair) => pair.key ?? null;
+var pairValue = (pair) => pair.value ?? null;
+function colonEnd(text, key) {
+  let at = key.range[1];
+  while (text[at] === " " || text[at] === "	") at++;
+  return text[at] === ":" ? at + 1 : key.range[1];
+}
+function member(node, segment) {
+  if (isMap(node)) {
+    const pair = node.items.find((item) => keyName(item.key) === segment);
+    return pair ? { pair, value: pairValue(pair) } : void 0;
+  }
+  if (isSeq(node)) {
+    if (!/^(?:0|[1-9][0-9]*)$/.test(segment)) return void 0;
+    const item = node.items[Number(segment)];
+    return item === void 0 ? void 0 : { value: item };
+  }
+  return void 0;
+}
+function openOf(text, value) {
+  const start = startOf(value);
+  if (isMap(value) && !value.flow) {
+    const first = value.items[0];
+    const key = first ? pairKey(first) : null;
+    if (key) return { offset: startOf(key), length: key.range[1] - startOf(key) };
+  }
+  return { offset: start, length: Math.min(1, endOf(text, value) - start) };
+}
+function locateYaml(text, segments, part) {
+  const { text: body, root, shift } = read(text);
+  if (!root || !hasText(body, root)) return void 0;
+  let value = root;
+  let pair;
+  let depth = 0;
+  for (const segment of segments) {
+    const next = value ? member(value, segment) : void 0;
+    if (!value || !next) break;
+    pair = next.pair;
+    value = next.value;
+    depth++;
+  }
+  const exact = depth === segments.length;
+  const key = pair ? pairKey(pair) : null;
+  const keySpan = key ? { offset: startOf(key), length: key.range[1] - startOf(key) } : void 0;
+  const keyAndColon = key ? { offset: startOf(key), length: colonEnd(body, key) - startOf(key) } : void 0;
+  const valueSpan = hasText(body, value) ? { offset: startOf(value), length: endOf(body, value) - startOf(value) } : void 0;
+  const choose = (wanted) => {
+    switch (wanted) {
+      case "value":
+        return valueSpan ?? keyAndColon;
+      case "open":
+        return hasText(body, value) ? openOf(body, value) : keyAndColon;
+      case "key":
+        return keySpan;
+      case "colon":
+        return keyAndColon;
+      case "entry":
+        return keySpan ? { offset: keySpan.offset, length: (valueSpan ? valueSpan.offset + valueSpan.length : (keyAndColon?.offset ?? 0) + (keyAndColon?.length ?? 0)) - keySpan.offset } : void 0;
+    }
+  };
+  const found = choose(part) ?? choose("value") ?? (depth === 0 ? { offset: startOf(root), length: endOf(body, root) - startOf(root) } : void 0);
+  return found ? { offset: found.offset + shift, length: found.length, exact } : void 0;
+}
+function pathAtYaml(text, offset) {
+  const { text: body, root, shift } = read(text);
+  const at = offset - shift;
+  const none = { path: [], part: "none" };
+  if (!root || !hasText(body, root) || at < startOf(root) || at > endOf(body, root)) return none;
+  const span = (node) => ({ offset: startOf(node) + shift, length: endOf(body, node) - startOf(node) });
+  const inside = (node) => hasText(body, node) && at >= startOf(node) && at <= endOf(body, node);
+  const walk = (node, path) => {
+    if (isMap(node)) {
+      for (const pair of node.items) {
+        const key = pairKey(pair);
+        const value = pairValue(pair);
+        const name = keyName(pair.key);
+        if (name === void 0) continue;
+        if (key && at >= startOf(key) && at <= key.range[1]) return { path: [...path, name], part: "key", range: span(key) };
+        if (inside(value)) return walk(value, [...path, name]);
+        if (key && at > key.range[1] && at <= (hasText(body, value) ? startOf(value) : colonEnd(body, key))) {
+          const end = hasText(body, value) ? startOf(value) : colonEnd(body, key);
+          return { path: [...path, name], part: "between", range: { offset: startOf(key) + shift, length: end - startOf(key) } };
+        }
+      }
+      return { path, part: "between", range: span(node) };
+    }
+    if (isSeq(node)) {
+      for (const [index, item] of node.items.entries()) if (inside(item)) return walk(item, [...path, String(index)]);
+      return { path, part: "between", range: span(node) };
+    }
+    return { path, part: "value", range: span(node) };
+  };
+  return walk(root, []);
+}
+
+// src/source-markdown.ts
+var BLANK = /^\s*$/;
+var readMarkdown2 = rememberByText((text) => readMarkdown(text));
+var scanMemo = rememberByText((text) => scanUncached(text));
+var isFenceKind = (word) => FENCE_KINDS.includes(word);
+function scanMarkdown(source2, options = {}) {
+  return options.split === void 0 ? scanMemo(source2) : scanUncached(source2, options);
+}
+function scanUncached(source2, options = {}) {
+  let lines = splitLines(source2);
+  if (lines[0]?.text.startsWith("\uFEFF")) lines = [{ ...lines[0], text: lines[0].text.slice(1), start: lines[0].start + 1 }, ...lines.slice(1)];
+  const scan = { slides: [], separators: [], comments: [], fences: [], notes: [] };
+  const matter = frontMatter(lines);
+  let body = lines;
+  if (matter === "unterminated") {
+    const first = lines[0];
+    scan.frontMatter = { from: first.start, to: source2.length, line: 1, yamlFrom: first.end, yamlTo: source2.length, closed: false };
+    body = lines.slice(1);
+  } else if (matter) {
+    const closing = lines[matter.end - 1];
+    scan.frontMatter = { from: lines[0].start, to: closing.end, line: 1, yamlFrom: matter.yaml.start, yamlTo: matter.yaml.end, closed: true };
+    body = lines.slice(matter.end);
+  }
+  const split = options.split ?? "auto";
+  const segments = splitSegments(body, split === "headings" || split === "auto" && isOutline(body) ? "headings" : "rules");
+  const inSegment = new Set(segments.flat());
+  for (const line of body) if (!inSegment.has(line) && !BLANK.test(line.text)) scan.separators.push(line.start);
+  let index = 0;
+  for (const segment of segments) {
+    const first = segment.find((line) => !BLANK.test(line.text));
+    if (!first) continue;
+    const last = [...segment].reverse().find((line) => !BLANK.test(line.text));
+    scan.slides.push({ index, from: first.start, to: last.end, line: first.no });
+    scanSegment(segment, index, scan);
+    index++;
+  }
+  return scan;
+}
+function scanSegment(lines, slide, scan) {
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const text = line.text;
+    if (BLANK.test(text)) {
+      i++;
+      continue;
+    }
+    if (NOTES.test(text)) {
+      scan.notes.push({ from: line.start, to: lines.at(-1).end, line: line.no, slide });
+      return;
+    }
+    const open = fenceStart(text);
+    if (open) {
+      const close = fenceClose(open.fence);
+      let end = i + 1;
+      while (end < lines.length && !close.test(lines[end].text)) end++;
+      const closed = end < lines.length;
+      const last = closed ? lines[end] : lines.at(-1);
+      const indent = /^ */.exec(text)[0].length;
+      const marker = open.fence;
+      const infoFrom = line.start + indent + marker.length + /^[ \t]*/.exec(text.slice(indent + marker.length))[0].length;
+      const word = /^[^\s{]*/.exec(open.info)[0];
+      const bodyLines = lines.slice(i + 1, closed ? end : lines.length);
+      scan.fences.push({
+        from: line.start,
+        to: last.end,
+        line: line.no,
+        marker,
+        info: open.info,
+        infoFrom,
+        infoTo: infoFrom + open.info.length,
+        word,
+        kind: isFenceKind(word) ? word : "code",
+        bodyFrom: bodyLines[0]?.start ?? line.end,
+        bodyTo: bodyLines.at(-1)?.end ?? line.end,
+        closed,
+        slide
+      });
+      i = closed ? end + 1 : lines.length;
+      continue;
+    }
+    if (COMMENT.test(text)) {
+      let end = i;
+      while (end < lines.length && !lines[end].text.includes("-->", end === i ? lines[end].text.indexOf("<!--") + 4 : 0)) end++;
+      const closed = end < lines.length;
+      const last = closed ? lines[end] : lines.at(-1);
+      const open2 = text.indexOf("<!--");
+      const innerFrom = line.start + open2 + 4;
+      const closeAt = closed ? last.start + last.text.indexOf("-->", end === i ? open2 + 4 : 0) : last.end;
+      const inner = source(lines, i, closed ? end : lines.length - 1).slice(open2 + 4);
+      const kind = /^\s*(slide|block)(?::|(?=\s*(?:-->|$)))/.exec(inner);
+      scan.comments.push({ from: line.start, to: closed ? closeAt + 3 : last.end, line: line.no, kind: kind?.[1] ?? "comment", innerFrom, innerTo: closeAt, closed, slide });
+      i = closed ? end + 1 : lines.length;
+      continue;
+    }
+    i++;
+  }
+}
+function source(lines, first, last) {
+  return lines.slice(first, last + 1).map((line) => line.text).join(" ");
+}
+var segmentsOfPointer = (path) => path.map((segment) => `/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+var SLIDE_OPTIONS = new Set(SLIDE_OPTION_KEYS);
+var OPTIONS_COMMENT = /^\s*<!--/;
+function firstLine(text, range) {
+  const end = text.slice(range.start, range.end).search(/[\r\n]/);
+  return { offset: range.start, length: end < 0 ? range.end - range.start : end };
+}
+function optionToken(text, comment, key, nth = 0) {
+  const inner = text.slice(comment.start, comment.end);
+  const open = inner.indexOf("<!--");
+  const colon = inner.indexOf(":", open);
+  const from = colon < 0 ? open + 4 : colon + 1;
+  const pattern = /(?:^|[\s,])([A-Za-z][\w-]*)(=("(?:[^"\\]|\\.)*"|[^\s,"]+))?/g;
+  const tail = inner.slice(from);
+  let seen = 0;
+  for (const match of tail.matchAll(pattern)) {
+    if (match[1] !== key) continue;
+    if (seen++ !== nth) continue;
+    const keyStart = comment.start + from + match.index + match[0].indexOf(match[1]);
+    const keySpan = { offset: keyStart, length: key.length };
+    const value = match[3] === void 0 ? void 0 : { offset: keyStart + key.length + 1, length: match[3].length };
+    return { key: keySpan, ...value ? { value } : {}, entry: { offset: keyStart, length: (value ? value.offset + value.length : keyStart + key.length) - keyStart } };
+  }
+  return void 0;
+}
+var MARKER = /^( {0,3}(?:#{1,6}|[-+*]|\d{1,9}[.)])[ \t]+)/;
+function afterMarker(text, range) {
+  const line = firstLine(text, range);
+  const lineText = text.slice(line.offset, line.offset + line.length);
+  const match = MARKER.exec(lineText);
+  if (!match) return void 0;
+  const lead = match[1];
+  const markerLength = lead.trimEnd().length;
+  const content = lineText.slice(lead.length);
+  const trimmed = content.replace(/(?:^|[ \t]+)#+[ \t]*$/, "").trimEnd();
+  return { marker: { offset: line.offset + lead.length - lead.trimStart().length, length: markerLength - (lead.length - lead.trimStart().length) }, content: { offset: line.offset + lead.length, length: trimmed.length } };
+}
+function embeddedFenceAt(scan, offset) {
+  return scan.fences.find((fence) => (fence.kind === "opf-block" || fence.kind === "opf-slide") && offset >= fence.from && offset <= fence.to);
+}
+function locateMarkdown(text, segments, part) {
+  const { ctx, front } = readMarkdown2(text);
+  if (segments.length === 0) {
+    const trimmed = text.replace(/\s+$/, "").length;
+    return trimmed > 0 ? { offset: 0, length: trimmed, exact: true } : void 0;
+  }
+  if (segments[0] !== "slides") {
+    if (!front) return void 0;
+    const found = locateYaml(text.slice(front.start, front.end), segments, part);
+    if (found) return { offset: found.offset + front.start, length: found.length, exact: found.exact };
+    return { offset: front.start, length: Math.max(0, front.end - front.start), exact: false };
+  }
+  const slidesSpan = () => {
+    const first = ctx.ranges.get("/slides/0");
+    let last;
+    for (let index = 0; ctx.ranges.get(`/slides/${index}`); index++) last = ctx.ranges.get(`/slides/${index}`);
+    return first && last ? { start: first.start, end: last.end } : void 0;
+  };
+  let consumed = segments.length;
+  let range;
+  for (; consumed > 1; consumed--) {
+    range = ctx.ranges.get(segmentsOfPointer(segments.slice(0, consumed)));
+    if (range) break;
+  }
+  if (!range) {
+    const whole = slidesSpan();
+    return whole ? { offset: whole.start, length: whole.end - whole.start, exact: segments.length === 1 } : void 0;
+  }
+  const exact = consumed === segments.length;
+  const field = segments[2];
+  if (consumed >= 3 && field !== void 0 && SLIDE_OPTIONS.has(field) && OPTIONS_COMMENT.test(text.slice(range.start, range.end))) {
+    const beatIndex = field === "beat" && consumed === 3 && segments[3] !== void 0 && /^\d+$/.test(segments[3]) ? Number(segments[3]) : 0;
+    const token = optionToken(text, range, field, beatIndex);
+    if (token) {
+      const span = part === "key" ? token.key : part === "entry" || part === "colon" ? token.entry : token.value ?? token.key;
+      return { ...span, exact: exact || field === "beat" && consumed === 3 && segments.length === 4 };
+    }
+  }
+  if (!exact) {
+    const fence = embeddedFenceAt(scanMarkdown(text), range.start);
+    if (fence) {
+      const rest = consumed >= 4 && segments[2] === "blocks" ? segments.slice(4) : consumed === 3 ? segments.slice(2) : void 0;
+      const inside = rest?.length ? locateYaml(text.slice(fence.bodyFrom, fence.bodyTo), rest, part) : void 0;
+      if (inside) return { offset: inside.offset + fence.bodyFrom, length: inside.length, exact: inside.exact };
+    }
+  }
+  const title = consumed === 3 && (field === "title" || field === "subtitle");
+  const item = exact && segments.length >= 4 && /^\d+$/.test(segments[segments.length - 1]) && segments[segments.length - 2] !== "blocks";
+  if (exact && (title || item)) {
+    const marked = afterMarker(text, range);
+    if (marked) {
+      const span = part === "key" ? marked.marker : part === "entry" ? firstLine(text, range) : marked.content;
+      if (span.length > 0) return { ...span, exact: true };
+    }
+  }
+  if (part === "open") return { ...firstLine(text, range), exact };
+  return { offset: range.start, length: Math.max(0, range.end - range.start), exact };
+}
+var unescapeSegment = (segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~");
+var spanOf = (range) => ({ offset: range.start, length: range.end - range.start });
+function pathAtMarkdown(text, offset) {
+  const { ctx, front } = readMarkdown2(text);
+  if (front && offset >= front.start && offset <= front.end) {
+    const inside = pathAtYaml(text.slice(front.start, front.end), offset - front.start);
+    return { path: inside.path, part: inside.part === "none" ? "between" : inside.part, ...inside.range ? { range: { offset: inside.range.offset + front.start, length: inside.range.length } } : {} };
+  }
+  const scan = scanMarkdown(text);
+  const fence = embeddedFenceAt(scan, offset);
+  if (fence && offset >= fence.bodyFrom && offset <= fence.bodyTo) {
+    const inside = pathAtYaml(text.slice(fence.bodyFrom, fence.bodyTo), offset - fence.bodyFrom);
+    if (inside.part !== "none" && inside.path.length) {
+      const block = fence.kind === "opf-block" ? blockIndex(ctx.ranges, fence.slide, fence.from) : -1;
+      const prefix = block >= 0 ? ["slides", String(fence.slide), "blocks", String(block)] : ["slides", String(fence.slide)];
+      return { path: [...prefix, ...inside.path], part: inside.part, ...inside.range ? { range: { offset: inside.range.offset + fence.bodyFrom, length: inside.range.length } } : {} };
+    }
+  }
+  let best;
+  for (const [pointer, range] of ctx.ranges) {
+    if (!pointer.startsWith("/slides/") || offset < range.start || offset > range.end) continue;
+    const depth = pointer.split("/").length;
+    if (!best || depth > best.depth || depth === best.depth && range.end - range.start < best.range.end - best.range.start) best = { pointer, range, depth };
+  }
+  if (!best) return { path: [], part: "none" };
+  const path = best.pointer.split("/").slice(1).map(unescapeSegment);
+  const field = path[2];
+  if (path.length === 3 && field && SLIDE_OPTIONS.has(field) && OPTIONS_COMMENT.test(text.slice(best.range.start, best.range.end))) {
+    for (const key of SLIDE_OPTIONS) {
+      for (let nth = 0; ; nth++) {
+        const token = optionToken(text, best.range, key, nth);
+        if (!token) break;
+        const at = key === "beat" ? [path[0], path[1], key, String(nth)] : [path[0], path[1], key];
+        if (offset >= token.key.offset && offset <= token.key.offset + token.key.length) return { path: at, part: "key", range: token.key };
+        if (token.value && offset >= token.value.offset && offset <= token.value.offset + token.value.length) return { path: at, part: "value", range: token.value };
+      }
+    }
+    return { path: path.slice(0, 2), part: "between", range: spanOf(best.range) };
+  }
+  return { path, part: "value", range: spanOf(best.range) };
+}
+function blockIndex(ranges, slide, start) {
+  for (let index = 0; ranges.has(`/slides/${slide}/blocks/${index}`); index++) if (ranges.get(`/slides/${slide}/blocks/${index}`).start === start) return index;
+  return -1;
+}
+
+// src/source-locate.ts
+var indexOrKey = (segment) => /^(?:0|[1-9][0-9]*)$/.test(segment) ? Number(segment) : segment;
 var isJson = (format) => format === "json";
+var isMarkdown = (format) => format === "md" || format === "markdown";
 var parseText = (text) => parseTree(text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text, [], { allowTrailingComma: true, allowEmptyContent: true, disallowComments: false });
-function segmentsOf(pointer) {
+function segmentsOf2(pointer) {
   if (Array.isArray(pointer)) return pointer.map(String);
   if (typeof pointer !== "string") return void 0;
   try {
@@ -15,7 +382,7 @@ function segmentsOf(pointer) {
     return void 0;
   }
 }
-function member(node, segment) {
+function member2(node, segment) {
   if (node.type === "array") return /^(?:0|[1-9][0-9]*)$/.test(segment) ? node.children?.[Number(segment)] : void 0;
   if (node.type === "object") return node.children?.find((property) => property.children?.[0]?.value === segment);
   return void 0;
@@ -37,17 +404,26 @@ function partOf(value, property, part) {
   }
 }
 function locate(text, format, pointer, options = {}) {
-  if (!isJson(format)) return void 0;
-  const segments = segmentsOf(pointer);
-  const root = segments ? parseText(text) : void 0;
-  if (!segments || !root) return void 0;
+  const segments = segmentsOf2(pointer);
+  if (!segments) return void 0;
   const part = options.part ?? "value";
   const place = createLocator(text);
+  if (format === "yaml") {
+    const found2 = locateYaml(text, segments, part);
+    return found2 ? { ...place(found2.offset, found2.length), ...found2.exact ? {} : { exact: false } } : void 0;
+  }
+  if (isMarkdown(format)) {
+    const found2 = locateMarkdown(text, segments, part);
+    return found2 ? { ...place(found2.offset, found2.length), ...found2.exact ? {} : { exact: false } } : void 0;
+  }
+  if (!isJson(format)) return void 0;
+  const root = parseText(text);
+  if (!root) return void 0;
   let value = root;
   let property;
   let depth = 0;
   for (const segment of segments) {
-    const next = value ? member(value, segment) : void 0;
+    const next = value ? member2(value, segment) : void 0;
     if (!value || !next) break;
     if (value.type === "object") {
       property = next;
@@ -64,9 +440,13 @@ function locate(text, format, pointer, options = {}) {
   return { ...place(found.offset, found.length), ...exact ? {} : { exact: false } };
 }
 function pathAt(text, format, offset) {
+  const place = createLocator(text);
+  if (format === "yaml" || isMarkdown(format)) {
+    const found = format === "yaml" ? pathAtYaml(text, offset) : pathAtMarkdown(text, offset);
+    return { path: found.path.map(indexOrKey), part: found.part, ...found.range ? { range: place(found.range.offset, found.range.length) } : {} };
+  }
   if (!isJson(format)) return void 0;
   const root = parseText(text);
-  const place = createLocator(text);
   const none = { path: [], part: "none" };
   if (!root || offset < root.offset || offset > root.offset + root.length) return none;
   const node = findNodeAtOffset(root, offset, true);
@@ -87,4 +467,4 @@ function pathAt(text, format, offset) {
   return { path: getNodePath(node), part: "value", range: range(node) };
 }
 
-export { locate, pathAt };
+export { locate, pathAt, scanMarkdown };

package/dist/validator.js

@@ -1,3 +1,3 @@
-export { DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-NJWI6MPT.js';
+export { DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-CIWC7DRZ.js';
 export { promotedRegionKeys } from './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';

package/dist/yaml.js

@@ -1,7 +1,8 @@
-export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml } from './chunk-PB5X2VSV.js';
-import './chunk-DEI2M2H6.js';
-import './chunk-PXOXTJTN.js';
-import './chunk-NJWI6MPT.js';
+export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml } from './chunk-WAZDP2WS.js';
+import './chunk-RYZPBJLB.js';
+import './chunk-KPALXWX3.js';
+import './chunk-HPEZCAYC.js';
+import './chunk-CIWC7DRZ.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-EQ6S5SEZ.js';
 import './chunk-F4HFDP6I.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf",
-  "version": "0.26.3",
+  "version": "0.26.5",
   "description": "Canonical Open Presentation Format schemas, TypeScript types, local validation and composition; in Node, the file API and the CLI defaults register the pptx.gallery catalog of @openpresentation/gallery.",
   "license": "MIT",
   "author": "Open Presentation",
@@ -145,7 +145,7 @@
     "ajv-formats": "^3.0.1",
     "jsonc-parser": "3.3.1",
     "yaml": "^2.9.1",
-    "@openpresentation/gallery": "^0.26.3"
+    "@openpresentation/gallery": "^0.26.5"
   },
   "devDependencies": {
     "@expo-google-fonts/arimo": "0.4.3",
@@ -165,8 +165,8 @@
     "typescript": "~5.9.3"
   },
   "peerDependencies": {
-    "@openpresentation/opf-pptx": "^0.26.3",
-    "@openpresentation/opf-render": "^0.26.3"
+    "@openpresentation/opf-pptx": "^0.26.5",
+    "@openpresentation/opf-render": "^0.26.5"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-pptx": {
@@ -186,5 +186,5 @@
     "test:packed": "node test/packed-install-smoke.mjs",
     "pack:dry-run": "pnpm run build:deps && pnpm run build && npm pack --dry-run --cache /tmp/opf-npm-cache"
   },
-  "gitHead": "570ebe0c803e9613f6b9f9fcca8160b38b16a826"
+  "gitHead": "750d120e715b6c4930906aa71322d092d057c58d"
 }