@openpresentation/opf 0.26.3 → 0.26.4

package/dist/markdown.js

@@ -1,7 +1,9 @@
-export { fromMarkdown, toMarkdown } from './chunk-WASENX2R.js';
-import './chunk-7RY7QWWJ.js';
-export { OPFMarkdownError } from './chunk-DEI2M2H6.js';
-import './chunk-PXOXTJTN.js';
-import './chunk-NJWI6MPT.js';
+export { fromMarkdown, toMarkdown } from './chunk-GWJBZ4LC.js';
+import './chunk-RYZPBJLB.js';
+import './chunk-MN7DRK57.js';
+import './chunk-O6BY3AU2.js';
+export { OPFMarkdownError } from './chunk-QAEBYDKY.js';
+import './chunk-6NBTZYYD.js';
+import './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';

package/dist/node-engine.d.ts

@@ -1,6 +1,6 @@
 export { b as DeckReport, c as DeckReportOptions, r as readDeckReport } from './deck-report-5vwMGcQz.js';
-import { F as FontsHandle, j as EmbeddedFace, R as Renderer, k as Reporter, P as Peer, l as PptxModule, f as OPFApiError } from './conversion-BjsKgxBZ.js';
-export { m as ConversionPlan, D as Diagnostic, n as EXPORT_FORMATS, o as EXPORT_TEXT, q as ExportContext, r as ExportFile, s as ExportFontSummary, E as ExportFormat, t as ExportOptions, u as ExportResult, v as ExportRun, w as ExportText, I as ImportOptions, x as ImportResult, g as OPFExportError, h as OPFImportError, y as PEER_RANGES, z as PPTX_PACKAGE, A as PreparedExport, B as RENDER_EXTRAS, G as RENDER_PACKAGE, H as ReportFinding, J as ResolvedExportOptions, i as SlideSelection, K as Source, V as VERSIONS, L as asApiError, M as assetRoot, N as checkDate, Q as checkOptions, T as checkRenamedOptions, U as checkScale, W as deckFileFormat, X as exportFormatOf, Y as finishReport, Z as importPresentation, _ as loadPptx, $ as loadRenderer, a0 as locatePackage, a1 as missingPeerFrom, p as parseSlideSelection, a2 as planConversion, a3 as prepareExport, a4 as reaches, a5 as readInput, a6 as reportThrown, a7 as resolveExportOptions, a8 as runExport, a9 as runPreparedExport, aa as writePlanned } from './conversion-BjsKgxBZ.js';
+import { F as FontsHandle, j as EmbeddedFace, R as Renderer, k as Reporter, P as Peer, l as PptxModule, f as OPFApiError } from './conversion-DSafOGzh.js';
+export { m as ConversionPlan, D as Diagnostic, n as EXPORT_FORMATS, o as EXPORT_TEXT, q as ExportContext, r as ExportFile, s as ExportFontSummary, E as ExportFormat, t as ExportOptions, u as ExportResult, v as ExportRun, w as ExportText, I as ImportOptions, x as ImportResult, g as OPFExportError, h as OPFImportError, y as PEER_RANGES, z as PPTX_PACKAGE, A as PreparedExport, B as RENDER_EXTRAS, G as RENDER_PACKAGE, H as ReportFinding, J as ResolvedExportOptions, i as SlideSelection, K as Source, V as VERSIONS, L as asApiError, M as assetRoot, N as checkDate, Q as checkOptions, T as checkRenamedOptions, U as checkScale, W as deckFileFormat, X as exportFormatOf, Y as finishReport, Z as importPresentation, _ as loadPptx, $ as loadRenderer, a0 as locatePackage, a1 as missingPeerFrom, p as parseSlideSelection, a2 as planConversion, a3 as prepareExport, a4 as reaches, a5 as readInput, a6 as reportThrown, a7 as resolveExportOptions, a8 as runExport, a9 as runPreparedExport, aa as writePlanned } from './conversion-DSafOGzh.js';
 import { a as Catalog } from './catalog-refs-BSfGELpt.js';
 import { e as PresentationPaginationResult } from './pagination-D_kJe4jH.js';
 import './presentation-Bwo8Ko6D.js';

package/dist/node-engine.js

