pptx-react-viewer 3.17.1 → 3.18.0

package/dist/{chunk-4SPZ5IZN.js → chunk-V32F4I45.js}

@@ -8122,11 +8122,11 @@ function createBuiltinVariables(ctx) {
   vars.set("b", h2);
   vars.set("hc", w / 2);
   vars.set("vc", h2 / 2);
-  const widthDivisors = [2, 3, 4, 5, 6, 8, 10, 12];
+  const widthDivisors = [2, 3, 4, 5, 6, 8, 10, 12, 16, 32];
   for (const d of widthDivisors) {
     vars.set(`wd${d}`, w / d);
   }
-  const heightDivisors = [2, 3, 4, 5, 6, 8, 10, 12];
+  const heightDivisors = [2, 3, 4, 5, 6, 8, 10, 12, 16, 32];
   for (const d of heightDivisors) {
     vars.set(`hd${d}`, h2 / d);
   }
@@ -37112,9 +37112,9 @@ function compoundChildIds(role, node, childrenOf) {
   const children13 = childrenOf.get(node.id) ?? [];
   const start = role.presentationOf?.start?.[chIndex] ?? 1;
   const count = role.presentationOf?.count?.[chIndex];
-  const positions2 = positionRange(start, count, 1, children13.length);
+  const positions = positionRange(start, count, 1, children13.length);
   const ids = [];
-  for (const position2 of positions2) {
+  for (const position2 of positions) {
     const child262 = children13[position2 - 1];
     if (!child262 || child262.text.trim().length === 0) {
       continue;
@@ -48835,7 +48835,7 @@ function parseValueColors(node, colorParser) {
   return colors.length > 0 ? colors : void 0;
 }
 function parseValueColorPositions(node, xmlLookup) {
-  const positions2 = [];
+  const positions = [];
   for (const posNode of xmlLookup.getChildrenArrayByLocalName(node, "pos")) {
     const kind = POSITION_KIND_MAP[String(posNode["@_type"] ?? "").trim()];
     if (!kind) {
@@ -48849,9 +48849,9 @@ function parseValueColorPositions(node, xmlLookup) {
         entry2.value = num;
       }
     }
-    positions2.push(entry2);
+    positions.push(entry2);
   }
-  return positions2.length > 0 ? positions2 : void 0;
+  return positions.length > 0 ? positions : void 0;
 }
 function parseCxValueColors(series, xmlLookup, colorParser) {
   const valueColorsNode = xmlLookup.getChildByLocalName(series, "valueColors");
@@ -48867,9 +48867,9 @@ function parseCxValueColors(series, xmlLookup, colorParser) {
     }
   }
   if (valueColorPositionsNode) {
-    const positions2 = parseValueColorPositions(valueColorPositionsNode, xmlLookup);
-    if (positions2) {
-      result.valueColorPositions = positions2;
+    const positions = parseValueColorPositions(valueColorPositionsNode, xmlLookup);
+    if (positions) {
+      result.valueColorPositions = positions;
     }
   }
   return Object.keys(result).length > 0 ? result : void 0;
@@ -51605,6 +51605,55 @@ function toStrictNamespaceUri(uri) {
 function isTransitionalNamespaceUri(uri) {
   return TRANSITIONAL_TO_STRICT_NS.has(uri) || deriveStrictUri(uri) !== void 0;
 }
+function isXmlWhitespace(char) {
+  return char.trim().length === 0;
+}
+function isConvertibleAttributeName(name) {
+  return name === "Type" || name === "uri" || name === "xmlns" || name.startsWith("xmlns:") && /^[A-Za-z_][\w.-]*$/u.test(name.slice("xmlns:".length));
+}
+function containsConvertibleStrictNamespaceAttribute(xml) {
+  let index = 0;
+  while (index < xml.length) {
+    while (index < xml.length && !isXmlWhitespace(xml[index])) {
+      index++;
+    }
+    while (index < xml.length && isXmlWhitespace(xml[index])) {
+      index++;
+    }
+    const nameStart = index;
+    while (index < xml.length && !isXmlWhitespace(xml[index]) && xml[index] !== "=") {
+      index++;
+    }
+    const name = xml.slice(nameStart, index);
+    if (!isConvertibleAttributeName(name)) {
+      continue;
+    }
+    while (index < xml.length && isXmlWhitespace(xml[index])) {
+      index++;
+    }
+    if (xml[index] !== "=") {
+      continue;
+    }
+    index++;
+    while (index < xml.length && isXmlWhitespace(xml[index])) {
+      index++;
+    }
+    const quote = xml[index];
+    if (quote !== '"' && quote !== "'") {
+      continue;
+    }
+    const valueStart = ++index;
+    const valueEnd = xml.indexOf(quote, valueStart);
+    if (valueEnd === -1) {
+      return false;
+    }
+    if (isTransitionalNamespaceUri(xml.slice(valueStart, valueEnd))) {
+      return true;
+    }
+    index = valueEnd + 1;
+  }
+  return false;
+}
 function convertXmlToStrict(node, setConformance = false) {
   if (typeof node !== "object" || node === null || Array.isArray(node)) {
     return node;
@@ -52067,6 +52116,178 @@ var init_activex_serializer = __esm({
   "src/core/utils/activex-serializer.ts"() {
   }
 });
+function parseShapeId(value, allowZero = false) {
+  const text22 = String(value ?? "").trim();
+  if (!/^\d+$/.test(text22)) {
+    return void 0;
+  }
+  const id = Number(text22);
+  return Number.isSafeInteger(id) && id >= (allowZero ? 0 : 1) && id <= MAX_SHAPE_ID ? id : void 0;
+}
+function visitXmlObjects(value, visit, tag = "") {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      visitXmlObjects(item, visit, tag);
+    }
+  } else if (value && typeof value === "object") {
+    const node = value;
+    visit(node, tag);
+    for (const [key2, child262] of Object.entries(node)) {
+      if (!key2.startsWith("@_")) {
+        visitXmlObjects(child262, visit, key2);
+      }
+    }
+  }
+}
+function remapAttribute(node, attribute6, ids) {
+  const current = node[attribute6];
+  if (current === void 0) {
+    return;
+  }
+  const replacement = ids.get(String(current).trim());
+  if (replacement !== void 0) {
+    node[attribute6] = replacement;
+  }
+}
+function remapShapeIdReferences(root, ids) {
+  if (ids.size === 0) {
+    return;
+  }
+  visitXmlObjects(root, (node, tag) => {
+    if (ID_REFERENCE_TAGS.has(tag)) {
+      remapAttribute(node, "@_id", ids);
+    } else if (SPID_REFERENCE_TAGS.has(tag)) {
+      remapAttribute(node, "@_spid", ids);
+    } else if (tag === "pptx:animation") {
+      for (const attribute6 of EDITOR_ANIMATION_ID_ATTRIBUTES) {
+        remapAttribute(node, attribute6, ids);
+      }
+    }
+  });
+}
+function findCnvPrNode(rawXml) {
+  if (!rawXml) {
+    return void 0;
+  }
+  for (const nvTag of NV_CONTAINER_TAGS) {
+    const nv = rawXml[nvTag];
+    const cNvPr = nv?.["p:cNvPr"] ?? nv?.["p14:cNvPr"];
+    if (cNvPr) {
+      return cNvPr;
+    }
+  }
+  return void 0;
+}
+function flattenElements(elements2, out) {
+  for (const element of elements2) {
+    out.push(element);
+    if (element.type === "group" && Array.isArray(element.children)) {
+      flattenElements(element.children, out);
+    }
+  }
+}
+function remapElementShapeIds(elements2, ids) {
+  if (ids.size === 0) {
+    return 0;
+  }
+  const flat = [];
+  flattenElements(elements2, flat);
+  const declaredId = (element) => {
+    const cNvPr = findCnvPrNode(element.rawXml);
+    if (cNvPr?.["@_id"] !== void 0) {
+      return String(cNvPr["@_id"]).trim();
+    }
+    return element.shapeId;
+  };
+  const holders = /* @__PURE__ */ new Map();
+  for (const element of flat) {
+    const declared = declaredId(element);
+    if (declared !== void 0 && ids.has(declared)) {
+      holders.set(declared, (holders.get(declared) ?? 0) + 1);
+    }
+  }
+  const keptKeys = /* @__PURE__ */ new Set();
+  const inPlaceRepairedIds = /* @__PURE__ */ new Set();
+  for (const element of flat) {
+    const rawId = findCnvPrNode(element.rawXml)?.["@_id"];
+    if (rawId !== void 0) {
+      inPlaceRepairedIds.add(String(rawId).trim());
+    }
+  }
+  let changed = 0;
+  for (const element of flat) {
+    const rawXml = element.rawXml;
+    const cNvPr = findCnvPrNode(rawXml);
+    const rawId = cNvPr?.["@_id"] === void 0 ? void 0 : String(cNvPr["@_id"]).trim();
+    const declared = rawId ?? element.shapeId;
+    let touched = false;
+    if (declared !== void 0 && ids.has(declared)) {
+      const fresh = ids.get(declared);
+      const retainsOldId = inPlaceRepairedIds.has(fresh);
+      if (!retainsOldId && ((holders.get(declared) ?? 0) === 1 || keptKeys.has(declared))) {
+        if (cNvPr && rawId !== void 0) {
+          cNvPr["@_id"] = fresh;
+        }
+        if (element.shapeId !== void 0) {
+          element.shapeId = fresh;
+        }
+        touched = true;
+      } else if (!retainsOldId) {
+        keptKeys.add(declared);
+      }
+    } else if (rawId !== void 0 && element.shapeId !== void 0 && element.shapeId !== rawId) {
+      if (ids.get(element.shapeId) === rawId) {
+        element.shapeId = rawId;
+        touched = true;
+      }
+    }
+    if (rawXml) {
+      remapShapeIdReferences(rawXml, ids);
+    }
+    const style = "shapeStyle" in element ? element.shapeStyle : void 0;
+    for (const connection of [style?.connectorStartConnection, style?.connectorEndConnection]) {
+      const replacement = connection?.shapeId === void 0 ? void 0 : ids.get(connection.shapeId.trim());
+      if (connection && replacement !== void 0) {
+        connection.shapeId = replacement;
+        touched = true;
+      }
+    }
+    if (touched) {
+      changed += 1;
+    }
+  }
+  return changed;
+}
+var MAX_SHAPE_ID;
+var ID_REFERENCE_TAGS;
+var SPID_REFERENCE_TAGS;
+var EDITOR_ANIMATION_ID_ATTRIBUTES;
+var NV_CONTAINER_TAGS;
+var init_shape_ids = __esm({
+  "src/core/utils/shape-ids.ts"() {
+    MAX_SHAPE_ID = 4294967295;
+    ID_REFERENCE_TAGS = /* @__PURE__ */ new Set(["a:stCxn", "a:endCxn"]);
+    SPID_REFERENCE_TAGS = /* @__PURE__ */ new Set([
+      "p:spTgt",
+      "p:bldP",
+      "p:bldOleChart",
+      "p:bldDgm",
+      "p:bldGraphic",
+      "p:inkTgt",
+      "p:control"
+    ]);
+    EDITOR_ANIMATION_ID_ATTRIBUTES = ["@_elementId", "@_triggerShapeId"];
+    NV_CONTAINER_TAGS = [
+      "p:nvSpPr",
+      "p:nvPicPr",
+      "p:nvCxnSpPr",
+      "p:nvGrpSpPr",
+      "p:nvGraphicFramePr",
+      "p:nvContentPartPr",
+      "p14:nvContentPartPr"
+    ];
+  }
+});
 function parseKinsoku(presentationXml3) {
   if (!presentationXml3) {
     return void 0;
@@ -52779,6 +53000,19 @@ var init_font_substitution = __esm({
       // fallbacks must stay condensed, or short numeric labels sized to the
       // narrow face overflow their text boxes and wrap (issue #132, "77%").
       "Bebas Neue": ["Oswald", "Arial Narrow", "Impact", "sans-serif"],
+      // Office stores named Source Sans weights as separate family names (e.g. a
+      // theme authored with "Source Sans Pro ExtraLight" as its own face), while
+      // Google Fonts and most local installs expose the base family with a
+      // weight axis instead. Keep the authored face first for a browser that
+      // does have it installed under that exact name, then fall back to the
+      // metrically compatible base family before generic sans-serif.
+      "Source Sans Pro ExtraLight": [
+        "Source Sans Pro",
+        "Calibri Light",
+        "Segoe UI Light",
+        "Arial",
+        "sans-serif"
+      ],
       "Century Gothic": ["URW Gothic", "Futura", "sans-serif"],
       Oswald: ["Agency FB", "Arial Narrow", "sans-serif"],
       "Franklin Gothic": ["Liberation Sans", "Helvetica Neue", "sans-serif"],
@@ -52878,6 +53112,11 @@ var init_pptx_validator_conformance_xml = __esm({
     };
   }
 });
+var init_pptx_validator_content_order = __esm({
+  "src/core/utils/pptx-validator-content-order.ts"() {
+    init_pptx_validator_conformance_xml();
+  }
+});
 var init_pptx_validator_facet_constants = __esm({
   "src/core/utils/pptx-validator-facet-constants.ts"() {
   }
@@ -52898,6 +53137,12 @@ var init_pptx_validator_mce = __esm({
     init_pptx_validator_conformance_xml();
   }
 });
+var init_pptx_validator_slide_parts = __esm({
+  "src/core/utils/pptx-validator-slide-parts.ts"() {
+    init_pptx_validator_conformance_xml();
+    init_pptx_validator_content_order();
+  }
+});
 var init_pptx_validator_transitions = __esm({
   "src/core/utils/pptx-validator-transitions.ts"() {
     init_pptx_validator_conformance_xml();
@@ -52914,9 +53159,11 @@ var init_pptx_validator_transitions = __esm({
 var init_pptx_validator_conformance = __esm({
   "src/core/utils/pptx-validator-conformance.ts"() {
     init_pptx_validator_conformance_xml();
+    init_pptx_validator_content_order();
     init_pptx_validator_facets();
     init_pptx_validator_helpers();
     init_pptx_validator_mce();
+    init_pptx_validator_slide_parts();
     init_pptx_validator_transitions();
   }
 });
@@ -52989,6 +53236,192 @@ var init_pptx_validator = __esm({
     init_pptx_validator_repair();
   }
 });
+function normalizeFace(face) {
+  return face?.trim().toLowerCase() ?? "";
+}
+function themeFace(scheme, role, script) {
+  const group2 = role === "major" ? scheme?.majorFont : scheme?.minorFont;
+  return group2?.[script] || group2?.latin;
+}
+function parseThemeFontToken(token2) {
+  const match = token2?.trim().toLowerCase().match(TOKEN_PATTERN);
+  if (!match) {
+    return void 0;
+  }
+  const role = match[1] === "mj" ? "major" : "minor";
+  const script = match[2] === "ea" ? "eastAsia" : match[2] === "cs" ? "complexScript" : "latin";
+  return { role, script };
+}
+function placeholderFontRole(element) {
+  const placeholderType2 = element.placeholderType?.trim().toLowerCase();
+  if (!placeholderType2) {
+    return void 0;
+  }
+  return placeholderType2 === "title" || placeholderType2 === "ctrtitle" ? "major" : "minor";
+}
+function resolveFace(current, token2, script, oldScheme, newScheme, fallbackRole) {
+  const parsed = parseThemeFontToken(token2);
+  if (parsed) {
+    const linked = themeFace(newScheme, parsed.role, parsed.script);
+    return linked && linked !== current ? linked : void 0;
+  }
+  if (!fallbackRole || !current) {
+    return void 0;
+  }
+  const oldFace = themeFace(oldScheme, fallbackRole, script);
+  const newFace = themeFace(newScheme, fallbackRole, script);
+  if (!oldFace || !newFace || normalizeFace(current) !== normalizeFace(oldFace)) {
+    return void 0;
+  }
+  return newFace !== current ? newFace : void 0;
+}
+function remapTextStyleFonts(style, oldScheme, newScheme, fallbackRole) {
+  const latin = resolveFace(
+    style.fontFamily,
+    style.latinFontThemeToken,
+    "latin",
+    oldScheme,
+    newScheme,
+    fallbackRole
+  );
+  const eastAsia = resolveFace(
+    style.eastAsiaFont,
+    style.eastAsiaFontThemeToken,
+    "eastAsia",
+    oldScheme,
+    newScheme,
+    fallbackRole
+  );
+  const complexScript = resolveFace(
+    style.complexScriptFont,
+    style.complexScriptFontThemeToken,
+    "complexScript",
+    oldScheme,
+    newScheme,
+    fallbackRole
+  );
+  if (latin === void 0 && eastAsia === void 0 && complexScript === void 0) {
+    return style;
+  }
+  return {
+    ...style,
+    ...latin !== void 0 && { fontFamily: latin },
+    ...eastAsia !== void 0 && { eastAsiaFont: eastAsia },
+    ...complexScript !== void 0 && { complexScriptFont: complexScript }
+  };
+}
+function remapSegmentFonts(segments, oldScheme, newScheme, fallbackRole) {
+  let changed = false;
+  const next = segments.map((segment) => {
+    if (!segment.style) {
+      return segment;
+    }
+    const style = remapTextStyleFonts(segment.style, oldScheme, newScheme, fallbackRole);
+    if (style === segment.style) {
+      return segment;
+    }
+    changed = true;
+    return { ...segment, style };
+  });
+  return changed ? next : segments;
+}
+function remapTableFonts(tableData, oldScheme, newScheme) {
+  let changed = false;
+  const rows = tableData.rows.map((row) => {
+    let rowChanged = false;
+    const cells2 = row.cells.map((cell) => {
+      const face = resolveFace(
+        cell.style?.fontFamily,
+        void 0,
+        "latin",
+        oldScheme,
+        newScheme,
+        "minor"
+      );
+      if (face === void 0) {
+        return cell;
+      }
+      rowChanged = true;
+      return { ...cell, style: { ...cell.style, fontFamily: face } };
+    });
+    if (!rowChanged) {
+      return row;
+    }
+    changed = true;
+    return { ...row, cells: cells2 };
+  });
+  return changed ? { ...tableData, rows } : tableData;
+}
+function remapElementFonts(element, oldScheme, newScheme) {
+  const patched = { ...element };
+  let changed = false;
+  const fallbackRole = placeholderFontRole(element);
+  if ("textStyle" in element && element.textStyle) {
+    const textStyle = remapTextStyleFonts(element.textStyle, oldScheme, newScheme, fallbackRole);
+    if (textStyle !== element.textStyle) {
+      patched.textStyle = textStyle;
+      changed = true;
+    }
+  }
+  if ("textSegments" in element && element.textSegments) {
+    const textSegments = remapSegmentFonts(
+      element.textSegments,
+      oldScheme,
+      newScheme,
+      fallbackRole
+    );
+    if (textSegments !== element.textSegments) {
+      patched.textSegments = textSegments;
+      changed = true;
+    }
+  }
+  if (element.type === "group" && element.children) {
+    const children13 = reResolveElementFonts(element.children, oldScheme, newScheme);
+    if (children13 !== element.children) {
+      patched.children = children13;
+      changed = true;
+    }
+  }
+  if (element.type === "table" && element.tableData) {
+    const tableData = remapTableFonts(element.tableData, oldScheme, newScheme);
+    if (tableData !== element.tableData) {
+      patched.tableData = tableData;
+      changed = true;
+    }
+  }
+  return changed ? patched : element;
+}
+function reResolveElementFonts(elements2, oldFontScheme, newFontScheme) {
+  let changed = false;
+  const next = elements2.map((element) => {
+    const remapped = remapElementFonts(element, oldFontScheme, newFontScheme);
+    if (remapped !== element) {
+      changed = true;
+    }
+    return remapped;
+  });
+  return changed ? next : elements2;
+}
+function reResolveSlideFonts(slides, oldFontScheme, newFontScheme) {
+  let changed = false;
+  const next = slides.map((slide) => {
+    const elements2 = reResolveElementFonts(slide.elements, oldFontScheme, newFontScheme);
+    const notesSegments = slide.notesSegments ? remapSegmentFonts(slide.notesSegments, oldFontScheme, newFontScheme, "minor") : slide.notesSegments;
+    const notesShapes = slide.notesShapes ? reResolveElementFonts(slide.notesShapes, oldFontScheme, newFontScheme) : slide.notesShapes;
+    if (elements2 === slide.elements && notesSegments === slide.notesSegments && notesShapes === slide.notesShapes) {
+      return slide;
+    }
+    changed = true;
+    return { ...slide, elements: elements2, notesSegments, notesShapes };
+  });
+  return changed ? next : slides;
+}
+var TOKEN_PATTERN;
+var init_theme_font_switching = __esm({
+  "src/core/utils/theme-font-switching.ts"() {
+    TOKEN_PATTERN = /^\+(mj|mn)-(lt|ea|cs)$/u;
+  }
+});
 function normalizeHex2(hex4) {
   if (!hex4) {
     return "";
@@ -53001,7 +53434,7 @@ function buildColorRemapTable(oldColorMap, newColorMap) {
   for (const key2 of allKeys) {
     const oldVal = normalizeHex2(oldColorMap[key2]);
     const newVal = normalizeHex2(newColorMap[key2]);
-    if (oldVal && newVal && oldVal !== newVal) {
+    if (oldVal && newVal && oldVal !== newVal && !remap.has(oldVal)) {
       remap.set(oldVal, `#${newVal}`);
       remap.set(`#${oldVal}`, `#${newVal}`);
     }
@@ -53219,7 +53652,8 @@ function reResolveElementColors(elements2, oldColorMap, newColorScheme) {
 function applyThemeToData(data, newColorScheme, newFontScheme, themeName) {
   const oldColorMap = data.themeColorMap ?? {};
   const newColorMap = buildThemeColorMap(newColorScheme);
-  const newSlides = reResolveSlideColors(data.slides, oldColorMap, newColorScheme);
+  const recolouredSlides = reResolveSlideColors(data.slides, oldColorMap, newColorScheme);
+  const newSlides = newFontScheme ? reResolveSlideFonts(recolouredSlides, data.theme?.fontScheme, newFontScheme) : recolouredSlides;
   const newTheme = {
     ...data.theme,
     colorScheme: newColorScheme,
@@ -53238,6 +53672,7 @@ var init_theme_switching = __esm({
     init_theme_color_ref();
     init_theme();
     init_gradient_angle();
+    init_theme_font_switching();
   }
 });
 function applyThemeOverrideToSlide(slide, baseColorScheme, nextOverride) {
@@ -60223,6 +60658,7 @@ var init_utils = __esm({
     init_vml_parser();
     init_activex_parser();
     init_activex_serializer();
+    init_shape_ids();
     init_kinsoku_parser();
     init_smart_tags_parser();
     init_header_footer_placeholder();
@@ -60232,6 +60668,7 @@ var init_utils = __esm({
     init_font_substitution();
     init_pptx_validator();
     init_theme_switching();
+    init_theme_font_switching();
     init_slide_theme_override();
     init_smartart_layout_definition();
     init_smartart_definition_metadata();
@@ -60474,14 +60911,109 @@ var init_custom_geometry_live_eval = __esm({
     ensureArray7 = (value) => ensureArrayValue(value);
   }
 });
-var init_connector_elbow_geometry = __esm({
-  "src/core/geometry/connector-elbow-geometry.ts"() {
+function formatCoordinate(value) {
+  return String(Number(value.toFixed(12)));
+}
+function flipPresetPath(pathData, width, height, flipH, flipV) {
+  const tokens = pathData.match(PATH_TOKEN);
+  if (!tokens) {
+    return void 0;
   }
-});
+  const output = [];
+  let command = "";
+  let coordinateIndex = 0;
+  for (const token2 of tokens) {
+    if (/^[A-Z]$/u.test(token2)) {
+      command = token2;
+      coordinateIndex = 0;
+      if (!(command in COMMAND_ARITY)) {
+        return void 0;
+      }
+      output.push(command);
+      continue;
+    }
+    const arity = COMMAND_ARITY[command];
+    if (!arity || coordinateIndex >= arity) {
+      return void 0;
+    }
+    const value = Number(token2);
+    const isX = coordinateIndex % 2 === 0;
+    const flipped = isX ? flipH ? width - value : value : flipV ? height - value : value;
+    output.push(formatCoordinate(flipped));
+    coordinateIndex += 1;
+  }
+  return output.join(" ");
+}
+function evaluateConnectorPresetPath(shapeType, width, height, adjustments, flipH, flipV) {
+  if (!CONNECTOR_PRESET.test(shapeType)) {
+    return void 0;
+  }
+  const pathData = evaluatePresetShape(shapeType, width, height, adjustments)?.svgPath;
+  if (!pathData || !flipH && !flipV) {
+    return pathData;
+  }
+  return flipPresetPath(pathData, width, height, flipH, flipV);
+}
+var CONNECTOR_PRESET;
+var PATH_TOKEN;
+var COMMAND_ARITY;
+var init_connector_preset_geometry = __esm({
+  "src/core/geometry/connector-preset-geometry.ts"() {
+    init_preset_shape_evaluator();
+    CONNECTOR_PRESET = /^(?:bent|curved)connector[2-5]$/iu;
+    PATH_TOKEN = /[MLQCZ]|[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/giu;
+    COMMAND_ARITY = {
+      M: 2,
+      L: 2,
+      Q: 4,
+      C: 6,
+      Z: 0
+    };
+  }
+});
+function getConnectorPathGeometry(element) {
+  const width = Math.max(element.width, 0);
+  const height = Math.max(element.height, 0);
+  const shapeType = element.shapeType || "";
+  const point = (x, y) => `${x} ${y}`;
+  const rawSpPr = element.rawXml?.["p:spPr"];
+  const rawXfrm = rawSpPr?.["a:xfrm"];
+  const xmlBoolean = (value) => value === true || value === 1 || value === "1" || value === "true";
+  const flipH = element.flipHorizontal ?? xmlBoolean(rawXfrm?.["@_flipH"]);
+  const flipV = element.flipVertical ?? xmlBoolean(rawXfrm?.["@_flipV"]);
+  const startX2 = flipH ? width : 0;
+  const startY = flipV ? height : 0;
+  const endX = flipH ? 0 : width;
+  const endY = flipV ? 0 : height;
+  const presetPath = evaluateConnectorPresetPath(
+    shapeType,
+    width,
+    height,
+    element.shapeAdjustments,
+    flipH,
+    flipV
+  );
+  if (presetPath) {
+    return {
+      startX: startX2,
+      startY,
+      endX,
+      endY,
+      pathData: presetPath
+    };
+  }
+  return {
+    startX: startX2,
+    startY,
+    endX,
+    endY,
+    pathData: `M ${point(startX2, startY)} L ${point(endX, endY)}`
+  };
+}
 var init_connector_geometry = __esm({
   "src/core/geometry/connector-geometry.ts"() {
     init_color_primitives();
-    init_connector_elbow_geometry();
+    init_connector_preset_geometry();
   }
 });
 function isTextOrientationMatrix(value) {
@@ -70088,39 +70620,76 @@ function collectCnvPrNodes(node, results, ensureArray20) {
     }
   }
 }
+var ShapeIdAllocator;
 var PptxShapeIdValidator;
 var init_PptxShapeIdValidator = __esm({
   "src/core/core/builders/PptxShapeIdValidator.ts"() {
+    init_shape_ids();
+    ShapeIdAllocator = class {
+      constructor(used, maxId) {
+        this.used = used;
+        this.maxId = maxId;
+      }
+      used;
+      maxId;
+      gapCursor = 1;
+      next() {
+        if (this.maxId < MAX_SHAPE_ID) {
+          this.maxId += 1;
+          this.used.add(this.maxId);
+          return this.maxId;
+        }
+        while (this.gapCursor <= MAX_SHAPE_ID && this.used.has(this.gapCursor)) {
+          this.gapCursor += 1;
+        }
+        if (this.gapCursor > MAX_SHAPE_ID) {
+          throw new Error("No free DrawingML shape id left in this shape tree.");
+        }
+        this.used.add(this.gapCursor);
+        return this.gapCursor;
+      }
+    };
     PptxShapeIdValidator = class {
-      validateAndDeduplicateIds(spTree, ensureArray20) {
+      validateAndDeduplicateIds(spTree, ensureArray20, referenceRoot = spTree) {
+        return this.repairShapeIds(spTree, ensureArray20, referenceRoot).reassigned;
+      }
+      /**
+       * Same repair, but also returns the old-id -> new-id map so a caller can
+       * replay it onto state that lives outside `referenceRoot` (the live element
+       * model, a cached `rawTiming`, typed ActiveX controls).
+       */
+      repairShapeIds(spTree, ensureArray20, referenceRoot = spTree) {
+        const ids = /* @__PURE__ */ new Map();
         const cNvPrNodes = [];
         collectCnvPrNodes(spTree, cNvPrNodes, ensureArray20);
         if (cNvPrNodes.length === 0) {
-          return 0;
+          return { reassigned: 0, ids };
         }
         const usedIds = /* @__PURE__ */ new Set();
-        const duplicates = [];
+        const invalid = [];
         let maxId = 0;
         for (const cNvPr of cNvPrNodes) {
-          const idRaw = Number.parseInt(String(cNvPr["@_id"] ?? "0"), 10);
-          const id = Number.isFinite(idRaw) ? idRaw : 0;
+          const id = parseShapeId(cNvPr["@_id"], true);
+          if (id === void 0 || id === 0 || usedIds.has(id)) {
+            invalid.push(cNvPr);
+            continue;
+          }
+          usedIds.add(id);
           if (id > maxId) {
             maxId = id;
           }
-          if (id === 0 || usedIds.has(id)) {
-            duplicates.push(cNvPr);
-          } else {
-            usedIds.add(id);
-          }
         }
-        let reassigned = 0;
-        for (const cNvPr of duplicates) {
-          maxId += 1;
-          cNvPr["@_id"] = String(maxId);
-          usedIds.add(maxId);
-          reassigned += 1;
+        const allocator = new ShapeIdAllocator(usedIds, maxId);
+        for (const cNvPr of invalid) {
+          const oldId = String(cNvPr["@_id"] ?? "").trim();
+          const fresh = String(allocator.next());
+          cNvPr["@_id"] = fresh;
+          if (oldId.length > 0) {
+            ids.set(oldId, fresh);
+          }
         }
-        return reassigned;
+        remapShapeIdReferences(referenceRoot, ids);
+        return { reassigned: invalid.length, ids };
       }
     };
   }
@@ -78503,6 +79072,62 @@ var init_embedded_font_list = __esm({
     };
   }
 });
+function partRelsPath(partPath) {
+  const lastSlash = partPath.lastIndexOf("/");
+  if (lastSlash < 0) {
+    return `_rels/${partPath}.rels`;
+  }
+  const directory = partPath.slice(0, lastSlash);
+  const fileName = partPath.slice(lastSlash + 1);
+  return `${directory}/_rels/${fileName}.rels`;
+}
+var init_part_rels_path = __esm({
+  "src/core/utils/part-rels-path.ts"() {
+  }
+});
+function isEmptyTextElement(element) {
+  if (element.type !== "text" || !hasTextProperties(element)) {
+    return false;
+  }
+  if (element.text && element.text.trim().length > 0) {
+    return false;
+  }
+  return !element.textSegments?.some((segment) => segment.text.trim().length > 0);
+}
+function enrichEmptyPlaceholderPrompts(elements2, resolver) {
+  return elements2.map((element) => {
+    if (!isEmptyTextElement(element) || element.promptText) {
+      return element;
+    }
+    const defaults = resolver.resolveDefaults(element);
+    const placeholderType2 = resolver.placeholderType(element);
+    if (!defaults && placeholderType2 === void 0) {
+      return element;
+    }
+    const textStyle = { ...element.textStyle ?? {} };
+    if (defaults) {
+      resolver.applyBodyDefaults(textStyle, defaults);
+      const firstLevel = defaults.levelStyles?.[0];
+      if (firstLevel) {
+        resolver.applyLevelDefaults(textStyle, firstLevel);
+      }
+    }
+    const enriched = {
+      ...element,
+      ...defaults?.promptText ? { promptText: defaults.promptText } : {},
+      ...Object.keys(textStyle).length > 0 ? { textStyle } : {}
+    };
+    if (placeholderType2 !== void 0) {
+      enriched.placeholderType = placeholderType2;
+    }
+    return enriched;
+  });
+}
+var init_layout_switch_placeholder_prompts = __esm({
+  "src/core/core/runtime/layout-switch-placeholder-prompts.ts"() {
+    init_types();
+  }
+});
 var DEFAULT_MAX_UNCOMPRESSED_BYTES;
 var MAX_ZIP_ENTRY_COUNT;
 var ZipBombError;
@@ -81492,19 +82117,6 @@ var init_color_scheme_index = __esm({
     };
   }
 });
-function partRelsPath(partPath) {
-  const lastSlash = partPath.lastIndexOf("/");
-  if (lastSlash < 0) {
-    return `_rels/${partPath}.rels`;
-  }
-  const directory = partPath.slice(0, lastSlash);
-  const fileName = partPath.slice(lastSlash + 1);
-  return `${directory}/_rels/${fileName}.rels`;
-}
-var init_part_rels_path = __esm({
-  "src/core/utils/part-rels-path.ts"() {
-  }
-});
 function rememberAuxiliaryMasterUnparsedNodes(runtime, partPath, nodesByTag) {
   let byPart = unparsedNodesByRuntime.get(runtime);
   if (!byPart) {
@@ -81562,6 +82174,16 @@ function masterPartElementSignature(elements2) {
     return "";
   }
 }
+function templateElementSignature(element) {
+  try {
+    return JSON.stringify(
+      element,
+      (key2, value) => TEMPLATE_ELEMENT_SKIP_KEYS.has(key2) ? void 0 : value
+    );
+  } catch {
+    return "";
+  }
+}
 function rememberMasterPartElementSignature(runtime, partPath, elements2) {
   let byPart = signaturesByRuntime.get(runtime);
   if (!byPart) {
@@ -81582,6 +82204,7 @@ function masterPartElementsChanged(runtime, partPath, elements2) {
 }
 var signaturesByRuntime;
 var SIGNATURE_SKIP_KEYS;
+var TEMPLATE_ELEMENT_SKIP_KEYS;
 var init_master_part_element_signature = __esm({
   "src/core/core/runtime/master-part-element-signature.ts"() {
     signaturesByRuntime = /* @__PURE__ */ new WeakMap();
@@ -81593,6 +82216,10 @@ var init_master_part_element_signature = __esm({
       "posterSrc",
       "thumbnailSrc"
     ]);
+    TEMPLATE_ELEMENT_SKIP_KEYS = /* @__PURE__ */ new Set([
+      ...SIGNATURE_SKIP_KEYS,
+      "shapeId"
+    ]);
   }
 });
 function masterPartIdPrefix(rootTag2, partPath) {
@@ -82870,6 +83497,86 @@ var init_pptx_print_properties = __esm({
     findKey13 = (node, name) => Object.keys(node).find((key2) => localName20(key2) === name);
   }
 });
+function canonicalPlaceholderType(value) {
+  const text22 = String(value ?? "").trim();
+  if (text22.length === 0) {
+    return void 0;
+  }
+  return CANONICAL_BY_LOWER2.get(text22.toLowerCase());
+}
+function canonicalizePlaceholderTypes(root) {
+  let changed = 0;
+  const visit = (value, tag) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        visit(item, tag);
+      }
+      return;
+    }
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    const node = value;
+    if (tag === "p:ph" && node["@_type"] !== void 0) {
+      const canonical = canonicalPlaceholderType(node["@_type"]);
+      if (canonical !== void 0 && canonical !== String(node["@_type"])) {
+        node["@_type"] = canonical;
+        changed += 1;
+      }
+    }
+    for (const [key2, child262] of Object.entries(node)) {
+      if (!key2.startsWith("@_")) {
+        visit(child262, key2);
+      }
+    }
+  };
+  visit(root, "");
+  return changed;
+}
+var VALID_PLACEHOLDER_TYPES;
+var CANONICAL_BY_LOWER2;
+var init_placeholder_validation = __esm({
+  "src/core/utils/placeholder-validation.ts"() {
+    VALID_PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
+      "body",
+      "chart",
+      "clipArt",
+      "ctrTitle",
+      "dgm",
+      "dt",
+      "ftr",
+      "hdr",
+      "media",
+      "obj",
+      "pic",
+      "sldImg",
+      "sldNum",
+      "subTitle",
+      "tbl",
+      "title",
+      // Additional types from extended specs
+      "half",
+      "qtr",
+      "txAndClipArt",
+      "txAndChart",
+      "txAndMedia",
+      "txAndObj",
+      "txAndTwoObj",
+      "txOverObj",
+      "objAndTx",
+      "twoObj",
+      "twoObjAndObj",
+      "twoObjAndTx",
+      "twoObjOverTx",
+      "objOverTx",
+      "twoColTx",
+      "fourObj"
+    ]);
+    CANONICAL_BY_LOWER2 = new Map(
+      Array.from(VALID_PLACEHOLDER_TYPES, (type) => [type.toLowerCase(), type])
+    );
+  }
+});
 function elementRectEmu(el) {
   return {
     x: el.xEmu ?? Math.round(el.x * EMU_PER_PX),
@@ -84975,10 +85682,10 @@ var init_group_writer = __esm({
     ZERO_RECT = { x: 0, y: 0, w: 0, h: 0 };
   }
 });
-var ShapeIdAllocator;
+var ShapeIdAllocator2;
 var init_shape_id_allocator = __esm({
   "src/core/ppt/writer/shape-id-allocator.ts"() {
-    ShapeIdAllocator = class {
+    ShapeIdAllocator2 = class {
       current;
       constructor(drawingId, clusterSize) {
         this.current = drawingId * clusterSize - 1;
@@ -85014,7 +85721,7 @@ function buildBackgroundShape(rgb2, allocator) {
   return record(OA.SpContainer, data, 0, true);
 }
 function buildDrawing(canvasRect, shapes, backgroundRgb, fonts, drawingId, hyperlinks, oleEmbeds, mediaEmbeds) {
-  const allocator = new ShapeIdAllocator(drawingId, SHAPE_ID_CLUSTER_SIZE2);
+  const allocator = new ShapeIdAllocator2(drawingId, SHAPE_ID_CLUSTER_SIZE2);
   const spgrData = new ByteWriter().bytes(buildCanvasPatriarch(allocator));
   if (backgroundRgb) {
     spgrData.bytes(buildBackgroundShape(backgroundRgb, allocator));
@@ -91113,7 +91820,7 @@ function scorePlaceholderMatch(element, source, target) {
   }
   const sourceType = normalizeType(source.type);
   const targetType = normalizeType(target.type);
-  let score = 0;
+  let score = 1;
   if (source.idx !== void 0 && source.idx === target.idx) {
     score += 100;
   }
@@ -93645,11 +94352,97 @@ var init_SvgExporter = __esm({
     };
   }
 });
+var TemplateElementBaselineTracker;
+var init_template_element_baselines = __esm({
+  "src/core/core/runtime/template-element-baselines.ts"() {
+    init_master_part_element_signature();
+    TemplateElementBaselineTracker = class {
+      /** Element id -> signature of the copy the owning part currently holds. */
+      baselines = /* @__PURE__ */ new Map();
+      /** Copies superseded by a written edit; skipped on every later save. */
+      stale = /* @__PURE__ */ new WeakSet();
+      /** Element id -> signature written back during the save in progress. */
+      pending = /* @__PURE__ */ new Map();
+      /** Every copy the save in progress looked at, keyed by element id. */
+      seen = /* @__PURE__ */ new Map();
+      /** Forget everything; called wherever the other per-load caches are cleared. */
+      reset() {
+        this.baselines.clear();
+        this.pending.clear();
+        this.seen.clear();
+        this.stale = /* @__PURE__ */ new WeakSet();
+      }
+      /**
+       * Record the as-parsed signature of freshly produced inherited copies. A
+       * baseline is written once per id: a later re-parse of the same part (layout
+       * switch, preview decoding) must not move it, because the part's XML may by
+       * then already carry an edit the tracker has committed.
+       */
+      recordBaselines(elements2) {
+        for (const element of elements2) {
+          if (!this.baselines.has(element.id)) {
+            this.baselines.set(element.id, templateElementSignature(element));
+          }
+        }
+      }
+      /** Drop any bookkeeping left over from a save that did not complete. */
+      beginSave() {
+        this.pending.clear();
+        this.seen.clear();
+      }
+      /**
+       * Decide whether the save writer has to write this copy back into its
+       * part. `false` means the part already holds it (or a newer edit of it),
+       * so the shared `rawXml` must be left untouched.
+       */
+      shouldWriteBack(element) {
+        if (this.stale.has(element)) {
+          return false;
+        }
+        const signature = templateElementSignature(element);
+        this.remember(element, signature);
+        const baseline = this.baselines.get(element.id);
+        if (baseline !== void 0 && baseline === signature) {
+          return false;
+        }
+        this.pending.set(element.id, signature);
+        return true;
+      }
+      /**
+       * Promote the signatures written during this save to baselines, and mark
+       * every other copy of the same id that still matched the previous baseline
+       * as stale.
+       */
+      commitSave() {
+        for (const [id, signature] of this.pending) {
+          const previous = this.baselines.get(id);
+          for (const copy2 of this.seen.get(id) ?? []) {
+            if (copy2.signature !== signature && copy2.signature === previous) {
+              this.stale.add(copy2.element);
+            }
+          }
+          this.baselines.set(id, signature);
+        }
+        this.pending.clear();
+        this.seen.clear();
+      }
+      remember(element, signature) {
+        const copies = this.seen.get(element.id);
+        if (copies) {
+          copies.push({ element, signature });
+        } else {
+          this.seen.set(element.id, [{ element, signature }]);
+        }
+      }
+    };
+  }
+});
 var PptxHandlerRuntime;
 var init_PptxHandlerRuntimeState = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeState.ts"() {
     init_utils();
     init_part_rels_path();
+    init_template_element_baselines();
     PptxHandlerRuntime = class {
       /** The in-memory ZIP archive representing the OPC (.pptx) package. */
       zip;
@@ -93679,6 +94472,13 @@ var init_PptxHandlerRuntimeState = __esm({
       layoutCache = /* @__PURE__ */ new Map();
       /** Cached parsed master elements keyed by master archive path. */
       masterCache = /* @__PURE__ */ new Map();
+      /**
+       * As-parsed signatures of the `layout-` / `master-` element copies merged
+       * into slides, plus the copies a later edit has superseded. Lets the save
+       * writer patch a shared template `rawXml` node only from the copy that was
+       * actually edited; see `template-element-baselines.ts`.
+       */
+      templateElementBaselines = new TemplateElementBaselineTracker();
       /** Raw parsed layout XML objects keyed by layout archive path. */
       layoutXmlMap = /* @__PURE__ */ new Map();
       /** Raw parsed master XML objects keyed by master archive path. */
@@ -99527,6 +100327,7 @@ var init_PptxHandlerRuntimeTextEditing = __esm({
   }
 });
 var PptxHandlerRuntime21;
+var NON_MATERIALIZED_PLACEHOLDER_TYPES;
 var init_PptxHandlerRuntimeLayoutSwitching = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeLayoutSwitching.ts"() {
     init_constants();
@@ -99746,11 +100547,15 @@ var init_PptxHandlerRuntimeLayoutSwitching = __esm({
           ...slot,
           matched: false
         }));
-        const resultElements = [];
-        for (const element of elements2) {
+        const claimOrder = [
+          ...elements2.filter((element) => !this.isUntouchedPlaceholderPrompt(element)),
+          ...elements2.filter((element) => this.isUntouchedPlaceholderPrompt(element))
+        ];
+        const remappedByElement = /* @__PURE__ */ new Map();
+        for (const element of claimOrder) {
           const phInfo = this.getElementPlaceholderInfo(element);
           if (!phInfo) {
-            resultElements.push(element);
+            remappedByElement.set(element, element);
             continue;
           }
           let resolvedLayoutPh;
@@ -99789,18 +100594,31 @@ var init_PptxHandlerRuntimeLayoutSwitching = __esm({
             if (updatedElement.rawXml) {
               retargetPlaceholder(updatedElement.rawXml, resolvedLayoutPh.phInfo);
             }
-            resultElements.push(updatedElement);
-          } else if (!this.isUntouchedPlaceholderPrompt(element)) {
-            resultElements.push(element);
+            const retyped = updatedElement;
+            if (resolvedLayoutPh.phInfo.type) {
+              retyped.placeholderType = resolvedLayoutPh.phInfo.type;
+            } else {
+              delete retyped.placeholderType;
+            }
+            remappedByElement.set(element, updatedElement);
+          } else {
+            remappedByElement.set(element, this.isUntouchedPlaceholderPrompt(element) ? null : element);
+          }
+        }
+        const resultElements = [];
+        for (const element of elements2) {
+          const remapped = remappedByElement.get(element);
+          if (remapped) {
+            resultElements.push(remapped);
           }
         }
         let slotIndex = 0;
+        const generatedElements = [];
         for (const lp of targets) {
           if (lp.matched) {
             continue;
           }
-          const skipTypes = /* @__PURE__ */ new Set(["dt", "ftr", "sldnum", "hdr"]);
-          if (lp.phInfo.type && skipTypes.has(lp.phInfo.type)) {
+          if (lp.phInfo.type && NON_MATERIALIZED_PLACEHOLDER_TYPES.has(lp.phInfo.type)) {
             continue;
           }
           const emptyElement = createEmptyPlaceholderElement(
@@ -99812,12 +100630,25 @@ var init_PptxHandlerRuntimeLayoutSwitching = __esm({
             `${newLayoutPath}-${slotIndex++}-${Date.now()}`
           );
           if (emptyElement) {
-            resultElements.push(emptyElement);
+            generatedElements.push(emptyElement);
           }
         }
-        return resultElements;
+        return [...generatedElements, ...resultElements];
       }
     };
+    NON_MATERIALIZED_PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
+      "dt",
+      "ftr",
+      "sldnum",
+      "hdr",
+      "pic",
+      "clipart",
+      "chart",
+      "tbl",
+      "dgm",
+      "media",
+      "sldimg"
+    ]);
   }
 });
 function writeCellFill(tcPr, style, resolveColorXml) {
@@ -103930,12 +104761,8 @@ var init_PptxHandlerRuntimeSaveDocumentParts = __esm({
             continue;
           }
           const isPresentationXml = path === "ppt/presentation.xml";
-          if (!isPresentationXml) {
-            const candidateUris = xmlText2.match(/https?:\/\/[^"'<>\s]+/gu);
-            const hasConvertibleUri = candidateUris?.some((uri) => isTransitionalNamespaceUri(uri));
-            if (!hasConvertibleUri) {
-              continue;
-            }
+          if (!isPresentationXml && !containsConvertibleStrictNamespaceAttribute(xmlText2)) {
+            continue;
           }
           try {
             const parsed = parse2(xmlText2);
@@ -105442,6 +106269,16 @@ var init_PptxHandlerRuntimeSaveTextWriter = __esm({
     };
   }
 });
+function shouldWritePictureGeometry(el, spPr) {
+  if (el.type !== "picture" && el.type !== "image") {
+    return true;
+  }
+  return Boolean(spPr["a:prstGeom"] || spPr["a:custGeom"]);
+}
+var init_save_picture_geometry_gate = __esm({
+  "src/core/core/runtime/save-picture-geometry-gate.ts"() {
+  }
+});
 function getMediaReferenceContainer(shape) {
   if (!shape) {
     return void 0;
@@ -105463,6 +106300,7 @@ var init_PptxHandlerRuntimeSaveElementEmbedding = __esm({
     init_drawing_media_reference();
     init_xml_access();
     init_PptxHandlerRuntimeSaveTextWriter();
+    init_save_picture_geometry_gate();
     PptxHandlerRuntime32 = class extends PptxHandlerRuntime31 {
       /** Serialize table, chart, and SmartArt data when applicable. */
       applyDataSerialization(shape, el, slideId) {
@@ -105504,7 +106342,7 @@ var init_PptxHandlerRuntimeSaveElementEmbedding = __esm({
           return;
         }
         const spPr = ensureXmlChild(shape, "p:spPr");
-        if (!spPr) {
+        if (!spPr || !shouldWritePictureGeometry(el, spPr)) {
           return;
         }
         const elWithPaths = el;
@@ -107360,6 +108198,9 @@ var init_PptxHandlerRuntimeSaveElementWriter = __esm({
        * transforms, geometry, styles, text, and sorts into collectors.
        */
       processSlideElement(el, collectors, ctx) {
+        if (this.isOwnTemplateElement(el, ctx) && !this.templateElementBaselines.shouldWriteBack(el)) {
+          return;
+        }
         let shape = el.rawXml;
         if ((el.type === "picture" || el.type === "image") && typeof el.imageData === "string") {
           shape = this.processImageEmbedding(el, shape, ctx) ?? shape;
@@ -107542,6 +108383,135 @@ var init_PptxHandlerRuntimeSaveElementWriter = __esm({
     };
   }
 });
+function structuralPartRootTag(path) {
+  return PART_ROOT_BY_PATH.find(([pattern]) => pattern.test(path))?.[1];
+}
+function spTreeOfPartRoot(root) {
+  const cSld = root?.["p:cSld"];
+  return cSld?.["p:spTree"];
+}
+function prescanStructuralPart(xml) {
+  let suspectIds = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of xml.matchAll(CNVPR_ID_RE)) {
+    const id = parseShapeId(match[1] ?? match[2], true);
+    if (id === void 0 || seen.has(id)) {
+      suspectIds = true;
+      break;
+    }
+    seen.add(id);
+  }
+  let placeholderCasing = false;
+  for (const match of xml.matchAll(PH_TYPE_RE)) {
+    const raw = match[1] ?? match[2] ?? "";
+    const canonical = canonicalPlaceholderType(raw);
+    if (canonical !== void 0 && canonical !== raw) {
+      placeholderCasing = true;
+      break;
+    }
+  }
+  return { suspectIds, placeholderCasing };
+}
+function countDeclaredIds(node, counts, ensureArray20) {
+  for (const [nvTag, cNvPrTag] of NV_CONTAINERS3) {
+    const cNvPr = node[nvTag]?.[cNvPrTag];
+    if (!cNvPr) {
+      continue;
+    }
+    const id = parseShapeId(cNvPr["@_id"], true);
+    if (id === void 0) {
+      return false;
+    }
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  for (const listKey of SHAPE_LISTS) {
+    for (const child262 of ensureArray20(node[listKey])) {
+      if (!countDeclaredIds(child262, counts, ensureArray20)) {
+        return false;
+      }
+    }
+  }
+  for (const envelope of ensureArray20(node["mc:AlternateContent"])) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const branchKey of ["mc:Choice", "mc:Fallback"]) {
+      for (const branch of ensureArray20(envelope[branchKey])) {
+        const branchCounts = /* @__PURE__ */ new Map();
+        if (!countDeclaredIds(branch, branchCounts, ensureArray20)) {
+          return false;
+        }
+        for (const [id, count] of branchCounts) {
+          merged.set(id, Math.max(merged.get(id) ?? 0, count));
+        }
+      }
+    }
+    for (const [id, count] of merged) {
+      counts.set(id, (counts.get(id) ?? 0) + count);
+    }
+  }
+  return true;
+}
+function hasStructuralIdDefects(spTree, ensureArray20) {
+  const counts = /* @__PURE__ */ new Map();
+  if (!countDeclaredIds(spTree, counts, ensureArray20)) {
+    return true;
+  }
+  for (const count of counts.values()) {
+    if (count > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function applyShapeIdMapToSlide(slide, ids) {
+  if (ids.size === 0) {
+    return;
+  }
+  remapElementShapeIds(
+    slide.elements.filter((element) => !isTemplateElementId(element.id)),
+    ids
+  );
+  if (slide.rawTiming) {
+    remapShapeIdReferences(slide.rawTiming, ids);
+  }
+  for (const control of slide.activeXControls ?? []) {
+    const replacement = control.shapeId === void 0 ? void 0 : ids.get(control.shapeId.trim());
+    if (replacement !== void 0) {
+      control.shapeId = replacement;
+    }
+  }
+}
+var PART_ROOT_BY_PATH;
+var CNVPR_ID_RE;
+var PH_TYPE_RE;
+var NV_CONTAINERS3;
+var SHAPE_LISTS;
+var init_save_structural_id_gate = __esm({
+  "src/core/core/runtime/save-structural-id-gate.ts"() {
+    init_group_ops();
+    init_placeholder_validation();
+    init_shape_ids();
+    PART_ROOT_BY_PATH = [
+      [/^ppt\/slides\/[^/]+\.xml$/u, "p:sld"],
+      [/^ppt\/slideLayouts\/[^/]+\.xml$/u, "p:sldLayout"],
+      [/^ppt\/slideMasters\/[^/]+\.xml$/u, "p:sldMaster"],
+      [/^ppt\/notesSlides\/[^/]+\.xml$/u, "p:notes"],
+      [/^ppt\/notesMasters\/[^/]+\.xml$/u, "p:notesMaster"],
+      [/^ppt\/handoutMasters\/[^/]+\.xml$/u, "p:handoutMaster"]
+    ];
+    CNVPR_ID_RE = /<(?:p|p14):cNvPr\b[^>]*?\sid\s*=\s*(?:"([^"]*)"|'([^']*)')/gu;
+    PH_TYPE_RE = /<p:ph\b[^>]*?\stype\s*=\s*(?:"([^"]*)"|'([^']*)')/gu;
+    NV_CONTAINERS3 = [
+      ["p:nvSpPr", "p:cNvPr"],
+      ["p:nvPicPr", "p:cNvPr"],
+      ["p:nvCxnSpPr", "p:cNvPr"],
+      ["p:nvGrpSpPr", "p:cNvPr"],
+      ["p:nvGraphicFramePr", "p:cNvPr"],
+      ["p:nvContentPartPr", "p:cNvPr"],
+      ["p14:nvContentPartPr", "p14:cNvPr"]
+    ];
+    SHAPE_LISTS = ["p:sp", "p:pic", "p:cxnSp", "p:graphicFrame", "p:grpSp", "p:contentPart"];
+  }
+});
 function hashString(hasher, text22) {
   hasher.update(`s${text22.length}:`);
   if (text22.length <= FULL_HASH_LIMIT) {
@@ -108155,6 +109125,7 @@ var init_PptxHandlerRuntimeSaveSlideWriter = __esm({
     init_builders();
     init_authored_slide_background();
     init_PptxHandlerRuntimeSaveElementWriter();
+    init_save_structural_id_gate();
     init_slide_fingerprint();
     init_slide_save_xml_order();
     init_slide_transition_reconcile();
@@ -108504,11 +109475,13 @@ var init_PptxHandlerRuntimeSaveSlideWriter = __esm({
         this.wrapNewContentPartEnvelopes(spTree, collectors.contentParts);
         this.wrapNewModel3DEnvelopes(spTree, collectors.model3ds);
         this.wrapNewZoomEnvelopes(spTree, collectors.zooms);
-        const reassigned = shapeIdValidator.validateAndDeduplicateIds(
+        const { reassigned, ids: reassignedIds } = shapeIdValidator.repairShapeIds(
           spTree,
-          (v) => this.ensureArray(v)
+          (v) => this.ensureArray(v),
+          xmlObj
         );
         if (reassigned > 0) {
+          applyShapeIdMapToSlide(slide, reassignedIds);
           this.compatibilityService.reportWarning({
             code: "SHAPE_ID_DEDUPLICATED",
             message: `Reassigned ${reassigned} duplicate shape ID(s) on slide '${slide.id}'.`,
@@ -109252,7 +110225,7 @@ function asObjects3(value) {
   return isXmlObject9(value) ? [value] : [];
 }
 function rememberTemplateSpTreePositions(runtime, partPath, spTree, positionOf) {
-  const positions2 = /* @__PURE__ */ new Map();
+  const positions = /* @__PURE__ */ new Map();
   for (const [key2, value] of Object.entries(spTree)) {
     if (!SHAPE_TREE_ELEMENT_TAGS.has(key2) && key2 !== ALTERNATE_CONTENT_TAG3) {
       continue;
@@ -109260,7 +110233,7 @@ function rememberTemplateSpTreePositions(runtime, partPath, spTree, positionOf)
     for (const node of asObjects3(value)) {
       const position2 = positionOf(node);
       if (position2 !== void 0) {
-        positions2.set(node, position2);
+        positions.set(node, position2);
       }
     }
   }
@@ -109269,7 +110242,7 @@ function rememberTemplateSpTreePositions(runtime, partPath, spTree, positionOf)
     byPart = /* @__PURE__ */ new Map();
     positionsByRuntime.set(runtime, byPart);
   }
-  byPart.set(partPath, positions2);
+  byPart.set(partPath, positions);
 }
 function withReplacedChild(container, tag, indexInType, replacement) {
   const existing = container[tag];
@@ -109298,17 +110271,17 @@ function orderContainer(container, plan, getLocalName2) {
       working = withReplacedChild(working, entry2.tag, entry2.indexInType, ordered4);
     }
   }
-  const positions2 = /* @__PURE__ */ new Map();
+  const positions = /* @__PURE__ */ new Map();
   plan.forEach((entry2, position2) => {
     const node = asObjects3(working[entry2.tag])[entry2.indexInType];
-    if (node && !positions2.has(node)) {
-      positions2.set(node, position2);
+    if (node && !positions.has(node)) {
+      positions.set(node, position2);
     }
   });
-  if (positions2.size === 0) {
+  if (positions.size === 0) {
     return working;
   }
-  return orderShapeTreeChildren(working, (node) => positions2.get(node), getLocalName2);
+  return orderShapeTreeChildren(working, (node) => positions.get(node), getLocalName2);
 }
 function orderedTemplatePartXml(options) {
   const {
@@ -109361,6 +110334,7 @@ var PptxHandlerRuntime46;
 var init_PptxHandlerRuntimeSaveMasterElements = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSaveMasterElements.ts"() {
     init_services();
+    init_shape_ids();
     init_builders();
     init_auxiliary_master_node_cache();
     init_master_part_element_signature();
@@ -109470,7 +110444,12 @@ var init_PptxHandlerRuntimeSaveMasterElements = __esm({
         }
         this.publishMasterCollectors(partPath, spTree, collectors);
         this.reapplyAlternateContentEnvelopes(spTree, collectors);
-        shapeIdValidator2.validateAndDeduplicateIds(spTree, (value) => this.ensureArray(value));
+        const idRepair = shapeIdValidator2.repairShapeIds(
+          spTree,
+          (value) => this.ensureArray(value),
+          root
+        );
+        remapElementShapeIds(elements2, idRepair.ids);
         rememberTemplateSpTreePositions(this, partPath, spTree, (node) => childOrder3.positionOf(node));
         relsRoot["Relationship"] = relationships;
         relsData["Relationships"] = relsRoot;
@@ -110520,7 +111499,104 @@ var init_PptxHandlerRuntimeSaveLegacyPpt = __esm({
     };
   }
 });
+var shapeIdValidator3;
 var PptxHandlerRuntime53;
+var init_PptxHandlerRuntimeSaveStructuralIds = __esm({
+  "src/core/core/runtime/PptxHandlerRuntimeSaveStructuralIds.ts"() {
+    init_placeholder_validation();
+    init_shape_ids();
+    init_builders();
+    init_PptxHandlerRuntimeSaveLegacyPpt();
+    init_save_structural_id_gate();
+    init_slide_fingerprint();
+    init_template_sp_tree_order();
+    shapeIdValidator3 = new PptxShapeIdValidator();
+    PptxHandlerRuntime53 = class extends PptxHandlerRuntime52 {
+      async repairStructuralIdsBeforeExport(slides) {
+        for (const path of Object.keys(this.zip.files)) {
+          const rootTag2 = structuralPartRootTag(path);
+          if (rootTag2 === void 0) {
+            continue;
+          }
+          const xml = await this.zip.file(path)?.async("string");
+          if (xml === void 0) {
+            continue;
+          }
+          const scan = prescanStructuralPart(xml);
+          if (!scan.suspectIds && !scan.placeholderCasing) {
+            continue;
+          }
+          await this.repairStructuralPart(path, rootTag2, xml, scan.suspectIds, slides);
+        }
+      }
+      /** The loader's cached parse of a part, which the live model's `rawXml` nodes belong to. */
+      cachedStructuralPart(path) {
+        return this.slideMap.get(path) ?? this.layoutXmlMap.get(path) ?? this.masterXmlMap.get(path);
+      }
+      async repairStructuralPart(path, rootTag2, xml, suspectIds, slides) {
+        const fresh = this.parser.parse(xml);
+        const ensureArray20 = (value) => this.ensureArray(value);
+        const freshTree = spTreeOfPartRoot(fresh[rootTag2]);
+        const needsIds = suspectIds && freshTree !== void 0 && hasStructuralIdDefects(freshTree, ensureArray20);
+        const cached = this.cachedStructuralPart(path);
+        let target = cached ?? fresh;
+        let repair = this.repairPartObject(target, rootTag2, needsIds, ensureArray20);
+        if (repair.reassigned === 0 && repair.casing === 0 && cached !== void 0) {
+          target = fresh;
+          repair = this.repairPartObject(target, rootTag2, needsIds, ensureArray20);
+        }
+        if (repair.reassigned === 0 && repair.casing === 0) {
+          return;
+        }
+        if (repair.ids.size > 0) {
+          const slide = slides.find((candidate) => candidate.id === path);
+          if (slide) {
+            applyShapeIdMapToSlide(slide, repair.ids);
+            this.savedSlideFingerprints.set(slide.id, fingerprintSlide(slide));
+          }
+          const templateElements = this.layoutCache.get(path) ?? this.masterCache.get(path);
+          if (templateElements) {
+            remapElementShapeIds(templateElements, repair.ids);
+          }
+        }
+        const ordered4 = orderedTemplatePartXml({
+          runtime: this,
+          partPath: path,
+          xmlObj: target,
+          rootTag: rootTag2,
+          sourceXml: xml,
+          getLocalName: (key2) => this.compatibilityService.getXmlLocalName(key2),
+          alternateContentBlockByRawXml: this.alternateContentBlockByRawXml
+        });
+        this.zip.file(path, this.builder.build(ordered4));
+        if (repair.reassigned > 0) {
+          this.compatibilityService.reportWarning({
+            code: "SHAPE_ID_DEDUPLICATED",
+            message: `Reassigned ${repair.reassigned} invalid or duplicate shape ID(s) in '${path}'.`,
+            scope: "save",
+            slideId: path
+          });
+        }
+        if (repair.casing > 0) {
+          this.compatibilityService.reportWarning({
+            code: "PLACEHOLDER_TYPE_CANONICALIZED",
+            message: `Corrected the casing of ${repair.casing} placeholder type(s) in '${path}'.`,
+            scope: "save",
+            slideId: path
+          });
+        }
+      }
+      repairPartObject(xmlObj, rootTag2, needsIds, ensureArray20) {
+        const root = xmlObj[rootTag2];
+        const spTree = spTreeOfPartRoot(root);
+        const idRepair = needsIds && root !== void 0 && spTree !== void 0 ? shapeIdValidator3.repairShapeIds(spTree, ensureArray20, root) : { reassigned: 0, ids: /* @__PURE__ */ new Map() };
+        const casing = root === void 0 ? 0 : canonicalizePlaceholderTypes(root);
+        return { ...idRepair, casing };
+      }
+    };
+  }
+});
+var PptxHandlerRuntime54;
 var init_PptxHandlerRuntimeSavePipeline = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSavePipeline.ts"() {
     init_modern_comment_package();
@@ -110528,8 +111604,8 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
     init_factories();
     init_header_footer_parts();
     init_pptx_print_properties();
-    init_PptxHandlerRuntimeSaveLegacyPpt();
-    PptxHandlerRuntime53 = class _PptxHandlerRuntime extends PptxHandlerRuntime52 {
+    init_PptxHandlerRuntimeSaveStructuralIds();
+    PptxHandlerRuntime54 = class _PptxHandlerRuntime extends PptxHandlerRuntime53 {
       /**
        * Resolve the effective conformance class for this save operation.
        *
@@ -110568,9 +111644,11 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
         });
         await this.ensureNotesMasterForAuthoredNotes(slides, saveConstants);
         await this.ensureHandoutMasterInfrastructure(options?.handoutMaster, saveConstants);
+        this.templateElementBaselines.beginSave();
         for (const slide of slides) {
           await this.processSlideForSave(slide, saveSession, saveConstants);
         }
+        this.templateElementBaselines.commitSave();
         const contentTypesXml3 = await this.zip.file("[Content_Types].xml")?.async("string");
         if (contentTypesXml3) {
           const contentTypesData = this.parser.parse(contentTypesXml3);
@@ -110734,6 +111812,7 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
         await this.stripDigitalSignatures();
         const outputFormat = options?.outputFormat ?? "pptx";
         await this.applyOutputFormatOverrides(outputFormat);
+        await this.repairStructuralIdsBeforeExport(slides);
         if (effectiveConformance === "strict") {
           await this.convertZipToStrictConformance();
         }
@@ -110817,14 +111896,14 @@ var init_PptxHandlerRuntimeSavePipeline = __esm({
   }
 });
 var SPECIAL_PLACEHOLDER_TYPES;
-var PptxHandlerRuntime54;
+var PptxHandlerRuntime55;
 var init_PptxHandlerRuntimeElementParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeElementParsing.ts"() {
     init_utils();
     init_placeholder_index();
     init_PptxHandlerRuntimeSavePipeline();
     SPECIAL_PLACEHOLDER_TYPES = /* @__PURE__ */ new Set(["dt", "ftr", "hdr", "sldnum"]);
-    PptxHandlerRuntime54 = class _PptxHandlerRuntime extends PptxHandlerRuntime53 {
+    PptxHandlerRuntime55 = class _PptxHandlerRuntime extends PptxHandlerRuntime54 {
       /**
        * Parse media data (video/audio path and MIME type) from graphic frame data.
        */
@@ -111119,11 +112198,11 @@ function readBoolean(value) {
   }
   return String(value) !== "0" && String(value).toLowerCase() !== "false";
 }
-var PptxHandlerRuntime55;
+var PptxHandlerRuntime56;
 var init_PptxHandlerRuntimeZoomParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeZoomParsing.ts"() {
     init_PptxHandlerRuntimeElementParsing();
-    PptxHandlerRuntime55 = class _PptxHandlerRuntime extends PptxHandlerRuntime54 {
+    PptxHandlerRuntime56 = class _PptxHandlerRuntime extends PptxHandlerRuntime55 {
       /** Parse an Office 2016 `pslz:sldZm` slide Zoom object. */
       async parseSlideZoomElement(zoom, id, slidePath) {
         try {
@@ -111190,12 +112269,12 @@ function readBoolean2(value) {
   }
   return String(value) !== "0" && String(value).toLowerCase() !== "false";
 }
-var PptxHandlerRuntime56;
+var PptxHandlerRuntime57;
 var init_PptxHandlerRuntimeSectionZoomParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSectionZoomParsing.ts"() {
     init_presentation_section_parser();
     init_PptxHandlerRuntimeZoomParsing();
-    PptxHandlerRuntime56 = class _PptxHandlerRuntime extends PptxHandlerRuntime55 {
+    PptxHandlerRuntime57 = class _PptxHandlerRuntime extends PptxHandlerRuntime56 {
       /** Parse an Office 2016 `psezm:sectionZm` section Zoom object. */
       async parseSectionZoomElement(zoom, id, slidePath) {
         try {
@@ -111255,12 +112334,12 @@ var init_PptxHandlerRuntimeSectionZoomParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime57;
+var PptxHandlerRuntime58;
 var init_PptxHandlerRuntimeSummaryZoomParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSummaryZoomParsing.ts"() {
     init_presentation_section_parser();
     init_PptxHandlerRuntimeSectionZoomParsing();
-    PptxHandlerRuntime57 = class _PptxHandlerRuntime extends PptxHandlerRuntime56 {
+    PptxHandlerRuntime58 = class _PptxHandlerRuntime extends PptxHandlerRuntime57 {
       /** Parse an Office 2016 Summary Zoom container and all section tiles. */
       async parseSummaryZoomElement(zoom, id, slidePath) {
         try {
@@ -111351,7 +112430,7 @@ var init_PptxHandlerRuntimeSummaryZoomParsing = __esm({
   }
 });
 var PLACEHOLDER_BUCKETS;
-var PptxHandlerRuntime58;
+var PptxHandlerRuntime59;
 var init_PptxHandlerRuntimePlaceholderLookup = __esm({
   "src/core/core/runtime/PptxHandlerRuntimePlaceholderLookup.ts"() {
     init_header_footer_placeholder();
@@ -111364,7 +112443,7 @@ var init_PptxHandlerRuntimePlaceholderLookup = __esm({
       { bucket: "p:pic", nvKey: "p:nvPicPr", contextKey: "picture" },
       { bucket: "p:graphicFrame", nvKey: "p:nvGraphicFramePr", contextKey: "graphicFrame" }
     ];
-    PptxHandlerRuntime58 = class extends PptxHandlerRuntime57 {
+    PptxHandlerRuntime59 = class extends PptxHandlerRuntime58 {
       findPlaceholderInShapeTree(spTree, expected) {
         return this.scanPlaceholderBuckets(spTree, (info) => this.placeholderMatches(expected, info));
       }
@@ -111597,14 +112676,22 @@ var init_preset_avlst_fmla = __esm({
     ]);
   }
 });
-var PptxHandlerRuntime59;
+function parseBoundedRectFraction(value) {
+  const fraction = parseOoxmlPercent(value);
+  if (fraction === void 0) {
+    return void 0;
+  }
+  return Math.max(-10, Math.min(10, fraction));
+}
+var PptxHandlerRuntime60;
 var init_PptxHandlerRuntimeGeometryParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeGeometryParsing.ts"() {
+    init_color_primitives();
     init_custom_geometry_parser();
     init_guide_formula();
     init_PptxHandlerRuntimePlaceholderLookup();
     init_preset_avlst_fmla();
-    PptxHandlerRuntime59 = class _PptxHandlerRuntime extends PptxHandlerRuntime58 {
+    PptxHandlerRuntime60 = class _PptxHandlerRuntime extends PptxHandlerRuntime59 {
       parseGeometryAdjustments(prstGeom) {
         if (!prstGeom) {
           return void 0;
@@ -111975,11 +113062,7 @@ var init_PptxHandlerRuntimeGeometryParsing = __esm({
        * hostile input.
        */
       parseCropFraction(value) {
-        const raw = Number.parseInt(String(value ?? ""), 10);
-        if (!Number.isFinite(raw)) {
-          return void 0;
-        }
-        return Math.max(-1e6, Math.min(1e6, raw)) / 1e5;
+        return parseBoundedRectFraction(value);
       }
       readImageCropFromBlipFill(blipFill) {
         const result = {};
@@ -112006,11 +113089,7 @@ var init_PptxHandlerRuntimeGeometryParsing = __esm({
        * magnitude is capped at 10x the frame to bound hostile input.
        */
       parseSignedRectFraction(value) {
-        const raw = Number.parseInt(String(value ?? ""), 10);
-        if (!Number.isFinite(raw)) {
-          return void 0;
-        }
-        return Math.max(-1e6, Math.min(1e6, raw)) / 1e5;
+        return parseBoundedRectFraction(value);
       }
       extractShapeStyle(spPr, styleNode) {
         return this.shapeStyleExtractor.extractShapeStyle(spPr, styleNode);
@@ -112018,12 +113097,12 @@ var init_PptxHandlerRuntimeGeometryParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime60;
+var PptxHandlerRuntime61;
 var init_PptxHandlerRuntimeShapeImageFill = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeShapeImageFill.ts"() {
     init_xml_access();
     init_PptxHandlerRuntimeGeometryParsing();
-    PptxHandlerRuntime60 = class _PptxHandlerRuntime extends PptxHandlerRuntime59 {
+    PptxHandlerRuntime61 = class _PptxHandlerRuntime extends PptxHandlerRuntime60 {
       /**
        * Parse a shape that has an image fill (a:blipFill inside spPr)
        * This handles shapes like rectangles filled with images (e.g., wood texture backgrounds)
@@ -112235,12 +113314,12 @@ var init_PptxHandlerRuntimeShapeImageFill = __esm({
     };
   }
 });
-var PptxHandlerRuntime61;
+var PptxHandlerRuntime62;
 var init_PptxHandlerRuntimeTextDefaults = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeTextDefaults.ts"() {
     init_color();
     init_PptxHandlerRuntimeShapeImageFill();
-    PptxHandlerRuntime61 = class extends PptxHandlerRuntime60 {
+    PptxHandlerRuntime62 = class extends PptxHandlerRuntime61 {
       /**
        * Apply {@link PlaceholderDefaults} body-level properties to a
        * {@link TextStyle} as fallback values (only sets fields that are
@@ -112417,7 +113496,7 @@ var init_PptxHandlerRuntimeTextDefaults = __esm({
     };
   }
 });
-var PptxHandlerRuntime62;
+var PptxHandlerRuntime63;
 var init_PptxHandlerRuntimeBulletParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeBulletParsing.ts"() {
     init_theme_color_ref();
@@ -112426,7 +113505,7 @@ var init_PptxHandlerRuntimeBulletParsing = __esm({
     init_paragraph_properties_parser();
     init_xml_access();
     init_PptxHandlerRuntimeTextDefaults();
-    PptxHandlerRuntime62 = class extends PptxHandlerRuntime61 {
+    PptxHandlerRuntime63 = class extends PptxHandlerRuntime62 {
       resolveParagraphBulletInfo(paragraph, paragraphIndex, txBody, inheritedTxBody, isBodyPlaceholder = false, slidePath, effectiveLevelStyles) {
         if (!paragraph) {
           return null;
@@ -112625,7 +113704,7 @@ var init_PptxHandlerRuntimeBulletParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime63;
+var PptxHandlerRuntime64;
 var init_PptxHandlerRuntimeShapeBodyParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeShapeBodyParsing.ts"() {
     init_alternate_content();
@@ -112633,7 +113712,7 @@ var init_PptxHandlerRuntimeShapeBodyParsing = __esm({
     init_text_body_scene3d();
     init_text_body_sp3d();
     init_PptxHandlerRuntimeBulletParsing();
-    PptxHandlerRuntime63 = class _PptxHandlerRuntime extends PptxHandlerRuntime62 {
+    PptxHandlerRuntime64 = class _PptxHandlerRuntime extends PptxHandlerRuntime63 {
       /**
        * Parse `a:spLocks` attributes into a structured {@link PptxShapeLocks} object.
        * Returns `undefined` when the node is absent or contains no lock attributes.
@@ -112854,12 +113933,12 @@ var init_PptxHandlerRuntimeShapeBodyParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime64;
+var PptxHandlerRuntime65;
 var init_PptxHandlerRuntimeShapeTextParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeShapeTextParsing.ts"() {
     init_paragraph_properties_parser();
     init_PptxHandlerRuntimeShapeBodyParsing();
-    PptxHandlerRuntime64 = class _PptxHandlerRuntime extends PptxHandlerRuntime63 {
+    PptxHandlerRuntime65 = class _PptxHandlerRuntime extends PptxHandlerRuntime64 {
       /**
        * A copy of an `a:lstStyle` level entry without its `a:defRPr`: run
        * defaults follow their own precedence chain, so only the paragraph-level
@@ -113150,7 +114229,7 @@ var init_PptxHandlerRuntimeShapeTextParsing = __esm({
   }
 });
 var PARAGRAPH_CONTENT_TAGS;
-var PptxHandlerRuntime65;
+var PptxHandlerRuntime66;
 var init_PptxHandlerRuntimeShapeParagraphContentParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeShapeParagraphContentParsing.ts"() {
     init_utils();
@@ -113169,7 +114248,7 @@ var init_PptxHandlerRuntimeShapeParagraphContentParsing = __esm({
       "mc:AlternateContent",
       "a:br"
     ]);
-    PptxHandlerRuntime65 = class extends PptxHandlerRuntime64 {
+    PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
       /**
        * Collect text content (runs, fields, equations, bullets) for a single
        * paragraph and return text parts + segments.  The returned `seedStyle`
@@ -113598,7 +114677,7 @@ var init_PptxHandlerRuntimeShapeParagraphContentParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime66;
+var PptxHandlerRuntime67;
 var init_PptxHandlerRuntimeShapeParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeShapeParsing.ts"() {
     init_decorative_extension();
@@ -113608,7 +114687,7 @@ var init_PptxHandlerRuntimeShapeParsing = __esm({
     init_auto_number_sequence();
     init_element_paragraph_geometry();
     init_PptxHandlerRuntimeShapeParagraphContentParsing();
-    PptxHandlerRuntime66 = class _PptxHandlerRuntime extends PptxHandlerRuntime65 {
+    PptxHandlerRuntime67 = class _PptxHandlerRuntime extends PptxHandlerRuntime66 {
       parseShape(shape, id, slidePath) {
         try {
           const spPr = shape["p:spPr"];
@@ -113915,7 +114994,7 @@ function parseEmuInt2(value) {
 }
 var INT32_MIN2;
 var INT32_MAX2;
-var PptxHandlerRuntime67;
+var PptxHandlerRuntime68;
 var init_PptxHandlerRuntimePictureParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimePictureParsing.ts"() {
     init_crop_shape_geometry();
@@ -113928,7 +115007,7 @@ var init_PptxHandlerRuntimePictureParsing = __esm({
     init_shape_lock_containers();
     INT32_MIN2 = -2147483648;
     INT32_MAX2 = 2147483647;
-    PptxHandlerRuntime67 = class _PptxHandlerRuntime extends PptxHandlerRuntime66 {
+    PptxHandlerRuntime68 = class _PptxHandlerRuntime extends PptxHandlerRuntime67 {
       async parsePicture(pic, id, slidePath) {
         try {
           const spPr = pic["p:spPr"];
@@ -114282,13 +115361,13 @@ var init_PptxHandlerRuntimePictureParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime68;
+var PptxHandlerRuntime69;
 var init_PptxHandlerRuntimeSpTreeParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSpTreeParsing.ts"() {
     init_alternate_content();
     init_vml_parser();
     init_PptxHandlerRuntimePictureParsing();
-    PptxHandlerRuntime68 = class _PptxHandlerRuntime extends PptxHandlerRuntime67 {
+    PptxHandlerRuntime69 = class _PptxHandlerRuntime extends PptxHandlerRuntime68 {
       /**
        * Known element tag names that appear as direct children of `p:spTree`
        * (or `p:grpSp`) and represent renderable shapes/objects.
@@ -114670,7 +115749,7 @@ var init_PptxHandlerRuntimeSpTreeParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime69;
+var PptxHandlerRuntime70;
 var init_PptxHandlerRuntimeGroupParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeGroupParsing.ts"() {
     init_transform_utils();
@@ -114679,7 +115758,7 @@ var init_PptxHandlerRuntimeGroupParsing = __esm({
     init_group_shape_geometry();
     init_PptxHandlerRuntimeSpTreeParsing();
     init_shape_lock_containers();
-    PptxHandlerRuntime69 = class _PptxHandlerRuntime extends PptxHandlerRuntime68 {
+    PptxHandlerRuntime70 = class _PptxHandlerRuntime extends PptxHandlerRuntime69 {
       /**
        * Parse the children of a `<p:grpSp>` into the group's own pixel space.
        *
@@ -114881,11 +115960,11 @@ var init_PptxHandlerRuntimeGroupParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime70;
+var PptxHandlerRuntime71;
 var init_PptxHandlerRuntimeSlideParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSlideParsing.ts"() {
     init_PptxHandlerRuntimeGroupParsing();
-    PptxHandlerRuntime70 = class extends PptxHandlerRuntime69 {
+    PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
       /**
        * Parse text body from a connector shape (p:cxnSp > p:txBody).
        * Uses the same text run extraction logic as regular shapes but
@@ -114996,7 +116075,7 @@ var init_PptxHandlerRuntimeSlideParsing = __esm({
   }
 });
 var DEFAULT_CLR_MAP_ALIAS;
-var PptxHandlerRuntime71;
+var PptxHandlerRuntime72;
 var init_PptxHandlerRuntimeColorAndEffects = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeColorAndEffects.ts"() {
     init_PptxHandlerRuntimeSlideParsing();
@@ -115006,7 +116085,7 @@ var init_PptxHandlerRuntimeColorAndEffects = __esm({
       bg2: "lt2",
       tx2: "dk2"
     };
-    PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
+    PptxHandlerRuntime72 = class extends PptxHandlerRuntime71 {
       /**
        * Forward declaration – implemented in PptxHandlerRuntimeThemeProcessing.
        * Re-resolves gradient stops by substituting `phClr` with the given colour.
@@ -115148,14 +116227,14 @@ var init_PptxHandlerRuntimeColorAndEffects = __esm({
     };
   }
 });
-var PptxHandlerRuntime72;
+var PptxHandlerRuntime73;
 var init_PptxHandlerRuntimeBackgroundParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeBackgroundParsing.ts"() {
     init_part_rels_path();
     init_strip_parent_dir_segments();
     init_xml_access();
     init_PptxHandlerRuntimeColorAndEffects();
-    PptxHandlerRuntime72 = class extends PptxHandlerRuntime71 {
+    PptxHandlerRuntime73 = class extends PptxHandlerRuntime72 {
       /**
        * Preserve the visual properties authored on a background `a:blipFill`.
        *
@@ -115599,14 +116678,14 @@ var init_PptxHandlerRuntimeBackgroundParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime73;
+var PptxHandlerRuntime74;
 var init_PptxHandlerRuntimeSlideUtils = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSlideUtils.ts"() {
     init_part_rels_path();
     init_strip_parent_dir_segments();
     init_notes_body_shapes();
     init_PptxHandlerRuntimeBackgroundParsing();
-    PptxHandlerRuntime73 = class extends PptxHandlerRuntime72 {
+    PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
       /**
        * Retrieve the background gradient from a layout, falling back to master.
        */
@@ -115949,14 +117028,14 @@ var init_PptxHandlerRuntimeSlideUtils = __esm({
     };
   }
 });
-var PptxHandlerRuntime74;
+var PptxHandlerRuntime75;
 var init_PptxHandlerRuntimePlaceholderStyles = __esm({
   "src/core/core/runtime/PptxHandlerRuntimePlaceholderStyles.ts"() {
     init_color_xml_preservation();
     init_paragraph_properties_parser();
     init_xml_access();
     init_PptxHandlerRuntimeSlideUtils();
-    PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
+    PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       /**
        * Parse a single `a:lvlXpPr` node into a structured
        * {@link PlaceholderTextLevelStyle}.
@@ -116106,11 +117185,11 @@ var init_PptxHandlerRuntimePlaceholderStyles = __esm({
     };
   }
 });
-var PptxHandlerRuntime75;
+var PptxHandlerRuntime76;
 var init_PptxHandlerRuntimePlaceholderDefaults = __esm({
   "src/core/core/runtime/PptxHandlerRuntimePlaceholderDefaults.ts"() {
     init_PptxHandlerRuntimePlaceholderStyles();
-    PptxHandlerRuntime75 = class _PptxHandlerRuntime extends PptxHandlerRuntime74 {
+    PptxHandlerRuntime76 = class _PptxHandlerRuntime extends PptxHandlerRuntime75 {
       /**
        * Extract structured {@link PlaceholderDefaults} from a layout or master
        * shape that carries a `p:ph` element.
@@ -116272,14 +117351,14 @@ function parseHeaderFooterFlags(hf) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
-var PptxHandlerRuntime76;
+var PptxHandlerRuntime77;
 var init_PptxHandlerRuntimeMasterElements = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeMasterElements.ts"() {
     init_part_rels_path();
     init_strip_parent_dir_segments();
     init_xml_access();
     init_PptxHandlerRuntimePlaceholderDefaults();
-    PptxHandlerRuntime76 = class extends PptxHandlerRuntime75 {
+    PptxHandlerRuntime77 = class extends PptxHandlerRuntime76 {
       /**
        * Parse a `CT_TextListStyle` node (`a:defPPr` + `a:lvl1pPr` … `a:lvl9pPr`)
        * into a level-keyed style map. Used for `<p:txStyles>` children
@@ -116563,7 +117642,7 @@ var init_PptxHandlerRuntimeMasterElements = __esm({
     };
   }
 });
-var PptxHandlerRuntime77;
+var PptxHandlerRuntime78;
 var init_PptxHandlerRuntimeAuxiliaryMasterElements = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeAuxiliaryMasterElements.ts"() {
     init_services();
@@ -116572,7 +117651,7 @@ var init_PptxHandlerRuntimeAuxiliaryMasterElements = __esm({
     init_master_part_element_signature();
     init_master_part_tags();
     init_PptxHandlerRuntimeMasterElements();
-    PptxHandlerRuntime77 = class extends PptxHandlerRuntime76 {
+    PptxHandlerRuntime78 = class extends PptxHandlerRuntime77 {
       /** Parse every editable element in a master or layout shape tree. */
       async enrichMasterPartElements(part, rootTag2) {
         if (!part) {
@@ -116677,14 +117756,14 @@ var init_PptxHandlerRuntimeAuxiliaryMasterElements = __esm({
     };
   }
 });
-var PptxHandlerRuntime78;
+var PptxHandlerRuntime79;
 var init_PptxHandlerRuntimeLayoutElements = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeLayoutElements.ts"() {
     init_part_rels_path();
     init_strip_parent_dir_segments();
     init_xml_access();
     init_PptxHandlerRuntimeAuxiliaryMasterElements();
-    PptxHandlerRuntime78 = class extends PptxHandlerRuntime77 {
+    PptxHandlerRuntime79 = class extends PptxHandlerRuntime78 {
       /**
        * Parse the layout artwork inherited by a slide.
        *
@@ -116868,6 +117947,7 @@ var init_PptxHandlerRuntimeLayoutElements = __esm({
           const masterElements = showMasterSp ? await this.getMasterElements(layoutPath) : [];
           this.currentSlideClrMapOverride = prevClrMapOverride;
           const allElements = [...masterElements, ...elements2];
+          this.templateElementBaselines.recordBaselines(allElements);
           this.layoutCache.set(layoutPath, allElements);
           return allElements;
         } catch (e) {
@@ -116878,13 +117958,13 @@ var init_PptxHandlerRuntimeLayoutElements = __esm({
     };
   }
 });
-var PptxHandlerRuntime79;
+var PptxHandlerRuntime80;
 var init_PptxHandlerRuntimeLayoutPreviews = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeLayoutPreviews.ts"() {
     init_constants();
     init_xml_access();
     init_PptxHandlerRuntimeLayoutElements();
-    PptxHandlerRuntime79 = class extends PptxHandlerRuntime78 {
+    PptxHandlerRuntime80 = class extends PptxHandlerRuntime79 {
       layoutPreviewCache = /* @__PURE__ */ new Map();
       /**
        * Build (or return the memoised) preview for one layout.
@@ -116997,7 +118077,7 @@ function extractFillStyleListChildOrder(rawXml, listTag) {
   return order;
 }
 var FILL_LIST_CHILD_TAGS;
-var PptxHandlerRuntime80;
+var PptxHandlerRuntime81;
 var init_PptxHandlerRuntimeThemeFormatScheme = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeThemeFormatScheme.ts"() {
     init_PptxHandlerRuntimeLayoutPreviews();
@@ -117008,7 +118088,7 @@ var init_PptxHandlerRuntimeThemeFormatScheme = __esm({
       "a:noFill",
       "a:grpFill"
     ];
-    PptxHandlerRuntime80 = class _PptxHandlerRuntime extends PptxHandlerRuntime79 {
+    PptxHandlerRuntime81 = class _PptxHandlerRuntime extends PptxHandlerRuntime80 {
       /**
        * Build a fill-style entry for one child node based on its tag.
        */
@@ -117291,12 +118371,12 @@ var init_PptxHandlerRuntimeThemeFormatScheme = __esm({
     };
   }
 });
-var PptxHandlerRuntime81;
+var PptxHandlerRuntime82;
 var init_PptxHandlerRuntimeThemeOverrides = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeThemeOverrides.ts"() {
     init_color_scheme_index();
     init_PptxHandlerRuntimeThemeFormatScheme();
-    PptxHandlerRuntime81 = class extends PptxHandlerRuntime80 {
+    PptxHandlerRuntime82 = class extends PptxHandlerRuntime81 {
       /**
        * Parse the `a:fmtScheme` element from the theme into a structured
        * {@link PptxThemeFormatScheme}.  Each sub-list (fillStyleLst, lnStyleLst,
@@ -117519,12 +118599,12 @@ var init_PptxHandlerRuntimeThemeOverrides = __esm({
     };
   }
 });
-var PptxHandlerRuntime82;
+var PptxHandlerRuntime83;
 var init_PptxHandlerRuntimeThemeRefResolution = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeThemeRefResolution.ts"() {
     init_utils();
     init_PptxHandlerRuntimeThemeOverrides();
-    PptxHandlerRuntime82 = class extends PptxHandlerRuntime81 {
+    PptxHandlerRuntime83 = class extends PptxHandlerRuntime82 {
       /**
        * Resolve a `a:effectRef` element into concrete effect properties
        * by looking up `@_idx` in the theme format scheme's effect style list.
@@ -117767,11 +118847,11 @@ var init_PptxHandlerRuntimeThemeRefResolution = __esm({
 function isPresentationThemePartPath(path) {
   return /^ppt\/theme\/(?!themeOverride)[^/]+\.xml$/iu.test(path);
 }
-var PptxHandlerRuntime83;
+var PptxHandlerRuntime84;
 var init_PptxHandlerRuntimeThemeLoading = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeThemeLoading.ts"() {
     init_PptxHandlerRuntimeThemeRefResolution();
-    PptxHandlerRuntime83 = class extends PptxHandlerRuntime82 {
+    PptxHandlerRuntime84 = class extends PptxHandlerRuntime83 {
       async resolvePrimaryThemePath() {
         const masterFiles = this.zip.file(/^ppt\/slideMasters\/slideMaster\d+\.xml$/);
         if (!masterFiles || masterFiles.length === 0) {
@@ -118308,13 +119388,13 @@ var init_theme_scheme_edit = __esm({
   }
 });
 var THEME_PART_PATTERN;
-var PptxHandlerRuntime84;
+var PptxHandlerRuntime85;
 var init_PptxHandlerRuntimeThemeProcessing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeThemeProcessing.ts"() {
     init_PptxHandlerRuntimeThemeLoading();
     init_theme_scheme_edit();
     THEME_PART_PATTERN = /^ppt\/theme\/theme\d+\.xml$/;
-    PptxHandlerRuntime84 = class extends PptxHandlerRuntime83 {
+    PptxHandlerRuntime85 = class extends PptxHandlerRuntime84 {
       /**
        * The theme parts an edit should touch, primary theme first.
        *
@@ -118467,14 +119547,14 @@ var init_PptxHandlerRuntimeThemeProcessing = __esm({
     };
   }
 });
-var PptxHandlerRuntime85;
+var PptxHandlerRuntime86;
 var init_PptxHandlerRuntimeComments = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeComments.ts"() {
     init_legacy_comment_threading();
     init_modern_comment_xml();
     init_xml_access();
     init_PptxHandlerRuntimeThemeProcessing();
-    PptxHandlerRuntime85 = class _PptxHandlerRuntime extends PptxHandlerRuntime84 {
+    PptxHandlerRuntime86 = class _PptxHandlerRuntime extends PptxHandlerRuntime85 {
       /**
        * Parse modern threaded comments (PowerPoint 2019+ / Office 365).
        * Modern comments use `p188:cmLst`/`p15:cmLst` roots within
@@ -118701,7 +119781,7 @@ var init_PptxHandlerRuntimeComments = __esm({
     };
   }
 });
-var PptxHandlerRuntime86;
+var PptxHandlerRuntime87;
 var init_PptxHandlerRuntimeSmartArtXmlUtils = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSmartArtXmlUtils.ts"() {
     init_smartart_color_lists();
@@ -118709,7 +119789,7 @@ var init_PptxHandlerRuntimeSmartArtXmlUtils = __esm({
     init_smart_art_text_helpers();
     init_PptxHandlerRuntimeComments();
     init_smartart_text_paragraphs();
-    PptxHandlerRuntime86 = class extends PptxHandlerRuntime85 {
+    PptxHandlerRuntime87 = class extends PptxHandlerRuntime86 {
       async readXmlPartByRelationshipId(slidePath, relationshipId2) {
         const normalizedRelationshipId = String(relationshipId2 || "").trim();
         if (normalizedRelationshipId.length === 0) {
@@ -119199,7 +120279,7 @@ var init_smartart_text_style_resolution = __esm({
   "src/core/core/runtime/smartart-text-style-resolution.ts"() {
   }
 });
-var PptxHandlerRuntime87;
+var PptxHandlerRuntime88;
 var init_PptxHandlerRuntimeSmartArtParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSmartArtParsing.ts"() {
     init_smartart_connector_labels();
@@ -119210,7 +120290,7 @@ var init_PptxHandlerRuntimeSmartArtParsing = __esm({
     init_smartart_style_label_refs();
     init_smartart_text_paragraphs();
     init_smartart_text_style_resolution();
-    PptxHandlerRuntime87 = class _PptxHandlerRuntime extends PptxHandlerRuntime86 {
+    PptxHandlerRuntime88 = class _PptxHandlerRuntime extends PptxHandlerRuntime87 {
       reportIncompleteSmartArtRelationships(graphicFrame, relationshipIds, slidePath) {
         const missing = [
           ["dm", relationshipIds?.dataRelId],
@@ -119600,7 +120680,7 @@ var init_smartart_layout_category = __esm({
     ];
   }
 });
-var PptxHandlerRuntime88;
+var PptxHandlerRuntime89;
 var init_PptxHandlerRuntimeSmartArt = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeSmartArt.ts"() {
     init_utils();
@@ -119613,7 +120693,7 @@ var init_PptxHandlerRuntimeSmartArt = __esm({
     init_smartart_text_paragraphs();
     init_smartart_text_style_resolution();
     init_smartart_xml_builders();
-    PptxHandlerRuntime88 = class _PptxHandlerRuntime extends PptxHandlerRuntime87 {
+    PptxHandlerRuntime89 = class _PptxHandlerRuntime extends PptxHandlerRuntime88 {
       async getSmartArtDataForGraphicFrame(slidePath, graphicFrame) {
         const graphicData = this.xmlLookupService.getChildByLocalName(
           this.xmlLookupService.getChildByLocalName(graphicFrame, "graphic"),
@@ -119832,12 +120912,12 @@ var init_PptxHandlerRuntimeSmartArt = __esm({
     };
   }
 });
-var PptxHandlerRuntime89;
+var PptxHandlerRuntime90;
 var init_PptxHandlerRuntimeChartDetection = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeChartDetection.ts"() {
     init_chart_multi_level_category_parser();
     init_PptxHandlerRuntimeSmartArt();
-    PptxHandlerRuntime89 = class extends PptxHandlerRuntime88 {
+    PptxHandlerRuntime90 = class extends PptxHandlerRuntime89 {
       detectChartType(plotArea) {
         if (!plotArea) {
           return "unknown";
@@ -120047,14 +121127,14 @@ function parseNumberVal(node) {
   return Number.isFinite(num) ? num : void 0;
 }
 var CHART_DATA_DISPLAY_OPTIONS_EXT_URI2;
-var PptxHandlerRuntime90;
+var PptxHandlerRuntime91;
 var init_PptxHandlerRuntimeChartParsingHelpers = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeChartParsingHelpers.ts"() {
     init_chart_ext_lookup();
     init_chart_pivot_source2();
     init_PptxHandlerRuntimeChartDetection();
     CHART_DATA_DISPLAY_OPTIONS_EXT_URI2 = "{56B9EC1D-385E-4148-901F-78D8002777C0}";
-    PptxHandlerRuntime90 = class extends PptxHandlerRuntime89 {
+    PptxHandlerRuntime91 = class extends PptxHandlerRuntime90 {
       /**
        * Parse `c:plotVisOnly` from the chart root element.
        *
@@ -120313,14 +121393,14 @@ var init_PptxHandlerRuntimeChartParsingHelpers = __esm({
   }
 });
 var CHART_USER_SHAPES_REL_TYPE2;
-var PptxHandlerRuntime91;
+var PptxHandlerRuntime92;
 var init_PptxHandlerRuntimeChartExternalData = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeChartExternalData.ts"() {
     init_chart_user_shapes_parser();
     init_chart_xlsx_parser();
     init_PptxHandlerRuntimeChartParsingHelpers();
     CHART_USER_SHAPES_REL_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartUserShapes";
-    PptxHandlerRuntime91 = class extends PptxHandlerRuntime90 {
+    PptxHandlerRuntime92 = class extends PptxHandlerRuntime91 {
       /**
        * Parse `c:externalData` from the chart's `c:chartSpace` and resolve
        * the external relationship target from the chart part's .rels file.
@@ -120477,12 +121557,12 @@ var init_PptxHandlerRuntimeChartExternalData = __esm({
     };
   }
 });
-var PptxHandlerRuntime92;
+var PptxHandlerRuntime93;
 var init_PptxHandlerRuntimeChartColorStyle = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeChartColorStyle.ts"() {
     init_chart_style_definition_parser();
     init_PptxHandlerRuntimeChartExternalData();
-    PptxHandlerRuntime92 = class extends PptxHandlerRuntime91 {
+    PptxHandlerRuntime93 = class extends PptxHandlerRuntime92 {
       /**
        * Parse the Office 2013+ chart-style part (`ppt/charts/style#.xml`)
        * referenced from the chart's relationships, sibling to
@@ -120622,7 +121702,7 @@ var init_PptxHandlerRuntimeChartColorStyle = __esm({
   }
 });
 var SCATTER_STYLES;
-var PptxHandlerRuntime93;
+var PptxHandlerRuntime94;
 var init_PptxHandlerRuntimeChartParsing = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeChartParsing.ts"() {
     init_chart_advanced_parser();
@@ -120659,7 +121739,7 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
       "smooth",
       "smoothMarker"
     ]);
-    PptxHandlerRuntime93 = class extends PptxHandlerRuntime92 {
+    PptxHandlerRuntime94 = class extends PptxHandlerRuntime93 {
       /**
        * Parse chart data from a graphic frame element on a slide.
        *
@@ -121311,14 +122391,14 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
     };
   }
 });
-var PptxHandlerRuntime94;
+var PptxHandlerRuntime95;
 var init_PptxHandlerRuntimePresentationStructure = __esm({
   "src/core/core/runtime/PptxHandlerRuntimePresentationStructure.ts"() {
     init_kinsoku_parser();
     init_presentation_section_parser();
     init_header_footer_parts();
     init_PptxHandlerRuntimeChartParsing();
-    PptxHandlerRuntime94 = class extends PptxHandlerRuntime93 {
+    PptxHandlerRuntime95 = class extends PptxHandlerRuntime94 {
       parseEditorAnimations(slideXml3) {
         return this.editorAnimationService.parseEditorAnimations(slideXml3);
       }
@@ -121503,7 +122583,7 @@ var init_PptxHandlerRuntimePresentationStructure = __esm({
     };
   }
 });
-var PptxHandlerRuntime95;
+var PptxHandlerRuntime96;
 var init_PptxHandlerRuntimeEmbeddedFonts = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeEmbeddedFonts.ts"() {
     init_eot_parser();
@@ -121512,7 +122592,7 @@ var init_PptxHandlerRuntimeEmbeddedFonts = __esm({
     init_strip_parent_dir_segments();
     init_xml_access();
     init_PptxHandlerRuntimePresentationStructure();
-    PptxHandlerRuntime95 = class extends PptxHandlerRuntime94 {
+    PptxHandlerRuntime96 = class extends PptxHandlerRuntime95 {
       async getEmbeddedFonts(fontList) {
         if (!fontList || fontList.fonts.length === 0) {
           return [];
@@ -121715,7 +122795,7 @@ var init_PptxHandlerRuntimeEmbeddedFonts = __esm({
   }
 });
 var MAX_OLE_EMBEDDING_BYTES;
-var PptxHandlerRuntime96;
+var PptxHandlerRuntime97;
 var init_PptxHandlerRuntimeLoadSession = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeLoadSession.ts"() {
     init_ole_embedded_extract();
@@ -121725,7 +122805,7 @@ var init_PptxHandlerRuntimeLoadSession = __esm({
     init_authored_slide_background();
     init_PptxHandlerRuntimeEmbeddedFonts();
     MAX_OLE_EMBEDDING_BYTES = 25 * 1024 * 1024;
-    PptxHandlerRuntime96 = class _PptxHandlerRuntime extends PptxHandlerRuntime95 {
+    PptxHandlerRuntime97 = class _PptxHandlerRuntime extends PptxHandlerRuntime96 {
       isZipContainer(data) {
         const bytes = new Uint8Array(data);
         if (bytes.byteLength < 4) {
@@ -121784,6 +122864,7 @@ var init_PptxHandlerRuntimeLoadSession = __esm({
         this.savedSlideFingerprints.clear();
         this.layoutCache.clear();
         this.masterCache.clear();
+        this.templateElementBaselines.reset();
         this.layoutXmlMap.clear();
         this.masterXmlMap.clear();
         this.masterTxStylesCache.clear();
@@ -122082,19 +123163,22 @@ var init_PptxHandlerRuntimeLoadSession = __esm({
     };
   }
 });
-var PptxHandlerRuntime97;
+var PptxHandlerRuntime98;
 var init_PptxHandlerRuntimeLoadPipeline = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeLoadPipeline.ts"() {
     init_fluent();
     init_embedded_font_list();
     init_guide_utils();
     init_layout_display_name();
+    init_part_rels_path();
     init_smart_tags_parser();
     init_strip_parent_dir_segments();
     init_builders();
+    init_authored_slide_background();
+    init_layout_switch_placeholder_prompts();
     init_PptxHandlerRuntimeLoadSession();
     init_slide_fingerprint();
-    PptxHandlerRuntime97 = class extends PptxHandlerRuntime96 {
+    PptxHandlerRuntime98 = class extends PptxHandlerRuntime97 {
       async buildLoadData(presentationState, slidesWithWarnings, slideMasters) {
         const headerFooter = this.extractHeaderFooter();
         const presentationProperties = await this.parsePresentationProperties();
@@ -122256,6 +123340,7 @@ var init_PptxHandlerRuntimeLoadPipeline = __esm({
         this.externalRelsMap.clear();
         this.layoutCache.clear();
         this.masterCache.clear();
+        this.templateElementBaselines.reset();
         this.layoutXmlMap.clear();
         this.masterXmlMap.clear();
         this.masterTxStylesCache.clear();
@@ -122517,15 +123602,28 @@ var init_PptxHandlerRuntimeLoadPipeline = __esm({
             }
           }
         }
+        if (!this.slideRelsMap.has(slidePath)) {
+          this.slideRelsMap.set(
+            slidePath,
+            /* @__PURE__ */ new Map([["rId1", `../slideLayouts/${layoutPath.split("/").pop()}`]])
+          );
+        }
         this.layoutCache.delete(layoutPath);
-        const remappedElements = this.remapElementsToNewLayout(
-          slide.elements,
-          layoutXml,
-          layoutPath
+        await this.getLayoutElements(slidePath);
+        const remappedElements = enrichEmptyPlaceholderPrompts(
+          this.remapElementsToNewLayout(slide.elements, layoutXml, layoutPath),
+          {
+            resolveDefaults: (element) => {
+              const phInfo = this.getElementPlaceholderInfo(element);
+              return phInfo ? this.lookupPlaceholderDefaults(slidePath, phInfo) : void 0;
+            },
+            placeholderType: (element) => this.getElementPlaceholderInfo(element)?.type,
+            applyBodyDefaults: (textStyle, defaults) => this.applyPlaceholderBodyDefaults(textStyle, defaults),
+            applyLevelDefaults: (textStyle, level) => this.applyPlaceholderLevelDefaults(textStyle, level)
+          }
         );
         const sldLayout = layoutXml["p:sldLayout"];
         const layoutName = String(sldLayout?.["p:cSld"]?.["@_name"] || "").trim() || layoutPath;
-        const layoutBgColor = this.extractBackgroundColor(layoutXml, "p:sldLayout");
         const updated = {
           ...slide,
           elements: remappedElements,
@@ -122533,10 +123631,24 @@ var init_PptxHandlerRuntimeLoadPipeline = __esm({
           layoutName,
           isDirty: true
         };
-        if (!slide.rawXml || !this.extractBackgroundColor(slide.rawXml)) {
-          if (layoutBgColor) {
-            updated.backgroundColor = layoutBgColor;
-          }
+        const origin = slideBackgroundOrigin(this, slidePath);
+        const inheritsBackground = origin ? slideBackgroundIsPurelyInherited(origin, slide) : !slide.rawXml || !this.extractBackgroundColor(slide.rawXml);
+        if (inheritsBackground) {
+          await this.loadSlideRelationships(layoutPath, partRelsPath(layoutPath));
+          const [color2, gradient, image] = await Promise.all([
+            this.getLayoutBackgroundColor(slidePath),
+            this.getLayoutBackgroundGradient(slidePath),
+            this.getLayoutBackgroundImage(slidePath)
+          ]);
+          updated.backgroundColor = color2 ?? slide.backgroundColor;
+          updated.backgroundGradient = gradient;
+          updated.backgroundImage = image;
+          rememberSlideBackgroundOrigin(this, slidePath, {
+            authored: false,
+            color: updated.backgroundColor,
+            gradient,
+            image
+          });
         }
         slides[slideIndex] = updated;
         return updated;
@@ -122544,14 +123656,14 @@ var init_PptxHandlerRuntimeLoadPipeline = __esm({
     };
   }
 });
-var PptxHandlerRuntime98;
+var PptxHandlerRuntime99;
 var init_PptxHandlerRuntimeImplementation = __esm({
   "src/core/core/runtime/PptxHandlerRuntimeImplementation.ts"() {
     init_PptxElementXmlBuilder();
     init_builders();
     init_factories();
     init_PptxHandlerRuntimeLoadPipeline();
-    PptxHandlerRuntime98 = class _PptxHandlerRuntime extends PptxHandlerRuntime97 {
+    PptxHandlerRuntime99 = class _PptxHandlerRuntime extends PptxHandlerRuntime98 {
       constructor(dependencyFactory = new PptxRuntimeDependencyFactory()) {
         super();
         this.dependencyFactory = dependencyFactory;
@@ -122688,11 +123800,11 @@ var init_PptxHandlerRuntimeImplementation = __esm({
     };
   }
 });
-var PptxHandlerRuntime99;
+var PptxHandlerRuntime100;
 var init_PptxHandlerRuntime = __esm({
   "src/core/core/PptxHandlerRuntime.ts"() {
     init_PptxHandlerRuntimeImplementation();
-    PptxHandlerRuntime99 = class extends PptxHandlerRuntime98 {
+    PptxHandlerRuntime100 = class extends PptxHandlerRuntime99 {
     };
   }
 });
@@ -122700,7 +123812,7 @@ var createDefaultPptxHandlerRuntime;
 var init_PptxHandlerRuntimeFactory = __esm({
   "src/core/core/PptxHandlerRuntimeFactory.ts"() {
     init_PptxHandlerRuntime();
-    createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime99();
+    createDefaultPptxHandlerRuntime = () => new PptxHandlerRuntime100();
   }
 });
 function deepClone(value) {
@@ -175197,7 +176309,7 @@ function markerText(info) {
 }
 function infoForParagraph(previous, kind, ordinal) {
   if (kind === "none") {
-    return { ...previous, none: true };
+    return { none: true };
   }
   const sameKind = previous && (kind === "numbered" ? Boolean(previous.autoNumType) : Boolean(
     previous.char || previous.imageRelId || previous.imageDataUrl || previous.imageBlipFillXml
@@ -175268,75 +176380,218 @@ function elementSegments(element) {
     { text: text22, style: { ...element.textStyle } }
   ]);
 }
-function splitParagraphs2(segments) {
-  const paragraphs = [
-    { segments: [] }
-  ];
-  for (const segment of segments) {
+function splitBulletParagraphs(segments) {
+  const paragraphs = [{ segments: [], indices: [] }];
+  for (const [index, segment] of segments.entries()) {
     if (isParagraphSeparatorSegment(segment)) {
       paragraphs[paragraphs.length - 1].terminator = segment;
-      paragraphs.push({ segments: [] });
+      paragraphs.push({ segments: [], indices: [] });
     } else {
       paragraphs[paragraphs.length - 1].segments.push(segment);
+      paragraphs[paragraphs.length - 1].indices.push(index);
     }
   }
   return paragraphs;
 }
-function elementBulletKind(element) {
-  for (const paragraph of splitParagraphs2(elementSegments(element))) {
-    if (paragraph.segments.length) {
-      return paragraphBulletKind(paragraph.segments);
-    }
+function resolveBulletSegments(element, override) {
+  if (override?.length) {
+    return [...override];
   }
-  return "none";
+  return elementSegments(element);
 }
-function setElementBullets(element, kind, range) {
-  if (!hasTextProperties(element)) {
-    return {};
+function paragraphsBulletKind(paragraphs) {
+  let kind;
+  for (const paragraph of paragraphs) {
+    if (paragraph.segments.length === 0) {
+      continue;
+    }
+    const current = paragraphBulletKind(paragraph.segments);
+    if (kind !== void 0 && kind !== current) {
+      return "mixed";
+    }
+    kind = current;
   }
-  if (range && (!Number.isInteger(range.startParagraph) || !Number.isInteger(range.endParagraph) || range.startParagraph < 0 || range.endParagraph < range.startParagraph)) {
-    return {};
+  return kind ?? "none";
+}
+function elementBulletKind(element) {
+  return paragraphsBulletKind(splitBulletParagraphs(resolveBulletSegments(element)));
+}
+function inScope(paragraph, selection) {
+  if (!selection) {
+    return true;
   }
-  const paragraphs = splitParagraphs2(elementSegments(element));
-  if (range && range.startParagraph >= paragraphs.length) {
-    return {};
+  return paragraph.indices.some(
+    (index) => index >= selection.startSegIdx && index <= selection.endSegIdx
+  );
+}
+function selectionBulletKind(element, selection, segments) {
+  const paragraphs = splitBulletParagraphs(resolveBulletSegments(element, segments));
+  return paragraphsBulletKind(paragraphs.filter((paragraph) => inScope(paragraph, selection)));
+}
+function setSelectionBullets(element, kind, selection, segments) {
+  if (!hasTextProperties(element)) {
+    return { patch: {}, newSelection: selection };
   }
+  const source = resolveBulletSegments(element, segments);
   const next = [];
-  const sequence = createAutoNumberSequence();
-  for (const [index, paragraph] of paragraphs.entries()) {
-    const selected = !range || index >= range.startParagraph && index <= range.endParagraph;
-    let segments = paragraph.segments;
-    if (selected) {
-      const empty = {
-        ...paragraph.terminator,
-        text: "",
-        style: { ...paragraph.terminator?.style }
-      };
-      delete empty.isParagraphBreak;
-      delete empty.isLineBreak;
-      segments = toggleParagraphBullet(segments.length ? segments : [empty], kind);
-    }
-    const first = segments[0] ?? paragraph.terminator;
-    const info = first?.bulletInfo;
-    const level = first?.paragraphLevel ?? 0;
-    if (info?.autoNumType && paragraphBulletKind(segments) === "numbered") {
-      const startAt = info.autoNumStartAt ?? 1;
-      const ordinal = nextAutoNumber(sequence, level, info.autoNumType, startAt) - startAt;
-      if (info.paragraphIndex !== ordinal) {
-        segments = toggleParagraphBullet(segments, "numbered", ordinal);
-      }
+  const indexMap = /* @__PURE__ */ new Map();
+  let ordinal = 0;
+  for (const paragraph of splitBulletParagraphs(source)) {
+    const content = paragraph.indices.filter(
+      (_index, position2) => !isBulletMarkerSegment(paragraph.segments[position2])
+    );
+    if (paragraph.segments.length > 0 && content.length > 0 && inScope(paragraph, selection)) {
+      const rewritten = toggleParagraphBullet(paragraph.segments, kind, ordinal);
+      ordinal += 1;
+      const contentStart = next.length + (kind === "none" ? 0 : 1);
+      for (const [position2, index] of content.entries()) {
+        indexMap.set(index, contentStart + position2);
+      }
+      next.push(...rewritten);
     } else {
-      breakAutoNumberRun(sequence, level);
+      for (const [position2, index] of paragraph.indices.entries()) {
+        indexMap.set(index, next.length + position2);
+      }
+      next.push(...paragraph.segments);
     }
-    next.push(...segments);
     if (paragraph.terminator) {
       next.push(paragraph.terminator);
     }
   }
-  return {
-    textSegments: next,
-    textStyle: withoutListType(element.textStyle)
-  };
+  const textStyle = withoutListType(element.textStyle);
+  const newSelection = selection ? {
+    startSegIdx: indexMap.get(selection.startSegIdx) ?? selection.startSegIdx,
+    startOffset: selection.startOffset,
+    endSegIdx: indexMap.get(selection.endSegIdx) ?? selection.endSegIdx,
+    endOffset: selection.endOffset
+  } : null;
+  return { patch: { textSegments: next, textStyle }, newSelection };
+}
+function toggleSelectionBullets(element, kind, selection, segments) {
+  const current = selectionBulletKind(element, selection, segments);
+  return setSelectionBullets(element, current === kind ? "none" : kind, selection, segments);
+}
+var TEXT_DECORATION_FLAGS = [
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough"
+];
+function isContentSegment(segment) {
+  return !segment.isParagraphBreak && segment.text !== "\n" && segment.text.length > 0 && !isBulletMarkerSegment(segment);
+}
+function contentSegmentsInSelection(segments, selection) {
+  if (!segments) {
+    return [];
+  }
+  return segments.filter(
+    (segment, index) => isContentSegment(segment) && (!selection || index >= selection.startSegIdx && index <= selection.endSegIdx)
+  );
+}
+function flagState(values) {
+  if (values.every((value) => value)) {
+    return "on";
+  }
+  return values.some((value) => value) ? "mixed" : "off";
+}
+function getSelectionTextStyleFlags(segments, selection, elementTextStyle) {
+  const runs = contentSegmentsInSelection(segments, selection);
+  const flags = {};
+  for (const flag of TEXT_DECORATION_FLAGS) {
+    const body = elementTextStyle?.[flag] ?? false;
+    flags[flag] = runs.length === 0 ? flagState([body]) : flagState(runs.map((run) => run.style?.[flag] ?? body));
+  }
+  return flags;
+}
+function nextToggleValue(state) {
+  return state !== "on";
+}
+var BODY_TEXT_STYLE_KEYS = /* @__PURE__ */ new Set([
+  // autofit (`a:normAutofit` / `a:spAutoFit`)
+  "autoFit",
+  "autoFitMode",
+  "autoFitFontScale",
+  "autoFitLineSpacingReduction",
+  // `a:bodyPr` anchoring, direction, rotation
+  "vAlign",
+  "anchorCenter",
+  "textDirection",
+  "textBodyRotation",
+  "upright",
+  // `a:bodyPr` columns, overflow, wrap
+  "columnCount",
+  "columnSpacing",
+  "rtlColumns",
+  "hOverflow",
+  "vertOverflow",
+  "textWrap",
+  // `a:bodyPr` insets
+  "bodyInsetLeft",
+  "bodyInsetTop",
+  "bodyInsetRight",
+  "bodyInsetBottom",
+  // paragraph geometry the block applies body-wide
+  "paragraphMarginLeft",
+  "paragraphMarginRight",
+  "paragraphIndent",
+  "paragraphSpacingBefore",
+  "paragraphSpacingAfter",
+  "lineSpacing",
+  "lineSpacingExactPt",
+  "tabStops",
+  "defaultTabSize",
+  "eaLineBreak",
+  "latinLineBreak",
+  "fontAlignment",
+  "hangingPunctuation",
+  // `a:bodyPr` flags
+  "spaceFirstLastParagraph",
+  "fromWordArt",
+  "forceAntiAlias",
+  "compatibleLineSpacing",
+  // warp and 3D scene on the body
+  "textWarpPreset",
+  "textWarpAdj",
+  "textWarpAdj2",
+  "text3d",
+  "textBodyScene3d",
+  "textBodyScene3dXml",
+  "flatText",
+  "bodyPropertiesExtLstXml"
+]);
+function isBodyTextStyleKey(key2) {
+  return BODY_TEXT_STYLE_KEYS.has(key2);
+}
+function splitTextStyleUpdate(updates) {
+  const body = {};
+  const run = {};
+  for (const [key2, value] of Object.entries(updates)) {
+    (isBodyTextStyleKey(key2) ? body : run)[key2] = value;
+  }
+  return { body, run };
+}
+function reconcileDecorationFlags(segments, textStyle, flags) {
+  const nextStyle = { ...textStyle ?? {} };
+  let nextSegments = [...segments];
+  for (const flag of flags) {
+    const body = nextStyle[flag] ?? false;
+    const content = nextSegments.filter(isContentSegment);
+    if (content.length === 0) {
+      continue;
+    }
+    if (content.every((segment) => segment.style?.[flag] ?? body)) {
+      nextStyle[flag] = true;
+      continue;
+    }
+    if (!body) {
+      continue;
+    }
+    delete nextStyle[flag];
+    nextSegments = nextSegments.map(
+      (segment) => isContentSegment(segment) && segment.style?.[flag] === void 0 ? { ...segment, style: { ...segment.style, [flag]: true } } : segment
+    );
+  }
+  return { textStyle: nextStyle, textSegments: nextSegments };
 }
 function updateTextSegmentStyle(segment, updates, options = {}) {
   return {
@@ -175597,128 +176852,37 @@ function findTextPositionInSegment(editor, segIdx, charOffset) {
   }
   return null;
 }
-function positions(segments) {
-  let offset = 0;
-  let paragraph = 0;
-  let first = true;
-  return segments.map((segment) => {
-    const marker = first && isBulletMarkerSegment(segment);
-    const start = offset;
-    if (!marker) {
-      offset += segment.text.length;
-    }
-    const entry2 = {
-      start,
-      end: offset,
-      paragraph,
-      editable: !marker && !isParagraphSeparatorSegment(segment)
-    };
-    first = isParagraphSeparatorSegment(segment);
-    if (first) {
-      paragraph += 1;
-    }
-    return entry2;
-  });
-}
-function restorePoint(segments, offset, end) {
-  const entries = positions(segments);
-  let fallback = { index: 0, offset: 0 };
-  for (const [index, entry2] of entries.entries()) {
-    if (!entry2.editable) {
-      continue;
-    }
-    fallback = { index, offset: segments[index].text.length };
-    if (end ? offset <= entry2.end : offset < entry2.end) {
-      return { index, offset: Math.max(0, offset - entry2.start) };
-    }
-  }
-  return fallback;
-}
-function restoreParagraphMetadata(original, updated) {
-  const firstRuns = original.filter(
-    (_, index) => index === 0 || isParagraphSeparatorSegment(original[index - 1])
-  );
-  let paragraph = 0;
-  return updated.map((segment, index) => {
-    const first = index === 0 || isParagraphSeparatorSegment(updated[index - 1]);
-    if (!first) {
-      return segment;
-    }
-    const source = firstRuns[paragraph++];
-    if (!source) {
-      return segment;
-    }
-    return {
-      ...segment,
-      bulletInfo: source.bulletInfo,
-      paragraphLevel: source.paragraphLevel,
-      paragraphProperties: source.paragraphProperties,
-      endParaRunProperties: source.endParaRunProperties
-    };
-  });
-}
-function selectedParagraphBulletKind(element, selection) {
-  if (!selection || !hasTextProperties(element) || !element.textSegments) {
-    return elementBulletKind(element);
-  }
-  let first = selection.startSegIdx;
-  while (first > 0 && !isParagraphSeparatorSegment(element.textSegments[first - 1])) {
-    first -= 1;
-  }
-  return paragraphBulletKind(element.textSegments.slice(first));
-}
-function applyListStyleUpdate(element, updates, selection) {
-  if (!hasTextProperties(element) || !updates.listType) {
-    return { patch: {}, selection };
-  }
-  const { listType, ...characterStyle } = updates;
-  let segments = element.textSegments;
-  let workingSelection = selection;
-  if (segments && Object.keys(characterStyle).length > 0) {
-    if (selection) {
-      const styled = applyStyleToSelectedSegments(segments, selection, characterStyle);
-      segments = restoreParagraphMetadata(segments, styled.newSegments);
-      workingSelection = styled.newSelection;
-    } else {
-      segments = segments.map((segment) => updateTextSegmentStyle(segment, characterStyle));
-    }
-  }
-  const working = {
-    ...element,
-    textSegments: segments,
-    textStyle: selection ? element.textStyle : { ...element.textStyle, ...characterStyle }
-  };
-  if (!workingSelection || !segments) {
-    return { patch: setElementBullets(working, listType), selection: null };
-  }
-  const entries = positions(segments);
-  const startEntry = entries[workingSelection.startSegIdx];
-  const endEntry = entries[workingSelection.endSegIdx];
-  if (!startEntry || !endEntry) {
-    return { patch: {}, selection: null };
-  }
-  const startOffset = startEntry.start + workingSelection.startOffset;
-  const endOffset = endEntry.start + workingSelection.endOffset;
-  const lastSelected = [...entries].reverse().find((entry2) => entry2.start < endOffset);
-  const patch = setElementBullets(working, listType, {
-    startParagraph: startEntry.paragraph,
-    endParagraph: lastSelected?.paragraph ?? endEntry.paragraph
-  });
-  const next = { ...working, ...patch };
-  const nextSegments = hasTextProperties(next) ? next.textSegments : void 0;
-  if (!nextSegments) {
-    return { patch, selection: null };
-  }
-  const start = restorePoint(nextSegments, startOffset, false);
-  const end = restorePoint(nextSegments, endOffset, true);
+function applyTextStyleUpdate(element, updates, selection, segments) {
+  if (!hasTextProperties(element)) {
+    return { patch: {}, newSelection: null };
+  }
+  const current = segments ?? element.textSegments;
+  if (selection && current && current.length > 0) {
+    const { body, run } = splitTextStyleUpdate(updates);
+    let textStyle2 = { ...element.textStyle, ...body };
+    let textSegments2 = [...current];
+    let newSelection = selection;
+    if (Object.keys(run).length > 0) {
+      const scoped = applyStyleToSelectedSegments(textSegments2, selection, run);
+      textSegments2 = scoped.newSegments;
+      newSelection = scoped.newSelection;
+    }
+    const touched = TEXT_DECORATION_FLAGS.filter((flag) => flag in run);
+    if (touched.length > 0) {
+      const reconciled = reconcileDecorationFlags(textSegments2, textStyle2, touched);
+      textStyle2 = reconciled.textStyle;
+      textSegments2 = reconciled.textSegments;
+    }
+    return { patch: { textStyle: textStyle2, textSegments: textSegments2 }, newSelection };
+  }
+  const textStyle = { ...element.textStyle, ...updates };
+  const textSegments = current?.map((segment) => ({
+    ...segment,
+    style: { ...segment.style, ...updates }
+  }));
   return {
-    patch,
-    selection: {
-      startSegIdx: start.index,
-      startOffset: start.offset,
-      endSegIdx: end.index,
-      endOffset: end.offset
-    }
+    patch: textSegments ? { textStyle, textSegments } : { textStyle },
+    newSelection: null
   };
 }
 var DEBOUNCE_MS = 600;
@@ -176867,12 +178031,15 @@ function buildTextBlockStyle(element, options = {}) {
   const bodyIndent = hasParagraphIndents ? 0 : ts?.paragraphIndent || 0;
   const bodyMarginLeft = hasParagraphIndents ? 0 : ts?.paragraphMarginLeft || 0;
   const bodyMarginRight = hasParagraphIndents ? 0 : ts?.paragraphMarginRight || 0;
+  const hasTextSegments = (element.textSegments?.length ?? 0) > 0;
   const decorations = [];
-  if (ts?.underline || ts?.hyperlink) {
-    decorations.push("underline");
-  }
-  if (ts?.strikethrough) {
-    decorations.push("line-through");
+  if (!hasTextSegments) {
+    if (ts?.underline || ts?.hyperlink) {
+      decorations.push("underline");
+    }
+    if (ts?.strikethrough) {
+      decorations.push("line-through");
+    }
   }
   const style = {};
   if (options.bodyLayout) {
@@ -176888,7 +178055,7 @@ function buildTextBlockStyle(element, options = {}) {
     }
   }
   style.color = ts?.hyperlink ? normalizeHexColor2(ts?.color, HYPERLINK_COLOR) : normalizeHexColor2(ts?.color, fallbackColor);
-  if ((element.textSegments?.length ?? 0) === 0 && ts?.highlightColor) {
+  if (!hasTextSegments && ts?.highlightColor) {
     style.backgroundColor = normalizeHexColor2(ts.highlightColor, void 0);
   }
   style.textAlign = resolveCssTextAlign(ts?.align, isRtl) ?? "left";
@@ -176901,7 +178068,7 @@ function buildTextBlockStyle(element, options = {}) {
   style.fontWeight = ts?.bold ? 700 : 400;
   style.fontStyle = ts?.italic ? "italic" : "normal";
   style.textDecorationLine = decorations.length > 0 ? decorations.join(" ") : "none";
-  if (ts?.strikethrough && ts?.strikeType === "dblStrike") {
+  if (!hasTextSegments && ts?.strikethrough && ts?.strikeType === "dblStrike") {
     style.textDecorationStyle = "double";
   }
   style.lineHeight = resolveLineHeight(ts);
@@ -181238,6 +182405,9 @@ function remapEmptyParagraph(text22, segments, terminator) {
   delete first.isParagraphBreak;
   return [{ ...first, text: text22, style: { ...insertionStyle } }];
 }
+function trailingWhitespace(text22) {
+  return text22.slice(text22.trimEnd().length);
+}
 function renumberRemappedParagraphs(segments) {
   const sequence = createAutoNumberSequence();
   let first = true;
@@ -181261,7 +182431,7 @@ function renumberRemappedParagraphs(segments) {
     if (isBulletMarkerSegment(segment)) {
       const resolved = resolveParagraphBullet(updated);
       if (resolved) {
-        updated.text = resolved.marker + (segment.text.match(/\s+$/u)?.[0] ?? "");
+        updated.text = resolved.marker + trailingWhitespace(segment.text);
       }
     }
     return updated;
@@ -181311,8 +182481,7 @@ function continueListParagraph(segments, donorSegments) {
   if (bullet.isNumbered && typeof paragraphIndex === "number" && Number.isFinite(paragraphIndex) && isBulletMarkerSegment(donor)) {
     const resolved = resolveParagraphBullet(continued);
     if (resolved) {
-      const trailingWhitespace = donor.text.match(/\s+$/u)?.[0] ?? "";
-      continued.text = `${resolved.marker}${trailingWhitespace}`;
+      continued.text = `${resolved.marker}${trailingWhitespace(donor.text)}`;
     }
   }
   return [continued, ...rest];
@@ -181545,6 +182714,22 @@ function remapTextToSegments(newText, originalSegments, elementTextStyle) {
     );
     if (!originalParagraph && precedingParagraph) {
       paraSegments = continueListParagraph(paraSegments, precedingParagraph);
+      const donor = precedingParagraph[0];
+      if (donor?.paragraphProperties?.alignment !== void 0 && paraSegments[0]) {
+        paraSegments = [
+          {
+            ...paraSegments[0],
+            paragraphLevel: donor.paragraphLevel,
+            paragraphProperties: donor.paragraphProperties
+          },
+          ...paraSegments.slice(1)
+        ];
+      }
+    } else if (!originalParagraph && pi === 0 && paraSegments[0]) {
+      const firstOriginal = originalParagraphs[0]?.segments[0];
+      if (firstOriginal?.paragraphLevel !== void 0) {
+        paraSegments = [{ ...paraSegments[0], paragraphLevel: firstOriginal.paragraphLevel }];
+      }
     }
     output.push(...paraSegments);
     precedingParagraph = paraSegments;
@@ -181655,7 +182840,7 @@ function adjustmentRange(def, key2, vars, isAngular) {
   }
   return isAngular ? { min: 0, max: ANGLE_UNITS_PER_TURN } : { min: -UNBOUNDED_CARTESIAN, max: UNBOUNDED_CARTESIAN };
 }
-var COMMAND_ARITY = {
+var COMMAND_ARITY2 = {
   M: { take: 2, points: [0] },
   L: { take: 2, points: [0] },
   Q: { take: 4, points: [0, 2] },
@@ -181675,7 +182860,7 @@ function pathCoordinates(paths) {
         i2 += 1;
         continue;
       }
-      const arity = COMMAND_ARITY[command];
+      const arity = COMMAND_ARITY2[command];
       if (!arity) {
         i2 += 1;
         continue;
@@ -187567,14 +188752,14 @@ var THREE_UNAVAILABLE = {
 var FOV = 50;
 async function loadThree() {
   try {
-    return await import('./three.module-GNNNRIMK.js');
+    return await import('./three.module-YZ4M24WM.js');
   } catch {
     return null;
   }
 }
 async function loadGltfLoaderCtor() {
   try {
-    const mod = await import('./GLTFLoader-Q7BHCGAW.js');
+    const mod = await import('./GLTFLoader-KY7AYPMX.js');
     return mod.GLTFLoader;
   } catch {
     return null;
@@ -187582,7 +188767,7 @@ async function loadGltfLoaderCtor() {
 }
 async function loadOrbitControlsCtor() {
   try {
-    const mod = await import('./OrbitControls-SMYCPLXO.js');
+    const mod = await import('./OrbitControls-CGYUF3BY.js');
     return mod.OrbitControls;
   } catch {
     return null;
@@ -187929,14 +189114,14 @@ function createChart3DLabelProjector(three, doc, labels) {
 }
 async function loadChart3DThree() {
   try {
-    return await import('./three.module-GNNNRIMK.js');
+    return await import('./three.module-YZ4M24WM.js');
   } catch {
     return null;
   }
 }
 async function loadChart3DOrbitControls() {
   try {
-    const mod = await import('./OrbitControls-SMYCPLXO.js');
+    const mod = await import('./OrbitControls-CGYUF3BY.js');
     return mod.OrbitControls;
   } catch {
     return null;
@@ -190771,27 +191956,41 @@ function projectDrawingShapes(elementId, shapes, viewBox, palette, style) {
 function styleShadowFilter(style) {
   return styleShadow(style);
 }
+function collectFontsFromElement(element, fonts) {
+  if (hasTextProperties(element)) {
+    if (element.textStyle?.fontFamily) {
+      fonts.add(element.textStyle.fontFamily);
+    }
+    for (const segment of element.textSegments ?? []) {
+      if (segment.style?.fontFamily) {
+        fonts.add(segment.style.fontFamily);
+      }
+    }
+  }
+  if (element.type === "group") {
+    for (const child27 of element.children ?? []) {
+      collectFontsFromElement(child27, fonts);
+    }
+  }
+}
+function collectUsedFonts(slides) {
+  const fonts = /* @__PURE__ */ new Set();
+  for (const slide of slides) {
+    for (const element of slide.elements ?? []) {
+      collectFontsFromElement(element, fonts);
+    }
+  }
+  return [...fonts].sort();
+}
 var GOOGLE_FONTS_CSS2_BASE = "https://fonts.googleapis.com/css2";
 var GOOGLE_WEBFONT_AXIS = "ital,wght@0,400;0,700;1,400;1,700";
 var DISPLAY_PARAM = "display=swap";
 function collectReferencedFontFamilies(slides) {
   const families = /* @__PURE__ */ new Set();
-  const visit = (elements) => {
-    for (const el of elements) {
-      if (el.type === "group") {
-        visit(el.children);
-      }
-      if (hasTextProperties(el) && el.textSegments) {
-        for (const seg of el.textSegments) {
-          if (seg.style.fontFamily) {
-            families.add(seg.style.fontFamily);
-          }
-        }
-      }
-    }
-  };
   for (const slide of slides) {
-    visit(slide.elements);
+    for (const el of slide.elements) {
+      collectFontsFromElement(el, families);
+    }
   }
   return families;
 }
@@ -198369,32 +199568,6 @@ function computeVirtualRange(totalItems, itemHeight, scrollTop, viewportHeight,
     visibleRange: { start: visibleStart, end: visibleEnd }
   };
 }
-function collectFontsFromElement(element, fonts) {
-  if (hasTextProperties(element)) {
-    if (element.textStyle?.fontFamily) {
-      fonts.add(element.textStyle.fontFamily);
-    }
-    for (const segment of element.textSegments ?? []) {
-      if (segment.style?.fontFamily) {
-        fonts.add(segment.style.fontFamily);
-      }
-    }
-  }
-  if (element.type === "group") {
-    for (const child27 of element.children ?? []) {
-      collectFontsFromElement(child27, fonts);
-    }
-  }
-}
-function collectUsedFonts(slides) {
-  const fonts = /* @__PURE__ */ new Set();
-  for (const slide of slides) {
-    for (const element of slide.elements ?? []) {
-      collectFontsFromElement(element, fonts);
-    }
-  }
-  return [...fonts].sort();
-}
 function browserFontSource() {
   return typeof document === "undefined" ? void 0 : document.fonts;
 }
@@ -201185,13 +202358,26 @@ async function fetchAsDataUrl(url) {
     return null;
   }
 }
-var CSS_URL_PATTERN = /url\(\s*(?:"([^"]*)"|'([^']*)'|([^"')\s]+))\s*\)/u;
 function extractCssUrl(value) {
-  const match = CSS_URL_PATTERN.exec(value);
-  if (!match) {
+  const start = value.indexOf("url(");
+  if (start === -1) {
+    return null;
+  }
+  const contents = value.slice(start + "url(".length).trimStart();
+  const quote = contents[0];
+  if (quote === '"' || quote === "'") {
+    const end2 = contents.indexOf(quote, 1);
+    if (end2 === -1 || !contents.slice(end2 + 1).trimStart().startsWith(")")) {
+      return null;
+    }
+    return contents.slice(1, end2);
+  }
+  const end = contents.indexOf(")");
+  if (end === -1) {
     return null;
   }
-  return match[1] ?? match[2] ?? match[3] ?? null;
+  const url = contents.slice(0, end).trimEnd();
+  return url && !url.includes('"') && !url.includes("'") && !url.includes(" ") && !url.includes("	") ? url : null;
 }
 function needsEmbedding(url) {
   return url.startsWith("blob:") || url.startsWith("http:") || url.startsWith("https:");
@@ -201329,6 +202515,89 @@ function calculateViewportFit(input, defaults = DEFAULTS2) {
     availableHeight
   };
 }
+var FREEFORM_COORD_SCALE = 100;
+var FREEFORM_MIN_POINTS = 2;
+var FREEFORM_CLOSE_TOLERANCE_FACTOR = 3;
+var FREEFORM_CLOSE_TOLERANCE_MIN_PX = 4;
+function freeformCloseTolerance(strokeWidth) {
+  return Math.max(FREEFORM_CLOSE_TOLERANCE_MIN_PX, strokeWidth * FREEFORM_CLOSE_TOLERANCE_FACTOR);
+}
+function isFreeformStrokeClosed(points4, tolerance) {
+  if (points4.length < 3) {
+    return false;
+  }
+  const first = points4[0];
+  const last = points4[points4.length - 1];
+  return Math.hypot(last.x - first.x, last.y - first.y) <= tolerance;
+}
+function buildFreeformStrokeGeometry(points4, strokeWidth, options = {}) {
+  if (points4.length < FREEFORM_MIN_POINTS) {
+    return null;
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const point of points4) {
+    minX = Math.min(minX, point.x);
+    minY = Math.min(minY, point.y);
+    maxX = Math.max(maxX, point.x);
+    maxY = Math.max(maxY, point.y);
+  }
+  minX -= strokeWidth;
+  minY -= strokeWidth;
+  maxX += strokeWidth;
+  maxY += strokeWidth;
+  const width = Math.max(maxX - minX, 1);
+  const height = Math.max(maxY - minY, 1);
+  const segments = points4.map((point, index) => {
+    const pt = {
+      x: Math.round((point.x - minX) * FREEFORM_COORD_SCALE),
+      y: Math.round((point.y - minY) * FREEFORM_COORD_SCALE)
+    };
+    return index === 0 ? { type: "moveTo", pt } : { type: "lineTo", pt };
+  });
+  const closed = isFreeformStrokeClosed(
+    points4,
+    options.closeTolerance ?? freeformCloseTolerance(strokeWidth)
+  );
+  if (closed) {
+    segments.push({ type: "close" });
+  }
+  return {
+    x: minX,
+    y: minY,
+    width,
+    height,
+    path: {
+      width: Math.round(width * FREEFORM_COORD_SCALE),
+      height: Math.round(height * FREEFORM_COORD_SCALE),
+      segments
+    },
+    closed
+  };
+}
+function buildFreeformShapeElement(points4, options) {
+  const geometry = buildFreeformStrokeGeometry(points4, options.width, options);
+  if (!geometry) {
+    return null;
+  }
+  return {
+    id: options.id ?? createEditorId("shape"),
+    type: "shape",
+    x: geometry.x,
+    y: geometry.y,
+    width: geometry.width,
+    height: geometry.height,
+    shapeType: "custom",
+    shapeStyle: {
+      fillColor: "transparent",
+      strokeColor: options.color,
+      strokeWidth: options.width
+    },
+    customGeometryPaths: [geometry.path]
+  };
+}
 var FALLBACK_DOWNLOAD_NAME = "presentation.pptx";
 var REVOKE_DELAY_MS = 200;
 var OPEN_REVOKE_DELAY_MS = 6e4;
@@ -203493,15 +204762,18 @@ async function rasterizeElementTiles(element, naturalWidth, naturalHeight, doc,
   return { fullWidth: plan.fullWidth, fullHeight: plan.fullHeight, tiled: plan.tiled, tiles };
 }
 function groupTilesByRow(tiles) {
-  const rowCount = tiles.reduce((max, t) => Math.max(max, t.row), 0) + 1;
-  const rows = Array.from({ length: rowCount }, () => []);
-  for (const tile of tiles) {
-    if (!Number.isInteger(tile.row) || !Number.isInteger(tile.col) || tile.row < 0 || tile.col < 0) {
-      continue;
-    }
-    rows[tile.row][tile.col] = tile;
-  }
-  return rows;
+  const validTiles = tiles.filter(
+    (tile) => Number.isInteger(tile.row) && Number.isInteger(tile.col) && tile.row >= 0 && tile.col >= 0
+  );
+  const rowCount = validTiles.reduce((max, tile) => Math.max(max, tile.row), 0) + 1;
+  return Array.from({ length: rowCount }, (_rowIndex, row) => {
+    const tilesInRow = validTiles.filter((tile) => tile.row === row);
+    const colCount = tilesInRow.reduce((max, tile) => Math.max(max, tile.col), -1) + 1;
+    return Array.from(
+      { length: colCount },
+      (_columnIndex, col) => tilesInRow.find((tile) => tile.col === col)
+    );
+  });
 }
 function combineTileRowPixels(tiles, fullWidth) {
   if (tiles.length === 0) {
@@ -203871,6 +205143,7 @@ exports.TABLE_STYLE_EDITOR_PARTS = TABLE_STYLE_EDITOR_PARTS;
 exports.TABLE_STYLE_PRESETS = TABLE_STYLE_PRESETS;
 exports.TAB_ROW_ACTION_CLASSES = TAB_ROW_ACTION_CLASSES;
 exports.TEXT_BUILD_ID_SEP = TEXT_BUILD_ID_SEP;
+exports.TEXT_DECORATION_FLAGS = TEXT_DECORATION_FLAGS;
 exports.TEXT_WARP_PRESETS = TEXT_WARP_PRESETS;
 exports.THEME_CATALOG = THEME_CATALOG;
 exports.THEME_COLOR_SLOT_LABEL_KEYS = THEME_COLOR_SLOT_LABEL_KEYS;
@@ -203923,7 +205196,6 @@ exports.applyFindReplacements = applyFindReplacements;
 exports.applyFormatToElement = applyFormatToElement;
 exports.applyHighlightClickStyle = applyHighlightClickStyle;
 exports.applyImagePathPatches = applyImagePathPatches;
-exports.applyListStyleUpdate = applyListStyleUpdate;
 exports.applyMasterViewCrudAction = applyMasterViewCrudAction;
 exports.applyMotionPathPreset = applyMotionPathPreset;
 exports.applyOleDocumentParagraphEdit = applyOleDocumentParagraphEdit;
@@ -203935,11 +205207,11 @@ exports.applyReadingViewCommand = applyReadingViewCommand;
 exports.applyRehearsalTimings = applyRehearsalTimings;
 exports.applyReroutedConnectors = applyReroutedConnectors;
 exports.applyResize = applyResize;
-exports.applyStyleToSelectedSegments = applyStyleToSelectedSegments;
 exports.applyTableStyleDelete = applyTableStyleDelete;
 exports.applyTableStyleFieldEdit = applyTableStyleFieldEdit;
 exports.applyTableStyleMapChange = applyTableStyleMapChange;
 exports.applyTableStylePreset = applyTableStylePreset;
+exports.applyTextStyleUpdate = applyTextStyleUpdate;
 exports.applyThemeOverrideToSlide = applyThemeOverrideToSlide;
 exports.applyThemeToData = applyThemeToData;
 exports.applyTransitionSoundFile = applyTransitionSoundFile;
@@ -203980,6 +205252,7 @@ exports.buildDuotoneCacheKey = buildDuotoneCacheKey;
 exports.buildElementClipboardPayload = buildElementClipboardPayload;
 exports.buildFieldSubstitutionContext = buildFieldSubstitutionContext;
 exports.buildFontCatalog = buildFontCatalog;
+exports.buildFreeformShapeElement = buildFreeformShapeElement;
 exports.buildGlyphEnvelope = buildGlyphEnvelope;
 exports.buildHandoutsHtml = buildHandoutsHtml;
 exports.buildHollowHitOutline = buildHollowHitOutline;
@@ -204067,7 +205340,6 @@ exports.clampOptionNumber = clampOptionNumber;
 exports.clampPercent2 = clampPercent2;
 exports.clampSorterZoom = clampSorterZoom;
 exports.clampTransitionNumber = clampTransitionNumber;
-exports.clampUnitInterval = clampUnitInterval2;
 exports.clampZoomScale = clampZoomScale;
 exports.classifyExtraConnections = classifyExtraConnections;
 exports.classifyMediaType = classifyMediaType;
@@ -204236,6 +205508,7 @@ exports.getComputedEffectStyle = getComputedEffectStyle;
 exports.getComputedFillStyle = getComputedFillStyle;
 exports.getComputedStrokeStyle = getComputedStrokeStyle;
 exports.getConnectorEndpointHandles = getConnectorEndpointHandles;
+exports.getConnectorPathGeometry = getConnectorPathGeometry;
 exports.getContentPartReplayStyles = getContentPartReplayStyles;
 exports.getCropShapeClipPath = getCropShapeClipPath;
 exports.getCurrentParagraphIndex = getCurrentParagraphIndex;
@@ -204277,6 +205550,7 @@ exports.getPendingSelectionRestore = getPendingSelectionRestore;
 exports.getPresetShapeClipPath = getPresetShapeClipPath;
 exports.getPresetShapeVectorGeometry = getPresetShapeVectorGeometry;
 exports.getPrintableArea = getPrintableArea;
+exports.getSelectionTextStyleFlags = getSelectionTextStyleFlags;
 exports.getSessionTabId = getSessionTabId;
 exports.getShapeAdjustmentHandleDescriptors = getShapeAdjustmentHandleDescriptors;
 exports.getShapeConnectionSites = getShapeConnectionSites;
@@ -204409,6 +205683,7 @@ exports.nestedTextDecorationStyle = nestedTextDecorationStyle;
 exports.newTableElement = newTableElement;
 exports.nextPresentedSlide = nextPresentedSlide;
 exports.nextShowSlideIndex = nextShowSlideIndex;
+exports.nextToggleValue = nextToggleValue;
 exports.normalizeColorsForCapture = normalizeColorsForCapture;
 exports.normalizeHexColor = normalizeHexColor2;
 exports.normalizeStrokeDashType = normalizeStrokeDashType;
@@ -204593,7 +205868,6 @@ exports.segmentsToEditorHtml = segmentsToEditorHtml;
 exports.segmentsToParagraphs = segmentsToParagraphs;
 exports.segmentsToPlainText = segmentsToPlainText;
 exports.selectGoogleWebfontFamilies = selectGoogleWebfontFamilies;
-exports.selectedParagraphBulletKind = selectedParagraphBulletKind;
 exports.sendBackward = sendBackward;
 exports.sendToBack = sendToBack;
 exports.seriesSecondaryAxisPatch = seriesSecondaryAxisPatch;
@@ -204686,6 +205960,7 @@ exports.toSlideIndex = toSlideIndex;
 exports.toggleBlackboard = toggleBlackboard;
 exports.toggleCommentResolvedInList = toggleCommentResolvedInList;
 exports.togglePresenterTimer = togglePresenterTimer;
+exports.toggleSelectionBullets = toggleSelectionBullets;
 exports.toggleSheet = toggleSheet;
 exports.toggleStageElementMedia = toggleStageElementMedia;
 exports.toggleText3dExtrusion = toggleText3dExtrusion;
@@ -204702,7 +205977,6 @@ exports.updateMasterViewElement = updateMasterViewElement;
 exports.updateMergeAttrsInRawXml = updateMergeAttrsInRawXml;
 exports.updateSmartArtNodeText = updateSmartArtNodeText;
 exports.updateTagInCollections = updateTagInCollections;
-exports.updateTextSegmentStyle = updateTextSegmentStyle;
 exports.validateMediaTrimRange = validateMediaTrimRange;
 exports.validateRoomId = validateRoomId;
 exports.vermilionDarkColors = vermilionDarkColors;