@portone/docx-editor 0.2.0 → 0.2.1

package/dist/docx/headersFooters.js

@@ -1,6 +1,7 @@
 // src/docx/headersFooters.ts
 import { ALIGN_BY_JC } from "../ooxml/units.js";
 import {
+  attributeByLocalName,
   decodeUtf8,
   elementChildren,
   parseXml,
@@ -20,12 +21,9 @@ var NO_HEADERS_FOOTERS = {
   evenAndOdd: false,
   pageNumberStart: 1
 };
-function attribute(el, localName) {
-  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
-}
 function isOn(el) {
   if (!el) return false;
-  const value = attribute(el, "val")?.toLowerCase();
+  const value = attributeByLocalName(el, "val")?.toLowerCase();
   return value !== "0" && value !== "false" && value !== "off";
 }
 function firstSectPrIn(root) {
@@ -58,13 +56,13 @@ function paragraphSegments(paragraph) {
       return;
     }
     if (el.namespaceURI === W_NS && el.localName === "fldSimple") {
-      const field = pageField(attribute(el, "instr") ?? "");
+      const field = pageField(attributeByLocalName(el, "instr") ?? "");
       if (field) dynamic(field);
       else for (const child of elementChildren(el)) visit(child);
       return;
     }
     if (el.namespaceURI === W_NS && el.localName === "fldChar") {
-      const kind = attribute(el, "fldCharType");
+      const kind = attributeByLocalName(el, "fldCharType");
       if (kind === "begin") {
         fields.push({ instruction: "", separated: false, field: null });
       } else if (kind === "separate") {
@@ -129,7 +127,7 @@ function readContent(bytes) {
   ) : void 0;
   return {
     segments,
-    align: jc ? ALIGN_BY_JC[attribute(jc, "val") ?? ""] ?? null : null
+    align: jc ? ALIGN_BY_JC[attributeByLocalName(jc, "val") ?? ""] ?? null : null
   };
 }
 function settingsEvenAndOdd(parts, mainPartPath) {
@@ -153,9 +151,9 @@ function readVariants(parts, mainPartPath, sectPr, kind) {
   const variants = { ...EMPTY_VARIANTS };
   for (const reference of elementChildren(sectPr)) {
     if (reference.localName !== `${kind}Reference`) continue;
-    const type = attribute(reference, "type") ?? "default";
+    const type = attributeByLocalName(reference, "type") ?? "default";
     if (type !== "default" && type !== "first" && type !== "even") continue;
-    const id = reference.getAttributeNS(R_NS, "id") ?? attribute(reference, "id");
+    const id = reference.getAttributeNS(R_NS, "id") ?? attributeByLocalName(reference, "id");
     if (!id) continue;
     const relationship = relationships.get(id);
     if (!relationship || relationship.external || relationship.type !== `${R_NS}/${kind}`) {
@@ -170,7 +168,7 @@ function pageNumberStart(sectPr) {
   const pgNumType = elementChildren(sectPr).find(
     (child) => child.localName === "pgNumType"
   );
-  const declared = pgNumType ? attribute(pgNumType, "start") : null;
+  const declared = pgNumType ? attributeByLocalName(pgNumType, "start") : null;
   if (declared === null) return 1;
   const start = Number(declared);
   return Number.isSafeInteger(start) && start >= 0 ? start : 1;

package/dist/docx/notes.js

@@ -1,5 +1,6 @@
 // src/docx/notes.ts
 import {
+  attributeByLocalName,
   decodeUtf8,
   elementChildren,
   parseXml,
@@ -16,9 +17,6 @@ var NO_NOTES = {
   footnotes: EMPTY_PART,
   endnotes: EMPTY_PART
 };
-function attribute(el, localName) {
-  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
-}
 function inlineText(node) {
   if (node.localName === "t") return node.textContent ?? "";
   if (node.localName === "tab") return "	";
@@ -42,9 +40,9 @@ function notePart(parts, mainPartPath, kind) {
   const root = parseXml(decodeUtf8(bytes).text).documentElement;
   const elements = elementChildren(root).filter((el) => el.localName === kind);
   const ordered = elements.flatMap((el) => {
-    const id = attribute(el, "id");
+    const id = attributeByLocalName(el, "id");
     if (id === null) return [];
-    const type = attribute(el, "type");
+    const type = attributeByLocalName(el, "type");
     const regular = type === null || type === "normal";
     const label = regular ? "?" : "";
     return [{ kind, id, label, text: noteText(el), type }];

package/dist/docx/paraProps.js

@@ -1,5 +1,12 @@
 // src/docx/paraProps.ts
-import { childByLocalName, escapeXml, localPart } from "../ooxml/xml.js";
+import {
+  attrPairs,
+  elementXml,
+  withoutAttrs
+} from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
+import { setAttr } from "../ooxml/precedence.js";
+import { childByLocalName, localPart } from "../ooxml/xml.js";
 import {
   layerParagraphFormat,
   layerRunFormat,
@@ -33,65 +40,66 @@ function readParagraphStyleRun(pPr, styles = NO_STYLES, defaultStyleId = null) {
 }
 function numPrXml(ref) {
   if (!ref) return null;
-  return `<w:numPr><w:ilvl w:val="${ref.ilvl}"/><w:numId w:val="${ref.numId}"/></w:numPr>`;
-}
-function keptIndAttrs(ind, dropped) {
-  if (!ind) return [];
-  return Array.from(ind.attributes).filter((attr) => !dropped.includes(localPart(attr.name))).map((attr) => [attr.name, attr.value]);
+  return elementXml(
+    wName("numPr"),
+    [],
+    [
+      elementXml(wName("ilvl"), [[wName("val"), `${ref.ilvl}`]]),
+      elementXml(wName("numId"), [[wName("val"), `${ref.numId}`]])
+    ]
+  );
 }
 function levelIndAttrs(indent) {
   const attrs = [];
   if (indent.startTwips !== null)
-    attrs.push(["w:left", `${indent.startTwips}`]);
+    attrs.push([wName("left"), `${indent.startTwips}`]);
   if (indent.hangingTwips !== null) {
-    attrs.push(["w:hanging", `${indent.hangingTwips}`]);
+    attrs.push([wName("hanging"), `${indent.hangingTwips}`]);
   } else if (indent.firstLineTwips !== null) {
-    attrs.push(["w:firstLine", `${indent.firstLineTwips}`]);
+    attrs.push([wName("firstLine"), `${indent.firstLineTwips}`]);
   }
   return attrs;
 }
-function attrsXml(tag, attrs) {
-  if (attrs.length === 0) return null;
-  const text = attrs.map(([name, value]) => `${name}="${escapeXml(value)}"`).join(" ");
-  return `<${tag} ${text}/>`;
-}
 function indXml(attrs) {
-  return attrsXml("w:ind", attrs);
+  return attrs.length === 0 ? null : elementXml(wName("ind"), attrs);
 }
 function nextIndXml(ind, change) {
   if (change.kind === "keep") return void 0;
   if (change.kind === "clearHanging") {
-    return indXml(keptIndAttrs(ind, HANGING_IND_ATTRS));
+    return indXml(withoutAttrs(attrPairs(ind), HANGING_IND_ATTRS));
   }
   const dropped = [...LEFT_IND_ATTRS, ...FIRST_LINE_IND_ATTRS];
   return indXml([
     ...levelIndAttrs(change.indent),
-    ...keptIndAttrs(ind, dropped)
+    ...withoutAttrs(attrPairs(ind), dropped)
   ]);
 }
 function leftIndAttrs(ind, leftTwips) {
-  const original = ind ? Array.from(ind.attributes) : [];
+  const original = attrPairs(ind);
   const slot = original.find(
-    (attr) => LEFT_TWIPS_IND_ATTRS.includes(localPart(attr.name))
-  )?.name;
-  const moved = original.flatMap((attr) => {
-    if (!LEFT_IND_ATTRS.includes(localPart(attr.name))) {
-      return [[attr.name, attr.value]];
-    }
-    return attr.name === slot && leftTwips > 0 ? [[attr.name, `${leftTwips}`]] : [];
-  });
-  return slot === void 0 && leftTwips > 0 ? [["w:left", `${leftTwips}`], ...moved] : moved;
+    ([name]) => LEFT_TWIPS_IND_ATTRS.includes(localPart(name))
+  )?.[0];
+  const written = leftTwips > 0 ? `${leftTwips}` : null;
+  const kept = withoutAttrs(
+    original,
+    LEFT_IND_ATTRS.filter(
+      (name) => slot === void 0 || name !== localPart(slot)
+    )
+  );
+  if (slot !== void 0) return setAttr(kept, "ind", localPart(slot), written);
+  return written === null ? kept : [[wName("left"), written], ...kept];
 }
 var EMPTY_P_PR = { tag: "w:pPr", attrs: null, children: [] };
 function editParagraphProps(pPr, styles, defaultStyleId, plan) {
   const props = pPr === null ? EMPTY_P_PR : parseProps(pPr);
   const element = pPr === null ? null : parsePropsXml(pPr);
   if (!props || pPr !== null && !element) return null;
-  const children = plan(element).reduce(
-    (kept, [name, xml]) => setPropsChild(kept, name, xml, P_PR_ORDER),
-    props.children
+  const rendered = renderProps(
+    plan(element).reduce(
+      (kept, [name, xml]) => setPropsChild(kept, name, xml, P_PR_ORDER),
+      props
+    )
   );
-  const rendered = renderProps({ ...props, children });
   const next = rendered === "" ? null : rendered;
   return {
     pPr: next,
@@ -116,19 +124,16 @@ function withLeftIndent(pPr, leftTwips, styles = NO_STYLES, defaultStyleId = nul
   });
 }
 function spacingAttrs(spacing, edits) {
-  const original = spacing ? Array.from(spacing.attributes) : [];
-  const editOf = (name) => edits.find(([edited]) => edited === localPart(name));
-  const changed = original.map((attr) => [
-    attr.name,
-    editOf(attr.name)?.[1] ?? attr.value
-  ]);
-  const added = edits.filter(
-    ([name]) => !original.some((attr) => localPart(attr.name) === name)
+  const changed = attrPairs(spacing).map(
+    ([name, value]) => [
+      name,
+      edits.find(([edited]) => edited === localPart(name))?.[1] ?? value
+    ]
+  );
+  return edits.reduce(
+    (attrs, [name, value]) => setAttr(attrs, "spacing", name, value),
+    changed
   );
-  return [
-    ...changed,
-    ...added.map(([name, value]) => [`w:${name}`, value])
-  ];
 }
 function withLineSpacing(pPr, spacing, styles = NO_STYLES, defaultStyleId = null) {
   const line = spacing.rule === "auto" ? Math.round(spacing.lines * 240) : Math.round(spacing.pt * 20);
@@ -138,11 +143,11 @@ function withLineSpacing(pPr, spacing, styles = NO_STYLES, defaultStyleId = null
       ["line", `${line}`],
       ["lineRule", spacing.rule]
     ]);
-    return [["spacing", attrsXml("w:spacing", attrs)]];
+    return [["spacing", elementXml(wName("spacing"), attrs)]];
   });
 }
 function withParagraphStyle(pPr, styleId, styles = NO_STYLES, defaultStyleId = null) {
-  const pStyle = styleId === null ? null : `<w:pStyle w:val="${escapeXml(styleId)}"/>`;
+  const pStyle = styleId === null ? null : elementXml(wName("pStyle"), [[wName("val"), styleId]]);
   return editParagraphProps(pPr, styles, defaultStyleId, () => [
     ["pStyle", pStyle]
   ]);
@@ -154,7 +159,7 @@ var JC_BY_ALIGN = {
   justify: "both"
 };
 function withParagraphAlign(pPr, align, styles = NO_STYLES, defaultStyleId = null) {
-  const jc = `<w:jc w:val="${JC_BY_ALIGN[align]}"/>`;
+  const jc = elementXml(wName("jc"), [[wName("val"), JC_BY_ALIGN[align]]]);
   return editParagraphProps(pPr, styles, defaultStyleId, () => [["jc", jc]]);
 }
 export {

package/dist/docx/propsXml.d.ts

@@ -10,12 +10,20 @@ export interface PropsChild {
     name: string;
     /** This child's original XML fragment exactly as it was */
     xml: string;
+    /**
+     * Whatever stood between the child before this one and this one: line breaks a producer laid
+     * out, comments, anything that is not an element. Carried so that rewriting one child does not
+     * quietly drop the rest of what the fragment said. Absent rather than empty when nothing did.
+     */
+    before?: string;
 }
 export interface Props {
     /** The opening tag name exactly as written (e.g. `w:tcPr`) */
     tag: string;
     attrs: string | null;
     children: PropsChild[];
+    /** The same, for what stood between the last child and the closing tag */
+    tail?: string;
 }
 /** The order the children are laid out in under `w:rPr` (CT_RPr) */
 export declare const RUN_PR_ORDER: readonly string[];
@@ -27,18 +35,28 @@ export declare const TC_PR_ORDER: readonly string[];
 export declare const TR_PR_ORDER: readonly string[];
 /** The order the children are laid out in under `w:tblPr` (CT_TblPr) */
 export declare const TBL_PR_ORDER: readonly string[];
+/**
+ * What stood inside a single element, and "" for one that stood empty or cannot be made out.
+ *
+ * The opening tag is read rather than scanned for, so a `>` inside an attribute value does not
+ * pass for the end of it.
+ */
+export declare function innerXml(xml: string): string;
 /**
  * Splits a formatting fragment into its opening tag and its list of children.
  * null if its shape cannot be made out (in which case leaving the original untouched is the safe move).
  */
 export declare function parseProps(xml: string): Props | null;
-/** With no children at all, the formatting fragment itself is not written */
+/**
+ * With nothing to say, the formatting fragment itself is not written. A fragment holding only
+ * whitespace says nothing; one holding a comment does, so it is written back.
+ */
 export declare function renderProps(props: Props): string;
 /**
  * Replaces a single child with new XML.
  * A null `xml` removes that child. A child that was not there goes into the spot the order calls for.
  */
-export declare function setPropsChild(children: PropsChild[], name: string, xml: string | null, order: readonly string[]): PropsChild[];
+export declare function setPropsChild(props: Props, name: string, xml: string | null, order: readonly string[]): Props;
 export declare function propsChild(children: PropsChild[], name: string): PropsChild | undefined;
 /**
  * Reads a single formatting fragment into an element.

package/dist/docx/propsXml.js

@@ -1,5 +1,10 @@
 // src/docx/propsXml.ts
-import { elementChildren, localPart, parseXml, W_NS } from "../ooxml/xml.js";
+import {
+  elementChildren,
+  localPart,
+  namespaceDecls,
+  parseXml
+} from "../ooxml/xml.js";
 var RUN_PR_ORDER = [
   "rStyle",
   "rFonts",
@@ -179,6 +184,12 @@ function attrsOf(source, tag) {
   const attrs = source.slice(tag.nameEnd, tag.end - closeLength).trim();
   return attrs.length > 0 ? attrs : null;
 }
+function innerXml(xml) {
+  const open = readTag(xml, 0);
+  if (!open || xml[0] !== "<" || open.kind !== "open") return "";
+  const close = xml.lastIndexOf("</");
+  return close > open.end ? xml.slice(open.end, close) : "";
+}
 function parseProps(xml) {
   const open = readTag(xml, 0);
   if (!open || xml[0] !== "<") return null;
@@ -192,6 +203,11 @@ function parseProps(xml) {
   let childStart = -1;
   let childName = "";
   let i = open.end;
+  let gapStart = open.end;
+  const gapBefore = (start) => {
+    const gap = xml.slice(gapStart, start);
+    return gap.length > 0 ? { before: gap } : {};
+  };
   while (i < xml.length) {
     const lt = xml.indexOf("<", i);
     if (lt === -1) return null;
@@ -204,15 +220,18 @@ function parseProps(xml) {
     if (depth === 0) {
       if (tag.kind === "close") {
         if (tag.name !== open.name || tag.end !== xml.length) return null;
-        return { tag: open.name, attrs, children };
+        const tail = xml.slice(gapStart, lt);
+        return tail.length > 0 ? { tag: open.name, attrs, children, tail } : { tag: open.name, attrs, children };
       }
       childStart = lt;
       childName = tag.name;
       if (tag.kind === "empty") {
         children.push({
           name: localPart(childName),
-          xml: xml.slice(childStart, tag.end)
+          xml: xml.slice(childStart, tag.end),
+          ...gapBefore(childStart)
         });
+        gapStart = tag.end;
       } else {
         depth = 1;
       }
@@ -223,8 +242,10 @@ function parseProps(xml) {
       if (depth === 0) {
         children.push({
           name: localPart(childName),
-          xml: xml.slice(childStart, tag.end)
+          xml: xml.slice(childStart, tag.end),
+          ...gapBefore(childStart)
         });
+        gapStart = tag.end;
       }
     }
     i = tag.end;
@@ -232,9 +253,11 @@ function parseProps(xml) {
   return null;
 }
 function renderProps(props) {
-  if (props.children.length === 0) return "";
+  const tail = props.tail ?? "";
+  if (props.children.length === 0 && tail.trim().length === 0) return "";
   const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
-  return open + props.children.map((child) => child.xml).join("") + `</${props.tag}>`;
+  const inner = props.children.map((child) => (child.before ?? "") + child.xml).join("");
+  return open + inner + tail + `</${props.tag}>`;
 }
 function insertIndex(children, name, order) {
   const target = order.indexOf(name);
@@ -248,37 +271,53 @@ function insertIndex(children, name, order) {
   }
   return children.length;
 }
-function setPropsChild(children, name, xml, order) {
-  const without = children.filter((child2) => child2.name !== name);
-  if (xml === null) return without;
-  const child = { name, xml };
-  const at = children.findIndex((entry) => entry.name === name);
-  if (at === -1) {
-    const index = insertIndex(without, name, order);
-    return [...without.slice(0, index), child, ...without.slice(index)];
+function dropChildren(children, name) {
+  const kept = [];
+  let carried = "";
+  for (const child of children) {
+    const before = carried + (child.before ?? "");
+    if (child.name === name) {
+      carried = before;
+      continue;
+    }
+    carried = "";
+    kept.push(
+      before === "" ? { name: child.name, xml: child.xml } : { ...child, before }
+    );
   }
-  return [
-    ...children.slice(0, at),
-    child,
-    ...children.slice(at + 1).filter((entry) => entry.name !== name)
-  ];
+  return { kept, carried };
 }
-function propsChild(children, name) {
-  return children.find((child) => child.name === name);
+function tailWith(props, carried) {
+  const tail = carried + (props.tail ?? "");
+  return tail === "" ? {} : { tail };
 }
-function namespaceDecls(xml) {
-  const prefixes = /* @__PURE__ */ new Set(["w"]);
-  for (const [, prefix] of xml.matchAll(/<\/?([A-Za-z_][\w.-]*):/g)) {
-    prefixes.add(prefix);
+function setPropsChild(props, name, xml, order) {
+  const at = props.children.findIndex((entry) => entry.name === name);
+  if (at !== -1 && xml !== null) {
+    const rest = dropChildren(props.children.slice(at + 1), name);
+    return {
+      ...props,
+      children: [
+        ...props.children.slice(0, at),
+        { ...props.children[at], xml },
+        ...rest.kept
+      ],
+      ...tailWith(props, rest.carried)
+    };
   }
-  for (const [, prefix] of xml.matchAll(/[\s"']([A-Za-z_][\w.-]*):[\w.-]+=/g)) {
-    prefixes.add(prefix);
+  const { kept, carried } = dropChildren(props.children, name);
+  if (xml === null) {
+    return { ...props, children: kept, ...tailWith(props, carried) };
   }
-  prefixes.delete("xml");
-  prefixes.delete("xmlns");
-  return Array.from(prefixes).map(
-    (prefix) => `xmlns:${prefix}="${prefix === "w" ? W_NS : `urn:docx-editor:${prefix}`}"`
-  ).join(" ");
+  const index = insertIndex(kept, name, order);
+  return {
+    ...props,
+    children: [...kept.slice(0, index), { name, xml }, ...kept.slice(index)],
+    ...tailWith(props, carried)
+  };
+}
+function propsChild(children, name) {
+  return children.find((child) => child.name === name);
 }
 function parsePropsXml(xml) {
   try {
@@ -294,6 +333,7 @@ export {
   TBL_PR_ORDER,
   TC_PR_ORDER,
   TR_PR_ORDER,
+  innerXml,
   parseProps,
   parsePropsXml,
   propsChild,

package/dist/docx/relationships.js

@@ -1,10 +1,10 @@
 // src/docx/relationships.ts
+import { elementXml } from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
 import {
   decodeUtf8,
   elementChildren,
   encodeUtf8,
-  escapeXml,
   parseXml
 } from "../ooxml/xml.js";
 var RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
@@ -48,8 +48,13 @@ function takeRelId(taken) {
   }
 }
 function relationshipXml(added) {
-  const mode = added.external ? ' TargetMode="External"' : "";
-  return `<Relationship Id="${added.id}" Type="${added.type}" Target="${escapeXml(added.target)}"${mode}/>`;
+  const mode = added.external ? [["TargetMode", "External"]] : [];
+  return elementXml("Relationship", [
+    ["Id", added.id],
+    ["Type", added.type],
+    ["Target", added.target],
+    ...mode
+  ]);
 }
 function relationshipsPart(original, added) {
   const entries = added.map(relationshipXml).join("");

package/dist/docx/runProps.js

@@ -1,7 +1,13 @@
 // src/docx/runProps.ts
 import { toRunFormat } from "../model/format.js";
+import {
+  attrPairs,
+  attrValue,
+  elementXml
+} from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
+import { setAttr } from "../ooxml/precedence.js";
 import { normalizeHex } from "../ooxml/units.js";
-import { escapeXml, localPart } from "../ooxml/xml.js";
 import { isEastAsianFontName } from "../styles/fontStack.js";
 import { fontNamesOf, readRunFormat } from "./formatting.js";
 import {
@@ -12,7 +18,6 @@ import {
   renderProps,
   setPropsChild
 } from "./propsXml.js";
-import { THEME_ATTRS } from "./theme.js";
 var TOGGLE_CHILDREN = {
   bold: ["b", "bCs"],
   italic: ["i", "iCs"],
@@ -32,11 +37,15 @@ var TOGGLE_OFF_VALUE = {
   strike: "0"
 };
 var MAX_FONT_SIZE_PT = 819;
-function elementXml(name, value) {
-  return value === null ? `<w:${name}/>` : `<w:${name} w:val="${value}"/>`;
+function valXml(name, value) {
+  return elementXml(wName(name), value === null ? [] : [[wName("val"), value]]);
 }
 function shadingXml(fill) {
-  return `<w:shd w:val="clear" w:color="auto" w:fill="${fill}"/>`;
+  return elementXml(wName("shd"), [
+    [wName("val"), "clear"],
+    [wName("color"), "auto"],
+    [wName("fill"), fill]
+  ]);
 }
 function halfPoints(pt) {
   if (!Number.isFinite(pt) || pt <= 0 || pt > MAX_FONT_SIZE_PT) return null;
@@ -53,29 +62,19 @@ function fontName(value) {
   const name = value.trim();
   return name.length > 0 && !/["';<>&]/.test(name) ? name : null;
 }
-function rFontsAttrs(xml) {
-  if (xml === null) return [];
-  const el = parsePropsXml(xml);
-  if (!el) return null;
-  return Array.from(el.attributes, (attr) => [
-    attr.name,
-    attr.value
-  ]);
-}
 function rFontsXml(current, name) {
-  const attrs = rFontsAttrs(current);
-  if (!attrs) return null;
-  const slots = fontSlots(
-    name,
-    attrs.some(([attr]) => localPart(attr) === "cs")
+  const el = current === null ? null : parsePropsXml(current);
+  if (current !== null && !el) return null;
+  const attrs = attrPairs(el);
+  const slots = fontSlots(name, attrValue(attrs, "cs") !== null);
+  const kept = slots.reduce(
+    (rest, slot) => setAttr(rest, "rFonts", slot, null),
+    attrs
   );
-  const dropped = slots.flatMap((slot) => [slot, ...THEME_ATTRS[slot] ?? []]);
-  const kept = attrs.filter(([attr]) => !dropped.includes(localPart(attr)));
-  const text = [
-    ...slots.map((slot) => [`w:${slot}`, name]),
+  return elementXml(wName("rFonts"), [
+    ...slots.map((slot) => [wName(slot), name]),
     ...kept
-  ].map(([attr, value]) => `${attr}="${escapeXml(value)}"`).join(" ");
-  return `<w:rFonts ${text}/>`;
+  ]);
 }
 function hasChild(xml, name) {
   if (xml === null) return false;
@@ -87,7 +86,7 @@ function propsOf(rPr) {
   return parseProps(rPr);
 }
 function offEdit(name, value, inherited) {
-  return [name, inherited ? elementXml(name, value) : null];
+  return [name, inherited ? valXml(name, value) : null];
 }
 function childEdits(edit, inherited, rFonts) {
   switch (edit.kind) {
@@ -95,7 +94,7 @@ function childEdits(edit, inherited, rFonts) {
       const names = TOGGLE_CHILDREN[edit.toggle];
       if (edit.on) {
         const value = TOGGLE_ON_VALUE[edit.toggle];
-        return names.map((name) => [name, elementXml(name, value)]);
+        return names.map((name) => [name, valXml(name, value)]);
       }
       const off = TOGGLE_OFF_VALUE[edit.toggle];
       return names.map((name) => offEdit(name, off, inherited));
@@ -110,8 +109,8 @@ function childEdits(edit, inherited, rFonts) {
       const half = halfPoints(edit.pt);
       if (half === null) return null;
       return [
-        ["sz", elementXml("sz", `${half}`)],
-        ["szCs", elementXml("szCs", `${half}`)]
+        ["sz", valXml("sz", `${half}`)],
+        ["szCs", valXml("szCs", `${half}`)]
       ];
     }
     case "fontFamily": {
@@ -124,7 +123,7 @@ function childEdits(edit, inherited, rFonts) {
     case "color": {
       if (edit.hex === null) return [offEdit("color", "auto", inherited)];
       const hex = normalizeHex(edit.hex);
-      return hex === null ? null : [["color", elementXml("color", hex)]];
+      return hex === null ? null : [["color", valXml("color", hex)]];
     }
     case "background": {
       const highlight = offEdit("highlight", "none", inherited);
@@ -162,11 +161,12 @@ function editRunProps(current, pPr, edit) {
   const rFonts = propsChild(props.children, "rFonts")?.xml ?? null;
   const edits = childEdits(edit, inherited, rFonts);
   if (!edits) return null;
-  const children = edits.reduce(
-    (kept, [name, xml]) => setPropsChild(kept, name, xml, RUN_PR_ORDER),
-    props.children
+  const rPr = renderProps(
+    edits.reduce(
+      (kept, [name, xml]) => setPropsChild(kept, name, xml, RUN_PR_ORDER),
+      props
+    )
   );
-  const rPr = renderProps({ ...props, children });
   return nextProps(rPr === "" ? null : rPr, current);
 }
 function isRunToggleOn(format, toggle) {