@@ -1,21 +1,23 @@
-import { loadRenderer, listFontDirectories, leaseSharedFonts, prepareFonts } from './chunk-34LIUOT7.js';
-export { EXPORT_FORMATS, EXPORT_TEXT, PEER_RANGES, PPTX_PACKAGE, RENDER_EXTRAS, RENDER_PACKAGE, Reporter, VERSIONS, assetRoot, checkDate, checkDestinations, checkOptions, checkOutputPattern, checkRenamedOptions, checkScale, createZip, deckFileFormat, deckStem, embeddedFor, exportFormatOf, finishReport, importPresentation, leaseSharedFonts, listFontDirectories, loadPptx, loadRenderer, localAssetProblems, locatePackage, missingPeerFrom, padNumber, planConversion, pointerOf, prepareExport, prepareFonts, publishNew, reaches, readInput, reportThrown, resolveExportOptions, runExport, runImport, runPreparedExport, stemOf, writeFiles, writePlanned } from './chunk-34LIUOT7.js';
-import { defaultCatalogs } from './chunk-2ZQBMZTZ.js';
-export { defaultCatalogs, galleryMismatch } from './chunk-2ZQBMZTZ.js';
-import { OPFApiError } from './chunk-GLLR3AQ5.js';
-export { OPFApiError, OPFExportError, OPFImportError, asApiError, parseSlideSelection } from './chunk-GLLR3AQ5.js';
+import { loadRenderer, listFontDirectories, leaseSharedFonts, prepareFonts } from './chunk-6IXSHIAL.js';
+export { EXPORT_FORMATS, EXPORT_TEXT, PEER_RANGES, PPTX_PACKAGE, RENDER_EXTRAS, RENDER_PACKAGE, Reporter, VERSIONS, assetRoot, checkDate, checkDestinations, checkOptions, checkOutputPattern, checkRenamedOptions, checkScale, createZip, deckFileFormat, deckStem, embeddedFor, exportFormatOf, finishReport, importPresentation, leaseSharedFonts, listFontDirectories, loadPptx, loadRenderer, localAssetProblems, locatePackage, missingPeerFrom, padNumber, planConversion, pointerOf, prepareExport, prepareFonts, publishNew, reaches, readInput, reportThrown, resolveExportOptions, runExport, runImport, runPreparedExport, stemOf, writeFiles, writePlanned } from './chunk-6IXSHIAL.js';
+import { defaultCatalogs } from './chunk-ZSZDVIDV.js';
+export { defaultCatalogs, galleryMismatch } from './chunk-ZSZDVIDV.js';
+import { OPFApiError } from './chunk-NZLW6FBQ.js';
+export { OPFApiError, OPFExportError, OPFImportError, asApiError, parseSlideSelection } from './chunk-NZLW6FBQ.js';
 import './chunk-UJSAR6GF.js';
 import './chunk-PJSPHHRK.js';
 import './chunk-TKQ2VFV5.js';
-import { paginate } from './chunk-54OV2WQC.js';
-export { readDeckReport } from './chunk-FXNUM2PN.js';
-import './chunk-WASENX2R.js';
-import './chunk-7RY7QWWJ.js';
-import './chunk-PB5X2VSV.js';
-import './chunk-DEI2M2H6.js';
-import './chunk-PXOXTJTN.js';
-import './chunk-YVNFACTC.js';
-import './chunk-NJWI6MPT.js';
+import { paginate } from './chunk-QH2W6HIM.js';
+export { readDeckReport } from './chunk-EDCRBTJF.js';
+import './chunk-GWJBZ4LC.js';
+import './chunk-PIO73BQ6.js';
+import './chunk-RYZPBJLB.js';
+import './chunk-MN7DRK57.js';
+import './chunk-O6BY3AU2.js';
+import './chunk-QAEBYDKY.js';
+import './chunk-6NBTZYYD.js';
+import './chunk-H5QC3X3K.js';
+import './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-EQ6S5SEZ.js';
 import './chunk-F4HFDP6I.js';

package/dist/pagination.js

@@ -1,4 +1,4 @@
-export { OPFPaginationError, paginate, paginateSlide } from './chunk-54OV2WQC.js';
-import './chunk-NJWI6MPT.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-QH2W6HIM.js';
+import './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';

package/dist/patch.js

@@ -1,3 +1,3 @@
-export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-NJWI6MPT.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';

package/dist/schema.js

@@ -1,3 +1,3 @@
-export { COMMON_KEYS, UNRANKED_PRIORITY, activeSchema, catalogKindAt, createSchemaValue, describeField, isPromotedRegionKey, listSchemaFields, resolveSchema, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, splitOpfPath } from './chunk-NJWI6MPT.js';
+export { COMMON_KEYS, UNRANKED_PRIORITY, activeSchema, catalogKindAt, createSchemaValue, describeField, isPromotedRegionKey, listSchemaFields, resolveSchema, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, splitOpfPath } from './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
 import './chunk-F4HFDP6I.js';

package/dist/source.d.ts

