@openpresentation/opf 0.26.3 → 0.26.5

package/dist/chunk-KPALXWX3.js

@@ -0,0 +1,712 @@
+import { isRecord, same } from './chunk-HPEZCAYC.js';
+import { createLocator } from './chunk-CIWC7DRZ.js';
+import { parseDocument, isMap, isSeq, isScalar, YAMLMap, Scalar, stringify, visit } from 'yaml';
+
+var sentence = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var code = (text) => `\`${text}\``;
+function lineAt(text, offset) {
+  const at = Math.max(0, Math.min(offset, text.length));
+  let start = at;
+  while (start > 0 && text[start - 1] !== "\n" && text[start - 1] !== "\r") start--;
+  let end = at;
+  while (end < text.length && text[end] !== "\n" && text[end] !== "\r") end++;
+  return { start, end };
+}
+var lineNumber = (text, offset) => createLocator(text)(offset, 0).line;
+function contentEnd(text, from, end) {
+  let quote = "";
+  let stop = end;
+  for (let index = from; index < end; index++) {
+    const char = text[index];
+    if (quote) {
+      if (char === "\\" && quote === '"') index++;
+      else if (char === quote) quote = "";
+      continue;
+    }
+    if ((char === '"' || char === "'") && (index === from || /[\s:,[{-]/.test(text[index - 1]))) quote = char;
+    else if (char === "#" && (index === from || /\s/.test(text[index - 1]))) {
+      stop = index;
+      break;
+    }
+  }
+  while (stop > from && /\s/.test(text[stop - 1])) stop--;
+  return stop;
+}
+function scan(text) {
+  const openers = [];
+  let quote;
+  let block;
+  let atLineStart = true;
+  let index = 0;
+  const startsValue = (at) => {
+    let back = at - 1;
+    while (back >= 0 && (text[back] === " " || text[back] === "	")) back--;
+    if (back < 0) return true;
+    const previous = text[back];
+    if (previous === "\n" || previous === "\r" || previous === "," || previous === "[" || previous === "{") return true;
+    if (previous === "-") return back === 0 || /\s/.test(text[back - 1]) || text[back - 1] === "\n";
+    if (previous === ":") return at > back + 1 || at === back + 1;
+    return false;
+  };
+  while (index < text.length) {
+    const char = text[index];
+    if (quote) {
+      if (quote.char === '"' && char === "\\") index += 2;
+      else if (quote.char === "'" && char === "'" && text[index + 1] === "'") index += 2;
+      else {
+        if (char === quote.char) quote = void 0;
+        index++;
+      }
+      continue;
+    }
+    if (char === "\n" || char === "\r") {
+      index++;
+      atLineStart = true;
+      continue;
+    }
+    if (atLineStart) {
+      atLineStart = false;
+      const line = lineAt(text, index);
+      const indent = /^[ ]*/.exec(text.slice(line.start, line.end))?.[0].length ?? 0;
+      const blank = text.slice(line.start, line.end).trim() === "";
+      if (block !== void 0) {
+        if (blank || indent > block) {
+          index = line.end;
+          continue;
+        }
+        block = void 0;
+      }
+      const body = contentEnd(text, line.start, line.end);
+      if (/(^|[:-]\s+|^\s*)[|>][+-]?\d?[+-]?$/.test(text.slice(line.start, body))) block = indent;
+    }
+    if (char === "#" && (index === 0 || /\s/.test(text[index - 1]))) {
+      index = lineAt(text, index).end;
+      continue;
+    }
+    if ((char === '"' || char === "'") && startsValue(index)) {
+      quote = { offset: index, char };
+      index++;
+      continue;
+    }
+    if ((char === "[" || char === "{") && startsValue(index)) openers.push({ offset: index, char });
+    else if ((char === "]" || char === "}") && openers.length) {
+      const last = openers[openers.length - 1];
+      if (last.char === "[" && char === "]" || last.char === "{" && char === "}") openers.pop();
+    }
+    index++;
+  }
+  return { ...quote ? { openQuote: quote } : {}, openers };
+}
+var indentOf = (text, offset) => {
+  const line = lineAt(text, offset);
+  return /^[ \t]*/.exec(text.slice(line.start, line.end))?.[0].length ?? 0;
+};
+function previousContentLine(text, offset) {
+  let line = lineAt(text, offset);
+  while (line.start > 0) {
+    line = lineAt(text, line.start - 1);
+    const body = text.slice(line.start, line.end).trim();
+    if (body && !body.startsWith("#")) return line;
+  }
+  return void 0;
+}
+function keyColumn(text, line) {
+  const raw = text.slice(line.start, line.end);
+  const match = /^([ \t]*(?:-[ \t]+)*)/.exec(raw);
+  return match?.[0].length ?? 0;
+}
+var fix = (id, title, edits, extra = {}) => ({ id, title, safe: false, edits, ...extra });
+function readTab(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  let end = line.start;
+  while (end < line.end && (text[end] === " " || text[end] === "	")) end++;
+  const number = lineNumber(text, line.start);
+  const tabLines = [];
+  let cursor = 0;
+  while (cursor <= text.length) {
+    const current = lineAt(text, cursor);
+    let stop = current.start;
+    while (stop < current.end && (text[stop] === " " || text[stop] === "	")) stop++;
+    if (text.slice(current.start, stop).includes("	") && text.slice(stop, current.end).trim() !== "") tabLines.push({ start: current.start, end: stop });
+    if (current.end >= text.length) break;
+    cursor = current.end + 1;
+    if (text[current.end] === "\r" && text[current.end + 1] === "\n") cursor++;
+  }
+  const edit = (range) => ({ offset: range.start, length: range.end - range.start, insert: text.slice(range.start, range.end).replaceAll("	", "  ") });
+  const fixes = [];
+  const here = { start: line.start, end };
+  if (tabLines.length > 1) {
+    fixes.push(fix("tabs-to-spaces-line", "Convert tabs to spaces on this line", [edit(here)], { safe: true }));
+    fixes.push(fix("tabs-to-spaces", "Convert tabs to spaces in the file", tabLines.map(edit), { safe: true }));
+  } else fixes.push(fix("tabs-to-spaces", "Convert tabs to spaces", [edit(here)], { safe: true }));
+  return { code: "tab-indent", start: line.start, end, message: `Line ${number} is indented with a tab. YAML needs spaces.`, next: "replace the tab with spaces (two for each level of indentation).", fixes };
+}
+function readQuote(text, error, scanned) {
+  const char = /'/.test(error.message.slice(0, 20)) ? "'" : '"';
+  const open = scanned.openQuote && scanned.openQuote.char === char ? scanned.openQuote : scanned.openQuote;
+  if (!open) return void 0;
+  const line = lineAt(text, open.offset);
+  const number = lineNumber(text, open.offset);
+  const insertAt = line.end;
+  let at = insertAt;
+  while (at > open.offset && /\s/.test(text[at - 1])) at--;
+  return {
+    code: "unclosed-quote",
+    start: open.offset,
+    end: Math.max(open.offset + 1, line.end),
+    message: `The ${open.char === '"' ? "double " : "single "}quote opened on line ${number} is never closed.`,
+    next: `end the text with a matching ${open.char} (a quoted value can continue on the next lines, but it must close).`,
+    fixes: [fix("close-quote", "Insert closing quote", [{ offset: at, length: 0, insert: open.char }], { caret: at + 1 })]
+  };
+}
+function readFlow(text, error, scanned) {
+  const wantsList = /Flow sequence/.test(error.message);
+  const opener = [...scanned.openers].reverse().find((entry) => entry.char === (wantsList ? "[" : "{")) ?? scanned.openers[scanned.openers.length - 1];
+  if (!opener) return void 0;
+  const closer = opener.char === "[" ? "]" : "}";
+  const line = lineAt(text, opener.offset);
+  const number = lineNumber(text, opener.offset);
+  let last = previousContentLine(text, error.pos[0]) ?? line;
+  if (last.start < line.start) last = line;
+  const at = contentEnd(text, last.start, last.end);
+  return {
+    code: opener.char === "[" ? "unclosed-list" : "unclosed-map",
+    start: opener.offset,
+    end: Math.max(opener.offset + 1, contentEnd(text, line.start, line.end)),
+    message: `The ${opener.char === "[" ? "list" : "map"} that starts with ${code(opener.char)} on line ${number} is never closed.`,
+    next: `add ${code(closer)} after the last ${opener.char === "[" ? "item" : "entry"}.`,
+    fixes: [fix("insert-closer", `Insert ${closer}`, [{ offset: at, length: 0, insert: closer }], { caret: at + 1 })]
+  };
+}
+function readImplicit(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  const body = text.slice(error.pos[0], line.end);
+  const end = error.pos[0] + contentEnd(body, 0, body.length);
+  const key = text.slice(error.pos[0], end).trim();
+  if (key.startsWith("- ") || key === "-") {
+    return {
+      code: "list-item-under-value",
+      start: error.pos[0],
+      end: Math.max(end, error.pos[0] + 1),
+      message: "This list item sits under a value that isn't a list.",
+      next: "put the item under a key such as `items:`, or indent it under the key above."
+    };
+  }
+  return {
+    code: "incomplete-key",
+    start: error.pos[0],
+    end: Math.max(end, error.pos[0] + 1),
+    message: `${code(key.length > 40 ? `${key.slice(0, 39)}\u2026` : key)} isn't a complete ${code("key: value")} line.`,
+    next: "add a colon and a value, or remove the line.",
+    fixes: [
+      fix("add-colon", "Add a colon", [{ offset: end, length: 0, insert: ": " }], { caret: end + 2 }),
+      fix("remove-line", "Remove the line", [{ offset: line.start, length: Math.min(text.length, nextLineStart(text, line.end)) - line.start, insert: "" }])
+    ]
+  };
+}
+function nextLineStart(text, end) {
+  if (text[end] === "\r" && text[end + 1] === "\n") return end + 2;
+  return end < text.length ? end + 1 : end;
+}
+function readColonInValue(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  const end = contentEnd(text, error.pos[0], line.end);
+  const value = text.slice(error.pos[0], end);
+  return {
+    code: "colon-in-value",
+    start: error.pos[0],
+    end: Math.max(end, error.pos[0] + 1),
+    message: `A value can't contain ${code(": ")} unless it is quoted.`,
+    next: "wrap the value in quotes.",
+    fixes: [fix("quote-value", "Quote the value", [{ offset: error.pos[0], length: end - error.pos[0], insert: JSON.stringify(value) }])]
+  };
+}
+function readAlignment(text, error, missingDash) {
+  const line = lineAt(text, error.pos[0]);
+  const number = lineNumber(text, line.start);
+  const indent = indentOf(text, line.start);
+  const previous = previousContentLine(text, line.start);
+  const fixes = [];
+  const reindent = (id, title, column) => {
+    if (column === indent || column < 0) return;
+    fixes.push(fix(id, title, [{ offset: line.start, length: indent, insert: " ".repeat(column) }]));
+  };
+  if (previous) {
+    reindent("align-with-line-above", "Align with the line above", keyColumn(text, previous));
+    let parent = previousContentLine(text, previous.start);
+    while (parent && keyColumn(text, parent) >= keyColumn(text, previous)) parent = previousContentLine(text, parent.start);
+    if (parent && !missingDash) reindent("align-with-parent", "Align with the parent key", keyColumn(text, parent));
+  }
+  const end = contentEnd(text, line.start, line.end);
+  return {
+    code: missingDash ? "missing-dash" : "misaligned",
+    start: line.start,
+    end: Math.max(end, line.start + 1),
+    message: missingDash ? `Line ${number} does not line up with the list item above.` : `Line ${number} is indented differently from the keys above it.`,
+    next: missingDash ? "align it with the item's first key, or start a new item with `- `." : "align it with the other keys of this mapping.",
+    fixes: fixes.slice(0, 2)
+  };
+}
+function readTrailing(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  const end = Math.max(error.pos[0] + 1, contentEnd(text, error.pos[0], line.end));
+  const snippet = text.slice(error.pos[0], end);
+  let from = error.pos[0];
+  while (from > line.start && /[ \t]/.test(text[from - 1])) from--;
+  return {
+    code: "trailing-text",
+    start: error.pos[0],
+    end,
+    message: `Unexpected text ${code(snippet.length > 30 ? `${snippet.slice(0, 29)}\u2026` : snippet)} after the value ends.`,
+    next: "remove it, or put the whole value in quotes if it belongs to the value.",
+    fixes: [fix("remove-text", "Remove the text", [{ offset: from, length: end - from, insert: "" }])]
+  };
+}
+function readMissingColon(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  const end = contentEnd(text, line.start, line.end);
+  const key = text.slice(line.start, end).trim();
+  return {
+    code: "missing-colon",
+    start: Math.min(line.start + (text.slice(line.start, line.end).length - text.slice(line.start, line.end).trimStart().length), end),
+    end: Math.max(end, line.start + 1),
+    message: `${code(key.length > 40 ? `${key.slice(0, 39)}\u2026` : key)} needs a colon and a value.`,
+    next: `write ${code(`${key}: `)} and a value.`,
+    fixes: [fix("add-colon", "Add a colon", [{ offset: end, length: 0, insert: ": " }], { caret: end + 2 })]
+  };
+}
+function readEscape(text, error) {
+  const written = text.slice(error.pos[0], error.pos[0] + 2);
+  return {
+    code: "bad-escape",
+    start: error.pos[0],
+    end: Math.min(text.length, error.pos[0] + 2),
+    message: `${code(written)} is not an escape YAML knows.`,
+    next: 'write a backslash as `\\\\` (the escapes are `\\n`, `\\t`, `\\"`, `\\\\`, `\\/`, `\\xNN` and `\\uNNNN`), or use single quotes, where a backslash is just a backslash.',
+    fixes: [fix("double-backslash", "Double the backslash", [{ offset: error.pos[0], length: 0, insert: "\\" }])]
+  };
+}
+function readReservedStart(text, error) {
+  const line = lineAt(text, error.pos[0]);
+  const end = contentEnd(text, error.pos[0], line.end);
+  const value = text.slice(error.pos[0], end);
+  return {
+    code: "reserved-start",
+    start: error.pos[0],
+    end: Math.max(end, error.pos[0] + 1),
+    message: `A plain value can't start with ${code(text[error.pos[0]] ?? "")}.`,
+    next: "put the value in quotes.",
+    fixes: [fix("quote-value", "Quote the value", [{ offset: error.pos[0], length: end - error.pos[0], insert: JSON.stringify(value) }])]
+  };
+}
+function firstEqualKey(doc, start) {
+  let found;
+  visit(doc, {
+    Map(_key, map) {
+      const items = map.items;
+      const at = items.findIndex((item) => isScalar(item.key) && item.key.range?.[0] === start);
+      if (at < 0) return void 0;
+      const repeat = items[at]?.key;
+      const earlier = items.slice(0, at).find((item) => isScalar(item.key) && String(item.key.value) === String(repeat.value));
+      if (earlier) found = { key: earlier.key, pair: earlier };
+      return visit.BREAK;
+    }
+  });
+  return found;
+}
+function removeEntryEdit(text, key, value) {
+  const start = lineAt(text, key.range[0]).start;
+  if (text.slice(start, key.range[0]).trim() !== "") return void 0;
+  const finish = Math.max(key.range[1], value?.range ? Math.max(value.range[0], value.range[1] - 1) : key.range[1]);
+  const lineEnd = lineAt(text, finish).end;
+  return { offset: start, length: nextLineStart(text, lineEnd) - start, insert: "" };
+}
+function readDuplicate(text, error, doc) {
+  const start = error.pos[0];
+  const lineOfRepeat = lineNumber(text, start);
+  const earlier = firstEqualKey(doc, start);
+  let repeatPair;
+  visit(doc, {
+    Pair(_key, pair) {
+      const key = pair.key;
+      if (key?.range && key.range[0] === start) {
+        repeatPair = { key, value: pair.value };
+        return visit.BREAK;
+      }
+      return void 0;
+    }
+  });
+  const repeatKey = repeatPair?.key;
+  const name = repeatKey ? text.slice(repeatKey.range[0], repeatKey.range[1]).trim() : String(earlier?.key?.value ?? "key");
+  const firstLine = earlier ? lineNumber(text, earlier.key.range[0]) : void 0;
+  const fixes = [];
+  if (earlier) {
+    const first = removeEntryEdit(text, earlier.key, earlier.pair.value);
+    const second = repeatPair ? removeEntryEdit(text, repeatPair.key, repeatPair.value) : void 0;
+    if (first) fixes.push(fix("remove-first", "Remove the first", [first]));
+    if (second) fixes.push(fix("remove-second", "Remove the second", [second]));
+  }
+  return {
+    rule: "duplicate-key",
+    code: "duplicate-key",
+    start,
+    end: Math.max(start + 1, repeatKey ? repeatKey.range[1] : error.pos[1]),
+    message: `${code(name)} appears twice at this level${firstLine ? ` (lines ${firstLine} and ${lineOfRepeat})` : ""}. The first value is ignored.`,
+    next: "keep one of them, or rename the one you meant as another key.",
+    fixes,
+    ...earlier ? { related: [{ start: earlier.key.range[0], end: Math.max(earlier.key.range[0] + 1, earlier.key.range[1]) }] } : {}
+  };
+}
+function readMultipleDocuments(text, error) {
+  const start = error.pos[0];
+  const line = lineAt(text, start);
+  const marker = /^---\s*$/.test(text.slice(line.start, line.end).trimEnd()) ? line : void 0;
+  return {
+    rule: "multiple-documents",
+    code: "multiple-documents",
+    start,
+    end: Math.max(error.pos[1], start + 1),
+    message: "The input holds more than one YAML document.",
+    next: "remove the extra `---` separators, or put each deck in its own file.",
+    help: "An OPF file is exactly one document: remove the extra --- separators, or put each deck in its own file.",
+    fixes: marker ? [fix("remove-separator", "Remove the extra `---`", [{ offset: marker.start, length: nextLineStart(text, marker.end) - marker.start, insert: "" }])] : []
+  };
+}
+function readOther(error) {
+  const text = error.message.split("\n")[0] ?? error.message;
+  return { code: "other", start: error.pos[0], end: Math.max(error.pos[0], error.pos[1]), message: `YAML: ${text}`, next: "fix the YAML at this position. An OPF file holds JSON-compatible YAML 1.2: mappings, lists and plain values." };
+}
+function readError(text, error, doc, scanned) {
+  const message = error.message;
+  switch (error.code) {
+    case "TAB_AS_INDENT":
+      return readTab(text, error);
+    case "DUPLICATE_KEY":
+      return readDuplicate(text, error, doc);
+    case "MULTIPLE_DOCS":
+      return readMultipleDocuments(text, error);
+    case "BAD_DQ_ESCAPE":
+      return readEscape(text, error);
+    case "BAD_SCALAR_START":
+      return readReservedStart(text, error);
+    case "KEY_OVER_1024_CHARS":
+      return { code: "long-key", start: error.pos[0], end: Math.max(error.pos[0] + 1, Math.min(text.length, error.pos[0] + 60)), message: "This key is longer than 1024 characters.", next: "shorten the key, or check for a missing colon before the end of the line." };
+    case "MULTILINE_IMPLICIT_KEY":
+      return readImplicit(text, error);
+    case "BLOCK_AS_IMPLICIT_KEY":
+      return readColonInValue(text, error);
+    case "UNEXPECTED_TOKEN":
+      return readTrailing(text, error);
+    case "MISSING_CHAR":
+      if (/Missing closing/.test(message)) return readQuote(text, error, scanned) ?? readOther(error);
+      if (/Sequence item without - indicator/.test(message)) return readAlignment(text, error, true);
+      if (/Implicit map keys need to be followed/.test(message)) return readMissingColon(text, error);
+      return readOther(error);
+    case "BAD_INDENT":
+      if (/Flow (sequence|map)/.test(message)) return readFlow(text, error, scanned) ?? readOther(error);
+      if (/same column/.test(message)) return readAlignment(text, error, false);
+      return readOther(error);
+    default:
+      return readOther(error);
+  }
+}
+var CASCADE = /* @__PURE__ */ new Set(["UNEXPECTED_TOKEN", "MISSING_CHAR", "MULTILINE_IMPLICIT_KEY", "BAD_INDENT", "BLOCK_AS_IMPLICIT_KEY"]);
+function describeYamlErrors(text, doc, errors, limit = 5) {
+  if (!errors.length) return [];
+  const scanned = scan(text);
+  const out = [];
+  let lastLine = -10;
+  let lastCode = "";
+  for (const error of errors) {
+    const line = lineNumber(text, error.pos[0]);
+    if (out.length && CASCADE.has(error.code) && CASCADE.has(lastCode) && line - lastLine <= 2 && error.code !== "DUPLICATE_KEY") continue;
+    const reading = readError(text, error, doc, scanned);
+    const next = reading.next;
+    out.push({
+      rule: reading.rule ?? "syntax",
+      code: reading.code,
+      start: reading.start,
+      end: reading.end,
+      message: reading.message,
+      next,
+      help: reading.help ?? sentence(next),
+      fixes: reading.fixes ?? [],
+      ...reading.related ? { related: reading.related } : {}
+    });
+    lastLine = line;
+    lastCode = error.code;
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+var SLIDE_KEYS = /* @__PURE__ */ new Set(["title", "subtitle", "items", "text", "layout", "blocks", "image", "chart", "table", "quote", "code", "metric", "timeline", "notes"]);
+function analyzeYamlSyntax(text, options = {}) {
+  const bom = text.startsWith("\uFEFF") ? 1 : 0;
+  const body = text.slice(bom);
+  const locate = createLocator(text);
+  const range = (start, end) => locate(start + bom, Math.max(0, end - start));
+  const shift = (edit) => ({ ...edit, offset: edit.offset + bom });
+  const doc = parseDocument(body, { schema: "core", uniqueKeys: true, merge: false, prettyErrors: false });
+  const wrap = (problem) => ({
+    ruleId: `yaml/${problem.rule}`,
+    code: problem.code,
+    severity: "error",
+    range: range(problem.start, problem.end),
+    message: problem.message,
+    next: problem.next,
+    fixes: problem.fixes.map((entry) => ({ ...entry, edits: entry.edits.map(shift), ...entry.caret !== void 0 ? { caret: entry.caret + bom } : {} })),
+    ...problem.related ? { related: problem.related.map((entry) => range(entry.start, entry.end)) } : {}
+  });
+  if (doc.errors.length) return describeYamlErrors(body, doc, doc.errors, options.limit ?? 5).map(wrap);
+  const root = doc.contents;
+  if (root === null || !root.range) {
+    const hasText = body.length > 0;
+    const prefix = hasText && !/\n$/.test(body) ? "\n" : "";
+    return [
+      wrap({
+        rule: "empty",
+        code: "empty-document",
+        start: 0,
+        end: Math.min(1, body.length),
+        message: "The document is empty (or everything in it is a comment).",
+        next: "write `slides:` and at least one `- title:` line.",
+        fixes: [fix("insert-minimal-deck", "Insert minimal deck", [{ offset: body.length, length: 0, insert: `${prefix}slides:
+  - title: Title
+` }], { safe: true })]
+      })
+    ];
+  }
+  if ((options.rootKind ?? "mapping") === "mapping" && !isMap(root)) {
+    const list = isSeq(root);
+    const slideLike = list && root.items.length > 0 && root.items.every((item) => isMap(item) && item.items.some((pair) => isScalar(pair.key) && SLIDE_KEYS.has(String(pair.key.value))));
+    const fixes = [];
+    if (slideLike) {
+      const first = lineAt(body, root.range[0]).start;
+      const edits = [{ offset: first, length: 0, insert: "slides:\n" }];
+      for (let cursor = first; cursor < body.length; ) {
+        const line = lineAt(body, cursor);
+        if (body.slice(line.start, line.end).trim() !== "") edits.push({ offset: line.start, length: 0, insert: "  " });
+        const following = nextLineStart(body, line.end);
+        if (following <= cursor) break;
+        cursor = following;
+      }
+      fixes.push(fix("wrap-in-slides", "Wrap as `slides:`", edits));
+    }
+    return [
+      wrap({
+        rule: "not-mapping",
+        code: "not-a-mapping",
+        start: root.range[0],
+        end: Math.max(root.range[0] + 1, root.range[1]),
+        message: `The top level must be ${code("key: value")} lines, but this is ${list ? "a list" : "plain text"}.`,
+        next: slideLike ? "put the list under `slides:`." : "start with `name:` and `slides:` lines.",
+        fixes
+      })
+    ];
+  }
+  return [];
+}
+function splitLines(source) {
+  const lines = [];
+  let start = 0;
+  let no = 1;
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\n" || c === "\r") {
+      lines.push({ text: source.slice(start, i), start, end: i, no: no++ });
+      if (c === "\r" && source[i + 1] === "\n") i++;
+      i++;
+      start = i;
+    } else i++;
+  }
+  if (start < source.length) lines.push({ text: source.slice(start), start, end: source.length, no });
+  return lines;
+}
+var Ctx = class {
+  constructor(source) {
+    this.source = source;
+    for (let i = 0; i < source.length; i++) {
+      if (source[i] === "\r") {
+        if (source[i + 1] === "\n") i++;
+        this.lineStarts.push(i + 1);
+      } else if (source[i] === "\n") this.lineStarts.push(i + 1);
+    }
+  }
+  source;
+  findings = [];
+  /** JSON Pointer in the converted document to the source range that produced it. */
+  ranges = /* @__PURE__ */ new Map();
+  lineStarts = [0];
+  location(range) {
+    let lo = 0;
+    let hi = this.lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((this.lineStarts[mid] ?? 0) <= range.start) lo = mid;
+      else hi = mid;
+    }
+    return { offset: range.start, length: Math.max(0, range.end - range.start), line: lo + 1, column: range.start - (this.lineStarts[lo] ?? 0) + 1 };
+  }
+  report(ruleId, severity, message, help, range, path = "", suggestions) {
+    this.findings.push({
+      ruleId,
+      severity,
+      category: "format",
+      scope: "document",
+      path,
+      message,
+      help,
+      location: this.location(range),
+      ...suggestions?.length ? { suggestions: suggestions.map((value) => ({ value, label: value, origin: "schema" })) } : {}
+    });
+  }
+  /** `suggestions`: values that would fix the finding (a near-miss option name, the chart types), offered by editors as "Change to ...". */
+  error(rule, message, help, range, path = "", suggestions) {
+    this.report(`markdown/${rule}`, "error", message, help, range, path, suggestions);
+  }
+  warn(rule, message, help, range, path = "", suggestions) {
+    this.report(`markdown/${rule}`, "warning", message, help, range, path, suggestions);
+  }
+  get errors() {
+    return this.findings.filter((d) => d.severity === "error").length;
+  }
+  /** The source range of a JSON Pointer, falling back to the nearest ancestor that has one. */
+  rangeOf(pointer) {
+    for (let path = pointer; ; path = path.slice(0, path.lastIndexOf("/"))) {
+      const found = this.ranges.get(path);
+      if (found) return found;
+      if (!path) return void 0;
+    }
+  }
+};
+var lineRange = (first, last = first) => ({ start: first.start, end: last.end });
+function readYamlMapping(text, base, ctx, rule, context) {
+  const keys = /* @__PURE__ */ new Map();
+  const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false, prettyErrors: false });
+  let ok = true;
+  for (const problem of describeYamlErrors(text, doc, doc.errors)) {
+    ok = false;
+    ctx.error(rule, problem.message, problem.help, { start: base + problem.start, end: base + Math.max(problem.end, problem.start) });
+  }
+  if (!ok) return { value: {}, keys, ok };
+  if (doc.contents === null) return { value: {}, keys, ok };
+  if (!(doc.contents instanceof YAMLMap)) {
+    const root = doc.contents;
+    const where = root.range ? { start: base + root.range[0], end: base + Math.max(root.range[0] + 1, root.range[1]) } : context;
+    if (root instanceof Scalar && typeof root.value === "string" && root.range) {
+      const key = text.slice(root.range[0], root.range[1]).trim();
+      ctx.error(`${rule}-not-mapping`, `\`${key.length > 40 ? `${key.slice(0, 39)}\u2026` : key}\` needs a colon and a value.`, `Write \`${key}: \` and a value, one \`key: value\` line each.`, where);
+    } else ctx.error(`${rule}-not-mapping`, "Expected a YAML mapping of keys and values.", "Write `key: value` lines; a list or a bare value is not accepted here.", where);
+    return { value: {}, keys, ok: false };
+  }
+  for (const pair of doc.contents.items) {
+    const key = pair.key;
+    const name = key instanceof Scalar ? String(key.value) : void 0;
+    if (name !== void 0 && key?.range) keys.set(name, { start: base + key.range[0], end: base + (pair.value?.range?.[1] ?? key.range[1]) });
+  }
+  let value;
+  try {
+    value = doc.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    ctx.error(rule, `YAML: ${error.message}`, "Anchors and aliases are not accepted; write each value out.", context);
+    return { value: {}, keys, ok: false };
+  }
+  const bad = nonJson(value);
+  if (bad) {
+    ctx.error(rule, `YAML value is not JSON-compatible (${bad}).`, "Quote special numbers such as .inf or .nan to keep them as strings.", context);
+    return { value: {}, keys, ok: false };
+  }
+  return { value, keys, ok };
+}
+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 (isRecord(value)) return Object.values(value).map(nonJson).find(Boolean);
+  return `a ${typeof value}`;
+}
+function writeYaml(value) {
+  for (const blockQuote of [true, false]) {
+    const text = stringify(value, { indent: 2, lineWidth: 0, minContentWidth: 0, blockQuote, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
+    const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false });
+    if (!doc.errors.length && same(doc.toJS({ maxAliasCount: 0 }), value)) return text.endsWith("\n") ? text : `${text}
+`;
+  }
+  return void 0;
+}
+var DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function scalarText(value) {
+  if (typeof value === "number") return DECIMAL.test(String(value)) ? String(value) : JSON.stringify(String(value));
+  const plain = value !== "" && value === value.trim() && !value.startsWith('"') && !/[\r\n]/.test(value) && !DECIMAL.test(value);
+  return plain ? value : JSON.stringify(value);
+}
+function readCsv(text) {
+  const rows = [];
+  let row = [];
+  let i = 0;
+  const n = text.length;
+  const endRecord = () => {
+    rows.push(row);
+    row = [];
+  };
+  while (i < n) {
+    while (text[i] === " " || text[i] === "	") i++;
+    if (text[i] === '"') {
+      let value = "";
+      i++;
+      for (; ; ) {
+        if (i >= n) return { rows, error: "A quoted field is not closed." };
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += text[i++];
+      }
+      while (text[i] === " " || text[i] === "	") i++;
+      if (i < n && text[i] !== "," && text[i] !== "\n" && text[i] !== "\r") return { rows, error: "Text follows a closing quote." };
+      row.push({ value, quoted: true });
+    } else {
+      let j = i;
+      while (j < n && text[j] !== "," && text[j] !== "\n" && text[j] !== "\r") j++;
+      row.push({ value: text.slice(i, j).trim(), quoted: false });
+      i = j;
+    }
+    if (text[i] === ",") {
+      i++;
+      if (i >= n || text[i] === "\n" || text[i] === "\r") row.push({ value: "", quoted: false });
+      continue;
+    }
+    if (text[i] === "\r" && text[i + 1] === "\n") i++;
+    i++;
+    endRecord();
+  }
+  if (row.length) endRecord();
+  return { rows };
+}
+var needsQuotes = (value) => /[",\r\n]/.test(value) || value !== value.trim() || value === "";
+function csvField(cell, header = false) {
+  if (cell === null) return "";
+  if (typeof cell === "number") return String(cell);
+  if (typeof cell === "boolean") return String(cell);
+  const text = String(cell);
+  const ambiguous = !header && (DECIMAL.test(text) || /^(?:true|false)$/.test(text));
+  return needsQuotes(text) || ambiguous ? `"${text.replaceAll('"', '""')}"` : text;
+}
+var OPFMarkdownError = class extends Error {
+  code;
+  details;
+  constructor(code2, message, details = {}) {
+    super(message);
+    this.name = "OPFMarkdownError";
+    this.code = code2;
+    this.details = details;
+  }
+};
+
+export { Ctx, DECIMAL, OPFMarkdownError, analyzeYamlSyntax, csvField, describeYamlErrors, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };