ooxml-core 1.8.3 → 1.9.0

package/dist/pptx/automation/index.cjs

@@ -39165,6 +39165,13 @@ function parseContentTypes(xml) {
   }
   return { defaults, overrides };
 }
+function contentTypeForPart(types, partName) {
+  const overridePath = partName.startsWith("/") ? partName : `/${partName}`;
+  const override = types.overrides.get(overridePath);
+  if (override) return override;
+  const extension = partName.split(".").pop()?.toLowerCase();
+  return extension ? types.defaults.get(extension) : void 0;
+}
 var init_content_types = __esm({
   "opc/content-types.ts"() {
     init_xml2();
@@ -39204,10 +39211,13 @@ function relativePartTarget(basePart, targetPart) {
 }
 async function clonePartGraph(options) {
   const { zip, sourcePart, targetPart, shouldClone } = options;
-  const copies = /* @__PURE__ */ new Map([[sourcePart, targetPart]]);
-  const types = parseContentTypes(await zip.file("[Content_Types].xml")?.async("string"));
+  const sourceZip = options.sourceZip ?? zip;
+  const copies = options.copies ?? /* @__PURE__ */ new Map();
+  copies.set(sourcePart, targetPart);
+  const types = parseContentTypes(await sourceZip.file("[Content_Types].xml")?.async("string"));
   const reserved = new Set(Object.keys(zip.files));
   reserved.add(targetPart);
+  for (const target of copies.values()) reserved.add(target);
   const allocate = (source) => {
     const match = /^(?<stem>.*?)(?:\d+)?(?<extension>\.[^/.]+)$/u.exec(source);
     const stem = match?.groups?.stem ?? source;
@@ -39219,9 +39229,9 @@ async function clonePartGraph(options) {
     return path2;
   };
   const copyRelationships = async (source, destination) => {
-    const contentType = types.overrides.get(`/${source}`);
+    const contentType = contentTypeForPart(types, source);
     if (contentType) await ensureContentTypeOverride(zip, destination, contentType);
-    const xml = await zip.file(relationshipsPartFor(source))?.async("string");
+    const xml = await sourceZip.file(relationshipsPartFor(source))?.async("string");
     if (!xml) return;
     const relationships2 = parseRelationships(xml);
     for (const relationship of relationships2.values()) {
@@ -39229,7 +39239,7 @@ async function clonePartGraph(options) {
       const originalTarget = resolvePartPath(source, relationship.target);
       let newTarget = copies.get(originalTarget);
       if (!newTarget && shouldClone(relationship, originalTarget)) {
-        const file = zip.file(originalTarget);
+        const file = sourceZip.file(originalTarget);
         if (!file) throw new Error(`Cannot clone missing package part: ${originalTarget}`);
         newTarget = allocate(originalTarget);
         copies.set(originalTarget, newTarget);
@@ -61136,7 +61146,13 @@ var init_PptxSlideNotesPartUpdater = __esm({
           init.slideNotesRelationshipType,
           `../notesSlides/${fileName}`
         );
-        init.zip.file(notesPath, init.xmlBuilder.build(this.buildNotesSlide(init.slide, strict)));
+        const notesXmlObject = this.buildNotesSlide(init.slide, strict);
+        init.updateNotesXmlText(
+          notesXmlObject,
+          init.slide.notes ?? init.slide.notesSegments?.map((segment) => segment.text).join("") ?? "",
+          init.slide.notesSegments
+        );
+        init.zip.file(notesPath, init.xmlBuilder.build(notesXmlObject));
         init.zip.file(
           `ppt/notesSlides/_rels/${fileName}.rels`,
           init.xmlBuilder.build({
@@ -93669,6 +93685,341 @@ var init_header_footer_parts = __esm({
   }
 });
 
+// pptx/core/utils/chart-xlsx-write-validation.ts
+function unsupported(reason) {
+  throw new Error(`Chart label replacement requires direct literal workbook cells: ${reason}.`);
+}
+async function validateAtomicChartWorkbookWrites(zip, parser, paths, writes, requireCurrentValues = false) {
+  const relationships2 = xmlChild(
+    parser.parse(
+      await zip.file("xl/_rels/workbook.xml.rels")?.async("string") ?? ""
+    ),
+    "Relationships"
+  );
+  for (const rel of xmlChildren(relationships2, "Relationship")) {
+    if (xmlAttr(rel, "TargetMode") === "External") {
+      unsupported("external worksheet relationships are not supported");
+    }
+  }
+  const sheets = /* @__PURE__ */ new Map();
+  const cellsByPath = /* @__PURE__ */ new Map();
+  for (const path2 of new Set(paths.values())) {
+    const file = zip.file(path2);
+    if (!file) {
+      unsupported("a referenced worksheet is missing");
+    }
+    let tree;
+    try {
+      tree = parser.parse(await file.async("string"));
+    } catch {
+      unsupported("a worksheet cannot be parsed");
+    }
+    const data = xmlChild(xmlChild(tree, "worksheet"), "sheetData");
+    if (!data) {
+      unsupported("a worksheet has no cell data");
+    }
+    if (Object.keys(data).some((key2) => key2.includes(":"))) {
+      unsupported("prefixed worksheet cell nodes are not supported");
+    }
+    const cells2 = /* @__PURE__ */ new Map();
+    for (const row of xmlChildren(data, "row")) {
+      if (Object.keys(row).some((key2) => key2.includes(":"))) {
+        unsupported("prefixed worksheet cell nodes are not supported");
+      }
+      for (const cell of xmlChildren(row, "c")) {
+        const ref = xmlAttr(cell, "r");
+        if (!ref || cells2.has(ref)) {
+          unsupported("duplicate or unidentified worksheet cells are not supported");
+        }
+        cells2.set(ref, cell);
+        if (Object.keys(cell).some((key2) => key2 === "f" || key2.endsWith(":f"))) {
+          unsupported("formula-dependent workbooks are not supported");
+        }
+      }
+    }
+    sheets.set(path2, data);
+    cellsByPath.set(path2, cells2);
+  }
+  const sharedFile = zip.file("xl/sharedStrings.xml");
+  const shared = sharedFile ? xmlChildren(
+    xmlChild(parser.parse(await sharedFile.async("string")), "sst"),
+    "si"
+  ) : [];
+  const destinations = /* @__PURE__ */ new Map();
+  for (const write of writes) {
+    const range = parseChartFormulaRange(write.formula);
+    if (!range || /[\[\]:!]/u.test(range.sheetName)) {
+      unsupported("a range is not a direct local reference");
+    }
+    if ([range.start, range.end].some(
+      (cell) => cell.row < 0 || cell.row >= 1048576 || cell.col < 0 || cell.col >= 16384
+    )) {
+      unsupported("a source cell lies outside the worksheet limits");
+    }
+    const addresses = expandRangeAddresses(range, write.values.length);
+    const path2 = paths.get(range.sheetName.toLowerCase());
+    const data = path2 ? sheets.get(path2) : void 0;
+    if (!addresses || !path2 || !data) {
+      unsupported("a source range cannot be resolved");
+    }
+    for (const [index, address] of addresses.entries()) {
+      const value = write.values[index];
+      const key2 = `${path2}!${address}`;
+      const prior = destinations.get(key2);
+      if (prior && (prior.value !== value || prior.numeric !== write.isNumeric)) {
+        unsupported("overlapping source ranges request conflicting values");
+      }
+      destinations.set(key2, { value, numeric: write.isNumeric });
+      const cell = cellsByPath.get(path2)?.get(address);
+      if (!cell) {
+        unsupported("a source cell is missing");
+      }
+      const type = xmlAttr(cell, "t") ?? "n";
+      const text2 = type === "s" ? shared[Number(xmlText(cell.v))] : xmlChild(cell, "is");
+      if (text2 && Object.keys(text2).some((node) => !node.startsWith("@_") && node !== "t" && node !== "#text")) {
+        unsupported("rich worksheet strings require source-workbook editing");
+      }
+      if (requireCurrentValues) {
+        const current = text2 ? xmlText(text2.t) : xmlText(cell.v);
+        const equal = write.isNumeric ? current !== void 0 && Number(current) === Number(value) : current === value;
+        if (!equal) {
+          unsupported("the workbook and chart caches disagree");
+        }
+      }
+      if (write.isNumeric && !Number.isFinite(Number(value))) {
+        unsupported("a numeric cache value is not finite");
+      }
+      if (!["n", "s", "inlineStr", "str"].includes(type)) {
+        unsupported("a source cell has an unsupported value type");
+      }
+    }
+  }
+}
+var init_chart_xlsx_write_validation = __esm({
+  "pptx/core/utils/chart-xlsx-write-validation.ts"() {
+    init_chart_xlsx_cellref();
+    init_xml_access();
+  }
+});
+function collectChartWorkbookWrite(xmlLookupService, container2, isNumeric2, values) {
+  if (!container2) {
+    return void 0;
+  }
+  const refNode = xmlLookupService.getChildByLocalName(container2, isNumeric2 ? "numRef" : "strRef");
+  const formula = refNode ? xmlLookupService.getScalarChildByLocalName(refNode, "f") : void 0;
+  return formula ? { formula, isNumeric: isNumeric2, values } : void 0;
+}
+function createSpreadsheetXmlParser2() {
+  return new fastXmlParser.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    trimValues: false,
+    parseTagValue: false,
+    tagValueProcessor: (tagName, tagValue) => preservesSpreadsheetXmlWhitespace(tagName) ? tagValue : tagValue.trim()
+  });
+}
+function createSpreadsheetXmlBuilder2() {
+  return new fastXmlParser.XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    suppressBooleanAttributes: false,
+    format: false
+  });
+}
+async function resolveWorksheetPathsByName(xlsxZip, parser) {
+  const result = /* @__PURE__ */ new Map();
+  const workbookFile = xlsxZip.file("xl/workbook.xml");
+  const relsFile = xlsxZip.file("xl/_rels/workbook.xml.rels");
+  if (!workbookFile || !relsFile) {
+    return result;
+  }
+  try {
+    const workbookTree = parser.parse(await workbookFile.async("string"));
+    const relsTree = parser.parse(await relsFile.async("string"));
+    const targetByRelId = /* @__PURE__ */ new Map();
+    const relationships2 = xmlChild(relsTree, "Relationships");
+    for (const rel of xmlChildren(relationships2, "Relationship")) {
+      const id = xmlAttr(rel, "Id");
+      const target = xmlAttr(rel, "Target");
+      if (id && target) {
+        targetByRelId.set(id, target);
+      }
+    }
+    const workbookRoot = xmlChild(workbookTree, "workbook");
+    const sheets = xmlChild(workbookRoot, "sheets");
+    for (const sheet of xmlChildren(sheets, "sheet")) {
+      const name = xmlAttr(sheet, "name");
+      const relId = xmlAttr(sheet, "r:id") ?? xmlAttr(sheet, "id");
+      const target = relId ? targetByRelId.get(relId) : void 0;
+      if (name && target) {
+        result.set(name.toLowerCase(), resolveWorkbookPartPath(target));
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function resolveWorkbookPartPath(target) {
+  return target.startsWith("/") ? target.slice(1) : `xl/${target}`;
+}
+async function writeChartWorkbookUpdates(xlsxBytes, writes, options = {}) {
+  if (writes.length === 0) {
+    return { unresolved: 0 };
+  }
+  let xlsxZip;
+  try {
+    xlsxZip = await JSZip3__default.default.loadAsync(xlsxBytes);
+  } catch {
+    if (options.atomic) {
+      throw new Error("Chart label replacement requires a readable embedded workbook.");
+    }
+    return { unresolved: writes.length };
+  }
+  const parser = createSpreadsheetXmlParser2();
+  const sheetPathByName = await resolveWorksheetPathsByName(xlsxZip, parser);
+  if (options.atomic) {
+    await validateAtomicChartWorkbookWrites(
+      xlsxZip,
+      parser,
+      sheetPathByName,
+      writes,
+      options.requireCurrentValues ?? false
+    );
+  }
+  const writesBySheetPath = /* @__PURE__ */ new Map();
+  let unresolved = 0;
+  for (const write of writes) {
+    const range = parseChartFormulaRange(write.formula);
+    const sheetPath = range ? sheetPathByName.get(range.sheetName.toLowerCase()) : void 0;
+    const refs = range ? expandRangeAddresses(range, write.values.length) : void 0;
+    if (!range || !sheetPath || !refs) {
+      unresolved += 1;
+      continue;
+    }
+    const bucket = writesBySheetPath.get(sheetPath) ?? [];
+    bucket.push({ refs, values: write.values, isNumeric: write.isNumeric });
+    writesBySheetPath.set(sheetPath, bucket);
+  }
+  const builder3 = createSpreadsheetXmlBuilder2();
+  let changedAny = false;
+  for (const [sheetPath, resolvedWrites] of writesBySheetPath) {
+    const sheetFile = xlsxZip.file(sheetPath);
+    if (!sheetFile) {
+      unresolved += resolvedWrites.length;
+      continue;
+    }
+    try {
+      const sheetTree = parser.parse(await sheetFile.async("string"));
+      const cellWrites = resolvedWrites.flatMap(
+        ({ refs, values, isNumeric: isNumeric2 }) => refs.map((ref, i2) => ({ ref, isNumeric: isNumeric2, value: values[i2] }))
+      );
+      if (applyCellWritesToWorksheet(sheetTree, cellWrites)) {
+        xlsxZip.file(sheetPath, builder3.build(sheetTree));
+        changedAny = true;
+      }
+    } catch {
+      unresolved += resolvedWrites.length;
+    }
+  }
+  if (options.atomic && unresolved > 0) {
+    throw new Error("Chart label replacement could not update every source range.");
+  }
+  if (!changedAny) {
+    return { unresolved };
+  }
+  const bytes = await xlsxZip.generateAsync({
+    type: "uint8array",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  return { bytes, unresolved };
+}
+var init_chart_xlsx_writer = __esm({
+  "pptx/core/utils/chart-xlsx-writer.ts"() {
+    init_chart_xlsx_cellref();
+    init_chart_xlsx_write_validation();
+    init_chart_xlsx_sheet_cells();
+    init_xml_access();
+    init_xml_whitespace();
+  }
+});
+function formulaCount(value) {
+  if (!value || typeof value !== "object") return 0;
+  if (Array.isArray(value)) return value.reduce((total, item) => total + formulaCount(item), 0);
+  return Object.entries(value).reduce(
+    (total, [key2, child30]) => total + (key2 === "f" || key2.endsWith(":f") ? 1 : formulaCount(child30)),
+    0
+  );
+}
+async function chartLabelsHaveEditableSources(xml, zip, chartSpace, seriesNodes, series, categories, external, chartPartPath, resolve) {
+  if (!chartSpace || seriesNodes.length !== series.length || !categories.length || external?.isExternal)
+    return false;
+  if (formulaCount(chartSpace) !== seriesNodes.reduce((sum, node) => sum + formulaCount(node), 0))
+    return false;
+  const writes = [];
+  const labelOwners = /* @__PURE__ */ new Map();
+  for (const [index, node] of seriesNodes.entries()) {
+    const entry2 = series[index];
+    for (const [name, numeric, values] of [
+      ["tx", false, [entry2.name]],
+      ["cat", false, [...categories]],
+      ["val", true, entry2.values.map(String)]
+    ]) {
+      const container2 = xml.getChildByLocalName(node, name);
+      if (!container2) return false;
+      const write = collectChartWorkbookWrite(xml, container2, numeric, [...values]);
+      if (write) {
+        writes.push(write);
+        if (!numeric) {
+          const range = parseChartFormulaRange(write.formula);
+          const addresses = range ? expandRangeAddresses(range, values.length) : void 0;
+          if (!range || !addresses) return false;
+          for (const [point2, address] of addresses.entries()) {
+            const key2 = `${range.sheetName.toLowerCase()}!${address}`;
+            const owner = name === "tx" ? `series:${index}` : `category:${point2}`;
+            if (labelOwners.has(key2) && labelOwners.get(key2) !== owner) return false;
+            labelOwners.set(key2, owner);
+          }
+        }
+      } else if (external || !xml.getChildByLocalName(container2, numeric ? "numLit" : "strLit") && !(name === "tx" && xml.getScalarChildByLocalName(container2, "v") !== void 0))
+        return false;
+    }
+  }
+  if (formulaCount(chartSpace) !== writes.length) return false;
+  if (!external) return writes.length === 0;
+  if (!external.targetPath || !external.embeddedWorkbookData) return false;
+  const target = resolve(chartPartPath, external.targetPath);
+  let references = 0;
+  const parser = new fastXmlParser.XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+  try {
+    for (const path2 of Object.keys(zip.files)) {
+      if (!path2.endsWith(".rels") || !path2.includes("/_rels/")) continue;
+      const source = path2.replace("/_rels/", "/").slice(0, -5);
+      const tree = parser.parse(await zip.file(path2).async("string"));
+      for (const rel of xmlChildren(xmlChild(tree, "Relationships"), "Relationship")) {
+        const relationshipTarget2 = xmlAttr(rel, "Target");
+        if (relationshipTarget2 && xmlAttr(rel, "TargetMode") !== "External" && resolve(source, relationshipTarget2) === target)
+          references++;
+      }
+    }
+    if (references !== 1) return false;
+    await writeChartWorkbookUpdates(external.embeddedWorkbookData, writes, {
+      atomic: true,
+      requireCurrentValues: true
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_chart_label_source = __esm({
+  "pptx/core/utils/chart-label-source.ts"() {
+    init_chart_xlsx_writer();
+    init_xml_access();
+    init_chart_xlsx_cellref();
+  }
+});
+
 // pptx/core/utils/chart-band-fmts.ts
 function safeUnsignedInt2(val) {
   const n = Number(val);
@@ -107769,6 +108120,18 @@ var init_tag_package = __esm({
   }
 });
 
+// pptx/core/utils/chart-workbook-data-signature.ts
+function chartWorkbookDataSignature(data) {
+  return JSON.stringify({
+    categories: data.dateCategories?.values ?? data.categories,
+    series: data.series.map((series) => ({ name: series.name, values: series.values }))
+  });
+}
+var init_chart_workbook_data_signature = __esm({
+  "pptx/core/utils/chart-workbook-data-signature.ts"() {
+  }
+});
+
 // pptx/core/utils/chart-axis-deleted.ts
 function authoredDeleted(node) {
   if (node === void 0) {
@@ -108856,6 +109219,33 @@ var init_chart_title_run_alignment = __esm({
   }
 });
 
+// pptx/core/utils/chart-title-text-edit.ts
+function patchChartTitleRunText(title, runs, local) {
+  const tx = title[findKey7(title, "tx", local) ?? ""];
+  const rich = tx?.[findKey7(tx, "rich", local) ?? ""];
+  const raw = rich?.[findKey7(rich, "p", local) ?? ""];
+  const paragraphs = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  if (paragraphs.length !== 1) return false;
+  const paragraph = paragraphs[0];
+  if (findKey7(paragraph, "br", local) || findKey7(paragraph, "fld", local)) return false;
+  const rawRuns = paragraph[findKey7(paragraph, "r", local) ?? ""];
+  const original = Array.isArray(rawRuns) ? rawRuns : rawRuns ? [rawRuns] : [];
+  if (original.length !== runs.length) return false;
+  const keys = original.map((run) => findKey7(run, "t", local));
+  if (keys.some((key2) => !key2)) return false;
+  for (const [index, value] of original.entries()) {
+    const run = value, key2 = keys[index];
+    const text2 = run[key2];
+    run[key2] = text2 && typeof text2 === "object" && !Array.isArray(text2) ? { ...text2, "#text": runs[index].text } : runs[index].text;
+  }
+  return true;
+}
+var init_chart_title_text_edit = __esm({
+  "pptx/core/utils/chart-title-text-edit.ts"() {
+    init_chart_title_xml_ops();
+  }
+});
+
 // pptx/core/utils/chart-title-serializer.ts
 function applyChartTitleToXml(chartRoot, model, getLocalName2, options = { prefix: "c" }) {
   const { prefix } = options;
@@ -108881,11 +109271,18 @@ function applyChartTitleToXml(chartRoot, model, getLocalName2, options = { prefi
     runs = realignOrCollapseTitleRuns(staleRuns, model.title);
   }
   let titleNode = existingKey ? chartRoot[existingKey] : void 0;
+  const textOnlyStylesMatch = Boolean(
+    runs && model.titleTextOnlyStyles?.length === runs.length && runs.every(
+      (run, index) => ["bold", "italic", "fontSize", "color"].every(
+        (key2) => run[key2] === model.titleTextOnlyStyles[index][key2]
+      )
+    )
+  );
   if (runs && titleNode && typeof titleNode === "object") {
     const existingTexts = [];
     collectAllText(titleNode, getLocalName2, existingTexts);
     const newTexts = runs.map((run) => run.text);
-    if (existingTexts.length === newTexts.length && existingTexts.every((text2, index) => text2 === newTexts[index])) {
+    if ((!model.titleTextOnly || textOnlyStylesMatch) && existingTexts.length === newTexts.length && existingTexts.every((text2, index) => text2 === newTexts[index])) {
       runs = void 0;
     }
   }
@@ -108897,6 +109294,12 @@ function applyChartTitleToXml(chartRoot, model, getLocalName2, options = { prefi
       insertAt2(chartRoot, 0, `${prefix}:title`, titleNode);
     }
   } else if (runs) {
+    if (model.titleTextOnly && textOnlyStylesMatch) {
+      if (!patchChartTitleRunText(titleNode, runs, getLocalName2))
+        throw new Error("This chart title cannot be replaced without changing its text source");
+      if (prefix === "c") setAutoTitleDeleted(chartRoot, false, getLocalName2);
+      return true;
+    }
     const txKey = findKey7(titleNode, "tx", getLocalName2);
     if (txKey) {
       titleNode[txKey] = buildTitleTextFromRuns(prefix, runs);
@@ -108920,6 +109323,7 @@ var init_chart_title_serializer = __esm({
   "pptx/core/utils/chart-title-serializer.ts"() {
     init_chart_title_node_builder();
     init_chart_title_run_alignment();
+    init_chart_title_text_edit();
     init_chart_title_xml_ops();
   }
 });
@@ -109081,131 +109485,6 @@ var init_chart_title_style_serializer = __esm({
     };
   }
 });
-function collectChartWorkbookWrite(xmlLookupService, container2, isNumeric2, values) {
-  if (!container2) {
-    return void 0;
-  }
-  const refNode = xmlLookupService.getChildByLocalName(container2, isNumeric2 ? "numRef" : "strRef");
-  const formula = refNode ? xmlLookupService.getScalarChildByLocalName(refNode, "f") : void 0;
-  return formula ? { formula, isNumeric: isNumeric2, values } : void 0;
-}
-function createSpreadsheetXmlParser2() {
-  return new fastXmlParser.XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    trimValues: false,
-    tagValueProcessor: (tagName, tagValue) => preservesSpreadsheetXmlWhitespace(tagName) ? tagValue : tagValue.trim()
-  });
-}
-function createSpreadsheetXmlBuilder2() {
-  return new fastXmlParser.XMLBuilder({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    suppressBooleanAttributes: false,
-    format: false
-  });
-}
-async function resolveWorksheetPathsByName(xlsxZip, parser) {
-  const result = /* @__PURE__ */ new Map();
-  const workbookFile = xlsxZip.file("xl/workbook.xml");
-  const relsFile = xlsxZip.file("xl/_rels/workbook.xml.rels");
-  if (!workbookFile || !relsFile) {
-    return result;
-  }
-  try {
-    const workbookTree = parser.parse(await workbookFile.async("string"));
-    const relsTree = parser.parse(await relsFile.async("string"));
-    const targetByRelId = /* @__PURE__ */ new Map();
-    const relationships2 = xmlChild(relsTree, "Relationships");
-    for (const rel of xmlChildren(relationships2, "Relationship")) {
-      const id = xmlAttr(rel, "Id");
-      const target = xmlAttr(rel, "Target");
-      if (id && target) {
-        targetByRelId.set(id, target);
-      }
-    }
-    const workbookRoot = xmlChild(workbookTree, "workbook");
-    const sheets = xmlChild(workbookRoot, "sheets");
-    for (const sheet of xmlChildren(sheets, "sheet")) {
-      const name = xmlAttr(sheet, "name");
-      const relId = xmlAttr(sheet, "r:id") ?? xmlAttr(sheet, "id");
-      const target = relId ? targetByRelId.get(relId) : void 0;
-      if (name && target) {
-        result.set(name.toLowerCase(), resolveWorkbookPartPath(target));
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-function resolveWorkbookPartPath(target) {
-  return target.startsWith("/") ? target.slice(1) : `xl/${target}`;
-}
-async function writeChartWorkbookUpdates(xlsxBytes, writes) {
-  if (writes.length === 0) {
-    return { unresolved: 0 };
-  }
-  let xlsxZip;
-  try {
-    xlsxZip = await JSZip3__default.default.loadAsync(xlsxBytes);
-  } catch {
-    return { unresolved: writes.length };
-  }
-  const parser = createSpreadsheetXmlParser2();
-  const sheetPathByName = await resolveWorksheetPathsByName(xlsxZip, parser);
-  const writesBySheetPath = /* @__PURE__ */ new Map();
-  let unresolved = 0;
-  for (const write of writes) {
-    const range = parseChartFormulaRange(write.formula);
-    const sheetPath = range ? sheetPathByName.get(range.sheetName.toLowerCase()) : void 0;
-    const refs = range ? expandRangeAddresses(range, write.values.length) : void 0;
-    if (!range || !sheetPath || !refs) {
-      unresolved += 1;
-      continue;
-    }
-    const bucket = writesBySheetPath.get(sheetPath) ?? [];
-    bucket.push({ refs, values: write.values, isNumeric: write.isNumeric });
-    writesBySheetPath.set(sheetPath, bucket);
-  }
-  const builder3 = createSpreadsheetXmlBuilder2();
-  let changedAny = false;
-  for (const [sheetPath, resolvedWrites] of writesBySheetPath) {
-    const sheetFile = xlsxZip.file(sheetPath);
-    if (!sheetFile) {
-      unresolved += resolvedWrites.length;
-      continue;
-    }
-    try {
-      const sheetTree = parser.parse(await sheetFile.async("string"));
-      const cellWrites = resolvedWrites.flatMap(
-        ({ refs, values, isNumeric: isNumeric2 }) => refs.map((ref, i2) => ({ ref, isNumeric: isNumeric2, value: values[i2] }))
-      );
-      if (applyCellWritesToWorksheet(sheetTree, cellWrites)) {
-        xlsxZip.file(sheetPath, builder3.build(sheetTree));
-        changedAny = true;
-      }
-    } catch {
-      unresolved += resolvedWrites.length;
-    }
-  }
-  if (!changedAny) {
-    return { unresolved };
-  }
-  const bytes = await xlsxZip.generateAsync({
-    type: "uint8array",
-    compression: "DEFLATE",
-    compressionOptions: { level: 6 }
-  });
-  return { bytes, unresolved };
-}
-var init_chart_xlsx_writer = __esm({
-  "pptx/core/utils/chart-xlsx-writer.ts"() {
-    init_chart_xlsx_cellref();
-    init_chart_xlsx_sheet_cells();
-    init_xml_access();
-    init_xml_whitespace();
-  }
-});
 
 // pptx/core/core/runtime/chart-cx-update-data.ts
 function findKey31(node, localName28, getLocalName2) {
@@ -109541,13 +109820,19 @@ var init_chart_cx_update = __esm({
 });
 
 // pptx/core/core/runtime/chart-external-workbook-save.ts
-async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath, externalData, writes) {
+async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath, externalData, writes, atomic = false) {
+  if (atomic && externalData && (!externalData.targetPath || externalData.isExternal)) {
+    throw new Error("Chart label replacement cannot update an external or missing workbook.");
+  }
   if (writes.length === 0 || !externalData?.targetPath) {
-    return;
+    return writes.length === 0;
   }
   const embeddingPath = deps.resolveImagePath(chartPartPath, externalData.targetPath);
   const looksEmbedded = embeddingPath.includes("embeddings/") && /\.xlsx$/iu.test(embeddingPath);
-  if (!looksEmbedded) {
+  if (!looksEmbedded || externalData.isExternal) {
+    if (atomic) {
+      throw new Error("Chart label replacement requires an embedded .xlsx workbook.");
+    }
     deps.reportWarning({
       code: "CHART_EXTERNAL_DATA_WRITEBACK_UNSUPPORTED",
       message: "Chart data changes were saved to the cached values only: the linked data source is external or not an embedded .xlsx workbook, so it was not updated.",
@@ -109556,10 +109841,13 @@ async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath,
       slideId: slidePath,
       xmlPath: chartPartPath
     });
-    return;
+    return false;
   }
   const xlsxFile = deps.zip.file(embeddingPath);
   if (!xlsxFile) {
+    if (atomic) {
+      throw new Error("Chart label replacement workbook is missing.");
+    }
     deps.reportWarning({
       code: "CHART_EMBEDDED_WORKBOOK_MISSING",
       message: "Chart data changes were saved to the cached values only: the referenced embedded workbook was not found in the package.",
@@ -109568,12 +109856,15 @@ async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath,
       slideId: slidePath,
       xmlPath: embeddingPath
     });
-    return;
+    return false;
   }
   let xlsxBytes;
   try {
     xlsxBytes = await xlsxFile.async("uint8array");
   } catch {
+    if (atomic) {
+      throw new Error("Chart label replacement workbook cannot be read.");
+    }
     deps.reportWarning({
       code: "CHART_EMBEDDED_WORKBOOK_UNREADABLE",
       message: "Chart data changes were saved to the cached values only: the referenced embedded workbook could not be read.",
@@ -109582,9 +109873,9 @@ async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath,
       slideId: slidePath,
       xmlPath: embeddingPath
     });
-    return;
+    return false;
   }
-  const result = await writeChartWorkbookUpdates(xlsxBytes, writes);
+  const result = await writeChartWorkbookUpdates(xlsxBytes, writes, { atomic });
   if (result.bytes) {
     deps.zip.file(embeddingPath, result.bytes);
   }
@@ -109598,6 +109889,7 @@ async function saveChartExternalWorkbookUpdates(deps, chartPartPath, slidePath,
       xmlPath: embeddingPath
     });
   }
+  return result.unresolved === 0;
 }
 var init_chart_external_workbook_save = __esm({
   "pptx/core/core/runtime/chart-external-workbook-save.ts"() {
@@ -113052,7 +113344,7 @@ var init_PptxHandlerRuntimeState = __esm({
        */
       savedSlideFingerprints = /* @__PURE__ */ new Map();
       /**
-       * `chartData` exactly as it stood right after `enrichChartData` parsed it,
+       * `chartData` as parsed or last serialized into the current ZIP,
        * serialized to JSON and keyed by `chartPartPath`. The save pipeline used
        * to re-serialize EVERY chart part on any slide rewrite regardless of
        * whether the chart itself was touched, which materializes the load-time
@@ -113065,6 +113357,10 @@ var init_PptxHandlerRuntimeState = __esm({
        * untouched chart part pass through byte-for-byte instead.
        */
       chartDataBaselines = /* @__PURE__ */ new Map();
+      /** Pending chart requests also retain warned workbook writes for later retry. */
+      pendingChartUpdates;
+      /** Last fully reconciled workbook data plus whether a write-back needs retry. */
+      chartWorkbookDataBaselines = /* @__PURE__ */ new Map();
       /** Per-slide relationship maps: slide path -> (rId -> target path). */
       slideRelsMap = /* @__PURE__ */ new Map();
       /** Tracks relationship IDs with TargetMode="External" per slide/part path. */
@@ -121073,6 +121369,7 @@ var init_table_tblpr_save = __esm({
 var CHART_DATA_DISPLAY_OPTIONS_EXT_URI, PptxHandlerRuntime24;
 var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
   "pptx/core/core/runtime/PptxHandlerRuntimeSaveDataSerialization.ts"() {
+    init_chart_workbook_data_signature();
     init_chart_axis_dispunits_serializer();
     init_chart_axis_gridlines_serializer();
     init_chart_axis_label_formatting();
@@ -121210,8 +121507,6 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
           console.warn("Failed to serialize table data:", e);
         }
       }
-      /** Pending chart data updates to process in the async save method. */
-      pendingChartUpdates;
       /**
        * Record `chartData` as parsed, straight off `enrichChartData`, as this
        * chart's load-time baseline. See {@link chartDataBaselines}.
@@ -121221,6 +121516,10 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
           return;
         }
         this.chartDataBaselines.set(chartData.chartPartPath, JSON.stringify(chartData));
+        this.chartWorkbookDataBaselines.set(chartData.chartPartPath, {
+          signature: chartWorkbookDataSignature(chartData),
+          pending: false
+        });
       }
       /**
        * Collect chart data for deferred async processing during save.
@@ -121237,12 +121536,28 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
       /**
        * Process all pending chart data updates (called from the async save method).
        */
-      async processPendingChartUpdates() {
+      async processPendingChartUpdates(slides) {
         if (!this.pendingChartUpdates || this.pendingChartUpdates.length === 0) {
           return;
         }
+        if (slides) {
+          const current = /* @__PURE__ */ new Map();
+          const visit = (elements3, slidePath) => {
+            for (const element of elements3) {
+              if (element.type === "group") visit(element.children, slidePath);
+              else if (element.type === "chart" && element.chartData?.chartPartPath) {
+                current.set(element.chartData.chartPartPath, {
+                  chartData: element.chartData,
+                  slidePath
+                });
+              }
+            }
+          };
+          for (const slide of slides) visit(slide.elements, slide.id);
+          this.pendingChartUpdates = [...current.values()];
+        }
         for (const { chartData, slidePath } of this.pendingChartUpdates) {
-          if (chartData.chartPartPath && this.chartDataBaselines.get(chartData.chartPartPath) === JSON.stringify(chartData)) {
+          if (chartData.chartPartPath && !this.chartWorkbookDataBaselines.get(chartData.chartPartPath)?.pending && this.chartDataBaselines.get(chartData.chartPartPath) === JSON.stringify(chartData)) {
             continue;
           }
           if (chartData.colorPalette && chartData.colorStylePartPath) {
@@ -121661,7 +121976,9 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
               {
                 title: chartData.title,
                 hasTitle: chartData.style?.hasTitle,
-                titleRuns: chartData.titleRuns
+                titleRuns: chartData.titleRuns,
+                titleTextOnly: chartData.titleTextOnly,
+                titleTextOnlyStyles: chartData.titleTextOnlyStyles
               },
               (key2) => this.compatibilityService.getXmlLocalName(key2)
             );
@@ -121853,23 +122170,41 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
               }
             }
             await this.syncChartUserShapesToXml(chartSpace, chartData, chartPartPath);
+            const serializedBaseline = this.chartDataBaselines.get(chartPartPath);
+            const signature = chartWorkbookDataSignature(chartData);
+            const workbookBaseline = this.chartWorkbookDataBaselines.get(chartPartPath);
+            const previousSignature = workbookBaseline?.signature ?? (serializedBaseline ? chartWorkbookDataSignature(JSON.parse(serializedBaseline)) : void 0);
+            const workbookDataChanged = workbookBaseline?.pending || signature !== previousSignature;
+            if (workbookDataChanged) {
+              const complete = await saveChartExternalWorkbookUpdates(
+                {
+                  zip: this.zip,
+                  resolveImagePath: (basePath, target) => this.resolveImagePath(basePath, target),
+                  reportWarning: (warning) => this.compatibilityService.reportWarning(warning)
+                },
+                chartPartPath,
+                slidePath,
+                chartData.externalData,
+                workbookWrites,
+                chartData.dataLabelTextOnly ?? false
+              );
+              this.chartWorkbookDataBaselines.set(chartPartPath, {
+                signature: complete ? signature : previousSignature ?? signature,
+                pending: !complete
+              });
+            }
             this.zip.file(chartPartPath, this.builder.build(chartXmlData));
-            await saveChartExternalWorkbookUpdates(
-              {
-                zip: this.zip,
-                resolveImagePath: (basePath, target) => this.resolveImagePath(basePath, target),
-                reportWarning: (warning) => this.compatibilityService.reportWarning(warning)
-              },
-              chartPartPath,
-              slidePath,
-              chartData.externalData,
-              workbookWrites
-            );
+            this.chartDataBaselines.set(chartPartPath, JSON.stringify(chartData));
           } catch (e) {
+            if (chartData.dataLabelTextOnly) {
+              throw e;
+            }
             console.warn(`[pptx-save] Failed to serialize chart data for ${chartPartPath}:`, e);
           }
         }
-        this.pendingChartUpdates = void 0;
+        this.pendingChartUpdates = this.pendingChartUpdates.filter(
+          ({ chartData }) => chartData.chartPartPath && this.chartWorkbookDataBaselines.get(chartData.chartPartPath)?.pending
+        );
       }
       /**
        * Route a chart save that the 2006 `c:*Chart` update loop cannot handle:
@@ -130073,22 +130408,44 @@ function drawingNamespace(strict) {
 var NOTES_MASTER_CONTENT_TYPE, PptxHandlerRuntime50;
 var init_PptxHandlerRuntimeSaveNotesInfrastructure = __esm({
   "pptx/core/core/runtime/PptxHandlerRuntimeSaveNotesInfrastructure.ts"() {
+    init_relationships();
     init_PptxHandlerRuntimeSaveViewProperties();
     NOTES_MASTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
     PptxHandlerRuntime50 = class extends PptxHandlerRuntime49 {
       /** Ensure authored notes have the global notes-master OPC infrastructure. */
       async ensureNotesMasterForAuthoredNotes(slides, constants) {
         const needsNotes = slides.some(
-          (slide) => slide.notes !== void 0 || Boolean(slide.notesSegments?.length)
+          (slide) => Boolean(slide.notes) || Boolean(slide.notesSegments?.some((segment) => segment.text))
         );
         if (!needsNotes || Object.keys(this.zip.files).some(
           (path2) => /^ppt\/notesMasters\/notesMaster\d+\.xml$/u.test(path2)
         )) {
           return;
         }
+        const relsPath2 = "ppt/_rels/presentation.xml.rels";
+        const relsXml = await this.zip.file(relsPath2)?.async("string");
+        if (!relsXml || !this.presentationData) return;
+        if (Array.from(parseRelationships(relsXml).values()).some(
+          (relationship) => relationship.type.endsWith("/notesMaster") && relationship.mode !== "External" && this.zip.file(resolvePartPath("ppt/presentation.xml", relationship.target))
+        ))
+          return;
         const strict = constants.conformance === "strict";
         const masterPath = "ppt/notesMasters/notesMaster1.xml";
-        const themePath = Object.keys(this.zip.files).find((path2) => /^ppt\/theme\/theme\d+\.xml$/u.test(path2)) ?? "ppt/theme/theme1.xml";
+        const sourceThemePath = Object.keys(this.zip.files).find((path2) => /^ppt\/theme\/theme\d+\.xml$/u.test(path2)) ?? "ppt/theme/theme1.xml";
+        let themeIndex = 1;
+        while (this.zip.file(`ppt/theme/theme${themeIndex}.xml`)) themeIndex += 1;
+        const themePath = `ppt/theme/theme${themeIndex}.xml`;
+        const themeBytes = await this.zip.file(sourceThemePath)?.async("uint8array");
+        const theme = themeBytes ?? this.buildThemeXml(themePath, void 0);
+        if (!theme) throw new Error("Cannot create a notes theme from the presentation state");
+        this.zip.file(themePath, theme);
+        const themeRelationships = await this.zip.file(`ppt/theme/_rels/${sourceThemePath.slice(sourceThemePath.lastIndexOf("/") + 1)}.rels`)?.async("uint8array");
+        if (themeRelationships)
+          this.zip.file(`ppt/theme/_rels/theme${themeIndex}.xml.rels`, themeRelationships);
+        await this.addContentTypeOverride(
+          `/${themePath}`,
+          "application/vnd.openxmlformats-officedocument.theme+xml"
+        );
         this.zip.file(masterPath, this.builder.build(this.buildDefaultNotesMaster(strict)));
         this.zip.file(
           "ppt/notesMasters/_rels/notesMaster1.xml.rels",
@@ -130103,11 +130460,6 @@ var init_PptxHandlerRuntimeSaveNotesInfrastructure = __esm({
             }
           })
         );
-        const relsPath2 = "ppt/_rels/presentation.xml.rels";
-        const relsXml = await this.zip.file(relsPath2)?.async("string");
-        if (!relsXml || !this.presentationData) {
-          return;
-        }
         const relsData = this.parser.parse(relsXml);
         const relsRoot = relsData["Relationships"] ?? {};
         const relationships2 = asArray7(relsRoot["Relationship"]);
@@ -130842,7 +131194,7 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
           saveSession,
           saveConstants
         );
-        await this.processPendingChartUpdates();
+        await this.processPendingChartUpdates(slides);
         await this.ensureChartPartContentTypes();
         await this.ensureOleEmbeddingContentTypes();
         await this.processPendingOleContentUpdates();
@@ -140853,6 +141205,7 @@ var init_PptxHandlerRuntimeChartExternalData = __esm({
         );
         const autoUpdateAttr = externalDataNode["@_autoUpdate"];
         const autoUpdate = autoUpdateNode?.["@_val"] === "1" || autoUpdateNode?.["@_val"] === "true" || autoUpdateAttr === "1" || autoUpdateAttr === "true" || false;
+        let isExternal = false;
         let targetPath;
         try {
           const chartDir = chartPartPath.substring(0, chartPartPath.lastIndexOf("/") + 1);
@@ -140867,6 +141220,7 @@ var init_PptxHandlerRuntimeChartExternalData = __esm({
               for (const rel of rels) {
                 if (String(rel?.["@_Id"] || "") === relId) {
                   targetPath = String(rel?.["@_Target"] || "").trim() || void 0;
+                  isExternal = String(rel?.["@_TargetMode"] || "") === "External";
                   break;
                 }
               }
@@ -140875,7 +141229,7 @@ var init_PptxHandlerRuntimeChartExternalData = __esm({
         } catch {
         }
         let embeddedWorkbookData;
-        if (targetPath) {
+        if (targetPath && !isExternal) {
           try {
             const embeddingPath = this.resolveImagePath(chartPartPath, targetPath);
             if (embeddingPath.includes("embeddings/") && embeddingPath.endsWith(".xlsx")) {
@@ -140889,6 +141243,7 @@ var init_PptxHandlerRuntimeChartExternalData = __esm({
         }
         return {
           relId,
+          ...isExternal ? { isExternal: true } : {},
           targetPath,
           autoUpdate,
           ...embeddedWorkbookData ? { embeddedWorkbookData } : {}
@@ -141259,6 +141614,8 @@ var init_PptxHandlerRuntimeChartExParsing = __esm({
           ...result.categoryLevels ? { categoryLevels: result.categoryLevels } : {},
           series: result.series,
           title: cxTitleText,
+          titleTextEditable: false,
+          dataLabelTextEditable: false,
           style: chartStyle2,
           chartPartPath,
           chartRelationshipId,
@@ -141282,6 +141639,7 @@ var init_PptxHandlerRuntimeChartExParsing = __esm({
 var PptxHandlerRuntime95;
 var init_PptxHandlerRuntimeChartParsing = __esm({
   "pptx/core/core/runtime/PptxHandlerRuntimeChartParsing.ts"() {
+    init_chart_label_source();
     init_chart_advanced_parser();
     init_chart_axis_parser();
     init_chart_band_fmts();
@@ -141472,12 +141830,34 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
           colorAdapter
         );
         const style = chartStyleFromNeutral(neutral, this.extractChartStyle(chartSpace, chartRoot));
+        const titleTx = reader2.xml.getChildByLocalName(
+          reader2.xml.getChildByLocalName(chartRoot, "title"),
+          "tx"
+        );
+        const titleRich = reader2.xml.getChildByLocalName(titleTx, "rich");
+        const titleParagraphs = reader2.xml.getChildrenArrayByLocalName(titleRich, "p");
+        const titleTextEditable = Boolean(
+          titleRuns?.length && titleParagraphs.length === 1 && !Object.keys(titleParagraphs[0] ?? {}).some(
+            (key2) => ["br", "fld"].includes(reader2.localName(key2))
+          )
+        );
         const groupOptions = groupOptionsFromNeutral(groups[0]?.group, chartType);
         const linesAndChrome = this.readChartLinesAndChrome(neutral, tree, groups, reader2);
         const facts = await this.readChartPartFacts(chartSpace, chartRoot, chartPartPath);
         const workbook = facts.embeddedWorkbookData;
         const dateCategories = rawDateCategories ? { ...rawDateCategories, date1904: neutral.date1904 ?? workbook?.date1904 ?? false } : void 0;
         const filled = applyEmbeddedWorkbookFallback(chartType, categories, built.series, workbook);
+        const dataLabelTextEditable = !categoryLevels && !dateCategories && await chartLabelsHaveEditableSources(
+          reader2.xml,
+          this.zip,
+          chartSpace,
+          built.seriesNodes,
+          filled.series,
+          filled.categories,
+          facts.externalData,
+          chartPartPath,
+          this.resolveImagePath.bind(this)
+        );
         const hasPicture = filled.series.some(
           (entry2) => entry2.picture || entry2.impliedPicture || entry2.dataPoints?.some((point2) => point2.picture || point2.impliedPicture)
         );
@@ -141510,6 +141890,14 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
           ...built.filtered,
           title: neutralTitleText(neutral.title),
           ...titleRuns ? { titleRuns } : {},
+          titleTextEditable,
+          dataLabelTextEditable,
+          ...dataLabelTextEditable ? {
+            dataLabelSourceShape: {
+              categoryCount: filled.categories.length,
+              seriesValueCounts: filled.series.map((series) => series.values.length)
+            }
+          } : {},
           style,
           grouping: groupOptions.grouping,
           ...groupOptions,
@@ -142007,6 +142395,8 @@ var init_PptxHandlerRuntimeLoadSession = __esm({
         this.slideMap.clear();
         this.savedSlideFingerprints.clear();
         this.chartDataBaselines.clear();
+        this.chartWorkbookDataBaselines.clear();
+        this.pendingChartUpdates = void 0;
         this.layoutCache.clear();
         this.masterCache.clear();
         this.templateElementBaselines.reset();
@@ -142496,6 +142886,8 @@ var init_PptxHandlerRuntimeLoadPipeline = __esm({
         this.slideMap.clear();
         this.savedSlideFingerprints.clear();
         this.chartDataBaselines.clear();
+        this.chartWorkbookDataBaselines.clear();
+        this.pendingChartUpdates = void 0;
         this.slideRelsMap.clear();
         this.externalRelsMap.clear();
         this.layoutCache.clear();
@@ -146841,11 +147233,16 @@ function duplicateSlide(slide, newSlideNumber) {
   cloned.elements = cloned.elements.map(reassignElementId);
   if (cloned.animations && cloned.animations.length > 0) {
     const idMap = /* @__PURE__ */ new Map();
-    slide.elements.forEach((originalEl, idx) => {
-      if (idx < cloned.elements.length) {
-        idMap.set(originalEl.id, cloned.elements[idx].id);
-      }
-    });
+    const mapElements = (originals, copies) => {
+      originals.forEach((original, index) => {
+        const copy = copies[index];
+        if (!copy) return;
+        idMap.set(original.id, copy.id);
+        if (original.type === "group" && copy.type === "group")
+          mapElements(original.children, copy.children);
+      });
+    };
+    mapElements(slide.elements, cloned.elements);
     cloned.animations = cloned.animations.map((anim) => ({
       ...anim,
       elementId: idMap.get(anim.elementId) ?? anim.elementId
@@ -149680,15 +150077,26 @@ init_font_substitution();
 var DEFAULT_FONT_SIZE = 18;
 var FALLBACK_PAD_FACTOR = 0.06;
 function drawTextSegments(ctx, segments, bodyStyle, w, h2, scaleFactor = 1) {
-  const padL = bodyStyle?.bodyInsetLeft ? bodyStyle.bodyInsetLeft * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
-  const padR = bodyStyle?.bodyInsetRight ? bodyStyle.bodyInsetRight * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
-  const padT = bodyStyle?.bodyInsetTop ? bodyStyle.bodyInsetTop * scaleFactor : Math.round(h2 * FALLBACK_PAD_FACTOR);
-  const padB = bodyStyle?.bodyInsetBottom ? bodyStyle.bodyInsetBottom * scaleFactor : Math.round(h2 * FALLBACK_PAD_FACTOR);
+  const padL = bodyStyle?.bodyInsetLeft !== void 0 ? bodyStyle.bodyInsetLeft * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
+  const padR = bodyStyle?.bodyInsetRight !== void 0 ? bodyStyle.bodyInsetRight * scaleFactor : Math.round(w * FALLBACK_PAD_FACTOR);
+  const padT = bodyStyle?.bodyInsetTop !== void 0 ? bodyStyle.bodyInsetTop * scaleFactor : Math.round(h2 * FALLBACK_PAD_FACTOR);
+  const padB = bodyStyle?.bodyInsetBottom !== void 0 ? bodyStyle.bodyInsetBottom * scaleFactor : Math.round(h2 * FALLBACK_PAD_FACTOR);
   const maxWidth = w - padL - padR;
   if (maxWidth <= 0) {
     return;
   }
-  const paragraphs = splitIntoParagraphs(segments);
+  const paragraphs = splitIntoParagraphs(
+    segments.map((segment) => ({
+      ...segment,
+      style: {
+        ...bodyStyle,
+        ...Object.fromEntries(
+          Object.entries(segment.style).filter(([, value]) => value !== void 0)
+        )
+      }
+    })),
+    bodyStyle
+  );
   const lines = layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor);
   if (lines.length === 0) {
     return;
@@ -149724,33 +150132,58 @@ function drawTextSegments(ctx, segments, bodyStyle, w, h2, scaleFactor = 1) {
     y += line2.height * 0.3;
   }
 }
-function splitIntoParagraphs(segments) {
-  const paragraphs = [[]];
+function splitIntoParagraphs(segments, bodyStyle) {
+  const paragraphs = [{ segments: [], style: bodyStyle ?? {} }];
   for (const seg of segments) {
-    if (seg.isParagraphBreak) {
-      paragraphs.push([]);
-    } else if (seg.text) {
-      paragraphs[paragraphs.length - 1].push(seg);
+    if (seg.isParagraphBreak || seg.text === "\n" && !seg.isLineBreak) {
+      paragraphs.push({ segments: [], style: seg.style });
+    } else if (seg.text || seg.isLineBreak) {
+      paragraphs[paragraphs.length - 1].segments.push(seg);
     }
   }
-  return paragraphs.filter((p) => p.length > 0);
+  return paragraphs;
 }
 function layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor) {
   const lines = [];
-  for (const para of paragraphs) {
-    const paraAlign = para[0]?.style?.align;
+  for (const paragraph of paragraphs) {
+    const para = paragraph.segments;
+    const paraAlign = para[0]?.style.align ?? paragraph.style.align;
     let currentLine = [];
     let lineWidth = 0;
     let lineHeight = 0;
+    let fallbackHeight = (para[0]?.style.fontSize ?? paragraph.style.fontSize ?? DEFAULT_FONT_SIZE) * scaleFactor * 1.2;
+    const flushLine = () => {
+      while (currentLine.length > 0 && /^\s+$/.test(currentLine[currentLine.length - 1].text)) {
+        lineWidth -= currentLine.pop().measuredWidth;
+      }
+      lines.push({
+        runs: currentLine,
+        width: lineWidth,
+        height: lineHeight || fallbackHeight,
+        align: paraAlign
+      });
+      currentLine = [];
+      lineWidth = 0;
+      lineHeight = 0;
+    };
     for (const seg of para) {
       ctx.font = buildFont(seg.style, scaleFactor);
       const fontSize = (seg.style.fontSize ?? DEFAULT_FONT_SIZE) * scaleFactor;
       const segHeight = fontSize * 1.2;
-      const tokens = seg.text.split(/(?<=\s)(?=\S)|(?<=\S)(?=\s)/);
+      fallbackHeight = segHeight;
+      if (seg.isLineBreak) {
+        flushLine();
+        continue;
+      }
+      const tokens = seg.text.split(/(\r\n|\r|\n)|(?<=\s)(?=\S)|(?<=\S)(?=\s)/);
       for (const raw of tokens) {
         if (!raw) {
           continue;
         }
+        if (/^(\r\n|\r|\n)$/.test(raw)) {
+          flushLine();
+          continue;
+        }
         if (/^\s+$/.test(raw)) {
           if (currentLine.length > 0) {
             const spaceW = ctx.measureText(raw).width;
@@ -149766,19 +150199,7 @@ function layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor) {
         const word = raw;
         const wordW = ctx.measureText(word).width;
         if (lineWidth + wordW > maxWidth && currentLine.length > 0) {
-          while (currentLine.length > 0 && /^\s+$/.test(currentLine[currentLine.length - 1].text)) {
-            const removed = currentLine.pop();
-            lineWidth -= removed.measuredWidth;
-          }
-          lines.push({
-            runs: currentLine,
-            width: lineWidth,
-            height: lineHeight,
-            align: paraAlign
-          });
-          currentLine = [];
-          lineWidth = 0;
-          lineHeight = 0;
+          flushLine();
         }
         currentLine.push({
           text: word,
@@ -149789,14 +150210,7 @@ function layoutParagraphs(ctx, paragraphs, maxWidth, scaleFactor) {
         lineHeight = Math.max(lineHeight, segHeight);
       }
     }
-    if (currentLine.length > 0) {
-      lines.push({
-        runs: currentLine,
-        width: lineWidth,
-        height: lineHeight,
-        align: paraAlign
-      });
-    }
+    flushLine();
   }
   return lines;
 }