@@ -1,5 +1,29 @@
 import { b as FindingLocation } from './finding-l9dlQ2NF.js';
 
+/** Keys of `<!-- slide: ... -->`. */
+declare const SLIDE_OPTION_KEYS: readonly ["id", "type", "layout", "section", "tag", "hidden", "beat"];
+/** Keys of `<!-- block: ... -->`. */
+declare const BLOCK_OPTION_KEYS: readonly ["id", "type", "as", "region"];
+/** Values of `as=` in a block options comment. */
+declare const BLOCK_AS_VALUES: readonly ["bullets", "video"];
+/** The first word of a fence info string that is not code: `chart`, `metric`, `timeline` and the two YAML escape hatches. */
+declare const FENCE_KINDS: readonly ["chart", "metric", "timeline", "opf-block", "opf-slide"];
+/** Lines of a ```metric fence: `key: value`. */
+declare const METRIC_KEYS: readonly ["value", "label", "description", "unit", "delta", "trend", "sentiment"];
+/** Attributes after the info word: `chart` takes `alt`, `timeline` `name` and `description`, a code fence `title`. */
+declare const FENCE_ATTRIBUTES: {
+    readonly chart: readonly ["alt"];
+    readonly timeline: readonly ["name", "description"];
+    readonly code: readonly ["title"];
+};
+/** Flags of an inline span `[text]{bold italic}` (the converter also reads `strikethrough`, `superscript` and `subscript`). */
+declare const SPAN_FLAGS: readonly ["bold", "italic", "underline", "strike", "sup", "sub"];
+/** Attributes of an inline span that take a value: `[text]{color=#B42318 size=24 font="Open Sans" lang=fr}`. */
+declare const SPAN_VALUES: readonly ["color", "size", "font", "lang"];
+/** Keywords a line of a slide can start with. */
+declare const LINE_KEYWORDS: readonly ["Note:", "Notes:"];
+type FenceKind = (typeof FENCE_KINDS)[number];
+
 /**
  * A range of source text in the `Finding.location` convention: UTF-16 offset and length, 1-based line and column (a line break is
  * `\r\n`, `\r` or `\n`). `exact: false` marks a range that is the nearest ancestor of a node the text does not have.
@@ -85,13 +109,87 @@ interface PathAtResult {
  * underlined in the source. Tolerant: it reads text with syntax errors, comments and trailing commas as far as it can be read.
  * When the node does not exist, the range is that of the nearest ancestor that does, with `exact: false`.
  *
- * Phase 1 reads JSON. YAML and Markdown return `undefined` (phase 2): no range is guessed.
+ * JSON, YAML and Markdown. YAML is read with the `yaml` library's tolerant parse, so a text with syntax errors is located as far as it
+ * can be read. Markdown uses the ranges the converter records for every part it reads (the ones its findings are located by): a
+ * slide, its title, a list item, a block, the `layout=` of an options comment, the keys of the front matter and of the YAML in
+ * `opf-slide` and `opf-block` fences. A slide field the Markdown writes as a line (`# Title`, `- item`) has `value` = the text after
+ * the marker, `key` = the marker and `entry` = the line.
  */
 declare function locate(text: string, format: SourceFormat, pointer: string | readonly (string | number)[], options?: LocateOptions): TextRange | undefined;
 /**
- * The document path and the kind of position at a character offset (a caret between characters). JSON only (phase 1); YAML and
- * Markdown return `undefined`. Tolerant of broken text.
+ * The document path and the kind of position at a character offset (a caret between characters), in JSON, YAML or Markdown.
+ * Tolerant of broken text. In YAML a position on the whitespace of a blank line is `none` after the last node and `between` inside
+ * a collection; in Markdown a position outside the front matter and the slides is `none`.
  */
 declare function pathAt(text: string, format: SourceFormat, offset: number): PathAtResult | undefined;
 
