ooxml-core 1.24.3 → 1.25.1

package/dist/drawingml/index.cjs

@@ -1644,9 +1644,851 @@ function themeDrawingColorTheme(scheme, colorMap) {
   };
 }
 
+// drawingml/read-run-properties.ts
+function outerXml(element) {
+  return buildXml(element);
+}
+function isDrawingElement(element) {
+  return !element.namespaceURI || element.namespaceURI === NS.a;
+}
+function parseDrawingFont(element) {
+  const typeface = stringAttribute(element, "typeface");
+  if (!element || typeface === void 0) return void 0;
+  const font = { typeface };
+  const panose = stringAttribute(element, "panose");
+  if (panose) font.panose = panose;
+  const pitchFamily = integerAttribute(element, "pitchFamily");
+  if (pitchFamily !== void 0) font.pitchFamily = pitchFamily;
+  const charset = integerAttribute(element, "charset");
+  if (charset !== void 0) font.charset = charset;
+  return font;
+}
+function parseDrawingHyperlink(element) {
+  const link = {};
+  const relId = attributeReader(element)("id")?.trim();
+  if (relId) link.relId = relId;
+  for (const [key, name] of [
+    ["tooltip", "tooltip"],
+    ["action", "action"],
+    ["invalidUrl", "invalidUrl"],
+    ["targetFrame", "tgtFrame"]
+  ]) {
+    const value = stringAttribute(element, name);
+    if (value) link[key] = value;
+  }
+  for (const [key, name] of [
+    ["history", "history"],
+    ["highlightClick", "highlightClick"],
+    ["endSound", "endSnd"]
+  ]) {
+    const value = booleanAttribute(element, name);
+    if (value !== void 0) link[key] = value;
+  }
+  const extra = elements(element).map(outerXml);
+  if (extra.length) link.extraXml = extra;
+  return link;
+}
+var BOOLEAN_ATTRIBUTES = [
+  ["bold", "b"],
+  ["italic", "i"],
+  ["kumimoji", "kumimoji"],
+  ["normalizeHeight", "normalizeH"],
+  ["noProof", "noProof"],
+  ["dirty", "dirty"],
+  ["spellingError", "err"],
+  ["smartTagClean", "smtClean"]
+];
+var STRING_ATTRIBUTES = [
+  ["underline", "u"],
+  ["strike", "strike"],
+  ["caps", "cap"],
+  ["language", "lang"],
+  ["altLanguage", "altLang"],
+  ["bookmark", "bmk"]
+];
+var FONT_SLOTS = {
+  latin: "latin",
+  ea: "eastAsian",
+  cs: "complexScript",
+  sym: "symbol"
+};
+function readAttributes(element, out) {
+  const size = integerAttribute(element, "sz");
+  if (size !== void 0) out.sizePt = size / 100;
+  for (const [key, name] of BOOLEAN_ATTRIBUTES) {
+    const value = booleanAttribute(element, name);
+    if (value !== void 0) out[key] = value;
+  }
+  for (const [key, name] of STRING_ATTRIBUTES) {
+    const value = stringAttribute(element, name);
+    if (value) out[key] = value;
+  }
+  const baseline = attributeReader(element)("baseline");
+  const baselineFraction = baseline === void 0 ? void 0 : parseOoxmlPercent(baseline);
+  if (baselineFraction !== void 0) out.baseline = baselineFraction;
+  const spacing = integerAttribute(element, "spc");
+  if (spacing !== void 0) out.spacingPt = spacing / 100;
+  const kern = integerAttribute(element, "kern");
+  if (kern !== void 0) out.kernPt = kern / 100;
+  const smartTagId = integerAttribute(element, "smtId");
+  if (smartTagId !== void 0) out.smartTagId = smartTagId;
+}
+function readChild(child, out, extra) {
+  const name = child.localName;
+  if (!isDrawingElement(child)) {
+    extra.push(outerXml(child));
+    return;
+  }
+  if (name === "ln") {
+    const line = parseDrawingLine(child);
+    if (line) out.line = line;
+    out.lineSourceXml = outerXml(child);
+  } else if (name in FONT_SLOTS) {
+    const font = parseDrawingFont(child);
+    if (font) out[FONT_SLOTS[name]] = font;
+    else extra.push(outerXml(child));
+  } else if (name === "highlight") {
+    const color = parseDrawingColorIn(child);
+    if (color) out.highlight = color;
+  } else if (name === "uLnTx") out.underlineLineFollowsText = true;
+  else if (name === "uLn") out.underlineLineXml = outerXml(child);
+  else if (name === "uFillTx") out.underlineFillFollowsText = true;
+  else if (name === "uFill") {
+    const fill = parseDrawingFill(child);
+    if (fill) out.underlineFill = fill;
+    else extra.push(outerXml(child));
+  } else if (name === "hlinkClick") out.hyperlinkClick = parseDrawingHyperlink(child);
+  else if (name === "hlinkMouseOver") out.hyperlinkMouseOver = parseDrawingHyperlink(child);
+  else if (name === "rtl") {
+    const value = booleanAttribute(child, "val");
+    out.rightToLeft = value ?? true;
+  } else extra.push(outerXml(child));
+}
+var WRITABLE_FILLS = /* @__PURE__ */ new Set(["none", "solid", "gradient"]);
+function parseDrawingRunProperties(element) {
+  if (!element) return void 0;
+  const out = {};
+  readAttributes(element, out);
+  const extra = [];
+  const fillElement = fillElementOf(element);
+  for (const child of elements(element)) {
+    if (child === fillElement) {
+      const fill = parseDrawingFill(element);
+      if (fill && WRITABLE_FILLS.has(fill.kind)) out.fill = fill;
+      else extra.push(outerXml(child));
+      continue;
+    }
+    readChild(child, out, extra);
+  }
+  if (extra.length) out.extraXml = extra;
+  return out;
+}
+
+// drawingml/read-paragraph-properties.ts
+function parseDrawingTextSpacing(element) {
+  const points = integerAttribute(first(element, "spcPts", NS.a), "val");
+  if (points !== void 0) return { unit: "points", value: points / 100 };
+  const percent = parseOoxmlPercent(first(element, "spcPct", NS.a)?.getAttribute("val"));
+  if (percent !== void 0) return { unit: "percent", value: percent };
+  return void 0;
+}
+var EMU_ATTRIBUTES = [
+  ["marginLeftEmu", "marL"],
+  ["marginRightEmu", "marR"],
+  ["indentEmu", "indent"],
+  ["defaultTabSizeEmu", "defTabSz"]
+];
+var BOOLEAN_ATTRIBUTES2 = [
+  ["rightToLeft", "rtl"],
+  ["eastAsianLineBreak", "eaLnBrk"],
+  ["latinLineBreak", "latinLnBrk"],
+  ["hangingPunctuation", "hangingPunct"]
+];
+function readAttributes2(element, out) {
+  const level = integerAttribute(element, "lvl");
+  if (level !== void 0) out.level = Math.min(Math.max(level, 0), 8);
+  const align = stringAttribute(element, "algn");
+  if (align) out.align = align;
+  for (const [key, name] of EMU_ATTRIBUTES) {
+    const value = integerAttribute(element, name);
+    if (value !== void 0) out[key] = value;
+  }
+  for (const [key, name] of BOOLEAN_ATTRIBUTES2) {
+    const value = booleanAttribute(element, name);
+    if (value !== void 0) out[key] = value;
+  }
+  const fontAlign = stringAttribute(element, "fontAlgn");
+  if (fontAlign) out.fontAlign = fontAlign;
+}
+function readTabStops(element) {
+  return children(element, "tab", NS.a).map((tab) => {
+    const stop = {};
+    const position = integerAttribute(tab, "pos");
+    if (position !== void 0) stop.positionEmu = position;
+    const align = stringAttribute(tab, "algn");
+    if (align) stop.align = align;
+    return stop;
+  });
+}
+function readBulletChild(child, out) {
+  switch (child.localName) {
+    case "buClrTx":
+      out.bulletColor = "text";
+      return true;
+    case "buClr": {
+      const color = parseDrawingColorIn(child);
+      if (color) out.bulletColor = color;
+      return color !== void 0;
+    }
+    case "buSzTx":
+      out.bulletSize = "text";
+      return true;
+    case "buSzPct": {
+      const value = parseOoxmlPercent(child.getAttribute("val"));
+      if (value !== void 0) out.bulletSize = { unit: "percent", value };
+      return value !== void 0;
+    }
+    case "buSzPts": {
+      const value = integerAttribute(child, "val");
+      if (value !== void 0) out.bulletSize = { unit: "points", value: value / 100 };
+      return value !== void 0;
+    }
+    case "buFontTx":
+      out.bulletFont = "text";
+      return true;
+    case "buFont": {
+      const font = parseDrawingFont(child);
+      if (font) out.bulletFont = font;
+      return font !== void 0;
+    }
+    case "buNone":
+      out.bullet = { kind: "none" };
+      return true;
+    case "buChar": {
+      const char = child.getAttribute("char");
+      if (char) out.bullet = { kind: "char", char };
+      return Boolean(char);
+    }
+    case "buAutoNum": {
+      const scheme = stringAttribute(child, "type");
+      if (!scheme) return false;
+      const startAt = integerAttribute(child, "startAt");
+      out.bullet = { kind: "autoNumber", scheme, ...startAt !== void 0 ? { startAt } : {} };
+      return true;
+    }
+    case "buBlip":
+      out.bullet = { kind: "picture", xml: outerXml(child) };
+      return true;
+    default:
+      return false;
+  }
+}
+function parseDrawingParagraphProperties(element) {
+  if (!element) return void 0;
+  const out = {};
+  readAttributes2(element, out);
+  const extra = [];
+  for (const child of elements(element)) {
+    if (!isDrawingElement(child)) {
+      extra.push(outerXml(child));
+      continue;
+    }
+    const name = child.localName;
+    if (name === "lnSpc" || name === "spcBef" || name === "spcAft") {
+      const spacing = parseDrawingTextSpacing(child);
+      const key = name === "lnSpc" ? "lineSpacing" : name === "spcBef" ? "spaceBefore" : "spaceAfter";
+      if (spacing) out[key] = spacing;
+      else extra.push(outerXml(child));
+    } else if (name === "tabLst") out.tabStops = readTabStops(child);
+    else if (name === "defRPr") {
+      const run = parseDrawingRunProperties(child);
+      if (run) out.defaultRunProperties = run;
+    } else if (!readBulletChild(child, out)) extra.push(outerXml(child));
+  }
+  if (extra.length) out.extraXml = extra;
+  return out;
+}
+
+// drawingml/read-text-body.ts
+var BODY_STRINGS = [
+  ["verticalOverflow", "vertOverflow"],
+  ["horizontalOverflow", "horzOverflow"],
+  ["vertical", "vert"],
+  ["wrap", "wrap"],
+  ["anchor", "anchor"]
+];
+var BODY_INTEGERS = [
+  ["insetLeftEmu", "lIns"],
+  ["insetTopEmu", "tIns"],
+  ["insetRightEmu", "rIns"],
+  ["insetBottomEmu", "bIns"],
+  ["columnCount", "numCol"],
+  ["columnSpacingEmu", "spcCol"]
+];
+var BODY_BOOLEANS = [
+  ["spaceFirstLastParagraph", "spcFirstLastPara"],
+  ["rightToLeftColumns", "rtlCol"],
+  ["fromWordArt", "fromWordArt"],
+  ["anchorCenter", "anchorCtr"],
+  ["forceAntiAlias", "forceAA"],
+  ["upright", "upright"],
+  ["compatibleLineSpacing", "compatLnSpc"]
+];
+function parseDrawingBodyProperties(element) {
+  if (!element) return void 0;
+  const out = {};
+  const rotation = integerAttribute(element, "rot");
+  if (rotation !== void 0) out.rotation = rotation / 6e4;
+  for (const [key, name] of BODY_STRINGS) {
+    const value = stringAttribute(element, name);
+    if (value) out[key] = value;
+  }
+  for (const [key, name] of BODY_INTEGERS) {
+    const value = integerAttribute(element, name);
+    if (value !== void 0) out[key] = value;
+  }
+  for (const [key, name] of BODY_BOOLEANS) {
+    const value = booleanAttribute(element, name);
+    if (value !== void 0) out[key] = value;
+  }
+  const extra = [];
+  for (const child of elements(element)) {
+    const name = isDrawingElement(child) ? child.localName : "";
+    if (name === "noAutofit") out.autofit = { kind: "none" };
+    else if (name === "spAutoFit") out.autofit = { kind: "shape" };
+    else if (name === "normAutofit") {
+      const read = attributeReader(child);
+      const fontScale = parseOoxmlPercent(read("fontScale") ?? "");
+      const reduction = parseOoxmlPercent(read("lnSpcReduction") ?? "");
+      out.autofit = {
+        kind: "normal",
+        ...read("fontScale") !== void 0 && fontScale !== void 0 ? { fontScale } : {},
+        ...read("lnSpcReduction") !== void 0 && reduction !== void 0 ? { lineSpacingReduction: reduction } : {}
+      };
+    } else extra.push(outerXml(child));
+  }
+  if (extra.length) out.extraXml = extra;
+  return out;
+}
+function parseDrawingListStyle(element) {
+  if (!element) return void 0;
+  const style = { levels: [] };
+  const extra = [];
+  for (const child of elements(element)) {
+    const level = isDrawingElement(child) ? /^lvl([1-9])pPr$/u.exec(child.localName) : null;
+    if (level) style.levels[Number(level[1]) - 1] = parseDrawingParagraphProperties(child);
+    else if (isDrawingElement(child) && child.localName === "defPPr")
+      style.default = parseDrawingParagraphProperties(child) ?? {};
+    else extra.push(outerXml(child));
+  }
+  style.levels = Array.from(style.levels);
+  if (extra.length) style.extraXml = extra;
+  return style;
+}
+function textOf(element) {
+  return first(element, "t", NS.a)?.textContent ?? "";
+}
+function readItem(child) {
+  const name = isDrawingElement(child) ? child.localName : "";
+  if (name === "pPr" || name === "endParaRPr") return void 0;
+  if (name === "r") {
+    const properties = parseDrawingRunProperties(first(child, "rPr", NS.a));
+    return { kind: "run", text: textOf(child), ...properties ? { properties } : {} };
+  }
+  if (name === "br") {
+    const properties = parseDrawingRunProperties(first(child, "rPr", NS.a));
+    return { kind: "break", ...properties ? { properties } : {} };
+  }
+  if (name === "fld") {
+    const properties = parseDrawingRunProperties(first(child, "rPr", NS.a));
+    const paragraphProperties = parseDrawingParagraphProperties(first(child, "pPr", NS.a));
+    const type = child.getAttribute("type");
+    return {
+      kind: "field",
+      id: child.getAttribute("id") ?? "",
+      ...type ? { type } : {},
+      text: textOf(child),
+      ...properties ? { properties } : {},
+      ...paragraphProperties ? { paragraphProperties } : {}
+    };
+  }
+  return { kind: "unknown", xml: outerXml(child) };
+}
+function parseDrawingParagraph(element) {
+  const items = [];
+  for (const child of elements(element)) {
+    const item = readItem(child);
+    if (item) items.push(item);
+  }
+  const properties = parseDrawingParagraphProperties(first(element, "pPr", NS.a));
+  const endProperties = parseDrawingRunProperties(first(element, "endParaRPr", NS.a));
+  return {
+    ...properties ? { properties } : {},
+    items,
+    ...endProperties ? { endProperties } : {}
+  };
+}
+function parseDrawingRichTextBody(element) {
+  if (!element) return void 0;
+  const bodyProperties = parseDrawingBodyProperties(first(element, "bodyPr", NS.a));
+  const listStyle = parseDrawingListStyle(first(element, "lstStyle", NS.a));
+  return {
+    ...bodyProperties ? { bodyProperties } : {},
+    ...listStyle ? { listStyle } : {},
+    paragraphs: children(element, "p", NS.a).map(parseDrawingParagraph)
+  };
+}
+function drawingParagraphText(paragraph) {
+  return paragraph.items.map(
+    (item) => item.kind === "run" || item.kind === "field" ? item.text : item.kind === "break" ? "\n" : ""
+  ).join("");
+}
+
+// drawingml/write-line.ts
+var FILLS = /* @__PURE__ */ new Set(["noFill", "solidFill", "gradFill", "pattFill"]);
+function dropDrawingDeclarations(element) {
+  if (element.getAttribute("xmlns:a") === NS.a) element.removeAttribute("xmlns:a");
+  for (const child of elements(element)) dropDrawingDeclarations(child);
+}
+function patchDrawingLine(ln, line) {
+  if (line.widthEmu === void 0) ln.removeAttribute("w");
+  else ln.setAttribute("w", String(Math.round(line.widthEmu)));
+  if (line.cap === void 0) ln.removeAttribute("cap");
+  else ln.setAttribute("cap", line.cap);
+  const fill = line.fill && drawingFillXml(line.fill);
+  if (fill || !line.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 (line.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", line.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);
+}
+
+// drawingml/write-text-xml.ts
+function drawingElement(doc, local) {
+  return doc.createElementNS(NS.a, `a:${local}`);
+}
+function dropRedundantDeclarations(element) {
+  if (element.getAttribute("xmlns:a") === NS.a) element.removeAttribute("xmlns:a");
+  if (element.getAttribute("xmlns:r") === NS.r) element.removeAttribute("xmlns:r");
+  for (const child of elements(element)) dropRedundantDeclarations(child);
+}
+function importDrawingXml(doc, xml) {
+  const wrapper = parseXml(`<w xmlns:a="${NS.a}" xmlns:r="${NS.r}">${xml}</w>`).documentElement;
+  const node = elements(wrapper)[0];
+  if (!node) throw new Error("Empty DrawingML fragment");
+  const imported = doc.importNode(node, true);
+  dropRedundantDeclarations(imported);
+  return imported;
+}
+function keptChildName(xml) {
+  const match = /^\s*<(?:[\w.-]+:)?([\w.-]+)/u.exec(xml);
+  return match?.[1] ?? "";
+}
+function keptChildren(doc, xml) {
+  return (xml ?? []).map((value) => ({
+    name: keptChildName(value),
+    node: importDrawingXml(doc, value)
+  }));
+}
+function appendInSchemaOrder(parent, order, entries) {
+  const rank = (name) => {
+    const index = order.indexOf(name);
+    return index < 0 ? order.length : index;
+  };
+  entries.map((entry, index) => ({ entry, index })).sort((a, b) => rank(a.entry.name) - rank(b.entry.name) || a.index - b.index).forEach(({ entry }) => parent.appendChild(entry.node));
+}
+function setBoolean(element, name, value) {
+  if (value !== void 0) element.setAttribute(name, value ? "1" : "0");
+}
+function setValue(element, name, value) {
+  if (value !== void 0) element.setAttribute(name, String(value));
+}
+function setScaled(element, name, value, scale) {
+  if (value !== void 0 && Number.isFinite(value))
+    element.setAttribute(name, String(Math.round(value * scale)));
+}
+
+// drawingml/write-run-properties.ts
+var RUN_PROPERTIES_ORDER = [
+  "ln",
+  "noFill",
+  "solidFill",
+  "gradFill",
+  "blipFill",
+  "pattFill",
+  "grpFill",
+  "effectLst",
+  "effectDag",
+  "highlight",
+  "uLnTx",
+  "uLn",
+  "uFillTx",
+  "uFill",
+  "latin",
+  "ea",
+  "cs",
+  "sym",
+  "hlinkClick",
+  "hlinkMouseOver",
+  "rtl",
+  "extLst"
+];
+var FILL_NAMES = /* @__PURE__ */ new Set(["noFill", "solidFill", "gradFill", "blipFill", "pattFill", "grpFill"]);
+function writeDrawingFont(doc, local, font) {
+  const element = drawingElement(doc, local);
+  element.setAttribute("typeface", font.typeface);
+  setValue(element, "panose", font.panose);
+  setValue(element, "pitchFamily", font.pitchFamily);
+  setValue(element, "charset", font.charset);
+  return element;
+}
+function writeHyperlink(doc, local, link) {
+  const element = drawingElement(doc, local);
+  if (link.relId !== void 0) element.setAttributeNS(NS.r, "r:id", link.relId);
+  setValue(element, "invalidUrl", link.invalidUrl);
+  setValue(element, "action", link.action);
+  setValue(element, "tgtFrame", link.targetFrame);
+  setValue(element, "tooltip", link.tooltip);
+  setBoolean(element, "history", link.history);
+  setBoolean(element, "highlightClick", link.highlightClick);
+  setBoolean(element, "endSnd", link.endSound);
+  for (const xml of link.extraXml ?? []) element.appendChild(importDrawingXml(doc, xml));
+  return element;
+}
+function setAttributes(element, value) {
+  setBoolean(element, "kumimoji", value.kumimoji);
+  setValue(element, "lang", value.language);
+  setValue(element, "altLang", value.altLanguage);
+  setScaled(element, "sz", value.sizePt, 100);
+  setBoolean(element, "b", value.bold);
+  setBoolean(element, "i", value.italic);
+  setValue(element, "u", value.underline);
+  setValue(element, "strike", value.strike);
+  setScaled(element, "kern", value.kernPt, 100);
+  setValue(element, "cap", value.caps);
+  setScaled(element, "spc", value.spacingPt, 100);
+  setBoolean(element, "normalizeH", value.normalizeHeight);
+  setScaled(element, "baseline", value.baseline, 1e5);
+  setBoolean(element, "noProof", value.noProof);
+  setBoolean(element, "dirty", value.dirty);
+  setBoolean(element, "err", value.spellingError);
+  setBoolean(element, "smtClean", value.smartTagClean);
+  setValue(element, "smtId", value.smartTagId);
+  setValue(element, "bmk", value.bookmark);
+}
+function fillChild(doc, fill) {
+  const xml = fill ? drawingFillXml(fill) : void 0;
+  if (!xml) return void 0;
+  const node = importDrawingXml(doc, xml);
+  return { name: node.localName, node };
+}
+function modelledChildren(doc, value) {
+  const out = [];
+  const add = (name, node) => out.push({ name, node });
+  if (value.line || value.lineSourceXml) {
+    const ln = value.lineSourceXml ? importDrawingXml(doc, value.lineSourceXml) : drawingElement(doc, "ln");
+    if (value.line) patchDrawingLine(ln, value.line);
+    add("ln", ln);
+  }
+  const fill = fillChild(doc, value.fill);
+  if (fill) out.push(fill);
+  if (value.highlight) {
+    const highlight = drawingElement(doc, "highlight");
+    highlight.appendChild(importDrawingXml(doc, drawingColorXml(value.highlight)));
+    add("highlight", highlight);
+  }
+  if (value.underlineLineFollowsText) add("uLnTx", drawingElement(doc, "uLnTx"));
+  else if (value.underlineLineXml) add("uLn", importDrawingXml(doc, value.underlineLineXml));
+  if (value.underlineFillFollowsText) add("uFillTx", drawingElement(doc, "uFillTx"));
+  else {
+    const underline = fillChild(doc, value.underlineFill);
+    if (underline) {
+      const uFill = drawingElement(doc, "uFill");
+      uFill.appendChild(underline.node);
+      add("uFill", uFill);
+    }
+  }
+  for (const [local, key] of [
+    ["latin", "latin"],
+    ["ea", "eastAsian"],
+    ["cs", "complexScript"],
+    ["sym", "symbol"]
+  ]) {
+    const font = value[key];
+    if (font) add(local, writeDrawingFont(doc, local, font));
+  }
+  if (value.hyperlinkClick)
+    add("hlinkClick", writeHyperlink(doc, "hlinkClick", value.hyperlinkClick));
+  if (value.hyperlinkMouseOver)
+    add("hlinkMouseOver", writeHyperlink(doc, "hlinkMouseOver", value.hyperlinkMouseOver));
+  if (value.rightToLeft !== void 0) {
+    const rtl = drawingElement(doc, "rtl");
+    if (!value.rightToLeft) rtl.setAttribute("val", "0");
+    add("rtl", rtl);
+  }
+  return out;
+}
+function writeDrawingRunProperties(doc, value, local = "rPr") {
+  const element = drawingElement(doc, local);
+  setAttributes(element, value);
+  const modelled = modelledChildren(doc, value);
+  const hasFill = modelled.some((child) => FILL_NAMES.has(child.name));
+  const kept = keptChildren(doc, value.extraXml).filter(
+    (child) => !(hasFill && FILL_NAMES.has(child.name))
+  );
+  appendInSchemaOrder(element, RUN_PROPERTIES_ORDER, [...modelled, ...kept]);
+  return element;
+}
+function drawingRunPropertiesXml(value, local = "rPr") {
+  const doc = parseXml(`<a:w xmlns:a="${NS.a}" xmlns:r="${NS.r}"/>`);
+  return buildXml(writeDrawingRunProperties(doc, value, local));
+}
+
+// drawingml/write-paragraph-properties.ts
+var PARAGRAPH_PROPERTIES_ORDER = [
+  "lnSpc",
+  "spcBef",
+  "spcAft",
+  "buClrTx",
+  "buClr",
+  "buSzTx",
+  "buSzPct",
+  "buSzPts",
+  "buFontTx",
+  "buFont",
+  "buNone",
+  "buAutoNum",
+  "buChar",
+  "buBlip",
+  "tabLst",
+  "defRPr",
+  "extLst"
+];
+function writeDrawingTextSpacing(doc, local, spacing) {
+  const element = drawingElement(doc, local);
+  const inner = drawingElement(doc, spacing.unit === "points" ? "spcPts" : "spcPct");
+  setScaled(inner, "val", spacing.value, spacing.unit === "points" ? 100 : 1e5);
+  element.appendChild(inner);
+  return element;
+}
+function setAttributes2(element, value) {
+  setValue(element, "marL", value.marginLeftEmu);
+  setValue(element, "marR", value.marginRightEmu);
+  setValue(element, "lvl", value.level);
+  setValue(element, "indent", value.indentEmu);
+  setValue(element, "algn", value.align);
+  setValue(element, "defTabSz", value.defaultTabSizeEmu);
+  setBoolean(element, "rtl", value.rightToLeft);
+  setBoolean(element, "eaLnBrk", value.eastAsianLineBreak);
+  setValue(element, "fontAlgn", value.fontAlign);
+  setBoolean(element, "latinLnBrk", value.latinLineBreak);
+  setBoolean(element, "hangingPunct", value.hangingPunctuation);
+}
+function bulletChildren(doc, value) {
+  const out = [];
+  const add = (name, node) => out.push({ name, node });
+  if (value.bulletColor === "text") add("buClrTx", drawingElement(doc, "buClrTx"));
+  else if (value.bulletColor) {
+    const color = drawingElement(doc, "buClr");
+    color.appendChild(importDrawingXml(doc, drawingColorXml(value.bulletColor)));
+    add("buClr", color);
+  }
+  const size = value.bulletSize;
+  if (size === "text") add("buSzTx", drawingElement(doc, "buSzTx"));
+  else if (size) {
+    const local = size.unit === "percent" ? "buSzPct" : "buSzPts";
+    const element = drawingElement(doc, local);
+    setScaled(element, "val", size.value, size.unit === "percent" ? 1e5 : 100);
+    add(local, element);
+  }
+  if (value.bulletFont === "text") add("buFontTx", drawingElement(doc, "buFontTx"));
+  else if (value.bulletFont) add("buFont", writeDrawingFont(doc, "buFont", value.bulletFont));
+  const bullet = value.bullet;
+  if (bullet?.kind === "none") add("buNone", drawingElement(doc, "buNone"));
+  else if (bullet?.kind === "char") {
+    const element = drawingElement(doc, "buChar");
+    element.setAttribute("char", bullet.char);
+    add("buChar", element);
+  } else if (bullet?.kind === "autoNumber") {
+    const element = drawingElement(doc, "buAutoNum");
+    element.setAttribute("type", bullet.scheme);
+    setValue(element, "startAt", bullet.startAt);
+    add("buAutoNum", element);
+  } else if (bullet?.kind === "picture") add("buBlip", importDrawingXml(doc, bullet.xml));
+  return out;
+}
+function writeDrawingParagraphProperties(doc, value, local = "pPr") {
+  const element = drawingElement(doc, local);
+  setAttributes2(element, value);
+  const children2 = [];
+  for (const [key, name] of [
+    ["lineSpacing", "lnSpc"],
+    ["spaceBefore", "spcBef"],
+    ["spaceAfter", "spcAft"]
+  ]) {
+    const spacing = value[key];
+    if (spacing) children2.push({ name, node: writeDrawingTextSpacing(doc, name, spacing) });
+  }
+  children2.push(...bulletChildren(doc, value));
+  if (value.tabStops) {
+    const list = drawingElement(doc, "tabLst");
+    for (const stop of value.tabStops) {
+      const tab = drawingElement(doc, "tab");
+      setValue(tab, "pos", stop.positionEmu);
+      setValue(tab, "algn", stop.align);
+      list.appendChild(tab);
+    }
+    children2.push({ name: "tabLst", node: list });
+  }
+  if (value.defaultRunProperties)
+    children2.push({
+      name: "defRPr",
+      node: writeDrawingRunProperties(doc, value.defaultRunProperties, "defRPr")
+    });
+  appendInSchemaOrder(element, PARAGRAPH_PROPERTIES_ORDER, [
+    ...children2,
+    ...keptChildren(doc, value.extraXml)
+  ]);
+  return element;
+}
+function drawingParagraphPropertiesXml(value, local = "pPr") {
+  const doc = parseXml(`<a:w xmlns:a="${NS.a}" xmlns:r="${NS.r}"/>`);
+  return buildXml(writeDrawingParagraphProperties(doc, value, local));
+}
+
+// drawingml/write-text-body.ts
+var BODY_PROPERTIES_ORDER = [
+  "prstTxWarp",
+  "noAutofit",
+  "normAutofit",
+  "spAutoFit",
+  "scene3d",
+  "sp3d",
+  "flatTx",
+  "extLst"
+];
+function writeDrawingBodyProperties(doc, value) {
+  const element = drawingElement(doc, "bodyPr");
+  setScaled(element, "rot", value.rotation, 6e4);
+  setBoolean(element, "spcFirstLastPara", value.spaceFirstLastParagraph);
+  setValue(element, "vertOverflow", value.verticalOverflow);
+  setValue(element, "horzOverflow", value.horizontalOverflow);
+  setValue(element, "vert", value.vertical);
+  setValue(element, "wrap", value.wrap);
+  setValue(element, "lIns", value.insetLeftEmu);
+  setValue(element, "tIns", value.insetTopEmu);
+  setValue(element, "rIns", value.insetRightEmu);
+  setValue(element, "bIns", value.insetBottomEmu);
+  setValue(element, "numCol", value.columnCount);
+  setValue(element, "spcCol", value.columnSpacingEmu);
+  setBoolean(element, "rtlCol", value.rightToLeftColumns);
+  setBoolean(element, "fromWordArt", value.fromWordArt);
+  setValue(element, "anchor", value.anchor);
+  setBoolean(element, "anchorCtr", value.anchorCenter);
+  setBoolean(element, "forceAA", value.forceAntiAlias);
+  setBoolean(element, "upright", value.upright);
+  setBoolean(element, "compatLnSpc", value.compatibleLineSpacing);
+  const children2 = [];
+  const autofit = value.autofit;
+  if (autofit) {
+    const local = autofit.kind === "none" ? "noAutofit" : autofit.kind === "shape" ? "spAutoFit" : "normAutofit";
+    const node = drawingElement(doc, local);
+    if (autofit.kind === "normal") {
+      setScaled(node, "fontScale", autofit.fontScale, 1e5);
+      setScaled(node, "lnSpcReduction", autofit.lineSpacingReduction, 1e5);
+    }
+    children2.push({ name: local, node });
+  }
+  appendInSchemaOrder(element, BODY_PROPERTIES_ORDER, [
+    ...children2,
+    ...keptChildren(doc, value.extraXml)
+  ]);
+  return element;
+}
+function writeDrawingListStyle(doc, value) {
+  const element = drawingElement(doc, "lstStyle");
+  if (value.default)
+    element.appendChild(writeDrawingParagraphProperties(doc, value.default, "defPPr"));
+  value.levels.forEach((level, index) => {
+    if (level)
+      element.appendChild(writeDrawingParagraphProperties(doc, level, `lvl${index + 1}pPr`));
+  });
+  for (const kept of keptChildren(doc, value.extraXml)) element.appendChild(kept.node);
+  return element;
+}
+function withText(doc, element, text) {
+  const t = drawingElement(doc, "t");
+  t.appendChild(doc.createTextNode(text));
+  element.appendChild(t);
+  return element;
+}
+function writeItem(doc, item) {
+  if (item.kind === "unknown") return importDrawingXml(doc, item.xml);
+  const element = drawingElement(
+    doc,
+    item.kind === "run" ? "r" : item.kind === "break" ? "br" : "fld"
+  );
+  if (item.kind === "field") {
+    element.setAttribute("id", item.id);
+    setValue(element, "type", item.type);
+  }
+  if (item.properties) element.appendChild(writeDrawingRunProperties(doc, item.properties));
+  if (item.kind === "field" && item.paragraphProperties)
+    element.appendChild(writeDrawingParagraphProperties(doc, item.paragraphProperties));
+  return item.kind === "break" ? element : withText(doc, element, item.text);
+}
+function writeDrawingParagraph(doc, paragraph) {
+  const element = drawingElement(doc, "p");
+  if (paragraph.properties)
+    element.appendChild(writeDrawingParagraphProperties(doc, paragraph.properties));
+  for (const item of paragraph.items) element.appendChild(writeItem(doc, item));
+  if (paragraph.endProperties)
+    element.appendChild(writeDrawingRunProperties(doc, paragraph.endProperties, "endParaRPr"));
+  return element;
+}
+function writeDrawingRichTextBody(container, body) {
+  const doc = container.ownerDocument;
+  if (body.bodyProperties)
+    container.appendChild(writeDrawingBodyProperties(doc, body.bodyProperties));
+  if (body.listStyle) container.appendChild(writeDrawingListStyle(doc, body.listStyle));
+  const paragraphs = body.paragraphs.length ? body.paragraphs : [{ items: [] }];
+  for (const paragraph of paragraphs) container.appendChild(writeDrawingParagraph(doc, paragraph));
+}
+function drawingRichTextBodyXml(body, qualifiedName = "a:txBody", namespace = NS.a) {
+  const prefix = qualifiedName.includes(":") ? qualifiedName.split(":")[0] : void 0;
+  const declaration = prefix && prefix !== "a" ? ` xmlns:${prefix}="${namespace}"` : "";
+  const doc = parseXml(`<${qualifiedName}${declaration} xmlns:a="${NS.a}" xmlns:r="${NS.r}"/>`);
+  writeDrawingRichTextBody(doc.documentElement, body);
+  return buildXml(doc);
+}
+
+exports.BODY_PROPERTIES_ORDER = BODY_PROPERTIES_ORDER;
 exports.DEFAULT_THEME_COLOR_MAP = DEFAULT_THEME_COLOR_MAP;
 exports.OFFICE_GRADIENT_PRESETS = OFFICE_GRADIENT_PRESETS;
+exports.PARAGRAPH_PROPERTIES_ORDER = PARAGRAPH_PROPERTIES_ORDER;
 exports.RECT_GRADIENT_DIRECTIONS = RECT_GRADIENT_DIRECTIONS;
+exports.RUN_PROPERTIES_ORDER = RUN_PROPERTIES_ORDER;
 exports.THEME_COLOR_SLOTS = THEME_COLOR_SLOTS;
 exports.attributeReader = attributeReader;
 exports.booleanAttribute = booleanAttribute;
@@ -1657,6 +2499,10 @@ exports.drawingColorBrightness = drawingColorBrightness;
 exports.drawingColorCss = drawingColorCss;
 exports.drawingColorXml = drawingColorXml;
 exports.drawingFillXml = drawingFillXml;
+exports.drawingParagraphPropertiesXml = drawingParagraphPropertiesXml;
+exports.drawingParagraphText = drawingParagraphText;
+exports.drawingRichTextBodyXml = drawingRichTextBodyXml;
+exports.drawingRunPropertiesXml = drawingRunPropertiesXml;
 exports.drawingThemeXml = drawingThemeXml;
 exports.fillElementOf = fillElementOf;
 exports.integerAttribute = integerAttribute;
@@ -1664,13 +2510,22 @@ exports.isThemeColorSlot = isThemeColorSlot;
 exports.officeGradientPresetFill = officeGradientPresetFill;
 exports.officeGradientPresetId = officeGradientPresetId;
 exports.orderedColorTransforms = orderedColorTransforms;
+exports.parseDrawingBodyProperties = parseDrawingBodyProperties;
 exports.parseDrawingColor = parseDrawingColor;
 exports.parseDrawingColorIn = parseDrawingColorIn;
 exports.parseDrawingColorList = parseDrawingColorList;
 exports.parseDrawingFill = parseDrawingFill;
+exports.parseDrawingFont = parseDrawingFont;
 exports.parseDrawingGeometry = parseDrawingGeometry;
+exports.parseDrawingHyperlink = parseDrawingHyperlink;
 exports.parseDrawingLine = parseDrawingLine;
+exports.parseDrawingListStyle = parseDrawingListStyle;
+exports.parseDrawingParagraph = parseDrawingParagraph;
+exports.parseDrawingParagraphProperties = parseDrawingParagraphProperties;
+exports.parseDrawingRichTextBody = parseDrawingRichTextBody;
+exports.parseDrawingRunProperties = parseDrawingRunProperties;
 exports.parseDrawingTextBody = parseDrawingTextBody;
+exports.parseDrawingTextSpacing = parseDrawingTextSpacing;
 exports.parseFrame = parseFrame;
 exports.parseTheme = parseTheme;
 exports.parseThemeColorMap = parseThemeColorMap;
@@ -1692,3 +2547,11 @@ exports.themeDrawingColorTheme = themeDrawingColorTheme;
 exports.themeSlotHex = themeSlotHex;
 exports.withDrawingColorBrightness = withDrawingColorBrightness;
 exports.withDrawingGradientGeometry = withDrawingGradientGeometry;
+exports.writeDrawingBodyProperties = writeDrawingBodyProperties;
+exports.writeDrawingFont = writeDrawingFont;
+exports.writeDrawingListStyle = writeDrawingListStyle;
+exports.writeDrawingParagraph = writeDrawingParagraph;
+exports.writeDrawingParagraphProperties = writeDrawingParagraphProperties;
+exports.writeDrawingRichTextBody = writeDrawingRichTextBody;
+exports.writeDrawingRunProperties = writeDrawingRunProperties;
+exports.writeDrawingTextSpacing = writeDrawingTextSpacing;