@openpresentation/opf 0.11.4 → 0.12.1

package/dist/convert.js

@@ -0,0 +1,1107 @@
+import { paginatePresentation, OPFPaginationError } from './chunk-AUM5MXBR.js';
+import { CONTENT_KEYS, isRecord, contentKeysOf, refuse, clone, Loss, isSlideLike, assertValidOwner, report, OPFConversionError, plainOf, assertValidOutput, same, splitRuns, runsOf, lineIsPlain, linePlain, concatText, parseQuoteLines, parseCodeFence, splitWhen, parseListLine, levelsFromIndents, lineValue, joinLines, hasFormatting, fenceCode } from './chunk-V2537ENL.js';
+export { OPFConversionError } from './chunk-V2537ENL.js';
+import './chunk-JKVKYVWL.js';
+import { promotedRegionKeys, visitContentPayloads } from './chunk-HOBSL7AJ.js';
+import './chunk-S5W34SIJ.js';
+import './chunk-E34DJ5LL.js';
+import './chunk-4LAM3N6S.js';
+
+// src/convert/tables.ts
+function cellOf(raw) {
+  if (isRecord(raw) && Object.hasOwn(raw, "value")) {
+    return { value: raw.value, styled: isRecord(raw.style) && Object.keys(raw.style).length > 0, merged: (raw.colSpan ?? 1) > 1 || (raw.rowSpan ?? 1) > 1 };
+  }
+  return { value: raw, styled: false, merged: false };
+}
+function valueText(value) {
+  if (Array.isArray(value)) return value;
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+var valuePlain = (value) => Array.isArray(value) ? plainOf(value) : value === null || value === void 0 ? "" : String(value);
+var valueEmpty = (value) => valuePlain(value).trim() === "";
+function readCells(table, loss, purpose, allowMerged = false) {
+  const rows = table?.rows;
+  if (!Array.isArray(rows) || rows.some((row) => !Array.isArray(row))) throw refuse("This table has no rows to convert.");
+  const all = [...Array.isArray(table.columns) ? [table.columns] : [], ...rows];
+  for (const row of all) {
+    for (const raw of row) {
+      const cell = cellOf(raw);
+      if (cell.merged) {
+        if (!allowMerged) throw refuse(`This table has merged cells, which ${purpose} cannot carry. Split the merged cells first.`);
+        loss.note("merged cells");
+      }
+      if (cell.styled) loss.note("cell styles");
+    }
+  }
+  return { columns: Array.isArray(table.columns) ? table.columns.map((cell) => cellOf(cell).value) : void 0, rows: rows.map((row) => row.map((cell) => cellOf(cell).value)) };
+}
+function listToTable(items, loss) {
+  const entries = items.map((item) => {
+    const object = isRecord(item);
+    if (object && (item.level ?? 0) > 0) loss.note("list nesting levels");
+    const text = object ? item.text : item;
+    return { text: valueText(text), description: object && item.description !== void 0 && plainOf(item.description) !== "" ? valueText(item.description) : void 0 };
+  });
+  if (!entries.length) throw refuse("A table needs at least one row, and this list has no items.");
+  const described = entries.some((entry) => entry.description !== void 0);
+  return { rows: entries.map((entry) => described ? [entry.text, entry.description ?? null] : [entry.text]) };
+}
+function tableToList(table, loss) {
+  const { columns, rows } = readCells(table, loss, "a list");
+  if (!rows.length) throw refuse("A list needs at least one item, and this table has no rows.");
+  if (columns) loss.note("column headings");
+  const width = Math.max(columns?.length ?? 0, ...rows.map((row) => row.length));
+  if (width > 2) loss.note("table columns beyond the second (joined into the description)");
+  return rows.map((row) => {
+    const text = valueText(row[0]);
+    const rest = row.slice(1).filter((value) => !valueEmpty(value));
+    if (!rest.length) return text;
+    let description;
+    if (rest.length === 1) description = valueText(rest[0]);
+    else if (rest.some(Array.isArray)) description = rest.flatMap((value, index) => [...index ? [", "] : [], ...runsOf(valueText(value))]);
+    else description = rest.map(valuePlain).join(", ");
+    return { text, description };
+  });
+}
+function timelineToTable(timeline, options, loss) {
+  const events = Array.isArray(timeline) ? timeline : timeline.events;
+  if (!Array.isArray(timeline)) {
+    if (timeline.name) loss.note("timeline name");
+    if (timeline.description) loss.note("timeline description");
+  }
+  const hasWhen = events.some((event) => event.when);
+  const hasDescription = events.some((event) => event.description);
+  const columns = [...hasWhen ? ["When"] : [], "What", ...hasDescription ? ["Description"] : []];
+  const rows = events.map((event) => [...hasWhen ? [event.when ?? null] : [], event.what, ...hasDescription ? [event.description ?? null] : []]);
+  return { ...options.headings === false ? {} : { columns }, rows };
+}
+var WHEN_HEADINGS = ["when", "date", "dates", "time", "year", "month", "quarter", "period", "deadline", "due", "due date", "start", "timeline"];
+var WHAT_HEADINGS = ["what", "event", "events", "milestone", "milestones", "title", "name", "step", "task", "activity", "initiative", "item", "phase", "stage", "deliverable"];
+var DESCRIPTION_HEADINGS = ["description", "details", "detail", "notes", "note", "summary", "comment", "comments"];
+var heading = (value) => valuePlain(value).trim().toLowerCase().replace(/:$/, "");
+function rolesFrom(columns, names, explicit) {
+  const roles = {};
+  for (const [role, index] of Object.entries(explicit ?? {})) if (index !== void 0) roles[role] = index;
+  if (columns) {
+    columns.forEach((value, index) => {
+      const label = heading(value);
+      for (const [role, list] of Object.entries(names)) if (roles[role] === void 0 && list.includes(label) && !Object.values(roles).includes(index)) roles[role] = index;
+    });
+  }
+  return roles;
+}
+function noteRenamedHeadings(columns, roles, names, loss) {
+  if (!columns) return;
+  for (const [role, index] of Object.entries(roles)) {
+    const label = heading(columns[index]);
+    if (label !== "" && !(names[role] ?? []).includes(label)) loss.note(`column heading "${valuePlain(columns[index])}"`);
+  }
+}
+function tableToTimeline(table, options, loss) {
+  const { columns, rows } = readCells(table, loss, "a timeline");
+  if (!columns && !options.columns) throw refuse('A timeline reads its columns by their headings. Add a heading row that names a "When", a "What" and optionally a "Description" column.');
+  const roles = rolesFrom(columns, { when: WHEN_HEADINGS, what: WHAT_HEADINGS, description: DESCRIPTION_HEADINGS }, options.columns);
+  const width = Math.max(columns?.length ?? 0, ...rows.map((row) => row.length));
+  if (roles.what === void 0) {
+    const free = Array.from({ length: width }, (_, index) => index).filter((index) => !Object.values(roles).includes(index));
+    if (free.length === 1) roles.what = free[0];
+  }
+  if (roles.what === void 0) throw refuse('No column holds the event text. Name one column "What" or "Event" (headings it understands: when, date, what, event, milestone, description, details).');
+  if (!rows.length) throw refuse("A timeline needs at least one event, and this table has no rows.");
+  const used = new Set(Object.values(roles));
+  columns?.forEach((value, index) => {
+    if (!used.has(index) && rows.some((row) => !valueEmpty(row[index]))) loss.note(`column "${valuePlain(value)}"`);
+  });
+  noteRenamedHeadings(columns, roles, { when: WHEN_HEADINGS, what: WHAT_HEADINGS, description: DESCRIPTION_HEADINGS }, loss);
+  const flat = (value) => {
+    if (hasFormatting(value)) loss.note("text formatting");
+    return valuePlain(value);
+  };
+  const events = rows.map((row) => {
+    const event = {};
+    if (roles.when !== void 0 && !valueEmpty(row[roles.when])) event.when = flat(row[roles.when]);
+    event.what = flat(row[roles.what]);
+    if (roles.description !== void 0 && !valueEmpty(row[roles.description])) event.description = flat(row[roles.description]);
+    return event;
+  });
+  return events;
+}
+var COLUMN_LABELS = { label: "Label", value: "Value", unit: "Unit", delta: "Delta", trend: "Trend", description: "Description" };
+var METRIC_HEADINGS = {
+  label: ["label", "metric", "name", "kpi", "measure", "indicator"],
+  value: ["value", "amount", "number", "result", "actual", "current"],
+  unit: ["unit", "units"],
+  delta: ["delta", "change", "growth", "difference", "vs", "vs."],
+  trend: ["trend", "direction"],
+  description: ["description", "details", "detail", "notes", "note", "context"]
+};
+function metricsToTable(blocks, options, loss) {
+  if (!blocks.length) throw refuse("This group has no blocks.");
+  const metrics = blocks.map((block, index) => {
+    const keys = isRecord(block) ? Object.keys(block).filter((key) => key !== "id" && key !== "extensions" && key !== "type") : [];
+    if (keys.length !== 1 || keys[0] !== "metric") throw refuse(`Block ${index + 1} is not a metric. A group converts to a table only when every block in it is a metric.`, { block: index });
+    if (block.id !== void 0 || block.extensions !== void 0) loss.note("block ids and extensions");
+    return isRecord(block.metric) ? block.metric : { value: block.metric };
+  });
+  const present = (field) => field === "value" || metrics.some((metric) => metric[field] !== void 0 && metric[field] !== "");
+  const fields = Object.keys(COLUMN_LABELS).filter(present);
+  return {
+    ...options.headings === false ? {} : { columns: fields.map((field) => COLUMN_LABELS[field]) },
+    rows: metrics.map((metric) => fields.map((field) => metric[field] === void 0 || metric[field] === "" ? null : metric[field]))
+  };
+}
+function tableToMetrics(table, loss) {
+  const { columns, rows } = readCells(table, loss, "a set of metrics");
+  if (!columns) throw refuse('Metrics read their columns by their headings. Add a heading row that names a "Value" column, and optionally "Label", "Unit", "Delta", "Trend" and "Description".');
+  const roles = rolesFrom(columns, METRIC_HEADINGS, void 0);
+  if (roles.value === void 0) throw refuse('No column holds the metric value. Name one column "Value" (headings it understands: value, amount, number, result, label, unit, delta, change, trend, description).');
+  if (!rows.length) throw refuse("A set of metrics needs at least one row, and this table has no rows.");
+  const used = new Set(Object.values(roles));
+  columns.forEach((value, index) => {
+    if (!used.has(index) && rows.some((row) => !valueEmpty(row[index]))) loss.note(`column "${valuePlain(value)}"`);
+  });
+  noteRenamedHeadings(columns, roles, METRIC_HEADINGS, loss);
+  const text = (value) => {
+    if (hasFormatting(value)) loss.note("text formatting");
+    return valuePlain(value);
+  };
+  return rows.map((row, rowIndex) => {
+    const raw = row[roles.value];
+    if (valueEmpty(raw)) throw refuse(`Row ${rowIndex + 1} has no value, so it cannot be a metric.`, { row: rowIndex });
+    const metric = { value: typeof raw === "number" ? raw : text(raw) };
+    if (roles.label !== void 0 && !valueEmpty(row[roles.label])) metric.label = text(row[roles.label]);
+    if (roles.unit !== void 0 && !valueEmpty(row[roles.unit])) metric.unit = text(row[roles.unit]);
+    if (roles.delta !== void 0 && !valueEmpty(row[roles.delta])) metric.delta = typeof row[roles.delta] === "number" ? row[roles.delta] : text(row[roles.delta]);
+    if (roles.trend !== void 0 && !valueEmpty(row[roles.trend])) {
+      const trend = text(row[roles.trend]).trim().toLowerCase();
+      if (trend === "up" || trend === "down" || trend === "flat") metric.trend = trend;
+      else loss.note("trend values other than up, down or flat");
+    }
+    if (roles.description !== void 0 && !valueEmpty(row[roles.description])) metric.description = text(row[roles.description]);
+    return { metric };
+  });
+}
+var escapePipe = (text) => text.replaceAll("\\", "\\\\").replaceAll("|", "\\|");
+var SEPARATOR_ROW = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+function tableToTextLines(table, loss) {
+  const { columns, rows } = readCells(table, loss, "text", true);
+  if (!rows.length && !columns) throw refuse("This table is empty.");
+  const cell = (value) => {
+    if (hasFormatting(value)) loss.note("text formatting");
+    const text = valuePlain(value);
+    if (/[\r\n]/.test(text)) loss.note("line breaks inside cells");
+    return text.replace(/\s*(?:\r\n|\r|\n)\s*/g, " ");
+  };
+  if (columns) {
+    const width = Math.max(columns.length, ...rows.map((row) => row.length));
+    const fill = (row) => Array.from({ length: width }, (_, index) => cell(row[index]));
+    const line = (cells) => `| ${cells.map(escapePipe).join(" | ")} |`;
+    return [line(fill(columns)), line(Array.from({ length: width }, () => "---")), ...rows.map((row) => line(fill(row)))];
+  }
+  return rows.map((row) => {
+    const line = row.map((value) => {
+      const text = cell(value);
+      if (text.includes("	")) throw refuse("A cell contains a tab, which cannot be written to tab-separated text.");
+      return text;
+    }).join("	");
+    if (line.trim() === "" && !line.includes("	")) loss.note("empty rows (a blank line is dropped when the text is read back)");
+    return line;
+  });
+}
+function splitPipes(line) {
+  const cells = [];
+  let current = "";
+  for (let index = 0; index < line.length; index++) {
+    const char = line[index];
+    if (char === "\\" && (line[index + 1] === "|" || line[index + 1] === "\\")) {
+      current += line[index + 1];
+      index++;
+    } else if (char === "|") {
+      cells.push(current);
+      current = "";
+    } else current += char;
+  }
+  cells.push(current);
+  if (cells[0].trim() === "") cells.shift();
+  if (cells.length && cells.at(-1).trim() === "") cells.pop();
+  return cells.map((cell) => cell.trim());
+}
+function textLinesToTable(lines, options) {
+  const separator = options.delimiter ?? "	";
+  const kept = lines.filter((line) => line.trim() !== "" || separator !== "" && line.includes(separator));
+  if (!kept.length) throw refuse("This text is empty.");
+  const rectangular = (rows, header) => {
+    const width = rows[0].length;
+    const bad = rows.findIndex((row) => row.length !== width);
+    if (bad >= 0) throw refuse(`Line ${bad + 1} has ${rows[bad].length} cells but the first line has ${width}. Every line needs the same number of cells.`, { line: bad });
+    if (header && rows.length < 1) throw refuse("A heading row needs at least one line.");
+    return header ? { columns: rows[0], rows: rows.slice(1) } : { rows };
+  };
+  if (!options.delimiter && kept.length >= 2 && SEPARATOR_ROW.test(kept[1]) && kept[0].includes("|")) {
+    const rows = [kept[0], ...kept.slice(2)].map(splitPipes);
+    const result = rectangular(rows, true);
+    if (splitPipes(kept[1]).length !== rows[0].length) throw refuse("The separator row of this Markdown table does not match its heading row.");
+    return result;
+  }
+  const delimiter = options.delimiter ?? "	";
+  if (delimiter.length === 0 || /[\r\n]/.test(delimiter)) throw refuse("Choose a delimiter that is not empty and not a line break.");
+  if (kept.some((line) => !line.includes(delimiter))) throw refuse(`This text has no table structure. A table needs tab-separated lines, a Markdown pipe table, or a delimiter you name${options.delimiter ? ` (every line must contain "${options.delimiter}")` : ""}.`);
+  return rectangular(kept.map((line) => line.split(delimiter)), options.header === true);
+}
+
+// src/convert/content.ts
+var CONTENT_KIND_LABELS = Object.freeze({
+  text: "Text",
+  list: "List",
+  quote: "Quote",
+  metric: "Metric",
+  code: "Code",
+  timeline: "Timeline",
+  chart: "Chart",
+  table: "Table",
+  image: "Image",
+  video: "Video",
+  group: "Group",
+  metrics: "Metric blocks"
+});
+var CONTENT_CONVERSIONS = Object.freeze({
+  text: ["list", "quote", "metric", "code", "timeline", "table"],
+  list: ["text", "timeline", "table"],
+  quote: ["text"],
+  metric: ["text"],
+  code: ["text"],
+  timeline: ["text", "list", "table"],
+  chart: ["table"],
+  table: ["chart", "list", "timeline", "text", "metrics"],
+  group: ["table"]
+});
+var KIND_OF_KEY = { items: "list", bullets: "list", blocks: "group" };
+var TYPE_OF_KIND = { text: "text", list: "list", quote: "quote", metric: "metric", code: "code", timeline: "timeline", chart: "chart", table: "table", metrics: "group" };
+function readContent(payload) {
+  if (!isRecord(payload)) return void 0;
+  if (Array.isArray(payload.blocks)) return contentKeysOf(payload).length ? void 0 : { key: "blocks", kind: "group", content: payload.blocks };
+  const keys = contentKeysOf(payload);
+  if (keys.length !== 1) return void 0;
+  const key = keys[0];
+  return { key, kind: KIND_OF_KEY[key] ?? key, content: payload[key] };
+}
+var MAX_METRIC_VALUE = 24;
+var INDENT = "  ";
+var indentRuns = (runs, level) => level > 0 ? [INDENT.repeat(level), ...runs] : runs;
+function toLines(kind, content, options, loss) {
+  switch (kind) {
+    case "text":
+      return splitRuns(runsOf(content));
+    case "list": {
+      const lines = [];
+      let previous = -1;
+      for (const item of content) {
+        const object = isRecord(item);
+        const level = object ? item.level ?? 0 : 0;
+        if (level > previous + 1) loss.note("list nesting levels (renumbered to follow the previous item)");
+        previous = level;
+        const itemLines = splitRuns(object ? runsOf(item.text) : runsOf(item));
+        for (const line of itemLines) lines.push(indentRuns(line, level));
+        if (object && item.description !== void 0 && plainOf(item.description) !== "") {
+          loss.note("list item descriptions (kept as indented lines)");
+          for (const line of splitRuns(runsOf(item.description))) lines.push(indentRuns(line, level + 1));
+        }
+      }
+      return lines;
+    }
+    case "quote": {
+      const quote = typeof content === "string" ? { text: content } : content;
+      const lines = splitRuns([quote.text]);
+      if (quote.attribution) lines.push([`\u2014 ${quote.attribution}`]);
+      if (quote.source) lines.push([quote.attribution ? `\u2014 ${quote.source}` : quote.source]);
+      return lines;
+    }
+    case "metric": {
+      const metric = isRecord(content) ? content : { value: content };
+      const value = `${metric.value}${metric.unit ? (/^[A-Za-z]/.test(metric.unit) ? " " : "") + metric.unit : ""}`;
+      const lines = [[value]];
+      for (const part of [metric.label, metric.description, metric.delta === void 0 ? void 0 : String(metric.delta)]) if (part !== void 0 && part !== "") lines.push(...splitRuns([part]));
+      if (metric.trend) loss.note("metric trend");
+      return lines;
+    }
+    case "code": {
+      const code = typeof content === "string" ? { source: content } : content;
+      if ((code.language || code.filename) && options.fences !== "never") return fenceCode(code.source, code.language, code.filename).map((line) => [line]);
+      if (code.language) loss.note("code language");
+      if (code.filename) loss.note("code filename");
+      return splitRuns([code.source]);
+    }
+    case "timeline": {
+      const events = Array.isArray(content) ? content : content.events;
+      if (!Array.isArray(content)) {
+        if (content.name) loss.note("timeline name");
+        if (content.description) loss.note("timeline description");
+      }
+      const lines = [];
+      for (const event of events) {
+        lines.push([event.when ? `${event.when}: ${event.what}` : event.what]);
+        if (event.description) for (const line of String(event.description).split(/\r\n|\r|\n/)) lines.push([`${INDENT}${line}`]);
+      }
+      return lines;
+    }
+    default:
+      throw refuse(`${CONTENT_KIND_LABELS[kind] ?? kind} content has no text lines.`, { kind });
+  }
+}
+var isBlank = (line) => linePlain(line).trim() === "";
+function nonBlank(lines, loss) {
+  const kept = lines.filter((line) => !isBlank(line));
+  if (kept.length !== lines.length) loss.note("blank lines");
+  return kept;
+}
+function fromLines(kind, lines, options, loss) {
+  const flat = (line) => {
+    if (!lineIsPlain(line)) loss.note("text formatting");
+    return linePlain(line);
+  };
+  switch (kind) {
+    case "text":
+      return { key: "text", value: joinLines(lines) };
+    case "list": {
+      const kept = nonBlank(lines, loss);
+      const parsed = kept.map(parseListLine);
+      if (parsed.some((entry) => entry.numbered)) loss.note("list numbering");
+      const levels = levelsFromIndents(parsed.map((entry) => entry.indent));
+      return {
+        key: "items",
+        value: parsed.map((entry, index) => {
+          const value = lineValue(entry.line);
+          return levels[index] ? { text: value, level: levels[index] } : value;
+        })
+      };
+    }
+    case "timeline": {
+      const kept = nonBlank(lines, loss);
+      if (!kept.length) throw refuse("A timeline needs at least one event, and this block has no text.", { kind });
+      const events = [];
+      for (const line of kept) {
+        const text = flat(line);
+        if (events.length && /^[ \t]/.test(text)) {
+          const detail = text.trim();
+          events.at(-1).description = events.at(-1).description ? `${events.at(-1).description}
+${detail}` : detail;
+          continue;
+        }
+        const split = splitWhen(text, options.looseWhen);
+        events.push(split ? { when: split.when, what: split.what } : { what: text });
+      }
+      return { key: "timeline", value: events };
+    }
+    case "code": {
+      const plain = lines.map(flat);
+      const fence = parseCodeFence(plain);
+      return { key: "code", value: fence ? { source: fence.source, ...fence.language ? { language: fence.language } : {}, ...fence.filename ? { filename: fence.filename } : {} } : { source: plain.join("\n") } };
+    }
+    case "quote": {
+      const plain = lines.map(flat);
+      const parsed = parseQuoteLines(plain);
+      let body = parsed.text;
+      while (body.length > 1 && body.at(-1).trim() === "" && parsed.attribution !== void 0) {
+        body = body.slice(0, -1);
+        loss.note("blank lines");
+      }
+      return { key: "quote", value: { text: body.join("\n"), ...parsed.attribution !== void 0 ? { attribution: parsed.attribution } : {}, ...parsed.source !== void 0 ? { source: parsed.source } : {} } };
+    }
+    case "metric": {
+      const kept = nonBlank(lines, loss);
+      if (!kept.length) throw refuse("A metric needs a value, and this block has no text.", { kind });
+      const first = flat(kept[0]).trim();
+      if (first.length > MAX_METRIC_VALUE) throw refuse(`The first line is longer than ${MAX_METRIC_VALUE} characters, which is too long to be a metric value. Shorten it or keep this block as text.`, { kind });
+      const metric = { value: /^-?(0|[1-9]\d*)(\.\d+)?$/.test(first) && String(Number(first)) === first ? Number(first) : first };
+      if (kept[1]) metric.label = flat(kept[1]);
+      if (kept.length > 2) metric.description = kept.slice(2).map(flat).join("\n");
+      return { key: "metric", value: metric };
+    }
+    default:
+      throw refuse(`Cannot convert text into ${CONTENT_KIND_LABELS[kind]?.toLowerCase() ?? kind}.`, { kind });
+  }
+}
+function listToTimeline(items, options, loss) {
+  if (!items.length) throw refuse("A timeline needs at least one event, and this list has no items.");
+  const events = items.map((item) => {
+    const object = isRecord(item);
+    if (object && (item.level ?? 0) > 0) loss.note("list nesting levels");
+    const text = object ? item.text : item;
+    if (hasFormatting(text) || object && hasFormatting(item.description)) loss.note("text formatting");
+    const plain = plainOf(text);
+    const split = splitWhen(plain, options.looseWhen);
+    const event = split ? { when: split.when, what: split.what } : { what: plain };
+    if (object && item.description !== void 0 && plainOf(item.description) !== "") event.description = plainOf(item.description);
+    return event;
+  });
+  return { key: "timeline", value: events };
+}
+function timelineToList(timeline, loss) {
+  const events = Array.isArray(timeline) ? timeline : timeline.events;
+  if (!Array.isArray(timeline)) {
+    if (timeline.name) loss.note("timeline name");
+    if (timeline.description) loss.note("timeline description");
+  }
+  return {
+    key: "items",
+    value: events.map((event) => {
+      const text = event.when ? `${event.when}: ${event.what}` : event.what;
+      return event.description ? { text, description: event.description } : text;
+    })
+  };
+}
+function chartToTable(chart, loss) {
+  const data = chart?.data;
+  if (!data || !Array.isArray(data.columns) || !Array.isArray(data.rows)) throw refuse("This chart reads external data. Only a chart with inline columns and rows converts to a table.");
+  if (chart.type) loss.note("chart type");
+  return { key: "table", value: { columns: clone(data.columns), rows: clone(data.rows) } };
+}
+function tableToChart(table) {
+  const { columns, rows } = table ?? {};
+  if (!Array.isArray(columns) || !columns.length || columns.some((label) => typeof label !== "string" || label === "")) throw refuse("A chart needs a plain text label for every column. Add column labels to the table first.");
+  const body = rows.map((row, rowIndex) => {
+    if (row.length !== columns.length) throw refuse(`Row ${rowIndex + 1} does not have ${columns.length} cells.`, { row: rowIndex });
+    return row.map((cell, columnIndex) => {
+      if (cell !== null && typeof cell === "object") throw refuse("This table has styled, merged or formatted cells. Chart data is plain values; clear them first.", { row: rowIndex, column: columnIndex });
+      if (columnIndex === 0) return cell;
+      if (cell === null || cell === "") return null;
+      if (typeof cell === "number") return cell;
+      if (typeof cell === "string" && cell.trim() !== "" && Number.isFinite(Number(cell)) && String(Number(cell)) === cell.trim()) return Number(cell);
+      throw refuse(`Row ${rowIndex + 1}, column ${columnIndex + 1} ("${String(cell)}") is not a number, so it cannot be a chart value.`, { row: rowIndex, column: columnIndex });
+    });
+  });
+  if (!body.length) throw refuse("A chart needs at least one row.");
+  return { key: "chart", value: { type: "column", data: { columns: [...columns], rows: body } } };
+}
+function convertField(from, to, content, options, loss) {
+  if (from === "chart") return chartToTable(content, loss);
+  if (from === "group") return { key: "table", value: metricsToTable(content, options, loss) };
+  if (from === "table") {
+    switch (to) {
+      case "chart":
+        return tableToChart(content);
+      case "list":
+        return { key: "items", value: tableToList(content, loss) };
+      case "timeline":
+        return { key: "timeline", value: tableToTimeline(content, options, loss) };
+      case "text":
+        return fromLines("text", tableToTextLines(content, loss).map((line) => [line]), options, loss);
+      case "metrics":
+        return { key: "blocks", value: tableToMetrics(content, loss) };
+    }
+  }
+  if (from === "list" && to === "table") return { key: "table", value: listToTable(content, loss) };
+  if (from === "list" && to === "timeline") return listToTimeline(content, options, loss);
+  if (from === "timeline" && to === "table") return { key: "table", value: timelineToTable(content, options, loss) };
+  if (from === "timeline" && to === "list") return timelineToList(content, loss);
+  if (from === "text" && to === "table") {
+    const lines = splitRuns(runsOf(content));
+    const plain = lines.map((line) => {
+      if (!lineIsPlain(line)) loss.note("text formatting");
+      return linePlain(line);
+    });
+    return { key: "table", value: textLinesToTable(plain, options) };
+  }
+  return fromLines(to, toLines(from, content, options, loss), options, loss);
+}
+function convertContent(payload, to, options = {}) {
+  const info = readContent(payload);
+  if (!info) throw refuse("Choose a payload that holds one text, list, quote, metric, code, timeline, chart or table, or a group of metric blocks.");
+  const owner = payload;
+  if (info.kind === to) return { payload: clone(owner), from: info.kind, to, key: info.key, changed: false, lossless: true, loss: [] };
+  const targets = CONTENT_CONVERSIONS[info.kind] ?? [];
+  if (!targets.includes(to)) {
+    const label = CONTENT_KIND_LABELS[info.kind] ?? info.kind;
+    throw refuse(`${label} content cannot be converted to ${CONTENT_KIND_LABELS[to]?.toLowerCase() ?? to}. ${targets.length ? `It converts to: ${targets.map((target) => CONTENT_KIND_LABELS[target].toLowerCase()).join(", ")}.` : "It has no text to convert."}`, { from: info.kind, to });
+  }
+  const loss = new Loss();
+  const { key, value } = convertField(info.kind, to, info.content, options, loss);
+  const out = {};
+  for (const [name, entry] of Object.entries(owner)) {
+    if (CONTENT_KEYS.includes(name) || name === "type" || name === "blocks") continue;
+    if (name === "composition" && info.kind === "group" && !isSlideLike(owner)) {
+      loss.note("group arrangement (composition)");
+      continue;
+    }
+    out[name] = clone(entry);
+  }
+  if (owner.type !== void 0) out.type = TYPE_OF_KIND[to] ?? to;
+  out[key] = value;
+  assertValidOwner(out);
+  return { payload: out, from: info.kind, to, key, changed: true, ...report(loss.list) };
+}
+function contentConversionTargets(payload, options = {}) {
+  const info = readContent(payload);
+  if (!info) return [];
+  if (info.kind === "group" && !info.content.every((block) => isRecord(block) && block.metric !== void 0 && Object.keys(block).every((key) => key === "metric" || key === "id" || key === "extensions" || key === "type"))) return [];
+  return (CONTENT_CONVERSIONS[info.kind] ?? []).map((kind) => {
+    const label = CONTENT_KIND_LABELS[kind];
+    try {
+      const result = convertContent(payload, kind, options);
+      return { kind, label, available: true, lossless: result.lossless, loss: result.loss };
+    } catch (error) {
+      if (!(error instanceof OPFConversionError)) throw error;
+      return { kind, label, available: false, lossless: false, loss: [], reason: error.message };
+    }
+  });
+}
+
+// src/convert/list.ts
+var listKey = (payload) => {
+  const keys = ["items", "bullets"].filter((key) => Array.isArray(payload?.[key]));
+  if (!isRecord(payload) || keys.length !== 1) throw refuse("Choose a payload that holds one list (items or bullets).");
+  return keys[0];
+};
+var levelOf = (item) => isRecord(item) ? item.level ?? 0 : 0;
+function withLevel(item, level) {
+  if (!isRecord(item)) return level > 0 ? { text: item, level } : item;
+  const next = { ...item };
+  if (level > 0) next.level = level;
+  else delete next.level;
+  return Object.keys(next).length === 1 && next.text !== void 0 ? next.text : next;
+}
+function shiftListLevels(payload, indices, delta, options = {}) {
+  const key = listKey(payload);
+  const items = payload[key];
+  if (!Number.isInteger(delta) || delta === 0) throw refuse("Choose a level change of one or more steps in or out.");
+  const selected = [...new Set(indices)].sort((a, b) => a - b);
+  if (!selected.length || selected.some((index) => !Number.isInteger(index) || index < 0 || index >= items.length)) throw refuse("Choose items that exist in the list.", { indices });
+  const original = items.map(levelOf);
+  const levels = [...original];
+  const moved = /* @__PURE__ */ new Set();
+  const withChildren = options.withChildren !== false;
+  for (const index of selected) {
+    if (moved.has(index)) continue;
+    const previous = index > 0 ? levels[index - 1] : -1;
+    const wanted = Math.max(0, original[index] + delta);
+    const level = Math.min(wanted, previous + 1);
+    const applied = level - levels[index];
+    moved.add(index);
+    if (applied === 0) continue;
+    levels[index] = level;
+    if (withChildren) {
+      for (let next2 = index + 1; next2 < items.length && original[next2] > original[index]; next2++) {
+        levels[next2] = Math.max(0, levels[next2] + applied);
+        moved.add(next2);
+      }
+    }
+  }
+  const changed = levels.some((level, index) => level !== original[index]);
+  if (!changed) {
+    const reason = delta > 0 ? selected[0] === 0 ? "The first item cannot be nested under another item." : "An item can be nested only one level below the item above it." : "These items are already at the top level.";
+    return { payload: clone(payload), changed: false, reason, levels, ...report([]) };
+  }
+  const next = clone(payload);
+  next[key] = items.map((item, index) => levels[index] === original[index] ? clone(item) : withLevel(clone(item), levels[index]));
+  assertValidOwner(next);
+  return { payload: next, changed: true, levels, ...report([]) };
+}
+var demoteListItems = (payload, indices, options) => shiftListLevels(payload, indices, 1, options);
+var promoteListItems = (payload, indices, options) => shiftListLevels(payload, indices, -1, options);
+function convertListForm(payload, to) {
+  const key = listKey(payload);
+  if (key === to) return { payload: clone(payload), changed: false, ...report([]) };
+  const loss = new Loss();
+  const items = payload[key].map((item) => {
+    if (to === "bullets" && isRecord(item) && item.description !== void 0 && plainOf(item.description) !== "") {
+      loss.note("list item descriptions");
+      const { description: _dropped, ...rest } = item;
+      return clone(withLevel(rest, rest.level ?? 0));
+    }
+    return clone(item);
+  });
+  const next = {};
+  for (const [name, value] of Object.entries(payload)) {
+    if (name === key) next[to] = items;
+    else next[name] = clone(value);
+  }
+  if (payload.type === "text" || payload.type === "list") next.type = to === "bullets" ? "text" : "list";
+  assertValidOwner(next);
+  return { payload: next, changed: true, ...report(loss.list) };
+}
+
+// src/convert/structure.ts
+var REGION_KEYS = new Set(promotedRegionKeys);
+var isRegionKey = (key) => REGION_KEYS.has(key);
+var regionKeysOf = (slide) => Object.keys(slide).filter(isRegionKey);
+function at(slide, path) {
+  let value = slide;
+  for (const part of path) value = value?.[part];
+  return value;
+}
+function explicitBlocks(owner) {
+  if (Array.isArray(owner.blocks)) return owner.blocks;
+  const keys = contentKeysOf(owner);
+  const blocks = keys.map((key) => ({ ...keys.length === 1 && owner.type ? { type: owner.type } : {}, [key]: owner[key] }));
+  for (const key of [...CONTENT_KEYS, "type"]) delete owner[key];
+  owner.blocks = blocks;
+  return blocks;
+}
+function ownerAt(slide, path, what) {
+  const owner = path.length ? at(slide, path) : slide;
+  if (!isRecord(owner)) throw refuse(`There is no ${what} at that location.`, { path });
+  return owner;
+}
+var finish = (slide, loss, path) => {
+  assertValidOutput(slide, "slide");
+  return { slide, changed: true, ...path ? { path } : {}, ...report(loss.list) };
+};
+function wrapBlocks(slide, indices, options = {}) {
+  const next = clone(slide);
+  const container = options.container ?? [];
+  const owner = ownerAt(next, container, "container");
+  if (!Array.isArray(owner.blocks) && container.length && contentKeysOf(owner).length < 2) throw refuse("This content is a single payload, not a list of blocks. There is nothing to group it with.");
+  const blocks = explicitBlocks(owner);
+  const selected = [...new Set(indices)].sort((a, b) => a - b);
+  if (!selected.length || selected.some((index) => !Number.isInteger(index) || index < 0 || index >= blocks.length)) throw refuse("Choose blocks that exist in this container.", { indices });
+  const group = { blocks: selected.map((index) => blocks[index]), ...options.composition ? { composition: clone(options.composition) } : {} };
+  const first = selected[0];
+  const rest = new Set(selected.slice(1));
+  owner.blocks = blocks.flatMap((block, index) => index === first ? [group] : rest.has(index) ? [] : [block]);
+  return finish(next, new Loss(), [...container, "blocks", first]);
+}
+function unwrapGroup(slide, path) {
+  const next = clone(slide);
+  const group = at(next, path);
+  if (!isRecord(group) || !Array.isArray(group.blocks)) throw refuse("Choose a group to unwrap.", { path });
+  const index = path.at(-1);
+  if (path.length < 2 || path.at(-2) !== "blocks" || typeof index !== "number") throw refuse("Only a group that sits inside a list of blocks can be unwrapped. Convert the regions to blocks first.", { path });
+  const parent = at(next, path.slice(0, -2));
+  const loss = new Loss();
+  if (group.composition) loss.note("group arrangement (composition)");
+  if (group.id !== void 0) loss.note("group id");
+  if (group.extensions !== void 0) loss.note("group extensions");
+  parent.blocks.splice(index, 1, ...group.blocks);
+  return finish(next, loss, [...path.slice(0, -1), index]);
+}
+var ROWS = ["top", "middle", "bottom"];
+var COLUMNS = ["left", "center", "right"];
+function cellsOf(key) {
+  const [first = "", second] = key.split(":");
+  const parts = (text) => text.split("+");
+  let rows = ROWS;
+  let columns = COLUMNS;
+  if (second !== void 0) {
+    rows = parts(first);
+    columns = parts(second);
+  } else if (ROWS.includes(parts(first)[0])) rows = parts(first);
+  else columns = parts(first);
+  return new Set(rows.flatMap((row) => columns.map((column) => `${row}:${column}`)));
+}
+var overlaps = (a, b) => {
+  const other = cellsOf(b);
+  return [...cellsOf(a)].some((cell) => other.has(cell));
+};
+function sortRegionKeys(keys) {
+  const rank = (key) => {
+    const cells = [...cellsOf(key)].map((cell) => cell.split(":"));
+    return [Math.min(...cells.map(([row]) => ROWS.indexOf(row))), Math.min(...cells.map(([, column]) => COLUMNS.indexOf(column)))];
+  };
+  return [...keys].sort((a, b) => {
+    const [ar, ac] = rank(a);
+    const [br, bc] = rank(b);
+    return ar - br || ac - bc || keys.indexOf(a) - keys.indexOf(b);
+  });
+}
+function blocksToRegions(slide, regions) {
+  const next = clone(slide);
+  if (regionKeysOf(next).length) throw refuse("This slide already uses named regions.");
+  const blocks = explicitBlocks(next);
+  if (!blocks.length) throw refuse("This slide has no blocks to place.");
+  if (regions.length !== blocks.length) throw refuse(`Name a region for each of the ${blocks.length} blocks.`, { blocks: blocks.length, regions: regions.length });
+  regions.forEach((key, index) => {
+    if (!isRegionKey(key)) throw refuse(`"${key}" is not a region (for example left, right, top:left, center+right).`, { region: key });
+    const clash = regions.findIndex((other, otherIndex) => otherIndex < index && overlaps(other, key));
+    if (clash >= 0) throw refuse(`Region "${key}" overlaps region "${regions[clash]}". Each block needs its own part of the slide.`, { region: key });
+  });
+  delete next.blocks;
+  regions.forEach((key, index) => {
+    next[key] = blocks[index];
+  });
+  return finish(next, new Loss(), [regions[0]]);
+}
+function regionsToBlocks(slide) {
+  const next = clone(slide);
+  const keys = sortRegionKeys(regionKeysOf(next));
+  if (!keys.length) throw refuse("This slide has no named regions.");
+  const blocks = keys.map((key) => next[key]);
+  for (const key of keys) delete next[key];
+  next.blocks = blocks;
+  const loss = new Loss();
+  loss.note("region placement");
+  return finish(next, loss, ["blocks", 0]);
+}
+function moveRegion(slide, from, to, options = {}) {
+  const next = clone(slide);
+  if (!isRegionKey(from) || next[from] === void 0) throw refuse(`This slide has no "${from}" region.`, { region: from });
+  if (!isRegionKey(to)) throw refuse(`"${to}" is not a region (for example left, right, top:left, center+right).`, { region: to });
+  if (from === to) return { slide: next, changed: false, path: [from], ...report([]) };
+  const occupied = next[to] !== void 0;
+  if (occupied && !options.swap) throw refuse(`The "${to}" region already has content. Choose to swap the two regions instead.`, { region: to });
+  const others = regionKeysOf(next).filter((key) => key !== from && key !== (options.swap ? to : void 0));
+  const clash = others.find((key) => overlaps(key, to) && key !== to);
+  if (clash) throw refuse(`Region "${to}" overlaps region "${clash}".`, { region: to });
+  const entries = Object.entries(next).map(([key, value]) => key === from ? [to, value] : options.swap && key === to ? [from, value] : [key, value]);
+  const rebuilt = Object.fromEntries(entries);
+  if (!occupied) rebuilt[to] = next[from];
+  return finish(rebuilt, new Loss(), [to]);
+}
+var IMAGE_POSITIONS = ["background", "top", "bottom", "left", "right"];
+function imageAsset(payload) {
+  if (!isRecord(payload)) throw refuse("Choose an image block.");
+  const keys = Object.keys(payload).filter((key) => key !== "id" && key !== "extensions" && key !== "type");
+  if (keys.length !== 1 || keys[0] !== "image") throw refuse("Choose a block that holds only an image.");
+  return isRecord(payload.image) ? payload.image : { src: payload.image };
+}
+function removePayload(slide, path) {
+  if (!path.length) {
+    for (const key of [...CONTENT_KEYS, "type"]) delete slide[key];
+    return;
+  }
+  const index = path.at(-1);
+  if (typeof index === "number" && path.at(-2) === "blocks") {
+    const owner = at(slide, path.slice(0, -2));
+    owner.blocks.splice(index, 1);
+    if (owner.blocks.length) return;
+    if (path.length === 2) delete slide.blocks;
+    else removePayload(slide, path.slice(0, -2));
+    return;
+  }
+  if (path.length === 1 && isRegionKey(String(path[0]))) {
+    delete slide[path[0]];
+    return;
+  }
+  throw refuse("Choose an image block of this slide.", { path });
+}
+function promoteImage(slide, path, to, options = {}) {
+  const next = clone(slide);
+  const holder = path.length ? at(next, path) : contentKeysOf(next).join() === "image" && !Array.isArray(next.blocks) ? { image: next.image } : void 0;
+  const asset = imageAsset(holder);
+  if (typeof asset.src !== "string" || asset.src === "") throw refuse("This image has no source.");
+  const design = isRecord(next.design) ? next.design : {};
+  if (design[to] !== void 0 && design[to] !== false && !options.replace) throw refuse(`This slide already sets its ${to === "slideImage" ? "slide image" : to}. Choose to replace it, or remove it first.`, { slot: to });
+  const loss = new Loss();
+  const extras = ["title", "description", "mediaType", "format"].filter((key) => asset[key] !== void 0);
+  const position = options.position ?? "right";
+  if (!IMAGE_POSITIONS.includes(position)) throw refuse(`Choose a position: ${IMAGE_POSITIONS.join(", ")}.`, { position });
+  const alt = typeof asset.alt === "string" && asset.alt !== "" ? asset.alt : void 0;
+  if (to === "slideImage") {
+    design.slideImage = { src: asset.src, position, ...alt ? { alt } : {} };
+    if (extras.length) loss.note(`image ${extras.join(", ")}`);
+  } else if (to === "background") {
+    design.background = { type: "image", image: { src: asset.src, fit: "cover" } };
+    if (alt) loss.note("image alt text");
+    if (extras.length) loss.note(`image ${extras.join(", ")}`);
+  } else {
+    const opacity = options.opacity ?? 0.1;
+    if (typeof opacity !== "number" || !(opacity >= 0 && opacity <= 1)) throw refuse("Watermark opacity must be between 0 and 1.", { opacity });
+    design.watermark = { src: asset.src, opacity };
+    if (alt) loss.note("image alt text");
+    if (extras.length) loss.note(`image ${extras.join(", ")}`);
+  }
+  if (path.length) {
+    const payload = at(next, path);
+    if (payload.id !== void 0) loss.note("block id");
+    if (payload.extensions !== void 0) loss.note("block extensions");
+  }
+  next.design = design;
+  removePayload(next, path);
+  return finish(next, loss);
+}
+function demoteImage(slide, from, options = {}) {
+  const next = clone(slide);
+  const design = next.design;
+  const value = isRecord(design) ? design[from] : void 0;
+  if (value === void 0 || value === false) throw refuse(`This slide does not set its own ${from === "slideImage" ? "slide image" : from}.`, { slot: from });
+  const loss = new Loss();
+  let asset;
+  if (from === "slideImage") {
+    if (typeof value === "string") asset = { src: value };
+    else if (isRecord(value) && "position" in value) {
+      if (typeof value.src !== "string") throw refuse("This slide image only configures placement; it has no image of its own.");
+      asset = { src: value.src, ...value.alt ? { alt: value.alt } : {} };
+      loss.note("image position and framing");
+    } else asset = clone(value);
+  } else if (from === "background") {
+    if (!isRecord(value) || value.type !== "image" || typeof value.image?.src !== "string") throw refuse("This slide's background is not an image.");
+    asset = { src: value.image.src };
+    if (value.opacity !== void 0 || value.image.fit !== void 0 && value.image.fit !== "cover") loss.note("background fit and opacity");
+  } else {
+    if (typeof value === "string") asset = { src: value };
+    else if (isRecord(value) && typeof value.src === "string") {
+      const { opacity, ...rest } = value;
+      asset = rest;
+      if (opacity !== void 0) loss.note("watermark opacity");
+    } else throw refuse("This watermark has no image of its own.");
+  }
+  const block = { image: Object.keys(asset).length === 1 ? asset.src : asset };
+  delete design[from];
+  if (!Object.keys(design).length) delete next.design;
+  const regions = regionKeysOf(next);
+  let path;
+  if (regions.length) {
+    if (!options.region || !isRegionKey(options.region) || regions.some((key) => overlaps(key, options.region))) throw refuse("This slide places its content in regions. Choose a free region for the image.", { region: options.region });
+    next[options.region] = block;
+    path = [options.region];
+  } else if (Array.isArray(next.blocks) || contentKeysOf(next).length) {
+    const blocks = explicitBlocks(next);
+    const index = options.index ?? blocks.length;
+    if (!Number.isInteger(index) || index < 0 || index > blocks.length) throw refuse("The position is outside the slide's blocks.", { index });
+    blocks.splice(index, 0, block);
+    path = ["blocks", index];
+  } else {
+    next.image = block.image;
+    path = [];
+  }
+  return finish(next, loss, path);
+}
+
+// src/convert/slides.ts
+var HEADINGS = ["title", "subtitle", "tag"];
+var BODY_KEYS = /* @__PURE__ */ new Set([...CONTENT_KEYS, "type", "blocks"]);
+function slideAt(presentation, index) {
+  const slides = presentation?.slides;
+  if (!Array.isArray(slides) || !Number.isInteger(index) || index < 0 || index >= slides.length) throw refuse("Choose a slide that exists.", { slideIndex: index });
+  return slides[index];
+}
+var slideIds = (slide) => {
+  const ids = typeof slide.id === "string" ? [slide.id] : [];
+  visitContentPayloads(slide, "", (payload) => {
+    if (typeof payload.id === "string") ids.push(payload.id);
+  });
+  return ids;
+};
+var documentIds = (presentation) => new Set(presentation.slides.flatMap(slideIds));
+function replaceSlides(presentation, start, deleteCount, slides) {
+  const next = clone(presentation);
+  next.slides.splice(start, deleteCount, ...clone(slides));
+  return next;
+}
+function splittableBlocks(slide, loss) {
+  const regions = sortRegionKeys(regionKeysOf(slide));
+  if (regions.length) {
+    loss.note("region placement");
+    return regions.map((key) => slide[key]);
+  }
+  if (Array.isArray(slide.blocks)) return slide.blocks;
+  const keys = contentKeysOf(slide);
+  return keys.map((key) => ({ ...keys.length === 1 && slide.type ? { type: slide.type } : {}, [key]: slide[key] }));
+}
+function splitSlide(presentation, slideIndex, options = {}) {
+  const source = slideAt(presentation, slideIndex);
+  const loss = new Loss();
+  const blocks = splittableBlocks(clone(source), loss);
+  if (blocks.length < 2) throw refuse("This slide has one block, so there is nothing to split. Add or move content first, or split it where it overflows.");
+  let starts;
+  if (options.each) starts = blocks.map((_, index) => index).slice(1);
+  else {
+    starts = [...new Set(options.at ?? [])].sort((a, b) => a - b);
+    if (!starts.length) throw refuse("Choose where to split: block indexes at which a new slide starts, or one block per slide.");
+    if (starts.some((index) => !Number.isInteger(index) || index < 1 || index >= blocks.length)) throw refuse(`Choose split points between blocks 1 and ${blocks.length - 1}.`, { at: options.at });
+  }
+  const bounds = [0, ...starts, blocks.length];
+  const base = {};
+  for (const [key, value] of Object.entries(source)) if (!BODY_KEYS.has(key) && !isRegionKey(key)) base[key] = clone(value);
+  const taken = documentIds(presentation);
+  const slides = bounds.slice(0, -1).map((from, part) => {
+    const slide = {};
+    for (const [key, value] of Object.entries(base)) {
+      if (part > 0 && (key === "notes" || options.repeatHeadings === false && HEADINGS.includes(key))) continue;
+      if (part > 0 && key === "id") continue;
+      slide[key] = clone(value);
+    }
+    if (part > 0 && typeof base.id === "string") {
+      let suffix = part + 1;
+      while (taken.has(`${base.id}--${suffix}`)) suffix++;
+      slide.id = `${base.id}--${suffix}`;
+      taken.add(slide.id);
+    }
+    slide.blocks = clone(blocks.slice(from, bounds[part + 1]));
+    return slide;
+  });
+  assertValidOutput(slides, "slides");
+  return { presentation: replaceSlides(presentation, slideIndex, 1, slides), slides, range: { start: slideIndex, deleteCount: 1 }, changed: true, ...report(loss.list) };
+}
+var remapPath = (path, from, to) => path.replace(new RegExp(`^slides\\.${from}(?=\\.|$)`), `slides.${to}`);
+function splitSlideOnOverflow(presentation, slideIndex, options = {}) {
+  const source = slideAt(presentation, slideIndex);
+  const whole = presentation;
+  let result;
+  try {
+    result = paginatePresentation({ ...clone(whole), slides: [clone(source)] }, options);
+  } catch (error) {
+    if (error instanceof OPFPaginationError) throw refuse(error.message, { diagnostics: error.diagnostics });
+    throw error;
+  }
+  const paginated = result.presentation.slides;
+  if (paginated.length === 1) {
+    return { presentation: clone(whole), slides: [clone(source)], range: { start: slideIndex, deleteCount: 1 }, changed: false, pages: [], ...report([]) };
+  }
+  const others = new Set(whole.slides.flatMap((slide, index) => index === slideIndex ? [] : slideIds(slide)));
+  const used = new Set(others);
+  const rename = (node) => {
+    if (typeof node.id !== "string") return;
+    let id = node.id;
+    for (let suffix = 2; used.has(id); suffix++) id = `${node.id}-${suffix}`;
+    node.id = id;
+    used.add(id);
+  };
+  for (const slide of paginated) {
+    rename(slide);
+    visitContentPayloads(slide, "", (payload) => rename(payload));
+  }
+  const pages = result.pages.map((page) => ({
+    ...page,
+    sourceSlideIndex: slideIndex,
+    slideIndex: slideIndex + page.slideIndex,
+    mappings: page.mappings.map((mapping) => ({ ...mapping, sourcePath: remapPath(mapping.sourcePath, 0, slideIndex), outputPath: remapPath(mapping.outputPath, 0, slideIndex + page.slideIndex) })),
+    ...page.repeatedMappings ? { repeatedMappings: page.repeatedMappings.map((mapping) => ({ ...mapping, sourcePath: remapPath(mapping.sourcePath, 0, slideIndex), outputPath: remapPath(mapping.outputPath, 0, slideIndex + page.slideIndex) })) } : {}
+  }));
+  assertValidOutput(paginated, "slides");
+  return { presentation: replaceSlides(whole, slideIndex, 1, paginated), slides: paginated, range: { start: slideIndex, deleteCount: 1 }, changed: true, pages, ...report([]) };
+}
+function mergeSlides(presentation, start, count = 2) {
+  if (!Number.isInteger(count) || count < 2) throw refuse("Choose at least two slides to merge.");
+  const slides = [];
+  for (let offset = 0; offset < count; offset++) {
+    if (!isRecord(presentation?.slides?.[start + offset])) throw refuse("Choose consecutive slides that exist.", { start, count });
+    slides.push(clone(slideAt(presentation, start + offset)));
+  }
+  const loss = new Loss();
+  if (slides.some((slide) => regionKeysOf(slide).length)) throw refuse("Slides that place content in named regions cannot be merged. Convert the regions to blocks first.");
+  const [first, ...others] = slides;
+  const merged = {};
+  for (const [key, value] of Object.entries(first)) if (!BODY_KEYS.has(key) && key !== "notes") merged[key] = value;
+  others.forEach((slide, index) => {
+    const number = start + index + 2;
+    for (const [key, value] of Object.entries(slide)) {
+      if (BODY_KEYS.has(key) || key === "notes") continue;
+      if (key === "id") loss.note(`slide id "${String(value)}"`);
+      else if (!same(first[key], value)) loss.note(`${key} of slide ${number}`);
+    }
+  });
+  const blocks = slides.flatMap((slide) => splittableBlocks(slide, loss));
+  if (blocks.length) merged.blocks = blocks;
+  const notes = slides.map((slide) => slide.notes).filter((note) => typeof note === "string" && note !== "");
+  if (notes.length) merged.notes = notes.join("\n\n");
+  assertValidOutput(merged, "slide");
+  return { presentation: replaceSlides(presentation, start, count, [merged]), slides: [merged], range: { start, deleteCount: count }, changed: true, ...report(loss.list) };
+}
+var segments = (path) => path.split(".");
+var valueAt = (root, path) => path.reduce((value, part) => value?.[part], root);
+function joinSlices(field, slices) {
+  const [first] = slices;
+  if (slices.length === 1) return clone(first);
+  switch (field) {
+    case "text":
+      return slices.slice(1).reduce((joined, slice) => concatText(joined, slice), clone(first));
+    case "items":
+    case "bullets":
+      return slices.flatMap((slice) => clone(slice));
+    case "code":
+    case "quote": {
+      const key = field === "code" ? "source" : "text";
+      const text = slices.map((slice) => typeof slice === "string" ? slice : slice[key]).join("");
+      return typeof first === "string" ? text : { ...clone(first), [key]: text };
+    }
+    case "table":
+      return { ...clone(first), rows: slices.flatMap((slice) => clone(slice.rows)) };
+    case "timeline":
+      return Array.isArray(first) ? slices.flatMap((slice) => clone(slice)) : { ...clone(first), events: slices.flatMap((slice) => clone(slice.events)) };
+    default:
+      return clone(first);
+  }
+}
+function unpaginate(presentation, pages, options = {}) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    if (options.sourceSlideIndex !== void 0 && page.sourceSlideIndex !== options.sourceSlideIndex) continue;
+    groups.set(page.sourceSlideIndex, [...groups.get(page.sourceSlideIndex) ?? [], page]);
+  }
+  const todo = [...groups.values()].filter((group) => group.length > 1);
+  if (!todo.length) throw refuse("Those slides were not split by pagination, or only one page was kept.");
+  let current = clone(presentation);
+  let first = Number.POSITIVE_INFINITY;
+  let end = 0;
+  let removed = 0;
+  for (const group of todo.sort((a, b) => b[0].slideIndex - a[0].slideIndex)) {
+    const indexes = group.map((page) => page.slideIndex);
+    if (indexes.some((index, position) => index !== indexes[0] + position)) throw refuse("The pages of this slide are no longer next to each other.", { slides: indexes });
+    const rebuilt = rebuild(current, group);
+    current = replaceSlides(current, indexes[0], indexes.length, [rebuilt]);
+    first = Math.min(first, indexes[0]);
+    end = Math.max(end, indexes[0] + indexes.length);
+    removed += indexes.length - 1;
+  }
+  assertValidOutput(current.slides, "slides");
+  const deleteCount = end - first;
+  return { presentation: current, slides: current.slides.slice(first, first + deleteCount - removed), range: { start: first, deleteCount }, changed: true, ...report([]) };
+}
+function rebuild(presentation, group) {
+  const firstPage = group[0];
+  const skeleton = clone(valueAt(presentation, ["slides", String(firstPage.slideIndex)]));
+  const root = {};
+  for (const [key, value] of Object.entries(skeleton)) if (!BODY_KEYS.has(key) && !isRegionKey(key)) root[key] = value;
+  const leaves = /* @__PURE__ */ new Map();
+  const order = [];
+  group.forEach((page, pageNumber) => {
+    for (const mapping of page.mappings) {
+      const outputSegments = segments(mapping.outputPath).slice(2);
+      const value = valueAt(presentation, ["slides", String(page.slideIndex), ...outputSegments]);
+      if (value === void 0) throw refuse(`The slide no longer has the content at ${mapping.outputPath}.`, { path: mapping.outputPath });
+      const key = segments(mapping.sourcePath).slice(2).join(".");
+      if (!leaves.has(key)) {
+        leaves.set(key, []);
+        order.push(key);
+      }
+      leaves.get(key).push({ page: pageNumber, value, ...mapping.range ? { range: mapping.range } : {}, outputSegments });
+    }
+  });
+  const place = (sourceSegments, containerOf, value) => {
+    let cursor = root;
+    for (let depth = 0; depth < sourceSegments.length - 1; depth++) {
+      const part = sourceSegments[depth];
+      if (part === "blocks") {
+        cursor.blocks ??= [];
+        continue;
+      }
+      const slot = Array.isArray(cursor.blocks) && /^\d+$/.test(part) ? cursor.blocks : cursor;
+      const key = Array.isArray(cursor.blocks) && /^\d+$/.test(part) ? Number(part) : part;
+      if (!isRecord(slot[key])) {
+        const model = containerOf(depth);
+        const copy = {};
+        for (const [name, entry] of Object.entries(model ?? {})) if (!BODY_KEYS.has(name) && !isRegionKey(name)) copy[name] = clone(entry);
+        slot[key] = copy;
+      }
+      cursor = slot[key];
+    }
+    cursor[sourceSegments.at(-1)] = value;
+  };
+  for (const key of order) {
+    const slices = leaves.get(key);
+    for (let index = 1; index < slices.length; index++) {
+      const previous = slices[index - 1].range;
+      const next = slices[index].range;
+      if (!previous || !next || previous.end !== next.start) throw refuse("The slices of this slide are not consecutive any more, so they cannot be put back together.", { path: key });
+    }
+    const sourceSegments = key.split(".");
+    const field = sourceSegments.at(-1);
+    const model = slices[0];
+    const containerOf = (depth) => valueAt(presentation, ["slides", String(group[model.page].slideIndex), ...model.outputSegments.slice(0, depth + 1)]);
+    place(sourceSegments, containerOf, joinSlices(field, slices.map((slice) => slice.value)));
+  }
+  const compact = (node) => {
+    if (Array.isArray(node.blocks)) {
+      node.blocks = node.blocks.filter((block) => block !== void 0);
+      for (const block of node.blocks) compact(block);
+    }
+    for (const key of Object.keys(node)) if (isRegionKey(key) && isRecord(node[key])) compact(node[key]);
+  };
+  compact(root);
+  if (skeleton.type !== void 0 && CONTENT_KEYS.some((key) => root[key] !== void 0)) root.type = skeleton.type;
+  return root;
+}
+
+export { CONTENT_CONVERSIONS, CONTENT_KIND_LABELS, blocksToRegions, contentConversionTargets, convertContent, convertListForm, demoteImage, demoteListItems, mergeSlides, moveRegion, promoteImage, promoteListItems, readContent, regionsToBlocks, shiftListLevels, splitSlide, splitSlideOnOverflow, unpaginate, unwrapGroup, wrapBlocks };