ooxml-core 1.24.3 → 1.25.1

package/dist/docx/ui/index.cjs

@@ -32,16 +32,16 @@ function _interopNamespace(e) {
 var Y2__namespace = /*#__PURE__*/_interopNamespace(Y2);
 
 // docx/ui/backstage-focus.ts
-function backstageFocus(element2) {
+function backstageFocus(element3) {
   let opener = null;
   const siblings = /* @__PURE__ */ new Map();
-  const active = () => element2.getRootNode().activeElement;
+  const active = () => element3.getRootNode().activeElement;
   return {
     open() {
       const current = active();
-      if (current instanceof HTMLElement && !element2.contains(current)) opener = current;
-      for (const sibling of element2.parentElement?.children ?? []) {
-        if (!(sibling instanceof HTMLElement) || sibling === element2 || siblings.has(sibling))
+      if (current instanceof HTMLElement && !element3.contains(current)) opener = current;
+      for (const sibling of element3.parentElement?.children ?? []) {
+        if (!(sibling instanceof HTMLElement) || sibling === element3 || siblings.has(sibling))
           continue;
         siblings.set(sibling, Boolean(sibling.inert));
         sibling.inert = true;
@@ -391,34 +391,34 @@ var buildXml = (node) => {
 var isElement = (node) => node.nodeType === 1;
 var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
 var makeNS = (doc, ns, qualified) => doc.createElementNS(ns, qualified);
-function named(element2, local, ns, lenient = true) {
-  if (!element2 || element2.localName !== local) return false;
-  return element2.namespaceURI === ns || lenient && !element2.namespaceURI;
+function named(element3, local, ns, lenient = true) {
+  if (!element3 || element3.localName !== local) return false;
+  return element3.namespaceURI === ns || lenient && !element3.namespaceURI;
 }
-var children = (parent, local, ns, lenient = true) => elements(parent).filter((element2) => named(element2, local, ns, lenient));
+var children = (parent, local, ns, lenient = true) => elements(parent).filter((element3) => named(element3, local, ns, lenient));
 var first = (parent, local, ns, lenient = true) => parent ? children(parent, local, ns, lenient)[0] : void 0;
-function attr(element2, local, ns, prefix) {
-  return element2?.getAttributeNS(ns, local) ?? element2?.getAttribute(`${prefix}:${local}`) ?? void 0;
+function attr(element3, local, ns, prefix) {
+  return element3?.getAttributeNS(ns, local) ?? element3?.getAttribute(`${prefix}:${local}`) ?? void 0;
 }
 
 // docx/xml.ts
 var WORD_NS = NS.w;
 var WORD_DATE_UTC_NS = "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
 var parseXml2 = (xml) => parseXml(xml, { label: "DOCX" });
-var named2 = (element2, local) => named(element2, local, WORD_NS);
+var named2 = (element3, local) => named(element3, local, WORD_NS);
 var children2 = (parent, local) => children(parent, local, WORD_NS);
 var first2 = (parent, local) => first(parent, local, WORD_NS);
-var getW = (element2, local) => attr(element2, local, WORD_NS, "w");
+var getW = (element3, local) => attr(element3, local, WORD_NS, "w");
 var makeW = (doc, local) => doc.createElementNS(WORD_NS, `w:${local}`);
 var XMLNS = "http://www.w3.org/2000/xmlns/";
-function importElement(doc, element2) {
-  const imported = doc.importNode(element2, true);
+function importElement(doc, element3) {
+  const imported = doc.importNode(element3, true);
   const root = doc.documentElement;
   const drop = (node) => {
     for (const attribute of Array.from(node.attributes))
       if (attribute.namespaceURI === XMLNS && root?.lookupNamespaceURI(attribute.prefix ? attribute.localName : null) === attribute.value)
         node.removeAttributeNode(attribute);
-    for (const child of Array.from(node.childNodes)) if (isElement(child)) drop(child);
+    for (const child3 of Array.from(node.childNodes)) if (isElement(child3)) drop(child3);
   };
   drop(imported);
   return imported;
@@ -439,9 +439,9 @@ function parseOnOff(value) {
       return void 0;
   }
 }
-function onOffElement(element2) {
-  if (!element2) return void 0;
-  const value = getW(element2, "val");
+function onOffElement(element3) {
+  if (!element3) return void 0;
+  const value = getW(element3, "val");
   return value === void 0 ? true : parseOnOff(value);
 }
 var SAFE_INTEGER = /^-?\d+$/;
@@ -518,14 +518,14 @@ function parseTintShade(value) {
 var KINDS = { textInput: "text", checkBox: "checkbox", ddList: "dropDown" };
 var elementOfKind = (kind) => Object.keys(KINDS).find((name) => KINDS[name] === kind);
 var elementChildren = (parent) => Array.from(parent.childNodes).filter(isElement);
-function infoText(element2) {
-  if (!element2) return void 0;
-  const type = getW(element2, "type") ?? "text";
-  return isStInfoTextType(type) ? { type, value: getW(element2, "val") ?? "" } : void 0;
+function infoText(element3) {
+  if (!element3) return void 0;
+  const type = getW(element3, "type") ?? "text";
+  return isStInfoTextType(type) ? { type, value: getW(element3, "val") ?? "" } : void 0;
 }
 function parseFormField(ffData) {
   const typed = elementChildren(ffData).find(
-    (child) => Object.hasOwn(KINDS, child.localName ?? "")
+    (child3) => Object.hasOwn(KINDS, child3.localName ?? "")
   );
   if (!typed || typed.namespaceURI !== WORD_NS) return void 0;
   const field = { kind: KINDS[typed.localName] };
@@ -564,7 +564,7 @@ function parseFormField(ffData) {
     const result = parseInteger(getW(first2(typed, "result"), "val"));
     const fallback = parseInteger(getW(first2(typed, "default"), "val"));
     field.dropDown = {
-      entries: elementChildren(typed).filter((child) => named2(child, "listEntry")).map((entry) => getW(entry, "val") ?? ""),
+      entries: elementChildren(typed).filter((child3) => named2(child3, "listEntry")).map((entry) => getW(entry, "val") ?? ""),
       ...result !== void 0 && { result },
       ...fallback !== void 0 && { default: fallback }
     };
@@ -572,18 +572,18 @@ function parseFormField(ffData) {
   field.sourceXml = buildXml(ffData);
   return field;
 }
-var isModeledFormFieldData = (element2) => named2(element2, "ffData") && parseFormField(element2) !== void 0;
+var isModeledFormFieldData = (element3) => named2(element3, "ffData") && parseFormField(element3) !== void 0;
 var withoutSource = ({ sourceXml: _source, ...field }) => field;
 var sameField = (a, b) => JSON.stringify(withoutSource(a)) === JSON.stringify(withoutSource(b));
 function valued(doc, local, value) {
-  const element2 = makeW(doc, local);
-  element2.setAttributeNS(WORD_NS, "w:val", value);
-  return element2;
+  const element3 = makeW(doc, local);
+  element3.setAttributeNS(WORD_NS, "w:val", value);
+  return element3;
 }
 var onOff = (doc, local, on) => on ? makeW(doc, local) : valued(doc, local, "0");
 function kindElement(doc, field) {
-  const element2 = makeW(doc, elementOfKind(field.kind));
-  const add3 = (child) => child && element2.appendChild(child);
+  const element3 = makeW(doc, elementOfKind(field.kind));
+  const add3 = (child3) => child3 && element3.appendChild(child3);
   if (field.kind === "text") {
     const input = field.textInput ?? {};
     if (input.type) add3(valued(doc, "type", input.type));
@@ -603,7 +603,7 @@ function kindElement(doc, field) {
     if (list.default !== void 0) add3(valued(doc, "default", String(list.default)));
     for (const entry of list.entries) add3(valued(doc, "listEntry", entry));
   }
-  return element2;
+  return element3;
 }
 function setChild(ffData, local, next) {
   const current = first2(ffData, local);
@@ -611,7 +611,7 @@ function setChild(ffData, local, next) {
   else if (current) ffData.removeChild(current);
   else if (next) {
     const kind = elementChildren(ffData).find(
-      (child) => Object.hasOwn(KINDS, child.localName ?? "")
+      (child3) => Object.hasOwn(KINDS, child3.localName ?? "")
     );
     ffData.insertBefore(next, kind ?? null);
   }
@@ -627,14 +627,14 @@ function writeFormFieldData(doc, field, source) {
   for (const key of ["helpText", "statusText"]) {
     if (JSON.stringify(current?.[key]) === JSON.stringify(field[key])) continue;
     const text2 = field[key];
-    const element2 = text2 && makeW(doc, key);
-    if (element2 && text2) {
-      element2.setAttributeNS(WORD_NS, "w:type", text2.type);
-      element2.setAttributeNS(WORD_NS, "w:val", text2.value);
+    const element3 = text2 && makeW(doc, key);
+    if (element3 && text2) {
+      element3.setAttributeNS(WORD_NS, "w:type", text2.type);
+      element3.setAttributeNS(WORD_NS, "w:val", text2.value);
     }
-    setChild(ffData, key, element2);
+    setChild(ffData, key, element3);
   }
-  const kind = elementChildren(ffData).find((child) => Object.hasOwn(KINDS, child.localName ?? ""));
+  const kind = elementChildren(ffData).find((child3) => Object.hasOwn(KINDS, child3.localName ?? ""));
   if (kind) ffData.replaceChild(kindElement(doc, field), kind);
   else ffData.appendChild(kindElement(doc, field));
   return ffData;
@@ -975,10 +975,10 @@ function cellText(doc, pos) {
   const cell = doc.nodeAt(pos);
   const text2 = { from: pos + 2, to: pos + cell.nodeSize - 2 };
   let first3 = true;
-  cell.forEach((child, offset) => {
-    if (child.type.name !== "paragraph") return;
+  cell.forEach((child3, offset) => {
+    if (child3.type.name !== "paragraph") return;
     if (first3) text2.from = pos + 2 + offset;
-    text2.to = pos + offset + child.nodeSize;
+    text2.to = pos + offset + child3.nodeSize;
     first3 = false;
   });
   return text2;
@@ -986,13 +986,13 @@ function cellText(doc, pos) {
 function cellContent(state, cell, text2) {
   const nodes = [];
   let placed = false;
-  cell.forEach((child) => {
-    if (child.type.name !== "paragraph") {
-      nodes.push(child);
+  cell.forEach((child3) => {
+    if (child3.type.name !== "paragraph") {
+      nodes.push(child3);
       return;
     }
-    const attrs2 = child.attrs.contentControl ? { ...child.attrs, contentControl: null } : child.attrs;
-    nodes.push(child.type.create(attrs2, placed ? null : text2));
+    const attrs2 = child3.attrs.contentControl ? { ...child3.attrs, contentControl: null } : child3.attrs;
+    nodes.push(child3.type.create(attrs2, placed ? null : text2));
     placed = true;
   });
   if (!placed) nodes.push(state.schema.nodes.paragraph.create(null, text2));
@@ -1408,9 +1408,9 @@ function pastedControlSources(slice, doc, copied = /* @__PURE__ */ new Set()) {
   const mapFragment = (fragment) => {
     const nodes = [];
     let changed = false;
-    fragment.forEach((child) => {
-      const next = mapNode(child);
-      changed ||= next !== child;
+    fragment.forEach((child3) => {
+      const next = mapNode(child3);
+      changed ||= next !== child3;
       nodes.push(next);
     });
     return changed ? prosemirrorModel.Fragment.fromArray(nodes) : fragment;
@@ -1574,7 +1574,7 @@ var IdempotencyCache = class {
 };
 function freezeDeep(value) {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
-    for (const child of Object.values(value)) freezeDeep(child);
+    for (const child3 of Object.values(value)) freezeDeep(child3);
     Object.freeze(value);
   }
   return value;
@@ -1613,21 +1613,21 @@ function repairCollaborativeDocumentIds(state, clientId, idGenerator = createCol
 var repairCollaborativeParagraphIds = repairCollaborativeDocumentIds;
 
 // docx/revision-properties.ts
-function propertiesSignature(element2) {
+function propertiesSignature(element3) {
   return JSON.stringify([
-    element2.namespaceURI,
-    element2.localName,
-    Array.from(element2.attributes).filter((attribute) => attribute.namespaceURI !== "http://www.w3.org/2000/xmlns/").map((attribute) => [attribute.namespaceURI, attribute.localName, attribute.value]).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
-    Array.from(element2.childNodes).flatMap(
-      (child) => child.nodeType === 1 ? [propertiesSignature(child)] : child.textContent?.trim() ? [child.textContent] : []
+    element3.namespaceURI,
+    element3.localName,
+    Array.from(element3.attributes).filter((attribute) => attribute.namespaceURI !== "http://www.w3.org/2000/xmlns/").map((attribute) => [attribute.namespaceURI, attribute.localName, attribute.value]).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
+    Array.from(element3.childNodes).flatMap(
+      (child3) => child3.nodeType === 1 ? [propertiesSignature(child3)] : child3.textContent?.trim() ? [child3.textContent] : []
     )
   ]);
 }
 function parsePropertiesSnapshot(xml, local) {
-  const element2 = parseXml2(xml).documentElement;
-  if (!named2(element2, local))
+  const element3 = parseXml2(xml).documentElement;
+  if (!named2(element3, local))
     throw new Error(`A formatting revision snapshot must contain Word ${local} properties.`);
-  return element2;
+  return element3;
 }
 
 // docx/element-order.ts
@@ -1681,14 +1681,14 @@ function orderChildren(parent, order) {
   const elements2 = Array.from(parent.childNodes).filter(isElement);
   const rankOf = (name) => order.findIndex((entry) => typeof entry === "string" ? entry === name : entry.includes(name));
   let previousRank = -1;
-  const ranked = elements2.map((element2, index) => {
-    const rank2 = element2.namespaceURI === WORD_NS ? rankOf(element2.localName ?? "") : -1;
+  const ranked = elements2.map((element3, index) => {
+    const rank2 = element3.namespaceURI === WORD_NS ? rankOf(element3.localName ?? "") : -1;
     if (rank2 >= 0) previousRank = rank2;
-    return { element: element2, index, rank: rank2 >= 0 ? rank2 : previousRank + 0.5 };
+    return { element: element3, index, rank: rank2 >= 0 ? rank2 : previousRank + 0.5 };
   });
   const sorted = [...ranked].sort((a, b) => a.rank - b.rank || a.index - b.index);
   if (sorted.every((entry, index) => entry.element === elements2[index])) return;
-  for (const { element: element2 } of sorted) parent.appendChild(element2);
+  for (const { element: element3 } of sorted) parent.appendChild(element3);
 }
 
 // color/color-primitives.ts
@@ -2159,7 +2159,7 @@ var WORD_2010_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
 var MC = "http://schemas.openxmlformats.org/markup-compatibility/2006";
 var XMLNS2 = "http://www.w3.org/2000/xmlns/";
 var ligatureElements = (props) => elements(props).filter(
-  (element2) => element2.namespaceURI === WORD_2010_NS && element2.localName === "ligatures"
+  (element3) => element3.namespaceURI === WORD_2010_NS && element3.localName === "ligatures"
 );
 var parseLigatures = (props) => {
   const value = ligatureElements(props)[0]?.getAttributeNS(WORD_2010_NS, "val");
@@ -2184,12 +2184,12 @@ function declareIgnorableExtension(doc, ns, preferred) {
   return prefix;
 }
 function writeLigatures(doc, props, value) {
-  for (const element3 of ligatureElements(props)) props.removeChild(element3);
+  for (const element4 of ligatureElements(props)) props.removeChild(element4);
   if (value === void 0) return;
   const prefix = declareIgnorableExtension(doc, WORD_2010_NS, "w14");
-  const element2 = doc.createElementNS(WORD_2010_NS, `${prefix}:ligatures`);
-  element2.setAttributeNS(WORD_2010_NS, `${prefix}:val`, value);
-  props.appendChild(element2);
+  const element3 = doc.createElementNS(WORD_2010_NS, `${prefix}:ligatures`);
+  element3.setAttributeNS(WORD_2010_NS, `${prefix}:val`, value);
+  props.appendChild(element3);
 }
 function enumValue(guard, raw, label) {
   if (raw === null || raw === void 0 || raw === "") return void 0;
@@ -2342,18 +2342,18 @@ function parseRunProperties(props) {
 }
 
 // docx/write-run-extra.ts
-function setAttribute(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function removeChildren(element2, local) {
-  for (const child of children2(element2, local)) element2.removeChild(child);
+function removeChildren(element3, local) {
+  for (const child3 of children2(element3, local)) element3.removeChild(child3);
 }
 function setToggle(doc, props, local, value) {
   removeChildren(props, local);
   if (value === void 0) return;
-  const element2 = makeW(doc, local);
-  if (!value) setAttribute(element2, "val", "0");
-  props.appendChild(element2);
+  const element3 = makeW(doc, local);
+  if (!value) setAttribute(element3, "val", "0");
+  props.appendChild(element3);
 }
 function setExtendedRunProperties(doc, props, run, base) {
   const changed = (key) => runPropertyChanged(run, base, key);
@@ -2378,9 +2378,9 @@ function setExtendedRunProperties(doc, props, run, base) {
     if (!changed(key)) continue;
     removeChildren(props, local);
     if (run[key] === void 0) continue;
-    const element2 = makeW(doc, local);
-    setAttribute(element2, "val", String(run[key]));
-    props.appendChild(element2);
+    const element3 = makeW(doc, local);
+    setAttribute(element3, "val", String(run[key]));
+    props.appendChild(element3);
   }
   if (changed("characterSpacingTwips")) {
     removeChildren(props, "spacing");
@@ -2475,7 +2475,7 @@ function buildWatermarkRun(doc, spec, uniqueId) {
   lock.setAttributeNS(VML_NS, "v:ext", "edit");
   lock.setAttribute("text", "t");
   lock.setAttribute("shapetype", "t");
-  for (const child of [formulas, path, typePath, handles, lock]) type.appendChild(child);
+  for (const child3 of [formulas, path, typePath, handles, lock]) type.appendChild(child3);
   const size = watermarkSizePt(spec);
   const shape = v("shape");
   shape.setAttribute("id", `${WATERMARK_PREFIX}${uniqueId}`);
@@ -2496,7 +2496,7 @@ function buildWatermarkRun(doc, spec, uniqueId) {
   const wrap = makeNS(doc, WORD10_NS, "w10:wrap");
   wrap.setAttribute("anchorx", "margin");
   wrap.setAttribute("anchory", "margin");
-  for (const child of [fill, text2, wrap]) shape.appendChild(child);
+  for (const child3 of [fill, text2, wrap]) shape.appendChild(child3);
   pict.appendChild(type);
   pict.appendChild(shape);
   run.appendChild(pict);
@@ -2552,7 +2552,7 @@ function patchTextBox(doc, drawing, image, base) {
   if (JSON.stringify(image.textBoxText) !== JSON.stringify(base.textBoxText)) {
     const content = descendants(drawing, W_NS, "txbxContent")[0];
     if (content) {
-      for (const child of Array.from(content.childNodes)) content.removeChild(child);
+      for (const child3 of Array.from(content.childNodes)) content.removeChild(child3);
       add(content, ...paragraphsFor(doc, image.textBoxText ?? []));
     }
   }
@@ -2625,33 +2625,33 @@ var COLOR_ELEMENTS = {
   scrgbClr: "scrgb",
   hslClr: "hsl"
 };
-function colorValue(kind, element2) {
-  const attribute = (name) => element2.getAttribute(name) ?? "";
+function colorValue(kind, element3) {
+  const attribute = (name) => element3.getAttribute(name) ?? "";
   if (kind === "scrgb") return `${attribute("r")},${attribute("g")},${attribute("b")}`;
   if (kind === "hsl") return `${attribute("hue")},${attribute("sat")},${attribute("lum")}`;
   return attribute("val");
 }
 function parseDrawingColorIn(container) {
   if (!container) return void 0;
-  for (const element2 of elements(container)) {
-    const kind = COLOR_ELEMENTS[element2.localName];
-    if (!kind || element2.namespaceURI && element2.namespaceURI !== NS.a) continue;
-    return parseDrawingColor(element2);
+  for (const element3 of elements(container)) {
+    const kind = COLOR_ELEMENTS[element3.localName];
+    if (!kind || element3.namespaceURI && element3.namespaceURI !== NS.a) continue;
+    return parseDrawingColor(element3);
   }
   return void 0;
 }
-function parseDrawingColor(element2) {
-  const kind = COLOR_ELEMENTS[element2.localName];
+function parseDrawingColor(element3) {
+  const kind = COLOR_ELEMENTS[element3.localName];
   if (!kind) return void 0;
   const color = {
     kind,
-    value: colorValue(kind, element2),
-    transforms: elements(element2).map((child) => ({
-      name: child.localName,
-      value: child.getAttribute("val") ?? ""
+    value: colorValue(kind, element3),
+    transforms: elements(element3).map((child3) => ({
+      name: child3.localName,
+      value: child3.getAttribute("val") ?? ""
     }))
   };
-  const fallback = kind === "system" ? element2.getAttribute("lastClr") : null;
+  const fallback = kind === "system" ? element3.getAttribute("lastClr") : null;
   if (fallback) color.fallback = fallback;
   return color;
 }
@@ -3046,11 +3046,758 @@ function themeSlotHex(color) {
   return value ? value.toUpperCase() : void 0;
 }
 
+// drawingml/write-line.ts
+var FILLS = /* @__PURE__ */ new Set(["noFill", "solidFill", "gradFill", "pattFill"]);
+function dropDrawingDeclarations(element3) {
+  if (element3.getAttribute("xmlns:a") === NS.a) element3.removeAttribute("xmlns:a");
+  for (const child3 of elements(element3)) dropDrawingDeclarations(child3);
+}
+function patchDrawingLine(ln, line2) {
+  if (line2.widthEmu === void 0) ln.removeAttribute("w");
+  else ln.setAttribute("w", String(Math.round(line2.widthEmu)));
+  if (line2.cap === void 0) ln.removeAttribute("cap");
+  else ln.setAttribute("cap", line2.cap);
+  const fill = line2.fill && drawingFillXml(line2.fill);
+  if (fill || !line2.fill) {
+    for (const node of elements(ln))
+      if (node.namespaceURI === NS.a && FILLS.has(node.localName)) ln.removeChild(node);
+  }
+  if (fill) {
+    const parsed = parseXml(`<w xmlns:a="${NS.a}">${fill}</w>`).documentElement;
+    for (const node of elements(parsed).reverse()) {
+      const imported = ln.ownerDocument.importNode(node, true);
+      dropDrawingDeclarations(imported);
+      ln.insertBefore(imported, ln.firstChild);
+    }
+  }
+  const dashes = elements(ln).filter(
+    (node) => node.namespaceURI === NS.a && (node.localName === "prstDash" || node.localName === "custDash")
+  );
+  if (line2.dash === void 0) {
+    for (const node of dashes) if (node.localName === "prstDash") ln.removeChild(node);
+    return;
+  }
+  const dash = ln.ownerDocument.createElementNS(NS.a, "a:prstDash");
+  dash.setAttribute("val", line2.dash);
+  for (const node of dashes) ln.removeChild(node);
+  const afterFill = elements(ln).find(
+    (node) => node.namespaceURI !== NS.a || !FILLS.has(node.localName)
+  );
+  ln.insertBefore(dash, afterFill ?? null);
+}
+function drawingLineXml(line2) {
+  const doc = parseXml(`<a:ln xmlns:a="${NS.a}"/>`);
+  patchDrawingLine(doc.documentElement, line2);
+  return buildXml(doc);
+}
+
 // docx/shape-parse.ts
 var A_NS2 = "http://schemas.openxmlformats.org/drawingml/2006/main";
 var WPS_NS2 = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
 var W_NS2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 
+// diagram/layout/smartart-tree.ts
+function buildForest(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const n2 of nodes) {
+    map.set(n2.id, { node: n2, children: [] });
+  }
+  const roots = [];
+  for (const n2 of nodes) {
+    const tn = map.get(n2.id);
+    if (n2.parentId && map.has(n2.parentId)) {
+      map.get(n2.parentId).children.push(tn);
+    } else {
+      roots.push(tn);
+    }
+  }
+  return roots;
+}
+var MAX_TREE_DEPTH = 256;
+function treeWidth(t, depth = 0) {
+  if (depth >= MAX_TREE_DEPTH) {
+    return 1;
+  }
+  if (t.children.length === 0) {
+    return 1;
+  }
+  let sum = 0;
+  for (const c of t.children) {
+    sum += treeWidth(c, depth + 1);
+  }
+  return sum;
+}
+function treeDepth(t, depth = 0) {
+  if (depth >= MAX_TREE_DEPTH) {
+    return 0;
+  }
+  if (t.children.length === 0) {
+    return 1;
+  }
+  let max = 0;
+  for (const c of t.children) {
+    const d = treeDepth(c, depth + 1);
+    if (d > max) {
+      max = d;
+    }
+  }
+  return 1 + max;
+}
+
+// diagram/edit/reflow-directional.ts
+function reflowTimeline(nodes, bounds) {
+  const padding = 24;
+  const lineY = bounds.y + bounds.height / 2;
+  const lineStartX = bounds.x + padding;
+  const lineEndX = bounds.x + bounds.width - padding;
+  const lineLen = lineEndX - lineStartX;
+  const nodeW = Math.max(40, Math.min(80, lineLen / (nodes.length * 1.2)));
+  const nodeH = nodeW * 0.5;
+  const labelOffset = Math.min(bounds.height * 0.28, 40);
+  const shapes = [];
+  shapes.push({
+    id: "reflow-timeline-bar",
+    shapeType: "rect",
+    x: lineStartX,
+    y: lineY - 2,
+    width: lineLen,
+    height: 4,
+    fillColor: "#94a3b8"
+  });
+  nodes.forEach((node, i) => {
+    const x = nodes.length === 1 ? (lineStartX + lineEndX) / 2 : lineStartX + i / (nodes.length - 1) * lineLen;
+    const above = i % 2 === 0;
+    const ny = above ? lineY - labelOffset - nodeH / 2 : lineY + labelOffset - nodeH / 2;
+    shapes.push({
+      id: `reflow-timeline-${node.id}`,
+      shapeType: "roundRect",
+      x: x - nodeW / 2,
+      y: ny,
+      width: nodeW,
+      height: nodeH,
+      text: node.text,
+      fontSize: Math.max(6, Math.min(10, nodeW * 0.1))
+    });
+  });
+  return shapes;
+}
+function reflowRelationship(nodes, bounds) {
+  const shapes = [];
+  if (nodes.length <= 2) {
+    const padding = 16;
+    const arrowGap = 24;
+    const usableW = bounds.width - padding * 2 - arrowGap;
+    const nodeW = usableW / nodes.length;
+    const nodeH = bounds.height * 0.5;
+    const yOffset = bounds.y + (bounds.height - nodeH) / 2;
+    nodes.forEach((node, i) => {
+      shapes.push({
+        id: `reflow-rel-${node.id}`,
+        shapeType: "roundRect",
+        x: bounds.x + padding + i * (nodeW + arrowGap),
+        y: yOffset,
+        width: nodeW,
+        height: nodeH,
+        text: node.text,
+        fontSize: Math.max(8, Math.min(11, nodeW * 0.1))
+      });
+    });
+    if (nodes.length === 2) {
+      const arrowX = bounds.x + padding + nodeW;
+      const arrowY = yOffset + nodeH / 2 - 6;
+      shapes.push({
+        id: "reflow-rel-arrow",
+        shapeType: "leftRightArrow",
+        x: arrowX,
+        y: arrowY,
+        width: arrowGap,
+        height: 12,
+        fillColor: "#94a3b8"
+      });
+    }
+  } else {
+    const size = Math.min(bounds.width, bounds.height);
+    const cx = bounds.x + bounds.width / 2;
+    const cy = bounds.y + bounds.height / 2;
+    const radius = size * 0.3;
+    const nodeW = Math.max(size * 0.16, Math.min(size * 0.24, 250 / nodes.length));
+    const nodeH = nodeW * 0.6;
+    nodes.forEach((node, i) => {
+      const angle = i / nodes.length * Math.PI * 2 - Math.PI / 2;
+      const nx = cx + radius * Math.cos(angle) - nodeW / 2;
+      const ny = cy + radius * Math.sin(angle) - nodeH / 2;
+      shapes.push({
+        id: `reflow-rel-${node.id}`,
+        shapeType: "roundRect",
+        x: nx,
+        y: ny,
+        width: nodeW,
+        height: nodeH,
+        text: node.text,
+        fontSize: Math.max(7, Math.min(10, nodeW * 0.1))
+      });
+    });
+  }
+  return shapes;
+}
+function reflowChevron(nodes, bounds) {
+  const padding = 8;
+  const gap = 4;
+  const usableW = bounds.width - padding * 2;
+  const itemW = (usableW - gap * (nodes.length - 1)) / nodes.length;
+  const itemH = Math.min(bounds.height - padding * 2, 60);
+  const yOffset = bounds.y + (bounds.height - itemH) / 2;
+  return nodes.map((node, i) => {
+    const x = bounds.x + padding + i * (itemW + gap);
+    return {
+      id: `reflow-chevron-${node.id}`,
+      shapeType: "chevron",
+      x,
+      y: yOffset,
+      width: itemW,
+      height: itemH,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(11, itemW * 0.1))
+    };
+  });
+}
+function reflowBending(nodes, bounds) {
+  const COLS = 4;
+  const padding = 8;
+  const gap = 6;
+  const rows = Math.ceil(nodes.length / COLS);
+  const usableW = bounds.width - padding * 2;
+  const usableH = bounds.height - padding * 2;
+  const cellW = (usableW - gap * (COLS - 1)) / COLS;
+  const cellH = (usableH - gap * (rows - 1)) / Math.max(rows, 1);
+  const boxW = cellW * 0.85;
+  const boxH = Math.min(cellH * 0.7, 40);
+  const shapes = [];
+  nodes.forEach((node, i) => {
+    const row = Math.floor(i / COLS);
+    const colInRow = i % COLS;
+    const col = row % 2 === 0 ? colInRow : COLS - 1 - colInRow;
+    const nodeCx = bounds.x + padding + col * (cellW + gap) + cellW / 2;
+    const nodeCy = bounds.y + padding + row * (cellH + gap) + cellH / 2;
+    shapes.push({
+      id: `reflow-bending-${node.id}`,
+      shapeType: "roundRect",
+      x: nodeCx - boxW / 2,
+      y: nodeCy - boxH / 2,
+      width: boxW,
+      height: boxH,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(10, boxW * 0.1))
+    });
+    if (i < nodes.length - 1) {
+      const nextRow = Math.floor((i + 1) / COLS);
+      const nextColInRow = (i + 1) % COLS;
+      const nextCol = nextRow % 2 === 0 ? nextColInRow : COLS - 1 - nextColInRow;
+      const nextCx = bounds.x + padding + nextCol * (cellW + gap) + cellW / 2;
+      const nextCy = bounds.y + padding + nextRow * (cellH + gap) + cellH / 2;
+      if (nextRow === row) {
+        const dir = nextCx > nodeCx ? 1 : -1;
+        const arrowX = dir > 0 ? nodeCx + boxW / 2 : nextCx + boxW / 2;
+        const arrowW = Math.abs(nextCx - nodeCx) - boxW;
+        shapes.push({
+          id: `reflow-bending-arrow-${node.id}`,
+          shapeType: dir > 0 ? "rightArrow" : "leftArrow",
+          x: arrowX,
+          y: nodeCy - 4,
+          width: Math.max(arrowW, 4),
+          height: 8,
+          fillColor: "#94a3b8"
+        });
+      } else {
+        const arrowY = nodeCy + boxH / 2;
+        const arrowH = Math.abs(nextCy - nodeCy) - boxH;
+        shapes.push({
+          id: `reflow-bending-arrow-${node.id}`,
+          shapeType: "downArrow",
+          x: nodeCx - 4,
+          y: arrowY,
+          width: 8,
+          height: Math.max(arrowH, 4),
+          fillColor: "#94a3b8"
+        });
+      }
+    }
+  });
+  return shapes;
+}
+
+// diagram/edit/reflow-geometric.ts
+function reflowCycle(nodes, bounds) {
+  const size = Math.min(bounds.width, bounds.height);
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const radius = size * 0.32;
+  const nodeW = Math.max(size * 0.18, Math.min(size * 0.28, 300 / nodes.length));
+  const nodeH = nodeW * 0.6;
+  return nodes.map((node, i) => {
+    const angle = i / nodes.length * Math.PI * 2 - Math.PI / 2;
+    const nx = cx + radius * Math.cos(angle) - nodeW / 2;
+    const ny = cy + radius * Math.sin(angle) - nodeH / 2;
+    return {
+      id: `reflow-cycle-${node.id}`,
+      shapeType: "ellipse",
+      x: nx,
+      y: ny,
+      width: nodeW,
+      height: nodeH,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(10, nodeW * 0.1))
+    };
+  });
+}
+function reflowMatrix(nodes, bounds) {
+  const cols = Math.ceil(Math.sqrt(nodes.length));
+  const rows = Math.ceil(nodes.length / cols);
+  const padding = 8;
+  const gap = 6;
+  const usableW = bounds.width - padding * 2;
+  const usableH = bounds.height - padding * 2;
+  const cellW = (usableW - gap * (cols - 1)) / cols;
+  const cellH = (usableH - gap * (rows - 1)) / rows;
+  return nodes.map((node, i) => {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    return {
+      id: `reflow-matrix-${node.id}`,
+      shapeType: "roundRect",
+      x: bounds.x + padding + col * (cellW + gap),
+      y: bounds.y + padding + row * (cellH + gap),
+      width: cellW,
+      height: cellH,
+      text: node.text,
+      fontSize: Math.max(8, Math.min(11, Math.min(cellW, cellH) * 0.12))
+    };
+  });
+}
+function reflowTarget(nodes, bounds) {
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const size = Math.min(bounds.width, bounds.height);
+  const maxRadius = size * 0.45;
+  return nodes.map((node, i) => {
+    const radiusFraction = 1 - i / nodes.length;
+    const r = maxRadius * radiusFraction;
+    const diameter = r * 2;
+    return {
+      id: `reflow-target-${node.id}`,
+      shapeType: "ellipse",
+      x: cx - r,
+      y: cy - r,
+      width: diameter,
+      height: diameter,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(10, r * 0.15))
+    };
+  });
+}
+function reflowGear(nodes, bounds) {
+  const gearNodes = nodes.slice(0, 3);
+  const extraNodes = nodes.slice(3);
+  const gearAreaW = extraNodes.length > 0 ? bounds.width * 0.7 : bounds.width;
+  const gearAreaH = bounds.height;
+  bounds.x + gearAreaW / 2;
+  const cy = bounds.y + gearAreaH / 2;
+  const spacing2 = gearAreaW / (gearNodes.length + 1);
+  const gearR = Math.min(spacing2 * 0.4, gearAreaH * 0.35);
+  const gearDiameter = gearR * 2;
+  const shapes = [];
+  gearNodes.forEach((node, i) => {
+    const gx = bounds.x + spacing2 * (i + 1);
+    const gy = cy + (i % 2 === 0 ? 0 : gearR * 0.35);
+    shapes.push({
+      id: `reflow-gear-${node.id}`,
+      shapeType: "ellipse",
+      x: gx - gearR,
+      y: gy - gearR,
+      width: gearDiameter,
+      height: gearDiameter,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(10, gearR * 0.15))
+    });
+  });
+  const labelH = 20;
+  const labelGap = 6;
+  const labelW = bounds.width - gearAreaW - 16;
+  const labelStartX = bounds.x + gearAreaW + 8;
+  const labelStartY = bounds.y + (bounds.height - extraNodes.length * (labelH + labelGap)) / 2;
+  extraNodes.forEach((node, i) => {
+    shapes.push({
+      id: `reflow-gear-extra-${node.id}`,
+      shapeType: "roundRect",
+      x: labelStartX,
+      y: labelStartY + i * (labelH + labelGap),
+      width: Math.max(labelW, 30),
+      height: labelH,
+      text: node.text,
+      fontSize: Math.max(7, Math.min(10, 10))
+    });
+  });
+  return shapes;
+}
+function reflowVenn(nodes, bounds) {
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const size = Math.min(bounds.width, bounds.height);
+  if (nodes.length <= 4) {
+    const r2 = size * 0.22;
+    const spread = r2 * 0.6;
+    return nodes.map((node, i) => {
+      const angle = i / nodes.length * Math.PI * 2 - Math.PI / 2;
+      const nx = cx + spread * Math.cos(angle) - r2;
+      const ny = cy + spread * Math.sin(angle) - r2;
+      return {
+        id: `reflow-venn-${node.id}`,
+        shapeType: "ellipse",
+        x: nx,
+        y: ny,
+        width: r2 * 2,
+        height: r2 * 2,
+        text: node.text,
+        fontSize: Math.max(7, Math.min(10, r2 * 0.1))
+      };
+    });
+  }
+  const r = Math.min(size * 0.15, bounds.width / (nodes.length * 1.5));
+  const totalW = nodes.length * r * 2;
+  const startX = cx - totalW / 2 + r;
+  return nodes.map((node, i) => ({
+    id: `reflow-venn-${node.id}`,
+    shapeType: "ellipse",
+    x: startX + i * r * 2 - r,
+    y: cy - r,
+    width: r * 2,
+    height: r * 2,
+    text: node.text,
+    fontSize: Math.max(6, Math.min(9, r * 0.1))
+  }));
+}
+
+// diagram/edit/reflow-stacked.ts
+function reflowPyramid(nodes, bounds) {
+  const padding = 8;
+  const gap = 4;
+  const usableH = bounds.height - padding * 2;
+  const bandH = (usableH - gap * (nodes.length - 1)) / nodes.length;
+  const maxW = bounds.width - padding * 2;
+  return nodes.map((node, i) => {
+    const widthFraction = 0.3 + i / Math.max(nodes.length - 1, 1) * 0.7;
+    const w = maxW * widthFraction;
+    const x = bounds.x + (bounds.width - w) / 2;
+    const y = bounds.y + padding + i * (bandH + gap);
+    return {
+      id: `reflow-pyramid-${node.id}`,
+      shapeType: "rect",
+      x,
+      y,
+      width: w,
+      height: bandH,
+      text: node.text,
+      fontSize: Math.max(8, Math.min(11, bandH * 0.4))
+    };
+  });
+}
+function reflowFunnel(nodes, bounds) {
+  const padding = 8;
+  const gap = 4;
+  const usableH = bounds.height - padding * 2;
+  const bandH = (usableH - gap * (nodes.length - 1)) / nodes.length;
+  const maxW = bounds.width - padding * 2;
+  return nodes.map((node, i) => {
+    const widthFraction = 1 - i / Math.max(nodes.length - 1, 1) * 0.7;
+    const w = maxW * widthFraction;
+    const x = bounds.x + (bounds.width - w) / 2;
+    const y = bounds.y + padding + i * (bandH + gap);
+    return {
+      id: `reflow-funnel-${node.id}`,
+      shapeType: "rect",
+      x,
+      y,
+      width: w,
+      height: bandH,
+      text: node.text,
+      fontSize: Math.max(8, Math.min(11, bandH * 0.4))
+    };
+  });
+}
+
+// diagram/edit/reflow-category.ts
+function resolveDiagramReflowCategory(layoutType) {
+  if (!layoutType) {
+    return "list";
+  }
+  const lower = layoutType.toLowerCase();
+  if (lower.includes("hierarchy") || lower.includes("org")) {
+    return "hierarchy";
+  }
+  if (lower.includes("cycle") || lower.includes("radial")) {
+    return "cycle";
+  }
+  if (lower.includes("funnel")) {
+    return "funnel";
+  }
+  if (lower.includes("target") || lower.includes("bullseye")) {
+    return "target";
+  }
+  if (lower.includes("gear") || lower.includes("interlock")) {
+    return "gear";
+  }
+  if (lower.includes("venn")) {
+    return "venn";
+  }
+  if (lower.includes("timeline")) {
+    return "timeline";
+  }
+  if (lower.includes("bending") || lower.includes("snake") || lower.includes("zigzag")) {
+    return "bending";
+  }
+  if (lower.includes("chevron")) {
+    return "chevron";
+  }
+  if (lower.includes("relationship")) {
+    return "relationship";
+  }
+  if (lower.includes("process") || lower.includes("arrow")) {
+    return "process";
+  }
+  if (lower.includes("matrix")) {
+    return "matrix";
+  }
+  if (lower.includes("pyramid")) {
+    return "pyramid";
+  }
+  if (lower.includes("list") || lower.includes("block")) {
+    return "list";
+  }
+  return "list";
+}
+
+// diagram/edit/reflow.ts
+function diagramContentNodes(nodes) {
+  return nodes.filter((n2) => n2.text.length > 0);
+}
+function reflowDiagramLayout(data, bounds) {
+  const nodes = diagramContentNodes(data.nodes);
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  const layoutType = data.resolvedLayoutType ?? resolveDiagramReflowCategory(data.layoutType);
+  switch (layoutType) {
+    case "list":
+      return reflowList(nodes, bounds);
+    case "process":
+      return reflowProcess(nodes, bounds);
+    case "hierarchy":
+      return reflowHierarchy(data.nodes, bounds);
+    case "cycle":
+      return reflowCycle(nodes, bounds);
+    case "matrix":
+      return reflowMatrix(nodes, bounds);
+    case "pyramid":
+      return reflowPyramid(nodes, bounds);
+    case "funnel":
+      return reflowFunnel(nodes, bounds);
+    case "target":
+      return reflowTarget(nodes, bounds);
+    case "gear":
+      return reflowGear(nodes, bounds);
+    case "venn":
+      return reflowVenn(nodes, bounds);
+    case "timeline":
+      return reflowTimeline(nodes, bounds);
+    case "relationship":
+      return reflowRelationship(nodes, bounds);
+    case "chevron":
+      return reflowChevron(nodes, bounds);
+    case "bending":
+      return reflowBending(nodes, bounds);
+    default:
+      return reflowList(nodes, bounds);
+  }
+}
+function reflowList(nodes, bounds) {
+  const padding = 8;
+  const gap = 6;
+  const usableW = bounds.width - padding * 2;
+  const usableH = bounds.height - padding * 2;
+  const itemH = (usableH - gap * (nodes.length - 1)) / nodes.length;
+  return nodes.map((node, i) => ({
+    id: `reflow-list-${node.id}`,
+    shapeType: "roundRect",
+    x: bounds.x + padding,
+    y: bounds.y + padding + i * (itemH + gap),
+    width: usableW,
+    height: itemH,
+    text: node.text,
+    fontSize: Math.max(8, Math.min(11, itemH * 0.4))
+  }));
+}
+function reflowProcess(nodes, bounds) {
+  const padding = 8;
+  const arrowGap = 16;
+  const usableW = bounds.width - padding * 2;
+  const usableH = bounds.height - padding * 2;
+  const nodeW = (usableW - arrowGap * (nodes.length - 1)) / nodes.length;
+  const nodeH = usableH * 0.6;
+  const yOffset = bounds.y + padding + (usableH - nodeH) / 2;
+  const shapes = [];
+  nodes.forEach((node, i) => {
+    const x = bounds.x + padding + i * (nodeW + arrowGap);
+    shapes.push({
+      id: `reflow-proc-${node.id}`,
+      shapeType: "roundRect",
+      x,
+      y: yOffset,
+      width: nodeW,
+      height: nodeH,
+      text: node.text,
+      fontSize: Math.max(8, Math.min(11, nodeW * 0.12))
+    });
+    if (i < nodes.length - 1) {
+      const arrowX = x + nodeW;
+      const arrowY = yOffset + nodeH / 2 - 6;
+      shapes.push({
+        id: `reflow-proc-arrow-${node.id}`,
+        shapeType: "rightArrow",
+        x: arrowX,
+        y: arrowY,
+        width: arrowGap,
+        height: 12,
+        fillColor: "#94a3b8"
+      });
+    }
+  });
+  return shapes;
+}
+function reflowHierarchy(nodes, bounds) {
+  const roots = buildForest(nodes);
+  if (roots.length === 0) {
+    return reflowList(diagramContentNodes(nodes), bounds);
+  }
+  const totalLeaves = roots.reduce((s, r) => s + treeWidth(r), 0);
+  const depth = Math.max(...roots.map(treeDepth));
+  const padding = 8;
+  const usableW = bounds.width - padding * 2;
+  const usableH = bounds.height - padding * 2;
+  const cellW = usableW / Math.max(totalLeaves, 1);
+  const cellH = usableH / Math.max(depth, 1);
+  const boxW = Math.min(cellW * 0.8, 140);
+  const boxH = Math.min(cellH * 0.35, 28);
+  const shapes = [];
+  const MAX_WALK_DEPTH = 256;
+  function walkTree(t, xOffset, level2) {
+    if (level2 >= MAX_WALK_DEPTH) {
+      return 1;
+    }
+    const w = treeWidth(t);
+    const cx = bounds.x + padding + (xOffset + w / 2) * cellW;
+    const cy = bounds.y + padding + level2 * cellH + cellH / 2;
+    shapes.push({
+      id: `reflow-hier-${t.node.id}`,
+      shapeType: "roundRect",
+      x: cx - boxW / 2,
+      y: cy - boxH / 2,
+      width: boxW,
+      height: boxH,
+      text: t.node.text,
+      fontSize: Math.max(7, Math.min(10, boxW / 14))
+    });
+    let childOffset = xOffset;
+    for (const child3 of t.children) {
+      walkTree(child3, childOffset, level2 + 1);
+      childOffset += treeWidth(child3);
+    }
+    return w;
+  }
+  let offset = 0;
+  for (const root of roots) {
+    offset += walkTree(root, offset, 0);
+  }
+  return shapes;
+}
+
+// diagram/drawing-from-views.ts
+var scheme = (value) => ({ kind: "scheme", value, transforms: [] });
+var srgb = (hex) => ({
+  kind: "srgb",
+  value: hex.replace("#", "").toUpperCase(),
+  transforms: []
+});
+function diagramDrawingFromViews(views, options2 = {}) {
+  const emu3 = options2.emuPerUnit ?? 9525;
+  const accents = options2.accents?.length ? options2.accents : ["accent1"];
+  let filled = 0;
+  const shapes = views.map((view) => {
+    const themed = !view.fillColor && !view.fillNone;
+    const fill = view.fillColor ? srgb(view.fillColor) : scheme(accents[filled++ % accents.length]);
+    const text2 = view.text?.trim() ? view.text : "";
+    const textColor = view.fontColor ? srgb(view.fontColor) : scheme(themed ? "lt1" : "tx1");
+    return {
+      modelId: view.id,
+      frame: {
+        x: Math.round(view.x * emu3),
+        y: Math.round(view.y * emu3),
+        width: Math.round(view.width * emu3),
+        height: Math.round(view.height * emu3)
+      },
+      ...view.rotation ? { rotation: view.rotation } : {},
+      geometry: view.shapeType ?? "rect",
+      fill: view.fillNone ? { kind: "none" } : { kind: "solid", color: fill },
+      line: {
+        widthEmu: 12700,
+        fill: { kind: "solid", color: view.strokeColor ? srgb(view.strokeColor) : scheme("lt1") }
+      },
+      ...text2 ? {
+        text: {
+          anchor: "ctr",
+          text: text2,
+          paragraphs: text2.split("\n").map((line2) => ({
+            runs: [
+              {
+                text: line2,
+                sizePt: Math.round((view.fontSize ?? 12) * 0.75 * 10) / 10,
+                color: textColor
+              }
+            ]
+          }))
+        }
+      } : {},
+      has3d: false
+    };
+  });
+  return { shapes, issues: [] };
+}
+
+// diagram/approximate.ts
+var EMU_PER_PX = 9525;
+var COLORFUL = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
+function approximateDiagramDrawingFromNodes(input) {
+  const width = input.extentEmu.width / EMU_PER_PX;
+  const height = input.extentEmu.height / EMU_PER_PX;
+  if (!(width > 0 && height > 0) || input.nodes.length === 0) return void 0;
+  const nodes = input.nodes.map((node) => ({
+    id: node.id,
+    text: node.text || " ",
+    ...node.parentId ? { parentId: node.parentId } : {}
+  }));
+  const views = reflowDiagramLayout(
+    {
+      nodes,
+      ...input.family ? { resolvedLayoutType: input.family } : {},
+      ...input.layoutId ? { layoutType: input.layoutId } : {}
+    },
+    { x: 0, y: 0, width, height }
+  );
+  if (!views?.length) return void 0;
+  return diagramDrawingFromViews(views, {
+    accents: input.colorsId?.includes("colorful") ? COLORFUL : ["accent1"]
+  });
+}
+
 // chart/regression.ts
 function computeLinearRegression(xVals, yVals) {
   const n2 = xVals.length;
@@ -3573,7 +4320,7 @@ function normalizeLevels(levels, pointCount) {
   });
 }
 function findOrAddParent(children3, label, colorIndex, parentLabelLayout) {
-  const existing = children3.find((child) => child.children && child.label === label);
+  const existing = children3.find((child3) => child3.children && child3.label === label);
   if (existing?.children) return existing;
   const parent = { label, weight: 0, children: [], colorIndex, parentLabelLayout };
   children3.push(parent);
@@ -3602,12 +4349,12 @@ function buildSeriesHierarchy(series, seriesIndex, categoryLabels, categoryLevel
   return roots;
 }
 function aggregate(node) {
-  if (node.children) node.weight = node.children.reduce((sum, child) => sum + aggregate(child), 0);
+  if (node.children) node.weight = node.children.reduce((sum, child3) => sum + aggregate(child3), 0);
   return node.weight;
 }
 function propagateColor(node, colorIndex) {
   node.colorIndex = colorIndex;
-  for (const child of node.children ?? []) propagateColor(child, colorIndex);
+  for (const child3 of node.children ?? []) propagateColor(child3, colorIndex);
 }
 function buildHierarchyRoots(series, categoryLabels, categoryLevels) {
   const colorStride = Math.max(categoryLabels.length, ...series.map((s) => s.values.length), 1);
@@ -4187,9 +4934,9 @@ function chartPaletteSeriesColorChoice(palette, i, n2) {
     transforms: Object.entries(transform).map(([name, value]) => ({ name, value: String(value) }))
   };
 }
-function chartPaletteSeriesColor(palette, i, n2, scheme) {
+function chartPaletteSeriesColor(palette, i, n2, scheme2) {
   const choice = chartPaletteSeriesColorChoice(palette, i, n2);
-  return (resolveDrawingColor(choice, { scheme: (name) => scheme[name] })?.hex ?? scheme[choice.value]).toUpperCase();
+  return (resolveDrawingColor(choice, { scheme: (name) => scheme2[name] })?.hex ?? scheme2[choice.value]).toUpperCase();
 }
 
 // chart/style-definition.ts
@@ -4419,51 +5166,6 @@ function chartCacheValues(cache) {
 }
 var chartSourceValues = (source) => chartCacheValues(source?.cache ?? source?.levels?.[0]);
 
-// drawingml/write-line.ts
-var FILLS = /* @__PURE__ */ new Set(["noFill", "solidFill", "gradFill", "pattFill"]);
-function dropDrawingDeclarations(element2) {
-  if (element2.getAttribute("xmlns:a") === NS.a) element2.removeAttribute("xmlns:a");
-  for (const child of elements(element2)) dropDrawingDeclarations(child);
-}
-function patchDrawingLine(ln, line2) {
-  if (line2.widthEmu === void 0) ln.removeAttribute("w");
-  else ln.setAttribute("w", String(Math.round(line2.widthEmu)));
-  if (line2.cap === void 0) ln.removeAttribute("cap");
-  else ln.setAttribute("cap", line2.cap);
-  const fill = line2.fill && drawingFillXml(line2.fill);
-  if (fill || !line2.fill) {
-    for (const node of elements(ln))
-      if (node.namespaceURI === NS.a && FILLS.has(node.localName)) ln.removeChild(node);
-  }
-  if (fill) {
-    const parsed = parseXml(`<w xmlns:a="${NS.a}">${fill}</w>`).documentElement;
-    for (const node of elements(parsed).reverse()) {
-      const imported = ln.ownerDocument.importNode(node, true);
-      dropDrawingDeclarations(imported);
-      ln.insertBefore(imported, ln.firstChild);
-    }
-  }
-  const dashes = elements(ln).filter(
-    (node) => node.namespaceURI === NS.a && (node.localName === "prstDash" || node.localName === "custDash")
-  );
-  if (line2.dash === void 0) {
-    for (const node of dashes) if (node.localName === "prstDash") ln.removeChild(node);
-    return;
-  }
-  const dash = ln.ownerDocument.createElementNS(NS.a, "a:prstDash");
-  dash.setAttribute("val", line2.dash);
-  for (const node of dashes) ln.removeChild(node);
-  const afterFill = elements(ln).find(
-    (node) => node.namespaceURI !== NS.a || !FILLS.has(node.localName)
-  );
-  ln.insertBefore(dash, afterFill ?? null);
-}
-function drawingLineXml(line2) {
-  const doc = parseXml(`<a:ln xmlns:a="${NS.a}"/>`);
-  patchDrawingLine(doc.documentElement, line2);
-  return buildXml(doc);
-}
-
 // chart/marker-shape.ts
 var CHART_PX_PER_PT = 4 / 3;
 var DEFAULT_MARKER_OUTLINE_PT = 0.75;
@@ -5029,10 +5731,10 @@ function chartAppearance(chart, theme) {
     if (base?.line || direct?.line) entry.line = { ...base?.line, ...direct?.line };
     entries[part] = entry;
   }
-  const scheme = chartColorScheme(theme);
+  const scheme2 = chartColorScheme(theme);
   const resolve = (color) => resolveDrawingColor(
     color,
-    { scheme: (name) => scheme[name] },
+    { scheme: (name) => scheme2[name] },
     { hslRounding: "halfDown", transformOrder: "document" }
   );
   const out = resolveChartStyleDefinition(
@@ -5044,7 +5746,7 @@ function chartAppearance(chart, theme) {
     if (!entry) continue;
     const family = typeface(entry, theme);
     const shadow = resolveDrawingShadowXml(entry.textEffectsXml, {
-      scheme: (name) => scheme[name]
+      scheme: (name) => scheme2[name]
     });
     if (shadow) (out[part] ??= {}).textShadow = shadow;
     if (family) (out[part] ??= {}).typeface = family;
@@ -5826,11 +6528,11 @@ function seriesName(series, index, evaluateRef) {
   return fromRef || series.name || `Series${index + 1}`;
 }
 function seriesContext(chart, theme, options2) {
-  const scheme = chartColorScheme(theme);
-  const resolver = { scheme: (name) => scheme[name] };
+  const scheme2 = chartColorScheme(theme);
+  const resolver = { scheme: (name) => scheme2[name] };
   return {
     theme,
-    scheme,
+    scheme: scheme2,
     palette: chart.colorPalette === void 0 ? void 0 : findChartColorPalette(chart.colorPalette),
     evaluateRef: options2.evaluateRef ?? (() => []),
     seriesColor: options2.seriesColor,
@@ -5842,13 +6544,13 @@ function seriesContext(chart, theme, options2) {
   };
 }
 function seriesView(ctx, s, index, total, categoriesOf) {
-  const { theme, scheme, palette, evaluateRef } = ctx;
+  const { theme, scheme: scheme2, palette, evaluateRef } = ctx;
   const values = resolveRef(s.valuesRef, evaluateRef)?.map(toNumber) ?? s.values.map(toNumber);
   categoriesOf(resolveRef(s.categoriesRef, evaluateRef) ?? s.categories);
-  const paletteColor = palette && chartPaletteSeriesColor(palette, index, total, scheme);
+  const paletteColor = palette && chartPaletteSeriesColor(palette, index, total, scheme2);
   const color = s.fill?.kind === "none" ? "none" : ctx.drawingColor(s.fill?.kind === "solid" ? s.fill.color : s.drawingColor) ?? ctx.seriesColor?.(s, index) ?? paletteColor ?? autoSeriesColor(theme, index);
   const view = { name: seriesName(s, index, evaluateRef), values, color };
-  const shadow = resolveDrawingShadowXml(s.effectsXml, { scheme: (name) => scheme[name] });
+  const shadow = resolveDrawingShadowXml(s.effectsXml, { scheme: (name) => scheme2[name] });
   if (shadow) view.shadow = shadow;
   const resolvedGradient = ctx.gradient(s.fill);
   if (resolvedGradient) view.gradient = resolvedGradient;
@@ -5919,7 +6621,7 @@ function hierarchyView(chart, model, evaluateRef) {
 }
 
 // chart/render/chart-view-stock.ts
-var EMU_PER_PX = 9525;
+var EMU_PER_PX2 = 9525;
 function paintOf(fill, ctx) {
   if (fill?.kind === "none") return "none";
   return fill?.kind === "solid" ? ctx.drawingColor(fill.color) : void 0;
@@ -5928,7 +6630,7 @@ function lineOf(shape, ctx, color) {
   const line2 = shape?.line;
   return {
     color: paintOf(line2?.fill, ctx) ?? color,
-    width: line2?.widthEmu === void 0 ? 1 : Math.max(0.5, line2.widthEmu / EMU_PER_PX)
+    width: line2?.widthEmu === void 0 ? 1 : Math.max(0.5, line2.widthEmu / EMU_PER_PX2)
   };
 }
 function barOf(shape, ctx, fallback) {
@@ -6197,7 +6899,7 @@ function chartSummaryView(chart, theme, options2 = {}) {
   const radial = type === "pie" || type === "doughnut";
   const byPoint = radial || type === "treemap" || type === "sunburst";
   const ctx = seriesContext(chart, theme, options2);
-  const { palette, scheme, drawingColor } = ctx;
+  const { palette, scheme: scheme2, drawingColor } = ctx;
   const grouping = chart.grouping ?? (type === "bar" || type === "column" ? "clustered" : "standard");
   const rawCategories = [];
   const collect = (cats) => void rawCategories.push(cats);
@@ -6218,7 +6920,7 @@ function chartSummaryView(chart, theme, options2 = {}) {
     series.forEach((s, seriesIndex) => {
       s.pointColors = s.values.map((_, i) => {
         const explicit = drawingColor(chart.series[seriesIndex]?.pointColors?.[i]);
-        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i, s.values.length, scheme) : autoSeriesColor(theme, i));
+        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i, s.values.length, scheme2) : autoSeriesColor(theme, i));
       });
     });
   } else
@@ -7411,13 +8113,13 @@ function renderChartSummarySvg(summary, options2) {
 }
 
 // docx/breaks.ts
-function isCachedPageBreak(element2) {
-  return named2(element2, "lastRenderedPageBreak") && !element2.childNodes.length && Array.from(element2.attributes).every(
+function isCachedPageBreak(element3) {
+  return named2(element3, "lastRenderedPageBreak") && !element3.childNodes.length && Array.from(element3.attributes).every(
     (attribute) => attribute.namespaceURI === "http://www.w3.org/2000/xmlns/"
   );
 }
-function hasSpecialBreak(element2) {
-  for (const attribute of Array.from(element2.attributes)) {
+function hasSpecialBreak(element3) {
+  for (const attribute of Array.from(element3.attributes)) {
     if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
     if (attribute.namespaceURI !== WORD_NS) return true;
     if (attribute.localName === "type") {
@@ -7428,14 +8130,14 @@ function hasSpecialBreak(element2) {
   }
   return false;
 }
-function classifyBreak(element2) {
-  const type = getW(element2, "type");
+function classifyBreak(element3) {
+  const type = getW(element3, "type");
   return type === "page" || type === "column" ? type : "textWrapping";
 }
-function isModeledBreak(element2) {
-  const kind = classifyBreak(element2);
+function isModeledBreak(element3) {
+  const kind = classifyBreak(element3);
   if (kind === "textWrapping") return false;
-  for (const attribute of Array.from(element2.attributes)) {
+  for (const attribute of Array.from(element3.attributes)) {
     if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
     if (attribute.namespaceURI !== WORD_NS || attribute.localName !== "type") return false;
   }
@@ -7451,13 +8153,13 @@ var add2 = (parent, ...items) => {
 };
 var emu2 = (px) => String(Math.max(1, Math.round(px * EMU_PER_PIXEL)));
 var emuOffset = (px) => String(Math.round(px * EMU_PER_PIXEL));
-var attrs = (element2, values) => {
-  for (const [name, value] of Object.entries(values)) element2.setAttribute(name, value);
-  return element2;
+var attrs = (element3, values) => {
+  for (const [name, value] of Object.entries(values)) element3.setAttribute(name, value);
+  return element3;
 };
-function dropDeclarations(element2) {
-  if (element2.getAttribute("xmlns:a") === A_NS2) element2.removeAttribute("xmlns:a");
-  for (const node of Array.from(element2.childNodes))
+function dropDeclarations(element3) {
+  if (element3.getAttribute("xmlns:a") === A_NS2) element3.removeAttribute("xmlns:a");
+  for (const node of Array.from(element3.childNodes))
     if (node.nodeType === 1) dropDeclarations(node);
 }
 function importFragment(doc, xml) {
@@ -7468,11 +8170,11 @@ function importFragment(doc, xml) {
     return imported;
   });
 }
-var srgb = (fill) => fill?.kind === "solid" && fill.color.kind === "srgb" ? fill.color.value : void 0;
+var srgb2 = (fill) => fill?.kind === "solid" && fill.color.kind === "srgb" ? fill.color.value : void 0;
 function explicitTextColor(spec) {
   if (!spec.fill) return void 0;
   if (spec.fill.kind === "none") return "000000";
-  const hex = srgb(spec.fill);
+  const hex = srgb2(spec.fill);
   if (!hex || !/^[0-9a-f]{6}$/i.test(hex)) return void 0;
   const channel = (i) => Number.parseInt(hex.slice(i, i + 2), 16) / 255;
   const light = 0.2126 * channel(0) + 0.7152 * channel(2) + 0.0722 * channel(4) > 0.6;
@@ -7503,9 +8205,9 @@ function textParagraphs(doc, lines, color) {
   });
 }
 function shapeStyle(doc) {
-  const ref = (name, idx, scheme, shade) => {
+  const ref = (name, idx, scheme2, shade) => {
     const node = attrs(el2(doc, A_NS2, `a:${name}`), { idx });
-    const color = attrs(el2(doc, A_NS2, "a:schemeClr"), { val: scheme });
+    const color = attrs(el2(doc, A_NS2, "a:schemeClr"), { val: scheme2 });
     if (shade) add2(color, attrs(el2(doc, A_NS2, "a:shade"), { val: shade }));
     return add2(node, color);
   };
@@ -7696,43 +8398,15 @@ function rebuildShapeDrawing(doc, image, old) {
   return next;
 }
 
-// docx/write-drawing.ts
+// docx/write-drawing-patch.ts
 var A_NS3 = "http://schemas.openxmlformats.org/drawingml/2006/main";
 var WP_NS3 = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
-function alternateContentDrawing(content) {
-  const choice = Array.from(content.childNodes).filter(isElement).find((node) => node.localName === "Choice");
-  return choice && findDrawingChild(choice);
-}
-function drawingContainer(run) {
-  if (!run) return void 0;
-  for (const child of Array.from(run.childNodes))
-    if (isElement(child) && (named2(child, "drawing") || named2(child, "pict"))) return child;
-  for (const child of Array.from(run.childNodes))
-    if (isElement(child) && child.localName === "AlternateContent" && alternateContentDrawing(child))
-      return child;
-  return void 0;
-}
-function findDrawingChild(run) {
-  if (!run) return void 0;
-  for (const child of Array.from(run.childNodes)) {
-    if (!isElement(child)) continue;
-    if (named2(child, "drawing") || named2(child, "pict")) return child;
-    if (child.localName === "AlternateContent") {
-      const inner = alternateContentDrawing(child);
-      if (inner) return inner;
-    }
-  }
-  return void 0;
-}
-function sameUnderlyingImage(a, b) {
-  return Boolean(a.partName) && a.relId === b.relId && a.partName === b.partName;
-}
 function walk(root, visit) {
   const stack = [root];
   while (stack.length) {
     const node = stack.shift();
     visit(node);
-    for (const child of Array.from(node.childNodes)) if (isElement(child)) stack.push(child);
+    for (const child3 of Array.from(node.childNodes)) if (isElement(child3)) stack.push(child3);
   }
 }
 function updateExtent(drawing, widthPx, heightPx) {
@@ -7759,11 +8433,11 @@ function updateDocPr(drawing, altText, title) {
 }
 function patchPosition(doc, anchor, name, relativeFrom, align, offsetPx) {
   const position2 = Array.from(anchor.childNodes).find(
-    (child) => isElement(child) && child.namespaceURI === WP_NS3 && child.localName === name
+    (child3) => isElement(child3) && child3.namespaceURI === WP_NS3 && child3.localName === name
   );
   if (!position2) return;
   if (relativeFrom) position2.setAttribute("relativeFrom", relativeFrom);
-  for (const child of Array.from(position2.childNodes)) position2.removeChild(child);
+  for (const child3 of Array.from(position2.childNodes)) position2.removeChild(child3);
   const value = align ? makeNS(doc, WP_NS3, "wp:align") : makeNS(doc, WP_NS3, "wp:posOffset");
   value.appendChild(
     doc.createTextNode(align ?? String(Math.round((offsetPx ?? 0) * EMU_PER_PIXEL)))
@@ -7792,10 +8466,79 @@ function updatePlacement(drawing, doc, placement) {
   });
 }
 function clearNonProperties(node, keep) {
-  for (const child of Array.from(node.childNodes)) {
-    if (isElement(child) && (named2(child, "rPr") || child === keep)) continue;
-    node.removeChild(child);
+  for (const child3 of Array.from(node.childNodes)) {
+    if (isElement(child3) && (named2(child3, "rPr") || child3 === keep)) continue;
+    node.removeChild(child3);
+  }
+}
+function chartRun(doc, node, image, base, oldDrawing, oldContainer, allocator) {
+  if (base?.chart && oldDrawing && image.chart?.partName && image.chart.partName === base.chart.partName && image.chart.relId === base.chart.relId) {
+    if (image.widthPx !== base.widthPx || image.heightPx !== base.heightPx)
+      updateExtent(oldDrawing, image.widthPx, image.heightPx);
+    clearNonProperties(node, oldContainer);
+    return node;
+  }
+  if (!base && image.chart?.chartSpace && !image.chart.relId && !image.chart.partName) {
+    throw new Error("Cannot insert a chart without a relationship allocator.");
+  }
+  return void 0;
+}
+
+// docx/chart-edit.ts
+function isDocxChartEditable(chart) {
+  return Boolean(chart?.chartSpace) && !chart?.layoutId && !chart?.chartEx;
+}
+var WP_NS5 = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+var EMU_PER_PIXEL2 = 9525;
+function isSameDiagram(base, next) {
+  return Boolean(base?.parts.data?.partName) && base?.parts.data?.partName === next.parts.data?.partName && !next.inserted;
+}
+function patchDiagramExtent(drawing, widthPx, heightPx) {
+  const extent = drawing.getElementsByTagNameNS(WP_NS5, "extent")[0];
+  if (!extent) return;
+  extent.setAttribute("cx", String(Math.max(1, Math.round(widthPx * EMU_PER_PIXEL2))));
+  extent.setAttribute("cy", String(Math.max(1, Math.round(heightPx * EMU_PER_PIXEL2))));
+}
+function diagramRun(doc, node, image, base, oldDrawing, oldContainer, allocator) {
+  if (!image.diagram) return void 0;
+  if (base?.diagram && oldDrawing && isSameDiagram(base.diagram, image.diagram)) {
+    if (image.widthPx !== base.widthPx || image.heightPx !== base.heightPx)
+      patchDiagramExtent(oldDrawing, image.widthPx, image.heightPx);
+    clearNonProperties(node, oldContainer);
+    return node;
+  }
+  if (!base && image.diagram.inserted) {
+    throw new Error("Cannot insert SmartArt without a relationship allocator.");
+  }
+  return void 0;
+}
+function alternateContentDrawing(content) {
+  const choice = Array.from(content.childNodes).filter(isElement).find((node) => node.localName === "Choice");
+  return choice && findDrawingChild(choice);
+}
+function drawingContainer(run) {
+  if (!run) return void 0;
+  for (const child3 of Array.from(run.childNodes))
+    if (isElement(child3) && (named2(child3, "drawing") || named2(child3, "pict"))) return child3;
+  for (const child3 of Array.from(run.childNodes))
+    if (isElement(child3) && child3.localName === "AlternateContent" && alternateContentDrawing(child3))
+      return child3;
+  return void 0;
+}
+function findDrawingChild(run) {
+  if (!run) return void 0;
+  for (const child3 of Array.from(run.childNodes)) {
+    if (!isElement(child3)) continue;
+    if (named2(child3, "drawing") || named2(child3, "pict")) return child3;
+    if (child3.localName === "AlternateContent") {
+      const inner = alternateContentDrawing(child3);
+      if (inner) return inner;
+    }
   }
+  return void 0;
+}
+function sameUnderlyingImage(a, b) {
+  return Boolean(a.partName) && a.relId === b.relId && a.partName === b.partName;
 }
 function createImageRun(doc, image, base, old, allocator) {
   const node = old ?? makeW(doc, "r");
@@ -7810,6 +8553,10 @@ function createImageRun(doc, image, base, old, allocator) {
     clearNonProperties(node, oldContainer);
     return node;
   }
+  const diagram = diagramRun(doc, node, image, base, oldDrawing, oldContainer);
+  if (diagram) return diagram;
+  const chart = chartRun(doc, node, image, base, oldDrawing, oldContainer);
+  if (chart) return chart;
   if (base && oldDrawing && image.unsupported && JSON.stringify(image) === JSON.stringify(base)) {
     clearNonProperties(node, oldContainer);
     return node;
@@ -7861,24 +8608,24 @@ var COMMENT_ANCHOR_NAMES = [
   "moveToRangeStart",
   "moveToRangeEnd"
 ];
-function isWordElement(element2, names) {
-  return (!element2.namespaceURI || element2.namespaceURI === WORD_NS) && names.includes(element2.localName);
+function isWordElement(element3, names) {
+  return (!element3.namespaceURI || element3.namespaceURI === WORD_NS) && names.includes(element3.localName);
 }
-var isRevisionWrapperElement = (element2) => isWordElement(element2, REVISION_WRAPPER_NAMES);
-var isCommentAnchorElement = (element2) => isWordElement(element2, COMMENT_ANCHOR_NAMES);
-function setAttribute2(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+var isRevisionWrapperElement = (element3) => isWordElement(element3, REVISION_WRAPPER_NAMES);
+var isCommentAnchorElement = (element3) => isWordElement(element3, COMMENT_ANCHOR_NAMES);
+function setAttribute2(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function removeChildren2(element2, local) {
-  for (const child of children2(element2, local)) element2.removeChild(child);
+function removeChildren2(element3, local) {
+  for (const child3 of children2(element3, local)) element3.removeChild(child3);
 }
-function writeRevisionMetadata(element2, revision) {
-  setAttribute2(element2, "id", revision.id);
-  setAttribute2(element2, "author", revision.author);
-  if (revision.date) setAttribute2(element2, "date", revision.date);
-  else element2.removeAttributeNS(WORD_NS, "date");
-  if (revision.dateUtc) element2.setAttributeNS(WORD_DATE_UTC_NS, "w16du:dateUtc", revision.dateUtc);
-  else element2.removeAttributeNS(WORD_DATE_UTC_NS, "dateUtc");
+function writeRevisionMetadata(element3, revision) {
+  setAttribute2(element3, "id", revision.id);
+  setAttribute2(element3, "author", revision.author);
+  if (revision.date) setAttribute2(element3, "date", revision.date);
+  else element3.removeAttributeNS(WORD_NS, "date");
+  if (revision.dateUtc) element3.setAttributeNS(WORD_DATE_UTC_NS, "w16du:dateUtc", revision.dateUtc);
+  else element3.removeAttributeNS(WORD_DATE_UTC_NS, "dateUtc");
 }
 function revisionTag(kind) {
   return kind === "delete" ? "del" : kind === "moveFrom" ? "moveFrom" : kind === "moveTo" ? "moveTo" : "ins";
@@ -7938,9 +8685,9 @@ function writeParagraphMarkRevision(doc, pPr, paragraph, base) {
     pPr.appendChild(rPr);
   }
   const revision = paragraph.markRevision;
-  const element2 = makeW(doc, revision.kind === "delete" ? "del" : "ins");
-  writeRevisionMetadata(element2, revision);
-  rPr.insertBefore(element2, rPr.firstChild);
+  const element3 = makeW(doc, revision.kind === "delete" ? "del" : "ins");
+  writeRevisionMetadata(element3, revision);
+  rPr.insertBefore(element3, rPr.firstChild);
 }
 
 // docx/highlight.ts
@@ -8038,8 +8785,8 @@ var allowedRunPropertyAttributes = {
   color: ["val", "themeColor", "themeTint", "themeShade"],
   shd: ["val", "fill", "color", "themeFill", "themeFillTint", "themeFillShade"]
 };
-function hasUnexpectedAttributes(element2, allowed, allowDateUtc = false) {
-  for (const attribute of Array.from(element2.attributes)) {
+function hasUnexpectedAttributes(element3, allowed, allowDateUtc = false) {
+  for (const attribute of Array.from(element3.attributes)) {
     if (attribute.namespaceURI === "http://www.w3.org/2000/xmlns/") continue;
     if (allowDateUtc && attribute.namespaceURI === WORD_DATE_UTC_NS && attribute.localName === "dateUtc")
       continue;
@@ -8058,7 +8805,7 @@ function runPropertiesHaveUnknownContent(properties4) {
     const property = node;
     if (property.namespaceURI === WORD_NS && property.localName === "rPrChange") {
       if (hasUnexpectedAttributes(property, ["id", "author", "date"], true) || Array.from(property.childNodes).some(
-        (child) => child.nodeType === 3 && child.textContent?.trim()
+        (child3) => child3.nodeType === 3 && child3.textContent?.trim()
       ) || elements(property).length !== 1 || !first2(property, "rPr") || !getW(property, "id") || !getW(property, "author"))
         return true;
       continue;
@@ -8133,13 +8880,13 @@ function restoreRunFormatting(run) {
 }
 
 // docx/field-flags.ts
-function writeFieldFlags(element2, flags) {
+function writeFieldFlags(element3, flags) {
   for (const [name, value] of [
     ["fldLock", flags?.locked],
     ["dirty", flags?.dirty]
   ]) {
-    if (value === void 0) element2.removeAttributeNS(WORD_NS, name);
-    else element2.setAttributeNS(WORD_NS, `w:${name}`, value ? "true" : "false");
+    if (value === void 0) element3.removeAttributeNS(WORD_NS, name);
+    else element3.setAttributeNS(WORD_NS, `w:${name}`, value ? "true" : "false");
   }
 }
 
@@ -8154,16 +8901,16 @@ function symbolCharacter(char) {
 var isSymbolFontCharacter = (character) => /^[\uF000-\uF0FF]$/.test(character);
 function runSymbol(content) {
   let found;
-  for (const child of content) {
-    if (!named2(child, "sym")) continue;
-    const symbol = { font: getW(child, "font") ?? "", char: getW(child, "char") ?? "" };
+  for (const child3 of content) {
+    if (!named2(child3, "sym")) continue;
+    const symbol = { font: getW(child3, "font") ?? "", char: getW(child3, "char") ?? "" };
     if (!isSymbolFontCharacter(symbolCharacter(symbol.char))) return null;
     if (found && (found.font !== symbol.font || found.char !== symbol.char)) return null;
     found = symbol;
   }
   const character = found && symbolCharacter(found.char);
   if (character && content.some(
-    (child) => (named2(child, "t") || named2(child, "delText")) && child.textContent?.includes(character)
+    (child3) => (named2(child3, "t") || named2(child3, "delText")) && child3.textContent?.includes(character)
   ))
     return null;
   return found;
@@ -8171,12 +8918,12 @@ function runSymbol(content) {
 function runPositionalTab(content) {
   let found;
   let ordinary = false;
-  for (const child of content) {
-    if (named2(child, "tab")) ordinary = true;
-    if (!named2(child, "ptab")) continue;
-    const alignment = getW(child, "alignment");
-    const relativeTo = getW(child, "relativeTo");
-    const leader = getW(child, "leader");
+  for (const child3 of content) {
+    if (named2(child3, "tab")) ordinary = true;
+    if (!named2(child3, "ptab")) continue;
+    const alignment = getW(child3, "alignment");
+    const relativeTo = getW(child3, "relativeTo");
+    const leader = getW(child3, "leader");
     if (!isStPTabAlignment(alignment) || !isStPTabRelativeTo(relativeTo) || leader !== void 0 && !isStPTabLeader(leader))
       return null;
     const tab = { alignment, relativeTo, ...leader !== void 0 && { leader } };
@@ -8185,7 +8932,7 @@ function runPositionalTab(content) {
   }
   return found && ordinary ? null : found;
 }
-function element(doc, local, attributes) {
+function element2(doc, local, attributes) {
   const node = makeW(doc, local);
   for (const [name, value] of Object.entries(attributes))
     if (value !== void 0) node.setAttributeNS(node.namespaceURI, `w:${name}`, value);
@@ -8194,40 +8941,40 @@ function element(doc, local, attributes) {
 function specialCharacterElement(doc, run, character) {
   if (character === "	" && run.positionalTab) {
     const { relativeTo, alignment, leader } = run.positionalTab;
-    return element(doc, "ptab", { relativeTo, alignment, leader });
+    return element2(doc, "ptab", { relativeTo, alignment, leader });
   }
   if (character === SOFT_HYPHEN) return makeW(doc, "softHyphen");
   if (character === NON_BREAKING_HYPHEN) return makeW(doc, "noBreakHyphen");
   if (run.symbol && character === symbolCharacter(run.symbol.char))
-    return element(doc, "sym", { font: run.symbol.font, char: run.symbol.char });
+    return element2(doc, "sym", { font: run.symbol.font, char: run.symbol.char });
   return void 0;
 }
 
 // docx/write-run.ts
-function setAttribute3(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute3(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function removeChildren3(element2, local) {
-  for (const child of children2(element2, local)) element2.removeChild(child);
+function removeChildren3(element3, local) {
+  for (const child3 of children2(element3, local)) element3.removeChild(child3);
 }
 function setToggle2(doc, props, local, value) {
   removeChildren3(props, local);
   if (value === void 0) return;
-  const element2 = makeW(doc, local);
-  if (!value) setAttribute3(element2, "val", "0");
-  props.appendChild(element2);
+  const element3 = makeW(doc, local);
+  if (!value) setAttribute3(element3, "val", "0");
+  props.appendChild(element3);
 }
 function setBooleanAttribute(doc, props, local, value) {
-  let element2 = first2(props, local);
+  let element3 = first2(props, local);
   if (value === void 0) {
     removeChildren3(props, local);
     return;
   }
-  if (!element2) {
-    element2 = makeW(doc, local);
-    props.appendChild(element2);
+  if (!element3) {
+    element3 = makeW(doc, local);
+    props.appendChild(element3);
   }
-  setAttribute3(element2, "val", value ? "1" : "0");
+  setAttribute3(element3, "val", value ? "1" : "0");
 }
 function setLanguageAttribute(doc, props, attribute, value) {
   let language = first2(props, "lang");
@@ -8401,8 +9148,8 @@ function createRun(doc, run, base, old, allocator) {
   setRunProperties(doc, node, run, base);
   if (run.image) return node;
   const formData = run.formField ? first2(first2(node, "fldChar"), "ffData") : void 0;
-  for (const child of Array.from(node.childNodes))
-    if (child.nodeType !== 1 || child.localName !== "rPr") node.removeChild(child);
+  for (const child3 of Array.from(node.childNodes))
+    if (child3.nodeType !== 1 || child3.localName !== "rPr") node.removeChild(child3);
   if (run.break) {
     const br = makeW(doc, "br");
     setAttribute3(br, "type", run.break);
@@ -8460,21 +9207,21 @@ function createRun(doc, run, base, old, allocator) {
 // docx/character-styles.ts
 function styleElements(document) {
   return Array.from(document.getElementsByTagName("*")).filter(
-    (element2) => named2(element2, "style") && (getW(element2, "type") === "character" || getW(element2, "type") === "paragraph")
+    (element3) => named2(element3, "style") && (getW(element3, "type") === "character" || getW(element3, "type") === "paragraph")
   );
 }
 function parseRunStyleCatalog(xml) {
   const document = parseXml2(xml);
   const defaults = first2(first2(document.documentElement, "docDefaults"), "rPrDefault");
   const styles = /* @__PURE__ */ Object.create(null);
-  for (const element2 of styleElements(document)) {
-    const id = getW(element2, "styleId");
+  for (const element3 of styleElements(document)) {
+    const id = getW(element3, "styleId");
     if (!id) continue;
-    const type = getW(element2, "type") === "character" ? "character" : "paragraph";
-    const basedOn = getW(first2(element2, "basedOn"), "val");
-    const linkedStyle = getW(first2(element2, "link"), "val");
-    const isDefault = parseOnOff(getW(element2, "default"));
-    const name = getW(first2(element2, "name"), "val");
+    const type = getW(element3, "type") === "character" ? "character" : "paragraph";
+    const basedOn = getW(first2(element3, "basedOn"), "val");
+    const linkedStyle = getW(first2(element3, "link"), "val");
+    const isDefault = parseOnOff(getW(element3, "default"));
+    const name = getW(first2(element3, "name"), "val");
     styles[id] = {
       id,
       type,
@@ -8482,7 +9229,7 @@ function parseRunStyleCatalog(xml) {
       ...basedOn ? { basedOn } : {},
       ...linkedStyle ? { linkedStyle } : {},
       ...isDefault === void 0 ? {} : { isDefault },
-      formatting: parseRunProperties(first2(element2, "rPr"))
+      formatting: parseRunProperties(first2(element3, "rPr"))
     };
   }
   const warnings = [];
@@ -8516,12 +9263,12 @@ var SIDES = [
   "insideH",
   "insideV"
 ];
-function borderSide(element2) {
-  if (!element2) return void 0;
-  const style = enumValue(isStBorder, getW(element2, "val"));
-  const size = parseEighthPoints(getW(element2, "sz"));
-  const color = parseRgbColor(getW(element2, "color"));
-  const themeColor2 = enumValue(isStThemeColor, getW(element2, "themeColor"));
+function borderSide(element3) {
+  if (!element3) return void 0;
+  const style = enumValue(isStBorder, getW(element3, "val"));
+  const size = parseEighthPoints(getW(element3, "sz"));
+  const color = parseRgbColor(getW(element3, "color"));
+  const themeColor2 = enumValue(isStThemeColor, getW(element3, "themeColor"));
   if (!style && size === void 0 && !color && !themeColor2) return void 0;
   const side = {};
   if (style) side.style = style;
@@ -8560,10 +9307,10 @@ function parseParagraphBorders(pBdr) {
   if (!pBdr) return void 0;
   const result = {};
   for (const side of ["top", "bottom", "left", "right", "between"]) {
-    const element2 = first2(pBdr, side) ?? (side === "left" ? first2(pBdr, "start") : side === "right" ? first2(pBdr, "end") : void 0);
-    const value = borderSide(element2);
+    const element3 = first2(pBdr, side) ?? (side === "left" ? first2(pBdr, "start") : side === "right" ? first2(pBdr, "end") : void 0);
+    const value = borderSide(element3);
     if (!value) continue;
-    const space = parseUnsignedInteger(getW(element2, "space"));
+    const space = parseUnsignedInteger(getW(element3, "space"));
     if (space !== void 0) value.spacePoints = space;
     result[side] = value;
   }
@@ -8616,8 +9363,8 @@ var PAGINATION_KEYS = [
   "contextualSpacing",
   "suppressLineNumbers"
 ];
-function parseOutlineLevel(element2) {
-  const raw = getW(element2, "val");
+function parseOutlineLevel(element3) {
+  const raw = getW(element3, "val");
   if (raw === void 0) return void 0;
   const value = Number(raw);
   if (!Number.isInteger(value) || value < 0 || value > 9) return void 0;
@@ -8680,7 +9427,7 @@ function parseStyleNumbering(pPr) {
 }
 function styleElements2(document) {
   return Array.from(document.getElementsByTagName("*")).filter(
-    (element2) => named2(element2, "style") && getW(element2, "type") === "paragraph"
+    (element3) => named2(element3, "style") && getW(element3, "type") === "paragraph"
   );
 }
 function parseParagraphStyleCatalog(xml) {
@@ -8688,20 +9435,20 @@ function parseParagraphStyleCatalog(xml) {
   const defaults = first2(first2(document.documentElement, "docDefaults"), "pPrDefault");
   const pDefaults = first2(defaults, "pPr");
   const styles = /* @__PURE__ */ Object.create(null);
-  for (const element2 of styleElements2(document)) {
-    const id = getW(element2, "styleId");
+  for (const element3 of styleElements2(document)) {
+    const id = getW(element3, "styleId");
     if (!id) continue;
-    const basedOn = getW(first2(element2, "basedOn"), "val");
-    const isDefault = parseOnOff(getW(element2, "default"));
-    const name = getW(first2(element2, "name"), "val");
-    const numbering = parseStyleNumbering(first2(element2, "pPr"));
+    const basedOn = getW(first2(element3, "basedOn"), "val");
+    const isDefault = parseOnOff(getW(element3, "default"));
+    const name = getW(first2(element3, "name"), "val");
+    const numbering = parseStyleNumbering(first2(element3, "pPr"));
     styles[id] = {
       id,
       ...name ? { name } : {},
       ...basedOn ? { basedOn } : {},
       ...isDefault === void 0 ? {} : { isDefault },
       ...numbering ? { numbering } : {},
-      formatting: parseFormatting(first2(element2, "pPr"))
+      formatting: parseFormatting(first2(element3, "pPr"))
     };
   }
   const warnings = [];
@@ -8749,7 +9496,7 @@ var REGIONS = [
 ];
 function tableStyleElements(document) {
   return Array.from(document.getElementsByTagName("*")).filter(
-    (element2) => named2(element2, "style") && getW(element2, "type") === "table"
+    (element3) => named2(element3, "style") && getW(element3, "type") === "table"
   );
 }
 function conditionalFormatting(block) {
@@ -8769,17 +9516,17 @@ function conditionalFormatting(block) {
 function parseTableStyleCatalog(xml) {
   const document = parseXml2(xml);
   const styles = /* @__PURE__ */ Object.create(null);
-  for (const element2 of tableStyleElements(document)) {
-    const id = getW(element2, "styleId");
+  for (const element3 of tableStyleElements(document)) {
+    const id = getW(element3, "styleId");
     if (!id) continue;
-    const basedOn = getW(first2(element2, "basedOn"), "val");
-    const isDefault = parseOnOff(getW(element2, "default"));
-    const name = getW(first2(element2, "name"), "val");
-    const tblPr = first2(element2, "tblPr");
+    const basedOn = getW(first2(element3, "basedOn"), "val");
+    const isDefault = parseOnOff(getW(element3, "default"));
+    const name = getW(first2(element3, "name"), "val");
+    const tblPr = first2(element3, "tblPr");
     const borders = parseTableBorders(first2(tblPr, "tblBorders"));
     const shadingFill = parseShadingFill(first2(tblPr, "shd"));
     const conditional = {};
-    for (const block of children2(element2, "tblStylePr")) {
+    for (const block of children2(element3, "tblStylePr")) {
       const type = getW(block, "type");
       if (type && REGIONS.includes(type))
         conditional[type] = conditionalFormatting(block);
@@ -8892,7 +9639,7 @@ function resolveTableStyleFormatting(tableStyleId, catalog, look, rowIndex, rowC
 // docx/content-control.ts
 var WORD_2012_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
 var sdtContent = (sdt) => first2(sdt, "sdtContent");
-var isSdt = (element2) => named2(element2, "sdt");
+var isSdt = (element3) => named2(element3, "sdt");
 var TYPE_ELEMENTS = {
   text: "text",
   dropDownList: "dropDownList",
@@ -8906,25 +9653,25 @@ var TYPE_ELEMENTS = {
   docPartObj: "docPartObj",
   docPartList: "docPartList"
 };
-function attrW14(element2, local) {
-  return element2?.getAttributeNS(WORD_2010_NS, local) ?? void 0;
+function attrW14(element3, local) {
+  return element3?.getAttributeNS(WORD_2010_NS, local) ?? void 0;
 }
-function glyph(element2) {
-  const code = attrW14(element2, "val");
+function glyph(element3) {
+  const code = attrW14(element3, "val");
   if (!code) return void 0;
-  const font = attrW14(element2, "font");
+  const font = attrW14(element3, "font");
   return { code, ...font ? { font } : {} };
 }
-function kindOf(child) {
-  if (child.namespaceURI === WORD_NS)
-    return Object.hasOwn(TYPE_ELEMENTS, child.localName) ? TYPE_ELEMENTS[child.localName] : void 0;
-  if (child.namespaceURI === WORD_2010_NS && child.localName === "checkbox") return "checkbox";
-  if (child.namespaceURI === WORD_2012_NS && child.localName === "repeatingSection")
+function kindOf(child3) {
+  if (child3.namespaceURI === WORD_NS)
+    return Object.hasOwn(TYPE_ELEMENTS, child3.localName) ? TYPE_ELEMENTS[child3.localName] : void 0;
+  if (child3.namespaceURI === WORD_2010_NS && child3.localName === "checkbox") return "checkbox";
+  if (child3.namespaceURI === WORD_2012_NS && child3.localName === "repeatingSection")
     return "repeatingSection";
   return void 0;
 }
 var typeElements = (sdtPr) => Array.from(sdtPr.childNodes).filter(isElement).filter(
-  (child) => kindOf(child) !== void 0 || child.namespaceURI === WORD_NS && child.localName === "richText" || child.namespaceURI === WORD_2010_NS && child.localName === "entityPicker" || child.namespaceURI === WORD_2012_NS && child.localName === "repeatingSectionItem"
+  (child3) => kindOf(child3) !== void 0 || child3.namespaceURI === WORD_NS && child3.localName === "richText" || child3.namespaceURI === WORD_2010_NS && child3.localName === "entityPicker" || child3.namespaceURI === WORD_2012_NS && child3.localName === "repeatingSectionItem"
 );
 function parseKind(sdtPr) {
   const [type] = typeElements(sdtPr);
@@ -8999,9 +9746,9 @@ function expectDefined2(value, context) {
 }
 function isCommentReferenceRun(run) {
   const content = Array.from(run.childNodes).filter(
-    (child) => isElement(child) && !named2(child, "rPr")
+    (child3) => isElement(child3) && !named2(child3, "rPr")
   );
-  return content.length > 0 && content.every((child) => named2(child, "commentReference"));
+  return content.length > 0 && content.every((child3) => named2(child3, "commentReference"));
 }
 
 // docx/content-control-values.ts
@@ -9077,28 +9824,28 @@ var TYPES = /* @__PURE__ */ new Set([
   `${WORD_2012_NS} repeatingSectionItem`
 ]);
 var EXTENSIBLE = /* @__PURE__ */ new Set(["sdtPr", "rPr"]);
-function propertyShaped(element2) {
-  if (Array.from(element2.attributes).some(
+function propertyShaped(element3) {
+  if (Array.from(element3.attributes).some(
     (attribute) => !ATTRIBUTE_NAMESPACES.has(attribute.namespaceURI ?? "")
   ))
     return false;
-  const word = element2.namespaceURI === WORD_NS;
-  const allowed = word ? PROPERTY_CHILDREN[element2.localName] : void 0;
-  const extensible = !word || EXTENSIBLE.has(element2.localName);
-  return Array.from(element2.childNodes).every((child) => {
-    if (child.nodeType === 3 || child.nodeType === 4) return !child.textContent?.trim();
-    if (child.nodeType !== 1) return true;
-    const item = child;
+  const word = element3.namespaceURI === WORD_NS;
+  const allowed = word ? PROPERTY_CHILDREN[element3.localName] : void 0;
+  const extensible = !word || EXTENSIBLE.has(element3.localName);
+  return Array.from(element3.childNodes).every((child3) => {
+    if (child3.nodeType === 3 || child3.nodeType === 4) return !child3.textContent?.trim();
+    if (child3.nodeType !== 1) return true;
+    const item = child3;
     const known = item.namespaceURI === WORD_NS ? allowed?.has(item.localName) === true : extensible && WORD_EXTENSIONS.has(item.namespaceURI ?? "");
     return known && propertyShaped(item);
   });
 }
 function onlyProperties(sdtPr) {
   if (!propertyShaped(sdtPr)) return false;
-  const names = elements(sdtPr).map((child) => `${child.namespaceURI} ${child.localName}`);
+  const names = elements(sdtPr).map((child3) => `${child3.namespaceURI} ${child3.localName}`);
   if (new Set(names).size < names.length) return false;
   if (names.filter((name) => TYPES.has(name)).length > 1) return false;
-  const value = (local) => children2(sdtPr, local).map((child) => getW(child, "val"));
+  const value = (local) => children2(sdtPr, local).map((child3) => getW(child3, "val"));
   return value("id").every((id) => validId(id) !== void 0) && value("lock").every((lock) => lock === "unlocked" || validLock(lock) !== void 0);
 }
 function verbatimProperties(doc, xml) {
@@ -9136,30 +9883,30 @@ var PROPERTY_ORDER = [
   "label",
   "tabIndex"
 ];
-var rank = (element2) => {
-  const index = element2.namespaceURI === WORD_NS ? PROPERTY_ORDER.indexOf(element2.localName) : -1;
+var rank = (element3) => {
+  const index = element3.namespaceURI === WORD_NS ? PROPERTY_ORDER.indexOf(element3.localName) : -1;
   return index < 0 ? PROPERTY_ORDER.length : index;
 };
-function place(sdtPr, element2) {
+function place(sdtPr, element3) {
   const siblings = Array.from(sdtPr.childNodes).filter((n2) => n2.nodeType === 1);
-  const after = siblings.find((sibling) => rank(sibling) > rank(element2));
-  sdtPr.insertBefore(element2, after ?? null);
+  const after = siblings.find((sibling) => rank(sibling) > rank(element3));
+  sdtPr.insertBefore(element3, after ?? null);
 }
 function setValued(doc, sdtPr, local, value) {
   for (const existing of children2(sdtPr, local)) sdtPr.removeChild(existing);
   if (typeof value !== "string") return;
-  const element2 = makeW(doc, local);
-  element2.setAttributeNS(WORD_NS, "w:val", value);
-  place(sdtPr, element2);
+  const element3 = makeW(doc, local);
+  element3.setAttributeNS(WORD_NS, "w:val", value);
+  place(sdtPr, element3);
 }
 var same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
 function w14(doc, local) {
   const prefix = declareIgnorableExtension(doc, WORD_2010_NS, "w14");
   return doc.createElementNS(WORD_2010_NS, `${prefix}:${local}`);
 }
-function w14Attribute(element2, local, value) {
-  const prefix = element2.lookupPrefix(WORD_2010_NS) ?? "w14";
-  element2.setAttributeNS(WORD_2010_NS, `${prefix}:${local}`, value);
+function w14Attribute(element3, local, value) {
+  const prefix = element3.lookupPrefix(WORD_2010_NS) ?? "w14";
+  element3.setAttributeNS(WORD_2010_NS, `${prefix}:${local}`, value);
 }
 function checkboxElement(sdtPr) {
   return Array.from(sdtPr.childNodes).find(
@@ -9192,20 +9939,20 @@ function writeCheckbox(doc, sdtPr, control) {
   const replace = (local, build, order) => {
     for (const old of Array.from(box.childNodes))
       if (old.localName === local) box.removeChild(old);
-    const element2 = w14(doc, local);
-    build(element2);
+    const element3 = w14(doc, local);
+    build(element3);
     const siblings = Array.from(box.childNodes);
-    box.insertBefore(element2, siblings[order] ?? null);
+    box.insertBefore(element3, siblings[order] ?? null);
   };
-  replace("checked", (el4) => w14Attribute(el4, "val", control.checked ? "1" : "0"), 0);
+  replace("checked", (el5) => w14Attribute(el5, "val", control.checked ? "1" : "0"), 0);
   const states = [validGlyph(control.checkedGlyph), validGlyph(control.uncheckedGlyph)];
   states.forEach((glyph2, index) => {
     if (glyph2)
       replace(
         index ? "uncheckedState" : "checkedState",
-        (el4) => {
-          w14Attribute(el4, "val", glyph2.code);
-          if (glyph2.font) w14Attribute(el4, "font", glyph2.font);
+        (el5) => {
+          w14Attribute(el5, "val", glyph2.code);
+          if (glyph2.font) w14Attribute(el5, "font", glyph2.font);
         },
         index + 1
       );
@@ -9216,10 +9963,10 @@ function writeItems(doc, sdtPr, control) {
   if (!list) return;
   for (const item of children2(list, "listItem")) list.removeChild(item);
   for (const item of validItems(control.items)) {
-    const element2 = makeW(doc, "listItem");
-    element2.setAttributeNS(WORD_NS, "w:displayText", item.display);
-    element2.setAttributeNS(WORD_NS, "w:value", item.value);
-    list.appendChild(element2);
+    const element3 = makeW(doc, "listItem");
+    element3.setAttributeNS(WORD_NS, "w:displayText", item.display);
+    element3.setAttributeNS(WORD_NS, "w:value", item.value);
+    list.appendChild(element3);
   }
 }
 function writeDate(doc, sdtPr, control) {
@@ -9232,9 +9979,9 @@ function writeDate(doc, sdtPr, control) {
   const set = (local, value, order) => {
     for (const old of children2(date, local)) date.removeChild(old);
     if (typeof value !== "string") return;
-    const element2 = makeW(doc, local);
-    element2.setAttributeNS(WORD_NS, "w:val", value);
-    date.insertBefore(element2, Array.from(date.childNodes)[order] ?? null);
+    const element3 = makeW(doc, local);
+    element3.setAttributeNS(WORD_NS, "w:val", value);
+    date.insertBefore(element3, Array.from(date.childNodes)[order] ?? null);
   };
   set("dateFormat", control.dateFormat, 0);
   set("lid", control.dateLocale, 1);
@@ -9326,7 +10073,7 @@ function resetContentControl(doc, sdt, control) {
     content = makeW(doc, "sdtContent");
     sdt.appendChild(content);
   }
-  for (const child of Array.from(content.childNodes)) content.removeChild(child);
+  for (const child3 of Array.from(content.childNodes)) content.removeChild(child3);
   return content;
 }
 
@@ -9340,13 +10087,13 @@ function rangeKeys(run) {
 }
 
 // docx/write-comments.ts
-function setAttribute4(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute4(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
 function commentRangeStartNode(doc, id) {
-  const element2 = makeW(doc, "commentRangeStart");
-  setAttribute4(element2, "id", id);
-  return element2;
+  const element3 = makeW(doc, "commentRangeStart");
+  setAttribute4(element3, "id", id);
+  return element3;
 }
 function commentRangeEndNodes(doc, id) {
   const end = makeW(doc, "commentRangeEnd");
@@ -9359,8 +10106,8 @@ function commentRangeEndNodes(doc, id) {
 }
 
 // docx/write-ranges.ts
-function setW(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setW(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
 function rangeStartNodes(doc, edge) {
   if (edge.kind === "comment") return [commentRangeStartNode(doc, edge.id)];
@@ -9740,11 +10487,11 @@ function moveMarkers(before, after, markers) {
 
 // docx/inline-markers.ts
 var POSITION_MARKERS = ["bookmarkStart", "bookmarkEnd", "proofErr", "permStart", "permEnd"];
-var isPositionMarker = (element2) => POSITION_MARKERS.some((name) => named2(element2, name));
-var isAnnotationWrapper = (element2) => named2(element2, "smartTag") || named2(element2, "customXml");
-function opensRange(element2) {
-  if (named2(element2, "proofErr")) return /Start$/.test(getW(element2, "type") ?? "");
-  return named2(element2, "bookmarkStart") || named2(element2, "permStart");
+var isPositionMarker = (element3) => POSITION_MARKERS.some((name) => named2(element3, name));
+var isAnnotationWrapper = (element3) => named2(element3, "smartTag") || named2(element3, "customXml");
+function opensRange(element3) {
+  if (named2(element3, "proofErr")) return /Start$/.test(getW(element3, "type") ?? "");
+  return named2(element3, "bookmarkStart") || named2(element3, "permStart");
 }
 function topLevel(node, paragraph) {
   let current = node;
@@ -9752,27 +10499,27 @@ function topLevel(node, paragraph) {
     current = current.parentNode;
   return current;
 }
-function contentLength(child) {
-  if (named2(child, "t") || named2(child, "delText")) return (child.textContent ?? "").length;
-  return named2(child, "sym") ? symbolCharacter(getW(child, "char") ?? "").length || 1 : 1;
+function contentLength(child3) {
+  if (named2(child3, "t") || named2(child3, "delText")) return (child3.textContent ?? "").length;
+  return named2(child3, "sym") ? symbolCharacter(getW(child3, "char") ?? "").length || 1 : 1;
 }
 function splitRun(run, offset) {
   const children3 = Array.from(run.childNodes).filter(isElement);
-  const properties4 = children3.find((child) => named2(child, "rPr"));
+  const properties4 = children3.find((child3) => named2(child3, "rPr"));
   const second = run.cloneNode(false);
   if (properties4) second.appendChild(properties4.cloneNode(true));
   let seen = 0;
-  for (const child of children3) {
-    if (child === properties4) continue;
-    const length = contentLength(child);
-    if (seen >= offset) second.appendChild(child);
+  for (const child3 of children3) {
+    if (child3 === properties4) continue;
+    const length = contentLength(child3);
+    if (seen >= offset) second.appendChild(child3);
     else if (seen + length > offset) {
-      const text2 = child.textContent ?? "";
-      const tail = child.cloneNode(false);
-      for (const node of Array.from(child.childNodes)) child.removeChild(node);
-      child.appendChild(run.ownerDocument.createTextNode(text2.slice(0, offset - seen)));
+      const text2 = child3.textContent ?? "";
+      const tail = child3.cloneNode(false);
+      for (const node of Array.from(child3.childNodes)) child3.removeChild(node);
+      child3.appendChild(run.ownerDocument.createTextNode(text2.slice(0, offset - seen)));
       tail.appendChild(run.ownerDocument.createTextNode(text2.slice(offset - seen)));
-      for (const part of [child, tail])
+      for (const part of [child3, tail])
         if (/^\s|\s$/.test(part.textContent ?? ""))
           part.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
       second.appendChild(tail);
@@ -9783,11 +10530,11 @@ function splitRun(run, offset) {
   run.parentNode.insertBefore(second, run.nextSibling);
   return second;
 }
-function rangeKey(element2) {
-  const id = getW(element2, "id");
+function rangeKey(element3) {
+  const id = getW(element3, "id");
   if (id === void 0) return void 0;
-  if (named2(element2, "bookmarkStart") || named2(element2, "bookmarkEnd")) return `bookmark:${id}`;
-  if (named2(element2, "permStart") || named2(element2, "permEnd")) return `perm:${id}`;
+  if (named2(element3, "bookmarkStart") || named2(element3, "bookmarkEnd")) return `bookmark:${id}`;
+  if (named2(element3, "permStart") || named2(element3, "permEnd")) return `perm:${id}`;
   return void 0;
 }
 function orderRangeEnds(markers) {
@@ -9806,7 +10553,7 @@ function orderRangeEnds(markers) {
 function placeMarkers(paragraph, markers, runs, placed, containers) {
   const positions = runPositions(runs);
   const pieces = /* @__PURE__ */ new Map();
-  const insideRun = (index, position2, element2) => {
+  const insideRun = (index, position2, element3) => {
     const run = placed[index]?.splittable;
     if (!run) return false;
     const parts = pieces.get(index) ?? [{ element: run, start: positions[index] }];
@@ -9815,7 +10562,7 @@ function placeMarkers(paragraph, markers, runs, placed, containers) {
     while (at > 0 && parts[at].start > position2) at--;
     const part = parts[at];
     if (part.start === position2) {
-      part.element.parentNode.insertBefore(element2, part.element);
+      part.element.parentNode.insertBefore(element3, part.element);
       return true;
     }
     const second = splitRun(part.element, position2 - part.start);
@@ -9823,14 +10570,14 @@ function placeMarkers(paragraph, markers, runs, placed, containers) {
     parts.splice(at + 1, 0, { element: second, start: position2 });
     const written = placed[index];
     if (written?.last === part.element) written.last = second;
-    second.parentNode.insertBefore(element2, second);
+    second.parentNode.insertBefore(element3, second);
     return true;
   };
   const done = /* @__PURE__ */ new Set();
-  const after = (node, element2) => {
+  const after = (node, element3) => {
     let anchor = node;
     while (anchor.nextSibling && done.has(anchor.nextSibling)) anchor = anchor.nextSibling;
-    anchor.parentNode.insertBefore(element2, anchor.nextSibling);
+    anchor.parentNode.insertBefore(element3, anchor.nextSibling);
   };
   const put = (marker) => {
     let boundary = marker.opening ? positions.indexOf(marker.position) : positions.lastIndexOf(marker.position);
@@ -9946,9 +10693,9 @@ function restoreAnnotations(markers, before, after) {
     }
     if (start && opening?.parentNode && node === closing && !between.some((item) => isElement(item) && isSdt(item)) && from.slice(start.source, marker.source) === to.slice(start.position, marker.position)) {
       const copy = annotation.wrapper.cloneNode(false);
-      for (const child of Array.from(annotation.wrapper.childNodes))
-        if (isElement(child) && (named2(child, "smartTagPr") || named2(child, "customXmlPr")))
-          copy.appendChild(child.cloneNode(true));
+      for (const child3 of Array.from(annotation.wrapper.childNodes))
+        if (isElement(child3) && (named2(child3, "smartTagPr") || named2(child3, "customXmlPr")))
+          copy.appendChild(child3.cloneNode(true));
       opening.parentNode.insertBefore(copy, opening);
       for (const item of between) copy.appendChild(item);
     }
@@ -9964,8 +10711,8 @@ function wordColor(color) {
   return hex ? hex.toUpperCase() : "auto";
 }
 function borderElement(doc, name, side) {
-  const element2 = makeW(doc, name);
-  const set = (local, value) => element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+  const element3 = makeW(doc, name);
+  const set = (local, value) => element3.setAttributeNS(WORD_NS, `w:${local}`, value);
   set("val", side.style ?? "single");
   if (side.style !== "none" && side.style !== "nil") {
     set("sz", String(side.sizeEighthPoints ?? 4));
@@ -9973,12 +10720,12 @@ function borderElement(doc, name, side) {
     set("color", wordColor(side.color));
     if (side.themeColor) set("themeColor", side.themeColor);
   }
-  return element2;
+  return element3;
 }
 var sameJson = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
 function updateShading(doc, props, paragraph, base) {
   if (base && paragraph.shadingFill === base.shadingFill) return;
-  for (const element2 of children2(props, "shd")) props.removeChild(element2);
+  for (const element3 of children2(props, "shd")) props.removeChild(element3);
   if (!paragraph.shadingFill) return;
   const shd = makeW(doc, "shd");
   shd.setAttributeNS(WORD_NS, "w:val", "clear");
@@ -9988,7 +10735,7 @@ function updateShading(doc, props, paragraph, base) {
 }
 function updateBorders(doc, props, paragraph, base) {
   if (base && sameJson(paragraph.borders, base.borders)) return;
-  for (const element2 of children2(props, "pBdr")) props.removeChild(element2);
+  for (const element3 of children2(props, "pBdr")) props.removeChild(element3);
   const borders = paragraph.borders;
   if (!borders) return;
   const pBdr = makeW(doc, "pBdr");
@@ -10004,18 +10751,18 @@ function writeParagraphDecoration(doc, props, paragraph, base) {
 }
 
 // docx/write-paragraph-properties.ts
-function setAttribute5(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute5(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function setWordValue(element2, local, value) {
-  if (value === void 0) element2.removeAttributeNS(WORD_NS, local);
-  else setAttribute5(element2, local, String(value));
+function setWordValue(element3, local, value) {
+  if (value === void 0) element3.removeAttributeNS(WORD_NS, local);
+  else setAttribute5(element3, local, String(value));
 }
 function updateDirection(doc, props, paragraph, base) {
   if (base && paragraph.direction === base.direction) return;
   let bidi = first2(props, "bidi");
   if (paragraph.direction === void 0) {
-    for (const element2 of children2(props, "bidi")) props.removeChild(element2);
+    for (const element3 of children2(props, "bidi")) props.removeChild(element3);
   } else {
     if (!bidi) {
       bidi = makeW(doc, "bidi");
@@ -10066,11 +10813,11 @@ function updateIndent(doc, props, paragraph, base) {
 }
 function updatePageBreakBefore(doc, props, paragraph, base) {
   if (base && paragraph.pageBreakBefore === base.pageBreakBefore) return;
-  for (const element2 of children2(props, "pageBreakBefore")) props.removeChild(element2);
+  for (const element3 of children2(props, "pageBreakBefore")) props.removeChild(element3);
   if (paragraph.pageBreakBefore !== void 0) {
-    const element2 = makeW(doc, "pageBreakBefore");
-    if (!paragraph.pageBreakBefore) element2.setAttributeNS(WORD_NS, "w:val", "0");
-    props.appendChild(element2);
+    const element3 = makeW(doc, "pageBreakBefore");
+    if (!paragraph.pageBreakBefore) element3.setAttributeNS(WORD_NS, "w:val", "0");
+    props.appendChild(element3);
   }
 }
 function updateKeepOptions(doc, props, paragraph, base) {
@@ -10082,12 +10829,12 @@ function updateKeepOptions(doc, props, paragraph, base) {
     "suppressLineNumbers"
   ]) {
     if (base && paragraph[key] === base[key]) continue;
-    for (const element3 of children2(props, key)) props.removeChild(element3);
+    for (const element4 of children2(props, key)) props.removeChild(element4);
     const value = paragraph[key];
     if (value === void 0) continue;
-    const element2 = makeW(doc, key);
-    if (!value) setAttribute5(element2, "val", "0");
-    props.appendChild(element2);
+    const element3 = makeW(doc, key);
+    if (!value) setAttribute5(element3, "val", "0");
+    props.appendChild(element3);
   }
 }
 function updateDropCap(doc, props, paragraph, base) {
@@ -10161,8 +10908,8 @@ function reconcileBookmarks(doc, starts, ends, names, baseNames, nextId) {
 }
 
 // docx/numbering-write.ts
-function setAttribute6(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute6(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
 function sameNumbering(a, b) {
   return a?.numId === b?.numId && a?.level === b?.level;
@@ -10228,8 +10975,8 @@ var MATH_NAMESPACES = /* @__PURE__ */ new Set([
   "http://purl.oclc.org/ooxml/officeDocument/math"
 ]);
 var MATH_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
-function isEquationElement(element2) {
-  return MATH_NAMESPACES.has(element2.namespaceURI ?? "") && (element2.localName === "oMath" || element2.localName === "oMathPara");
+function isEquationElement(element3) {
+  return MATH_NAMESPACES.has(element3.namespaceURI ?? "") && (element3.localName === "oMath" || element3.localName === "oMathPara");
 }
 function writeEquation(doc, run, base, old) {
   const equation = run.equation;
@@ -10247,19 +10994,19 @@ function writeEquation(doc, run, base, old) {
   }
   if (!isEquationElement(source))
     throw new Error("Equation markup must be an m:oMath or m:oMathPara element.");
-  let element2 = doc.importNode(source, true);
-  if (equation.display && element2.localName === "oMath") {
+  let element3 = doc.importNode(source, true);
+  if (equation.display && element3.localName === "oMath") {
     const para = doc.createElementNS(MATH_NS, "m:oMathPara");
     para.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:m", MATH_NS);
-    para.appendChild(element2);
-    element2 = para;
-  } else if (!equation.display && element2.localName === "oMathPara") {
-    const inner = Array.from(element2.childNodes).find(
+    para.appendChild(element3);
+    element3 = para;
+  } else if (!equation.display && element3.localName === "oMathPara") {
+    const inner = Array.from(element3.childNodes).find(
       (node) => node.nodeType === 1 && node.localName === "oMath"
     );
-    if (inner) element2 = inner;
+    if (inner) element3 = inner;
   }
-  return element2;
+  return element3;
 }
 
 // docx/field-lock.ts
@@ -10436,8 +11183,8 @@ function containerSources(runs, base, slots) {
 }
 
 // docx/write-inline.ts
-function setW2(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setW2(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
 function newHyperlink(doc, link, allocator) {
   const container = makeW(doc, "hyperlink");
@@ -10521,7 +11268,7 @@ function buildInlineContent(doc, runs, base, slots, allocator, ranges, sources =
       target = resetContentControl(doc, container, group2.control);
     } else if (reusable) {
       container = onlyContainer;
-      for (const child of Array.from(container.childNodes)) container.removeChild(child);
+      for (const child3 of Array.from(container.childNodes)) container.removeChild(child3);
     } else if (group2.kind === "control") {
       const created = createContentControl(doc, group2.control);
       container = created.sdt;
@@ -10548,7 +11295,7 @@ function buildInlineContent(doc, runs, base, slots, allocator, ranges, sources =
 // docx/inline-slots.ts
 function runIsSafe(run) {
   const content = Array.from(run.childNodes).filter(
-    (child) => isElement(child) && !named2(child, "rPr") && !isCachedPageBreak(child)
+    (child3) => isElement(child3) && !named2(child3, "rPr") && !isCachedPageBreak(child3)
   );
   const only = content.length === 1 ? content[0] : void 0;
   if (only && named2(only, "br") && isModeledBreak(only)) return true;
@@ -10565,14 +11312,14 @@ function runIsSafe(run) {
     const [ffData] = data;
     return type === "begin" && data.length === 1 && isElement(ffData) && isModeledFormFieldData(ffData);
   }
-  if (content.length && content.every((element2) => named2(element2, "instrText"))) return true;
+  if (content.length && content.every((element3) => named2(element3, "instrText"))) return true;
   if (runSymbol(content) === null || runPositionalTab(content) === null) return false;
   const kinds = /* @__PURE__ */ new Set();
-  for (const element2 of content) {
-    if (element2.localName === "br" && hasSpecialBreak(element2)) return false;
-    if (element2.localName === "cr" && element2.attributes.length > 0) return false;
-    if (element2.localName === "AlternateContent") {
-      if (!alternateContentDrawing(element2)) return false;
+  for (const element3 of content) {
+    if (element3.localName === "br" && hasSpecialBreak(element3)) return false;
+    if (element3.localName === "cr" && element3.attributes.length > 0) return false;
+    if (element3.localName === "AlternateContent") {
+      if (!alternateContentDrawing(element3)) return false;
       kinds.add("drawing");
       continue;
     }
@@ -10589,51 +11336,51 @@ function runIsSafe(run) {
       "drawing",
       "pict"
     ];
-    if (!allowed.includes(element2.localName)) return false;
-    kinds.add(element2.localName);
+    if (!allowed.includes(element3.localName)) return false;
+    kinds.add(element3.localName);
   }
   return !((kinds.has("drawing") || kinds.has("pict")) && kinds.size > 1);
 }
 function runsOf(parent, container, slots, markers, paragraph, revision) {
   const inContainer = { ...container && { container }, ...revision && { revision } };
-  for (const child of Array.from(parent.childNodes)) {
-    if (!isElement(child)) {
-      if (child.nodeType === 3 && child.textContent?.trim()) return false;
+  for (const child3 of Array.from(parent.childNodes)) {
+    if (!isElement(child3)) {
+      if (child3.nodeType === 3 && child3.textContent?.trim()) return false;
       continue;
     }
-    if (parent === paragraph && named2(child, "pPr")) continue;
-    if (isEquationElement(child)) {
-      slots.push({ element: child, ...inContainer });
-    } else if (named2(child, "r")) {
-      if (isCommentReferenceRun(child)) continue;
-      if (!runIsSafe(child)) return false;
-      slots.push({ element: child, ...inContainer });
-    } else if (isPositionMarker(child)) {
-      markers.push({ element: child, boundary: slots.length, ...inContainer });
-    } else if (named2(child, "smartTagPr") || named2(child, "customXmlPr")) {
+    if (parent === paragraph && named2(child3, "pPr")) continue;
+    if (isEquationElement(child3)) {
+      slots.push({ element: child3, ...inContainer });
+    } else if (named2(child3, "r")) {
+      if (isCommentReferenceRun(child3)) continue;
+      if (!runIsSafe(child3)) return false;
+      slots.push({ element: child3, ...inContainer });
+    } else if (isPositionMarker(child3)) {
+      markers.push({ element: child3, boundary: slots.length, ...inContainer });
+    } else if (named2(child3, "smartTagPr") || named2(child3, "customXmlPr")) {
       if (!isAnnotationWrapper(parent)) return false;
-    } else if (isAnnotationWrapper(child)) {
+    } else if (isAnnotationWrapper(child3)) {
       const edge = (side) => markers.push({
-        element: annotationEdge(child),
+        element: annotationEdge(child3),
         boundary: slots.length,
-        annotation: { wrapper: child, edge: side },
+        annotation: { wrapper: child3, edge: side },
         ...inContainer
       });
       edge("start");
-      if (!runsOf(child, container, slots, markers, paragraph, revision)) return false;
+      if (!runsOf(child3, container, slots, markers, paragraph, revision)) return false;
       edge("end");
-    } else if (isRevisionWrapperElement(child) && (!container || isSdt(container))) {
-      if (!runsOf(child, container, slots, markers, paragraph, child)) return false;
-    } else if (isSdt(child) && parent === paragraph) {
-      const content = sdtContent(child);
+    } else if (isRevisionWrapperElement(child3) && (!container || isSdt(container))) {
+      if (!runsOf(child3, container, slots, markers, paragraph, child3)) return false;
+    } else if (isSdt(child3) && parent === paragraph) {
+      const content = sdtContent(child3);
       const before = slots.length;
-      if (content && !runsOf(content, child, slots, markers, paragraph)) return false;
-      if (slots.length === before) slots.push({ container: child });
-    } else if ((named2(child, "hyperlink") || named2(child, "fldSimple")) && !container) {
+      if (content && !runsOf(content, child3, slots, markers, paragraph)) return false;
+      if (slots.length === before) slots.push({ container: child3 });
+    } else if ((named2(child3, "hyperlink") || named2(child3, "fldSimple")) && !container) {
       const before = slots.length;
-      if (!runsOf(child, child, slots, markers, paragraph, revision)) return false;
-      if (named2(child, "fldSimple") && slots.length === before) slots.push({ container: child });
-    } else if (!isCommentAnchorElement(child) || container) return false;
+      if (!runsOf(child3, child3, slots, markers, paragraph, revision)) return false;
+      if (named2(child3, "fldSimple") && slots.length === before) slots.push({ container: child3 });
+    } else if (!isCommentAnchorElement(child3) || container) return false;
   }
   return true;
 }
@@ -10644,7 +11391,7 @@ function collectInlineSlots(paragraph) {
 }
 function replaceableInlineChildren(paragraph) {
   return Array.from(paragraph.childNodes).filter(
-    (child) => isElement(child) && (isEquationElement(child) || named2(child, "r") || named2(child, "hyperlink") || named2(child, "fldSimple") || isSdt(child) || isRevisionWrapperElement(child) || isAnnotationWrapper(child) || isPositionMarker(child) || isCommentAnchorElement(child))
+    (child3) => isElement(child3) && (isEquationElement(child3) || named2(child3, "r") || named2(child3, "hyperlink") || named2(child3, "fldSimple") || isSdt(child3) || isRevisionWrapperElement(child3) || isAnnotationWrapper(child3) || isPositionMarker(child3) || isCommentAnchorElement(child3))
   );
 }
 
@@ -10725,11 +11472,11 @@ function runsToWriteAnew(paragraph, base, slots) {
 }
 
 // docx/write-paragraph.ts
-function setAttribute7(element2, local, value) {
-  element2.setAttributeNS(WORD_NS, `w:${local}`, value);
+function setAttribute7(element3, local, value) {
+  element3.setAttributeNS(WORD_NS, `w:${local}`, value);
 }
-function removeChildren4(element2, local) {
-  for (const child of children2(element2, local)) element2.removeChild(child);
+function removeChildren4(element3, local) {
+  for (const child3 of children2(element3, local)) element3.removeChild(child3);
 }
 function writeParagraphImpl(doc, paragraph, node, base, allocator, spans) {
   const ranges = spans;
@@ -10783,12 +11530,12 @@ function writeParagraphImpl(doc, paragraph, node, base, allocator, spans) {
   orderParagraphProperties(pPr);
   const { slots, markers } = layout;
   const anew = runsToWriteAnew(paragraph, base, slots);
-  const isBookmark = (element2) => named2(element2, "bookmarkStart") || named2(element2, "bookmarkEnd");
+  const isBookmark = (element3) => named2(element3, "bookmarkStart") || named2(element3, "bookmarkEnd");
   const sourceBookmarks = markers.map((marker) => marker.element).filter(isBookmark);
   const { starts, ends } = reconcileBookmarks(
     doc,
-    sourceBookmarks.filter((element2) => named2(element2, "bookmarkStart")),
-    sourceBookmarks.filter((element2) => named2(element2, "bookmarkEnd")),
+    sourceBookmarks.filter((element3) => named2(element3, "bookmarkStart")),
+    sourceBookmarks.filter((element3) => named2(element3, "bookmarkEnd")),
     paragraph.bookmarks ?? [],
     [],
     () => "0"
@@ -10827,7 +11574,7 @@ function writeParagraphImpl(doc, paragraph, node, base, allocator, spans) {
     anew
   );
   let anchor = pPr;
-  for (const bookmark of starts.filter((element2) => !source.has(element2))) {
+  for (const bookmark of starts.filter((element3) => !source.has(element3))) {
     node.insertBefore(bookmark, anchor.nextSibling);
     anchor = bookmark;
   }
@@ -10837,7 +11584,7 @@ function writeParagraphImpl(doc, paragraph, node, base, allocator, spans) {
   }
   placeMarkers(node, carried, paragraph.runs, placed, containers);
   restoreAnnotations(carried, [], paragraph.runs);
-  for (const bookmark of ends.filter((element2) => !source.has(element2))) node.appendChild(bookmark);
+  for (const bookmark of ends.filter((element3) => !source.has(element3))) node.appendChild(bookmark);
   if (!pPr.childNodes.length) node.removeChild(pPr);
   return node;
 }
@@ -11008,9 +11755,9 @@ function restoreParagraphFormatting(paragraph) {
   if (paragraph.sourceParagraphPropertiesXml) {
     const current = parsePropertiesSnapshot(paragraph.sourceParagraphPropertiesXml, "pPr");
     for (const name of ["rPr", "sectPr"]) {
-      const element2 = first2(current, name);
-      if (element2 && !first2(properties4, name))
-        properties4.appendChild(properties4.ownerDocument.importNode(element2, true));
+      const element3 = first2(current, name);
+      if (element3 && !first2(properties4, name))
+        properties4.appendChild(properties4.ownerDocument.importNode(element3, true));
     }
     orderParagraphProperties(properties4);
   }
@@ -11377,9 +12124,9 @@ var runPropertiesMark = {
   parseDOM: [
     {
       tag: "span[data-run-props]",
-      getAttrs: (el4) => {
+      getAttrs: (el5) => {
         try {
-          return { props: JSON.parse(el4.dataset.runProps || "null") };
+          return { props: JSON.parse(el5.dataset.runProps || "null") };
         } catch {
           return { props: null };
         }
@@ -11428,11 +12175,11 @@ function commentIdsFromNode(node) {
 }
 
 // docx/ui/run-mark-properties.ts
-function propertyOfMark(child, name) {
-  return child.marks.find((mark) => mark.type.name === name);
+function propertyOfMark(child3, name) {
+  return child3.marks.find((mark) => mark.type.name === name);
 }
-function linkFromMarks(child) {
-  const link = propertyOfMark(child, "link");
+function linkFromMarks(child3) {
+  const link = propertyOfMark(child3, "link");
   if (!link) return void 0;
   const info = {};
   if (link.attrs.href) info.href = link.attrs.href;
@@ -11440,28 +12187,28 @@ function linkFromMarks(child) {
   if (link.attrs.tooltip) info.tooltip = link.attrs.tooltip;
   return info.href || info.anchor ? info : void 0;
 }
-function applyMarkFormatting(run, child) {
-  if (propertyOfMark(child, "bold")) run.bold = true;
-  if (propertyOfMark(child, "italic")) run.italic = true;
-  if (propertyOfMark(child, "underline")) run.underline = true;
-  if (propertyOfMark(child, "strike")) run.strike = true;
-  const highlight = propertyOfMark(child, "highlight");
+function applyMarkFormatting(run, child3) {
+  if (propertyOfMark(child3, "bold")) run.bold = true;
+  if (propertyOfMark(child3, "italic")) run.italic = true;
+  if (propertyOfMark(child3, "underline")) run.underline = true;
+  if (propertyOfMark(child3, "strike")) run.strike = true;
+  const highlight = propertyOfMark(child3, "highlight");
   if (highlight?.attrs.color) run.highlight = highlight.attrs.color;
-  const verticalAlign = propertyOfMark(child, "verticalAlign");
+  const verticalAlign = propertyOfMark(child3, "verticalAlign");
   if (verticalAlign?.attrs.value) run.verticalAlign = verticalAlign.attrs.value;
-  const language = propertyOfMark(child, "language");
+  const language = propertyOfMark(child3, "language");
   if (language?.attrs.language != null) run.language = language.attrs.language;
   if (language?.attrs.eastAsiaLanguage != null)
     run.eastAsiaLanguage = language.attrs.eastAsiaLanguage;
   if (language?.attrs.bidiLanguage != null) run.bidiLanguage = language.attrs.bidiLanguage;
-  const rtl = propertyOfMark(child, "runRtl");
+  const rtl = propertyOfMark(child3, "runRtl");
   if (rtl) run.rtl = rtl.attrs.value;
-  const font = propertyOfMark(child, "font");
+  const font = propertyOfMark(child3, "font");
   if (font?.attrs.family) run.fontFamily = font.attrs.family;
   if (font?.attrs.size) run.fontSize = font.attrs.size;
   if (font?.attrs.color) run.color = font.attrs.color;
-  const insertion = propertyOfMark(child, "insertion");
-  const deletion = propertyOfMark(child, "deletion");
+  const insertion = propertyOfMark(child3, "insertion");
+  const deletion = propertyOfMark(child3, "deletion");
   const revisionMark = insertion ?? deletion;
   if (revisionMark) {
     const move = typeof revisionMark.attrs.move === "string" ? JSON.parse(revisionMark.attrs.move) : void 0;
@@ -11475,19 +12222,19 @@ function applyMarkFormatting(run, child) {
       ...move ? { move } : {}
     };
   }
-  const commentIds = commentIdsFromMarks(child.marks);
+  const commentIds = commentIdsFromMarks(child3.marks);
   if (commentIds.length) run.commentIds = commentIds;
-  const control = propertyOfMark(child, "contentControl");
+  const control = propertyOfMark(child3, "contentControl");
   if (control?.attrs.data) run.contentControl = JSON.parse(String(control.attrs.data));
-  const field = propertyOfMark(child, "field");
+  const field = propertyOfMark(child3, "field");
   if (field)
     run.field = {
       instr: String(field.attrs.instr),
       ...field.attrs.simple ? { simple: true } : {}
     };
-  const characterStyle = propertyOfMark(child, "characterStyle");
+  const characterStyle = propertyOfMark(child3, "characterStyle");
   if (characterStyle?.attrs.id) run.style = String(characterStyle.attrs.id);
-  const extra = propertyOfMark(child, "runProperties");
+  const extra = propertyOfMark(child3, "runProperties");
   if (extra?.attrs.props)
     for (const [key, value] of Object.entries(structuredClone(extra.attrs.props))) {
       const field2 = key;
@@ -11689,90 +12436,90 @@ function runToInlineNodes(run, schema, noteNumber) {
     (piece) => piece === "\n" ? [breakNode()] : piece ? [schema.text(piece, marks)] : []
   );
 }
-function applyInlineFormat(run, child) {
-  Object.assign(run, inlineRunProperties(child));
+function applyInlineFormat(run, child3) {
+  Object.assign(run, inlineRunProperties(child3));
   const marks = { text: "", ...run.revision ? { revision: run.revision } : {} };
-  applyMarkFormatting(marks, child);
+  applyMarkFormatting(marks, child3);
   const { text: _text, ...properties4 } = marks;
   Object.assign(run, properties4);
-  const ids = commentIdsFromNode(child);
+  const ids = commentIdsFromNode(child3);
   if (ids.length) run.commentIds = ids;
   else delete run.commentIds;
 }
-function inlineNodeRun(child) {
+function inlineNodeRun(child3) {
   const runs = [];
-  appendInlineNode(runs, child);
+  appendInlineNode(runs, child3);
   return runs[0];
 }
-function appendInlineNode(runs, child) {
-  if (child.type.name === "equation") {
+function appendInlineNode(runs, child3) {
+  if (child3.type.name === "equation") {
     const run2 = {
       text: "",
-      equation: { omml: String(child.attrs.omml), display: Boolean(child.attrs.display) }
+      equation: { omml: String(child3.attrs.omml), display: Boolean(child3.attrs.display) }
     };
-    applyInlineFormat(run2, child);
+    applyInlineFormat(run2, child3);
     runs.push(run2);
     return;
   }
-  if (child.type.name === "pageBreak") {
-    const run2 = { text: "", break: child.attrs.kind === "column" ? "column" : "page" };
-    applyInlineFormat(run2, child);
+  if (child3.type.name === "pageBreak") {
+    const run2 = { text: "", break: child3.attrs.kind === "column" ? "column" : "page" };
+    applyInlineFormat(run2, child3);
     runs.push(run2);
     return;
   }
-  if (child.type.name === "fieldMarker") {
-    const marker = child.attrs.kind === "code" ? { text: "", fieldCode: String(child.attrs.code ?? "") } : { text: "", fieldChar: child.attrs.kind };
-    applyInlineFormat(marker, child);
+  if (child3.type.name === "fieldMarker") {
+    const marker = child3.attrs.kind === "code" ? { text: "", fieldCode: String(child3.attrs.code ?? "") } : { text: "", fieldChar: child3.attrs.kind };
+    applyInlineFormat(marker, child3);
     runs.push(marker);
     return;
   }
-  if (child.type.name === "noteReference") {
+  if (child3.type.name === "noteReference") {
     const reference = {
       text: "",
       noteReference: {
-        kind: child.attrs.kind === "endnote" ? "endnote" : "footnote",
-        id: String(child.attrs.id || "")
+        kind: child3.attrs.kind === "endnote" ? "endnote" : "footnote",
+        id: String(child3.attrs.id || "")
       }
     };
-    applyInlineFormat(reference, child);
+    applyInlineFormat(reference, child3);
     runs.push(reference);
     return;
   }
-  if (child.type.name === "image") {
-    const imageLink = linkFromMarks(child);
+  if (child3.type.name === "image") {
+    const imageLink = linkFromMarks(child3);
     runs.push({
       text: "",
       image: {
-        relId: child.attrs.relId,
-        partName: child.attrs.partName,
-        contentType: child.attrs.contentType,
-        widthPx: child.attrs.widthPx,
-        heightPx: child.attrs.heightPx,
-        ...child.attrs.altText ? { altText: child.attrs.altText } : {},
-        ...child.attrs.title ? { title: child.attrs.title } : {},
-        ...child.attrs.anchored ? { anchored: true } : {},
-        ...child.attrs.svgPartName ? { svgPartName: child.attrs.svgPartName } : {},
+        relId: child3.attrs.relId,
+        partName: child3.attrs.partName,
+        contentType: child3.attrs.contentType,
+        widthPx: child3.attrs.widthPx,
+        heightPx: child3.attrs.heightPx,
+        ...child3.attrs.altText ? { altText: child3.attrs.altText } : {},
+        ...child3.attrs.title ? { title: child3.attrs.title } : {},
+        ...child3.attrs.anchored ? { anchored: true } : {},
+        ...child3.attrs.svgPartName ? { svgPartName: child3.attrs.svgPartName } : {},
         // Same key order as the parser's run: the writer compares an unchanged placeholder run by JSON.
-        ...child.attrs.unsupported ? { unsupported: child.attrs.unsupported } : {},
-        ...typeof child.attrs.diagram === "string" ? { diagram: JSON.parse(child.attrs.diagram) } : {},
-        ...typeof child.attrs.chart === "string" ? { chart: JSON.parse(child.attrs.chart) } : {},
-        ...typeof child.attrs.shape === "string" ? { shape: JSON.parse(child.attrs.shape) } : {},
-        ...typeof child.attrs.placement === "string" ? { placement: JSON.parse(child.attrs.placement) } : {},
-        ...typeof child.attrs.textBoxText === "string" ? { textBoxText: JSON.parse(child.attrs.textBoxText) } : {},
-        ...child.attrs.textBoxEditable ? { textBoxEditable: true } : {},
-        ...child.attrs.textBoxEditable && child.attrs.textBoxBorder !== null ? { textBoxBorder: Boolean(child.attrs.textBoxBorder) } : {}
+        ...child3.attrs.unsupported ? { unsupported: child3.attrs.unsupported } : {},
+        ...typeof child3.attrs.diagram === "string" ? { diagram: JSON.parse(child3.attrs.diagram) } : {},
+        ...typeof child3.attrs.chart === "string" ? { chart: JSON.parse(child3.attrs.chart) } : {},
+        ...typeof child3.attrs.shape === "string" ? { shape: JSON.parse(child3.attrs.shape) } : {},
+        ...typeof child3.attrs.placement === "string" ? { placement: JSON.parse(child3.attrs.placement) } : {},
+        ...typeof child3.attrs.textBoxText === "string" ? { textBoxText: JSON.parse(child3.attrs.textBoxText) } : {},
+        ...child3.attrs.textBoxEditable ? { textBoxEditable: true } : {},
+        ...child3.attrs.textBoxEditable && child3.attrs.textBoxBorder !== null ? { textBoxBorder: Boolean(child3.attrs.textBoxBorder) } : {}
       },
       ...imageLink && { link: imageLink }
     });
-    applyInlineFormat(runs.at(-1), child);
+    applyInlineFormat(runs.at(-1), child3);
     return;
   }
-  if (!child.isText && child.type.name !== "hardBreak") return;
-  const run = { text: child.isText ? child.text || "" : "\n" };
-  const link = linkFromMarks(child);
+  if (!child3.isText && child3.type.name !== "hardBreak") return;
+  const run = { text: child3.isText ? child3.text || "" : "\n" };
+  const link = linkFromMarks(child3);
   if (link) run.link = link;
-  if (!child.isText && child.type.spec.attrs?.format) applyInlineFormat(run, child);
-  else applyMarkFormatting(run, child);
+  if (!child3.isText && child3.type.spec.attrs?.format) applyInlineFormat(run, child3);
+  else applyMarkFormatting(run, child3);
   const previous = runs.at(-1);
   const fields = [
     "bold",
@@ -12067,10 +12814,10 @@ function sameContent(before, after) {
     if (!sameContent(before.child(index), after.child(index))) return false;
   return true;
 }
-function paragraphProperties(element2) {
+function paragraphProperties(element3) {
   for (const name of ["rPr", "sectPr", "pPrChange"])
-    for (const child of children2(element2, name)) element2.removeChild(child);
-  return element2;
+    for (const child3 of children2(element3, name)) element3.removeChild(child3);
+  return element3;
 }
 function properties3(node) {
   const paragraph = paragraphFromAttrs(node.attrs, String(node.attrs.id), []);
@@ -12157,19 +12904,19 @@ function fieldResultRanges(doc) {
   doc.descendants((node, pos) => {
     if (node.type.name !== "paragraph") return true;
     let open;
-    node.forEach((child, offset) => {
-      const mark = child.isText ? child.marks.find((item) => item.type === field) : void 0;
+    node.forEach((child3, offset) => {
+      const mark = child3.isText ? child3.marks.find((item) => item.type === field) : void 0;
       const start = pos + 1 + offset;
-      if (mark && open?.mark.eq(mark) && identityOf(open.marks) === identityOf(child.marks) && sameFieldFlags(flagsOf(open.marks), flagsOf(child.marks))) {
-        open.to = start + child.nodeSize;
-        open.text += child.text ?? "";
+      if (mark && open?.mark.eq(mark) && identityOf(open.marks) === identityOf(child3.marks) && sameFieldFlags(flagsOf(open.marks), flagsOf(child3.marks))) {
+        open.to = start + child3.nodeSize;
+        open.text += child3.text ?? "";
       } else if (mark) {
         open = {
           from: start,
-          to: start + child.nodeSize,
+          to: start + child3.nodeSize,
           mark,
-          text: child.text ?? "",
-          marks: child.marks
+          text: child3.text ?? "",
+          marks: child3.marks
         };
         runs.push(open);
       } else open = void 0;
@@ -12188,7 +12935,7 @@ function fieldClipboardSlice(slice) {
         const open = stack.pop();
         if (open?.valid) {
           complete.add(pos);
-          for (const child of open.positions) complete.add(child);
+          for (const child3 of open.positions) complete.add(child3);
         }
       } else {
         const open = stack.at(-1);
@@ -12207,8 +12954,8 @@ function fieldClipboardSlice(slice) {
     if (node.type.name === "fieldMarker" && !complete.has(pos)) return null;
     if (!node.isLeaf) {
       const children4 = [];
-      node.forEach((child, offset) => {
-        const projected = project(child, pos + 1 + offset);
+      node.forEach((child3, offset) => {
+        const projected = project(child3, pos + 1 + offset);
         if (projected) children4.push(projected);
       });
       return node.copy(prosemirrorModel.Fragment.fromArray(children4));
@@ -12304,8 +13051,8 @@ function safeParagraph(node, allowInsertion = false) {
   if (node.type.name !== "paragraph" || !node.type.spec.attrs?.markRevision) return false;
   if (node.attrs.markRevision && !allowInsertion) return false;
   let fields = false;
-  node.descendants((child) => {
-    if (child.type.name === "fieldMarker" || child.marks.some((mark) => mark.type.name === "field"))
+  node.descendants((child3) => {
+    if (child3.type.name === "fieldMarker" || child3.marks.some((mark) => mark.type.name === "field"))
       fields = true;
   });
   return !fields;
@@ -12417,7 +13164,7 @@ function simpleFieldPasteSlice(slice, state) {
   const project = (node) => {
     if (node.isText) return node.mark(resultMarks(node, field));
     const children4 = [];
-    node.forEach((child) => children4.push(project(child)));
+    node.forEach((child3) => children4.push(project(child3)));
     return node.copy(prosemirrorModel.Fragment.fromArray(children4));
   };
   const children3 = [];
@@ -13140,15 +13887,15 @@ function formFieldBeside(doc, pos) {
   if (!$pos.parent.isTextblock) return void 0;
   const open = [];
   let beside;
-  $pos.parent.forEach((child, offset) => {
-    if (child.type.name !== "fieldMarker") return;
+  $pos.parent.forEach((child3, offset) => {
+    if (child3.type.name !== "fieldMarker") return;
     const at = $pos.start() + offset;
-    if (child.attrs.kind === "begin") open.push({ begin: at, field: formFieldOfNode(child) });
-    else if (child.attrs.kind === "end") {
+    if (child3.attrs.kind === "begin") open.push({ begin: at, field: formFieldOfNode(child3) });
+    else if (child3.attrs.kind === "end") {
       const top = open.pop();
       const kind = top?.field?.kind;
       if (!top || kind !== "checkbox" && kind !== "dropDown") return;
-      if (pos >= top.begin && pos <= at + child.nodeSize && (beside === void 0 || pos === top.begin))
+      if (pos >= top.begin && pos <= at + child3.nodeSize && (beside === void 0 || pos === top.begin))
         beside = top.begin;
     }
   });
@@ -13159,19 +13906,19 @@ function formTextResults(doc) {
   const open = [];
   doc.descendants((node, pos) => {
     if (!node.isTextblock) return true;
-    node.forEach((child, offset) => {
+    node.forEach((child3, offset) => {
       const at = pos + 1 + offset;
-      if (child.type.name !== "fieldMarker") {
+      if (child3.type.name !== "fieldMarker") {
         const top = open.at(-1);
-        if (top?.from !== void 0) top.length += child.isText ? child.text.length : 1;
+        if (top?.from !== void 0) top.length += child3.isText ? child3.text.length : 1;
         return;
       }
-      if (child.attrs.kind === "begin")
-        open.push({ field: formFieldOfNode(child), begin: at, length: 0 });
-      else if (child.attrs.kind === "separate") {
+      if (child3.attrs.kind === "begin")
+        open.push({ field: formFieldOfNode(child3), begin: at, length: 0 });
+      else if (child3.attrs.kind === "separate") {
         const top = open.at(-1);
-        if (top) top.from = at + child.nodeSize;
-      } else if (child.attrs.kind === "end") {
+        if (top) top.from = at + child3.nodeSize;
+      } else if (child3.attrs.kind === "end") {
         const top = open.pop();
         if (top?.field?.kind === "text" && top.from !== void 0)
           results.push({
@@ -13199,7 +13946,7 @@ var hardBreakNodeSpec = {
   parseDOM: [
     {
       tag: "br",
-      getAttrs: (el4) => ({ format: el4.dataset.runProperties ?? null })
+      getAttrs: (el5) => ({ format: el5.dataset.runProperties ?? null })
     }
   ],
   toDOM: (node) => ["br", inlineRunPropertiesDomAttrs(node)]
@@ -13214,9 +13961,9 @@ var pageBreakNodeSpec = {
   parseDOM: [
     {
       tag: "span[data-docx-break]",
-      getAttrs: (el4) => ({
-        kind: el4.dataset.docxBreak === "column" ? "column" : "page",
-        format: el4.dataset.runProperties ?? null
+      getAttrs: (el5) => ({
+        kind: el5.dataset.docxBreak === "column" ? "column" : "page",
+        format: el5.dataset.runProperties ?? null
       })
     }
   ],
@@ -13252,11 +13999,11 @@ var noteReferenceNodeSpec = {
     {
       tag: "sup[data-docx-note-kind]",
       priority: 60,
-      getAttrs: (el4) => ({
-        kind: el4.dataset.docxNoteKind === "endnote" ? "endnote" : "footnote",
-        format: el4.dataset.runProperties ?? null,
-        id: el4.dataset.docxNoteId || "",
-        number: Number(el4.textContent) || 1
+      getAttrs: (el5) => ({
+        kind: el5.dataset.docxNoteKind === "endnote" ? "endnote" : "footnote",
+        format: el5.dataset.runProperties ?? null,
+        id: el5.dataset.docxNoteId || "",
+        number: Number(el5.textContent) || 1
       })
     }
   ],
@@ -13287,10 +14034,10 @@ var fieldMarkerNodeSpec = {
   parseDOM: [
     {
       tag: "span[data-field-marker]",
-      getAttrs: (el4) => ({
-        kind: el4.dataset.fieldMarker || "begin",
-        format: el4.dataset.runProperties ?? null,
-        code: el4.dataset.fieldCode ?? null
+      getAttrs: (el5) => ({
+        kind: el5.dataset.fieldMarker || "begin",
+        format: el5.dataset.runProperties ?? null,
+        code: el5.dataset.fieldCode ?? null
       })
     }
   ],
@@ -13881,7 +14628,7 @@ var WordYjsInlineCommentAnchors = class {
       if (node.isLeaf) return node;
       const children3 = [];
       node.forEach(
-        (child, offset) => children3.push(visit(child, pos + offset + (node.type === doc.type ? 0 : 1)))
+        (child3, offset) => children3.push(visit(child3, pos + offset + (node.type === doc.type ? 0 : 1)))
       );
       return node.copy(prosemirrorModel.Fragment.fromArray(children3));
     };
@@ -14012,15 +14759,15 @@ var WordYjsComments = class {
   }
 };
 function removeSharedAnchor(fragment, id) {
-  for (const child of fragment.toArray()) {
-    if (child instanceof Y2__namespace.XmlElement) removeSharedAnchor(child, id);
-    else if (child instanceof Y2__namespace.XmlText) {
+  for (const child3 of fragment.toArray()) {
+    if (child3 instanceof Y2__namespace.XmlElement) removeSharedAnchor(child3, id);
+    else if (child3 instanceof Y2__namespace.XmlText) {
       let offset = 0;
-      for (const part of child.toDelta()) {
+      for (const part of child3.toDelta()) {
         const length = typeof part.insert === "string" ? part.insert.length : 1;
         for (const [key, attrs2] of Object.entries(part.attributes ?? {})) {
           if (key.startsWith("comment--") && Array.isArray(attrs2.ids) && attrs2.ids.includes(id))
-            child.format(offset, length, { [key]: null });
+            child3.format(offset, length, { [key]: null });
         }
         offset += length;
       }
@@ -14052,14 +14799,14 @@ function independentCommentAnchors(node) {
     return node.mark(marks);
   }
   const children3 = [];
-  node.forEach((child) => children3.push(independentCommentAnchors(child)));
+  node.forEach((child3) => children3.push(independentCommentAnchors(child3)));
   return node.type.create(node.attrs, children3, marks);
 }
 function seedEmptyParagraphText(fragment) {
-  for (const child of fragment.toArray()) {
-    if (!(child instanceof Y2__namespace.XmlElement)) continue;
-    if (child.nodeName === "paragraph" && child.length === 0) child.insert(0, [new Y2__namespace.XmlText()]);
-    else seedEmptyParagraphText(child);
+  for (const child3 of fragment.toArray()) {
+    if (!(child3 instanceof Y2__namespace.XmlElement)) continue;
+    if (child3.nodeName === "paragraph" && child3.length === 0) child3.insert(0, [new Y2__namespace.XmlText()]);
+    else seedEmptyParagraphText(child3);
   }
 }
 function guardDeletedNodeSelection(doc, view, binding) {
@@ -14337,8 +15084,8 @@ function tableStructureGuardPlugin() {
     const result = /* @__PURE__ */ new Map();
     if (node.type.name === "table") result.set(String(node.attrs.id), node);
     else if (!node.isTextblock && !node.isLeaf)
-      node.forEach((child) => {
-        for (const [id, table] of tables(child)) result.set(id, table);
+      node.forEach((child3) => {
+        for (const [id, table] of tables(child3)) result.set(id, table);
       });
     cache.set(node, result);
     return result;
@@ -14354,13 +15101,13 @@ function tableStructureGuardPlugin() {
         for (const attr2 of ["sourceCellKey", "colspan", "rowspan", "widthTwips"])
           if (cell.attrs[attr2] !== target.attrs[attr2]) return false;
         for (let i = 0; i < cell.childCount; i++) {
-          const child = cell.child(i), other = target.child(i);
-          if (child.type !== other.type) return false;
-          if (child.type.name === "paragraph") {
-            if (child.attrs.id !== other.attrs.id) return false;
-          } else if (child.type.name === "table") {
-            if (!child.sameMarkup(other) || !sameStructure(child, other)) return false;
-          } else if (!child.eq(other)) return false;
+          const child3 = cell.child(i), other = target.child(i);
+          if (child3.type !== other.type) return false;
+          if (child3.type.name === "paragraph") {
+            if (child3.attrs.id !== other.attrs.id) return false;
+          } else if (child3.type.name === "table") {
+            if (!child3.sameMarkup(other) || !sameStructure(child3, other)) return false;
+          } else if (!child3.eq(other)) return false;
         }
       }
     }
@@ -14426,18 +15173,18 @@ var insertWordHardBreak = (state, dispatch, view) => {
 
 // docx/ui/chart-spec.ts
 var SVG_NS2 = "http://www.w3.org/2000/svg";
-function elementSpec(element2, root) {
+function elementSpec(element3, root) {
   const attrs2 = {};
-  for (const attr2 of Array.from(element2.attributes)) {
+  for (const attr2 of Array.from(element3.attributes)) {
     if (attr2.name === "xmlns" || attr2.name.startsWith("xmlns:") || /^on/i.test(attr2.name)) continue;
     attrs2[attr2.name] = attr2.value;
   }
   const children3 = [];
-  for (const child of Array.from(element2.childNodes)) {
-    if (isElement(child)) children3.push(elementSpec(child, false));
-    else if (child.nodeType === 3 && child.nodeValue) children3.push(child.nodeValue);
+  for (const child3 of Array.from(element3.childNodes)) {
+    if (isElement(child3)) children3.push(elementSpec(child3, false));
+    else if (child3.nodeType === 3 && child3.nodeValue) children3.push(child3.nodeValue);
   }
-  const tag = root ? `${SVG_NS2} ${element2.localName}` : element2.localName;
+  const tag = root ? `${SVG_NS2} ${element3.localName}` : element3.localName;
   return [tag, attrs2, ...children3];
 }
 function svgMarkupSpec(svg) {
@@ -14543,17 +15290,17 @@ var imageNodeSpec = {
   parseDOM: [
     {
       tag: "img[data-docx-image], span[data-docx-image-placeholder]",
-      getAttrs: (el4) => ({
-        format: el4.dataset.runProperties ?? null,
-        relId: el4.dataset.relId || "",
-        partName: el4.dataset.partName || "",
-        contentType: el4.dataset.contentType || "",
-        widthPx: Number(el4.dataset.widthPx) || 96,
-        heightPx: Number(el4.dataset.heightPx) || 96,
-        altText: el4.getAttribute("alt") || null,
-        title: el4.getAttribute("title") || null,
-        anchored: el4.dataset.anchored === "1",
-        unsupported: el4.dataset.unsupported || null
+      getAttrs: (el5) => ({
+        format: el5.dataset.runProperties ?? null,
+        relId: el5.dataset.relId || "",
+        partName: el5.dataset.partName || "",
+        contentType: el5.dataset.contentType || "",
+        widthPx: Number(el5.dataset.widthPx) || 96,
+        heightPx: Number(el5.dataset.heightPx) || 96,
+        altText: el5.getAttribute("alt") || null,
+        title: el5.getAttribute("title") || null,
+        anchored: el5.dataset.anchored === "1",
+        unsupported: el5.dataset.unsupported || null
       })
     }
   ],
@@ -14604,10 +15351,10 @@ var linkMarkSpec = {
   parseDOM: [
     {
       tag: "a[data-docx-link]",
-      getAttrs: (el4) => ({
-        href: el4.dataset.href || (el4.dataset.anchor ? null : el4.getAttribute("href")) || null,
-        anchor: el4.dataset.anchor || null,
-        tooltip: el4.getAttribute("title") || null
+      getAttrs: (el5) => ({
+        href: el5.dataset.href || (el5.dataset.anchor ? null : el5.getAttribute("href")) || null,
+        anchor: el5.dataset.anchor || null,
+        tooltip: el5.getAttribute("title") || null
       })
     }
   ],
@@ -14632,11 +15379,11 @@ function wordLinkRangeAt(state, pos) {
   const $pos = state.doc.resolve(pos);
   const items = [];
   let cursor = $pos.start();
-  $pos.parent.forEach((child) => {
-    const target = inlineNodeRun(child)?.link;
+  $pos.parent.forEach((child3) => {
+    const target = inlineNodeRun(child3)?.link;
     const link = target ? type.create(target) : void 0;
-    items.push({ from: cursor, to: cursor + child.nodeSize, ...link && { link } });
-    cursor += child.nodeSize;
+    items.push({ from: cursor, to: cursor + child3.nodeSize, ...link && { link } });
+    cursor += child3.nodeSize;
   });
   let index = items.findIndex((item) => item.link && item.from <= pos && pos < item.to);
   if (index < 0) index = items.findIndex((item) => item.link && item.from < pos && pos <= item.to);
@@ -14813,6 +15560,45 @@ function resolveNoteRevisions(doc, resolvedBody, mode) {
   const value = notePartsJson(next);
   return value !== notePartsJson(notesModel(doc)) ? new NotePartsStep(value) : void 0;
 }
+function selectedChart(state) {
+  const { selection } = state;
+  if (!(selection instanceof prosemirrorState.NodeSelection) || selection.node.type.name !== "image")
+    return void 0;
+  const chart = nodeChart(selection.node);
+  if (!chart) return void 0;
+  return { pos: selection.from, node: selection.node, chart, editable: isDocxChartEditable(chart) };
+}
+function replaceSelectedChart(state, chart) {
+  const selected = selectedChart(state);
+  if (!selected) return null;
+  const tr = state.tr.setNodeMarkup(selected.pos, void 0, {
+    ...selected.node.attrs,
+    chart: JSON.stringify(chart)
+  });
+  return prosemirrorHistory.closeHistory(tr.setSelection(prosemirrorState.NodeSelection.create(tr.doc, selected.pos)));
+}
+function insertChartImage(state, image) {
+  const type = state.schema.nodes.image;
+  if (!type || !image.chart) return null;
+  const node = type.create({
+    relId: image.relId,
+    partName: image.partName,
+    contentType: image.contentType,
+    widthPx: image.widthPx,
+    heightPx: image.heightPx,
+    altText: image.altText ?? null,
+    title: image.title ?? null,
+    anchored: false,
+    unsupported: image.unsupported ?? "Chart",
+    chart: JSON.stringify(image.chart)
+  });
+  const tr = prosemirrorHistory.closeHistory(state.tr.replaceSelectionWith(node, false));
+  const pos = tr.mapping.map(state.selection.from, -1);
+  const at = tr.doc.nodeAt(pos)?.type === type ? pos : tr.selection.from - node.nodeSize;
+  if (at >= 0 && tr.doc.nodeAt(at)?.type === type)
+    tr.setSelection(prosemirrorState.NodeSelection.create(tr.doc, at));
+  return prosemirrorHistory.closeHistory(tr.scrollIntoView());
+}
 
 // docx/ui/node-numbering.ts
 function nodeNumbering(node, model) {
@@ -14859,8 +15645,8 @@ var reviewMarks = {
     parseDOM: [
       {
         tag: "span[data-inline-comment-ids]",
-        getAttrs: (el4) => ({
-          ids: (el4.dataset.inlineCommentIds ?? "").split(",").filter(Boolean)
+        getAttrs: (el5) => ({
+          ids: (el5.dataset.inlineCommentIds ?? "").split(",").filter(Boolean)
         })
       }
     ],
@@ -14888,11 +15674,11 @@ var reviewMarks = {
     parseDOM: [
       {
         tag: "ins[data-revision-id]",
-        getAttrs: (el4) => ({
-          author: el4.dataset.author || "",
-          date: el4.dataset.date || null,
-          dateUtc: el4.dataset.dateUtc || null,
-          id: el4.dataset.revisionId || "",
+        getAttrs: (el5) => ({
+          author: el5.dataset.author || "",
+          date: el5.dataset.date || null,
+          dateUtc: el5.dataset.dateUtc || null,
+          id: el5.dataset.revisionId || "",
           move: null
         })
       }
@@ -14923,11 +15709,11 @@ var reviewMarks = {
     parseDOM: [
       {
         tag: "del[data-revision-id]",
-        getAttrs: (el4) => ({
-          author: el4.dataset.author || "",
-          date: el4.dataset.date || null,
-          dateUtc: el4.dataset.dateUtc || null,
-          id: el4.dataset.revisionId || "",
+        getAttrs: (el5) => ({
+          author: el5.dataset.author || "",
+          date: el5.dataset.date || null,
+          dateUtc: el5.dataset.dateUtc || null,
+          id: el5.dataset.revisionId || "",
           move: null
         })
       }
@@ -14953,8 +15739,8 @@ var reviewMarks = {
     parseDOM: [
       {
         tag: "span[data-comment-ids]",
-        getAttrs: (el4) => ({
-          ids: (el4.dataset.commentIds || "").split(",").filter(Boolean)
+        getAttrs: (el5) => ({
+          ids: (el5.dataset.commentIds || "").split(",").filter(Boolean)
         })
       }
     ],
@@ -15466,12 +16252,25 @@ var RIBBON_ACTION_IDS = [
   "drop-cap",
   "content-control",
   "shapes",
+  "insert-smartart",
+  "add-smartart-shape",
+  "smartart-text-pane",
+  "promote-smartart-shape",
+  "demote-smartart-shape",
+  "move-smartart-shape-up",
+  "move-smartart-shape-down",
+  "change-smartart-layout",
   "shape-fill",
   "shape-outline",
   "shape-outline-weight",
   "wrap-text",
   "shape-height",
   "shape-width",
+  "insert-chart",
+  "chart-legend",
+  "edit-chart-data",
+  "change-chart-type",
+  "format-chart-selection",
   "equation",
   "change-case",
   "format-painter",
@@ -15647,12 +16446,25 @@ var RIBBON_ACTION_LABELS = {
   "drop-cap": "Drop cap",
   "content-control": "Content control",
   shapes: "Shapes",
+  "insert-smartart": "Insert SmartArt",
+  "add-smartart-shape": "Add Shape",
+  "smartart-text-pane": "Text Pane",
+  "promote-smartart-shape": "Promote",
+  "demote-smartart-shape": "Demote",
+  "move-smartart-shape-up": "Move Up",
+  "move-smartart-shape-down": "Move Down",
+  "change-smartart-layout": "Change Layout",
   "shape-fill": "Shape fill",
   "shape-outline": "Shape outline",
   "shape-outline-weight": "Shape outline weight",
   "wrap-text": "Wrap text",
   "shape-height": "Shape height (inches)",
   "shape-width": "Shape width (inches)",
+  "insert-chart": "Insert chart",
+  "chart-legend": "Legend",
+  "edit-chart-data": "Edit Data",
+  "change-chart-type": "Change Chart Type",
+  "format-chart-selection": "Format Selection",
   equation: "Equation",
   "change-case": "Change case",
   "format-painter": "Format painter",
@@ -15940,8 +16752,8 @@ var markSpecs = {
     parseDOM: [
       {
         tag: 'span[style*="background-color"]',
-        getAttrs: (el4) => {
-          const color = el4.style.backgroundColor.toLowerCase();
+        getAttrs: (el5) => {
+          const color = el5.style.backgroundColor.toLowerCase();
           if (color === "white" || color === "rgb(255, 255, 255)" || color === "#ffffff")
             return false;
           const entry = Object.entries(wordHighlightColors).find(([, css]) => {
@@ -15978,10 +16790,10 @@ var markSpecs = {
     parseDOM: [
       {
         tag: "span[lang], span[data-docx-east-asia-language], span[data-docx-bidi-language]",
-        getAttrs: (el4) => ({
-          language: el4.getAttribute("lang"),
-          eastAsiaLanguage: el4.dataset.docxEastAsiaLanguage || null,
-          bidiLanguage: el4.dataset.docxBidiLanguage || null
+        getAttrs: (el5) => ({
+          language: el5.getAttribute("lang"),
+          eastAsiaLanguage: el5.dataset.docxEastAsiaLanguage || null,
+          bidiLanguage: el5.dataset.docxBidiLanguage || null
         })
       }
     ],
@@ -16011,8 +16823,8 @@ var markSpecs = {
     parseDOM: [
       {
         tag: "span",
-        getAttrs: (el4) => {
-          const style = el4.style;
+        getAttrs: (el5) => {
+          const style = el5.style;
           const attrs2 = {
             family: pastedFontFamily(style.fontFamily),
             size: style.fontSize ? parseFontSize(style.fontSize) : null,
@@ -16040,7 +16852,7 @@ var markSpecs = {
     parseDOM: [
       {
         tag: "span[data-docx-style]",
-        getAttrs: (el4) => ({ id: el4.dataset.docxStyle || null })
+        getAttrs: (el5) => ({ id: el5.dataset.docxStyle || null })
       }
     ],
     toDOM: (mark) => ["span", { "data-docx-style": mark.attrs.id }, 0]
@@ -16052,8 +16864,8 @@ var markSpecs = {
       {
         tag: "span[data-sdt]",
         // Only a control is taken from (pasted) HTML; the span's text stays either way.
-        getAttrs: (el4) => {
-          const control = controlFromData(el4.dataset.sdt, "inline");
+        getAttrs: (el5) => {
+          const control = controlFromData(el5.dataset.sdt, "inline");
           return control ? { data: JSON.stringify(control) } : false;
         }
       }
@@ -16067,9 +16879,9 @@ var markSpecs = {
     parseDOM: [
       {
         tag: "span[data-field]",
-        getAttrs: (el4) => ({
-          instr: el4.dataset.field || "",
-          simple: el4.dataset.fieldSimple === "1"
+        getAttrs: (el5) => ({
+          instr: el5.dataset.field || "",
+          simple: el5.dataset.fieldSimple === "1"
         })
       }
     ],
@@ -16134,6 +16946,17 @@ function themeDrawing(drawing, theme) {
   };
 }
 
+// docx/ui/smartart-approximate.ts
+function approximateDiagramDrawing(diagram) {
+  return approximateDiagramDrawingFromNodes({
+    extentEmu: diagram.extentEmu,
+    nodes: diagram.nodes,
+    layoutId: diagram.layout?.uniqueId,
+    family: diagram.layout?.family,
+    colorsId: diagram.colorsId
+  });
+}
+
 // docx/ui/table-render.ts
 var NONE_STYLES = /* @__PURE__ */ new Set(["none", "nil"]);
 function cssBorderStyle(style) {
@@ -16349,7 +17172,7 @@ function documentWordCount(node, locale) {
   if (value !== void 0) return value;
   let count = 0;
   if (node.isTextblock) count = countWords(node.textBetween(0, node.content.size, " "), locale);
-  else node.forEach((child) => count += documentWordCount(child, locale));
+  else node.forEach((child3) => count += documentWordCount(child3, locale));
   const counts = cached2 ?? /* @__PURE__ */ new Map();
   counts.set(key, count);
   documentCounts.set(node, counts);
@@ -16735,6 +17558,7 @@ exports.applyMarkFormatting = applyMarkFormatting;
 exports.applyRunFormattingPatch = applyRunFormattingPatch;
 exports.applyThemeColors = applyThemeColors;
 exports.applyWordLink = applyWordLink;
+exports.approximateDiagramDrawing = approximateDiagramDrawing;
 exports.authorColor = authorColor;
 exports.backstageFocus = backstageFocus;
 exports.chartNodeSpec = chartNodeSpec;
@@ -16795,6 +17619,7 @@ exports.hasChangeAtCursor = hasChangeAtCursor;
 exports.hasNoteRevisions = hasNoteRevisions;
 exports.imageNodeSpec = imageNodeSpec;
 exports.inlineNodeRun = inlineNodeRun;
+exports.insertChartImage = insertChartImage;
 exports.insertContentControl = insertContentControl;
 exports.insertWordHardBreak = insertWordHardBreak;
 exports.insertedTextMarks = insertedTextMarks;
@@ -16839,6 +17664,7 @@ exports.repairCollaborativeDocumentIds = repairCollaborativeDocumentIds;
 exports.repairCollaborativeParagraphIds = repairCollaborativeParagraphIds;
 exports.replaceAroundMarkers = replaceAroundMarkers;
 exports.replaceControlContent = replaceControlContent;
+exports.replaceSelectedChart = replaceSelectedChart;
 exports.replyToComment = replyToComment;
 exports.resolveCellVisuals = resolveCellVisuals;
 exports.resolveComment = resolveComment;
@@ -16853,6 +17679,7 @@ exports.sameJson = sameJson2;
 exports.sameRuns = sameRuns;
 exports.sectionPartsJson = sectionPartsJson;
 exports.selectFormDropDownAt = selectFormDropDownAt;
+exports.selectedChart = selectedChart;
 exports.setCommentThreads = setCommentThreads;
 exports.setReviewRecordingPreferences = setReviewRecordingPreferences;
 exports.staysInFormFields = staysInFormFields;