-export { type AnalyzeOptions, type LocateOptions, type LocatePart, type PathAtResult, type SourceFormat, type SyntaxFix, type SyntaxProblem, type SyntaxProblemCode, type TextEdit, type TextRange, analyzeJsonSyntax, applyTextEdits, locate, pathAt };
+/** A range of the text: UTF-16 offsets, `from` inclusive and `to` exclusive, and the one-based line `from` is on. */
+interface ScanRange {
+    from: number;
+    to: number;
+    line: number;
+}
+interface MarkdownFrontMatter extends ScanRange {
+    /** The YAML between the two `---` lines: from the end of the opening line to the start of the closing line. */
+    yamlFrom: number;
+    yamlTo: number;
+    /** False when the closing `---` (or `...`) line is missing: then the YAML runs to the end of the text. */
+    closed: boolean;
+}
+interface MarkdownSlideScan extends ScanRange {
+    /** The slide's number in the converted deck (empty segments between `---` lines are not slides). */
+    index: number;
+}
+interface MarkdownCommentScan extends ScanRange {
+    /** `slide` and `block` are options comments (`<!-- slide: ... -->`), `comment` any other. */
+    kind: "slide" | "block" | "comment";
+    /** The text between `<!--` and `-->` (for an unclosed comment, to the end of its last line). */
+    innerFrom: number;
+    innerTo: number;
+    closed: boolean;
+    /** The slide it is in. */
+    slide: number;
+}
+interface MarkdownFenceScan extends ScanRange {
+    /** The opening fence characters (```` ``` ````, `~~~~`). */
+    marker: string;
+    /** The info string after the fence characters, trimmed; `infoFrom` and `infoTo` are its offsets. */
+    info: string;
+    infoFrom: number;
+    infoTo: number;
+    /** The first word of the info string. */
+    word: string;
+    /** `chart`, `metric`, `timeline`, `opf-block`, `opf-slide`, or `code` for any other fence. */
+    kind: FenceKind | "code";
+    /** The lines between the fences: `bodyFrom` is the start of the first line, `bodyTo` the end of the last (equal when the body is empty). */
+    bodyFrom: number;
+    bodyTo: number;
+    closed: boolean;
+    slide: number;
+}
+interface MarkdownNotesScan extends ScanRange {
+    slide: number;
+}
+interface MarkdownScan {
+    frontMatter?: MarkdownFrontMatter;
+    /** The slides, in order; each runs from its first to its last non-blank line. */
+    slides: MarkdownSlideScan[];
+    /** Offsets of the `---` lines that separate slides. */
+    separators: number[];
+    comments: MarkdownCommentScan[];
+    fences: MarkdownFenceScan[];
+    /** Speaker notes: from the `Note:` or `Notes:` line to the end of the slide. */
+    notes: MarkdownNotesScan[];
+}
+interface ScanMarkdownOptions {
+    /** How the text is cut into slides, as for `fromMarkdown`. */
+    split?: "auto" | "rules" | "headings";
+}
+/**
+ * The structure of a Markdown deck, found with the converter's line rules: front matter, slides, option comments, fences and notes, as
+ * offset ranges. Tolerant: an unclosed front matter, comment or fence is reported with `closed: false` and runs to the end of its slide.
+ * It is the one place an editor learns the dialect's regions from.
+ */
+declare function scanMarkdown(source: string, options?: ScanMarkdownOptions): MarkdownScan;
+
+export { type AnalyzeOptions, BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, type LocateOptions, type LocatePart, METRIC_KEYS, type MarkdownCommentScan, type MarkdownFenceScan, type MarkdownFrontMatter, type MarkdownNotesScan, type MarkdownScan, type MarkdownSlideScan, type PathAtResult, SLIDE_OPTION_KEYS, SPAN_FLAGS, SPAN_VALUES, type ScanMarkdownOptions, type ScanRange, type SourceFormat, type SyntaxFix, type SyntaxProblem, type SyntaxProblemCode, type TextEdit, type TextRange, analyzeJsonSyntax, applyTextEdits, locate, pathAt, scanMarkdown };

package/dist/source.js

@@ -1,10 +1,376 @@
-import { createLocator, parsePointer } from './chunk-NJWI6MPT.js';
-export { analyzeJsonSyntax, applyTextEdits } from './chunk-NJWI6MPT.js';
+import { readMarkdown, frontMatter, splitSegments, isOutline, NOTES, fenceStart, fenceClose, COMMENT, SLIDE_OPTION_KEYS, FENCE_KINDS } from './chunk-MN7DRK57.js';
+export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, SLIDE_OPTION_KEYS, SPAN_FLAGS, SPAN_VALUES } from './chunk-MN7DRK57.js';
+import './chunk-O6BY3AU2.js';
+import { splitLines } from './chunk-QAEBYDKY.js';
+import './chunk-6NBTZYYD.js';
+import { rememberByText, createLocator, parsePointer } from './chunk-XFOOKVRI.js';
+export { analyzeJsonSyntax, applyTextEdits } from './chunk-XFOOKVRI.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) {
   if (Array.isArray(pointer)) return pointer.map(String);
@@ -15,7 +381,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 +403,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;
+  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 +439,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 +466,4 @@ function pathAt(text, format, offset) {
   return { path: getNodePath(node), part: "value", range: range(node) };
 }
 
-export { locate, pathAt };
+export { locate, pathAt, scanMarkdown };