@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/protectionPolicy.d.ts

@@ -0,0 +1,127 @@
+/**
+ * What a protection level lets a change rewrite, as one value every side of the package reads.
+ *
+ * A level says three things: which parts of the package a change may write, what an entry in one
+ * of those parts may look like, and how the story reads once the markup the level is about is
+ * taken out of it. The part planners write those parts and the verifier judges them, and each
+ * carried its own copy of the first two with nothing but a test holding them together. Declaring
+ * them once means a part the writer starts adding is a part the verifier already knows.
+ *
+ * A level with no policy registered is one no file is judged under: `protectionPolicyFor` answers
+ * undefined, and a caller holding the level alone has nothing to run.
+ */
+import { type XmlParser } from "../ooxml/xml";
+import type { EditableComments, EditingProtection } from "../schema/protection";
+import { type DocxBytes } from "./importDocx";
+import type { SessionStore } from "./session";
+import { type Story } from "./storyProjection";
+/** One entry of a story part: the element read out of it, and its text for the byte-for-byte case */
+export interface StoryEntry {
+    el: Element;
+    xml: string;
+}
+/**
+ * How a part's entries are read.
+ *
+ * `arrived` is the reference a submission is held against rather than something to judge, so it
+ * takes what it can read and passes over the rest, leaving an entry standing on something
+ * unreadable to be judged as one that appeared. `submitted` is what is judged.
+ */
+export type EntryReading = "arrived" | "submitted";
+/** What a judgement may be told about the reader beyond the two documents */
+export interface PolicyOptions {
+    editableComments: EditableComments;
+}
+/** What a judgement over two files may be told beyond that */
+export interface VerifyOptions extends PolicyOptions {
+    xmlParser?: XmlParser;
+}
+/** One package part a protection lets an editor rewrite, and how a rewritten entry is judged */
+export interface StoryPartKind {
+    relType: string;
+    contentType: string;
+    /** Where the reader found this part, and null for a package that holds none */
+    pathIn(session: SessionStore): string | null;
+    /**
+     * Where the part goes when it is written: where it already sits, or the first name in the
+     * story's own folder that no part of the package has taken.
+     */
+    writePathIn(session: SessionStore): string;
+    /**
+     * The part's entries keyed by the id the story or a sibling part refers to them by, and null
+     * for a submitted part this editor's writer could not have put out at all.
+     */
+    entriesIn(session: SessionStore, reading: EntryReading): ReadonlyMap<string, StoryEntry> | null;
+    /**
+     * Whether the element the entries stand in came back as it left, save for the compatibility
+     * markup the writer declares on a part it writes a thread key into.
+     */
+    rootKept(before: SessionStore, after: SessionStore): boolean;
+    /** The keys this file still stands behind, which is what an entry has to be keyed by */
+    referents(story: Story): ReadonlySet<string>;
+    /** Grammar alone: whether the entry is one this editor's writer could have put out, whoever it belongs to */
+    wellFormed(entry: Element): boolean;
+    /**
+     * Whether the entry came back differing from the one that arrived in nothing but a change this
+     * protection leaves to everyone. Such an entry is nobody's rewrite, so it is held neither to
+     * the grammar this editor writes in nor to who owns it.
+     */
+    anyonesChange(entry: Element, original: Element): boolean;
+    /**
+     * Permission alone: whether `authorId` may have written (`original === null`) or rewritten this
+     * entry under `options`. `session` is the submission's, so a kind can look across at a sibling
+     * part, the way a comment's author resolves through the people part.
+     */
+    allowed(entry: Element, original: Element | null, authorId: string, options: PolicyOptions, session: SessionStore): boolean;
+}
+/** The two reasons the package comparison answers with, whatever the policy */
+export type PackageReason = "part-changed" | "relationship-changed";
+/**
+ * The shape every verdict takes: a story reason carries no part, a part reason names the part it
+ * was reached over. A public verdict keeps its own declaration and is one instance of this.
+ */
+export type ChangeVerdict<StoryReason extends string, PartReason extends string> = {
+    ok: true;
+} | {
+    ok: false;
+    reason: StoryReason;
+} | {
+    ok: false;
+    reason: PartReason;
+    part: string;
+};
+export interface ProtectionPolicy<StoryReason extends string, PartReason extends string> {
+    level: EditingProtection;
+    parts: readonly StoryPartKind[];
+    /** The reason a rewritten entry is refused under when no part takes it as well formed and allowed */
+    rejectedMarkup: PartReason;
+    /** Whether the story reads the same once this protection's own markup is taken out */
+    storyKept(before: Story, after: Story, authorId: string, options: PolicyOptions): ChangeVerdict<StoryReason, PartReason>;
+}
+/** Records the policy under its level and hands it back, so a module declares and registers at once */
+export declare function registerProtectionPolicy<S extends string, P extends string>(policy: ProtectionPolicy<S, P>): ProtectionPolicy<S, P>;
+/**
+ * The policy for a level, and undefined for a level no loaded module declares one for, `none` and
+ * `readOnly` among them.
+ */
+export declare function protectionPolicyFor(level: EditingProtection): ProtectionPolicy<string, string> | undefined;
+/**
+ * Whether the parts this protection lets an edit rewrite came back holding only entries this
+ * editor writes, each of them one this author was in a position to write.
+ *
+ * This runs after the story has been judged, so a comment rewritten, re-anchored or deleted by the
+ * wrong hand is already named for what it is. What is left to this is everything the story cannot
+ * show: markup forged into a body, an entry nothing refers to, an identity recorded for somebody
+ * else.
+ */
+export declare function partsKept<P extends string>(policy: ProtectionPolicy<string, P>, before: Story, after: Story, authorId: string, options: PolicyOptions): ChangeVerdict<never, P>;
+/**
+ * Whether the submitted file differs from the original in nothing this protection forbids.
+ *
+ * Both files are opened inside the one parser scope, so the parser named here is the parser both
+ * reads go through even though neither `importDocx` call is given it. The package is judged first,
+ * then the story, then the parts the policy excused from the package comparison: the parts are
+ * last so that an edit the wrong hand made is named for the edit rather than for the part it was
+ * written across.
+ */
+export declare function verifyChange<S extends string, P extends string>(policy: ProtectionPolicy<S, P>, original: DocxBytes, submitted: DocxBytes, authorId: string, { xmlParser, ...options }: VerifyOptions): ChangeVerdict<S, P | PackageReason>;

package/dist/docx/protectionPolicy.js

@@ -0,0 +1,169 @@
+// src/docx/protectionPolicy.ts
+import {
+  decodeUtf8,
+  elementChildren,
+  parseXml,
+  withXmlParser
+} from "../ooxml/xml.js";
+import { importDocx } from "./importDocx.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import {
+  readRelationships,
+  relsPathOf
+} from "./relationships.js";
+import { isModelledBlock } from "./storyProjection.js";
+var policies = /* @__PURE__ */ new Map();
+function registerProtectionPolicy(policy) {
+  policies.set(policy.level, policy);
+  return policy;
+}
+function protectionPolicyFor(level) {
+  return policies.get(level);
+}
+function sameBytes(before, after) {
+  return before.length === after.length && before.every((byte, index) => byte === after[index]);
+}
+function partPathsOf(policy, session) {
+  return policy.parts.map((kind) => kind.pathIn(session));
+}
+function excusedPaths(policy, session) {
+  return partPathsOf(policy, session).filter(
+    (path) => path !== null
+  );
+}
+function aroundTheStory(session) {
+  const preserved = session.blocks.filter((block) => !isModelledBlock(block.node)).map((block) => block.xml).join("");
+  return session.documentPrefix + preserved + session.documentSuffix;
+}
+function relationshipsKept(before, after, relTypes) {
+  if (new Set(before.map((entry) => entry.id)).size !== before.length || new Set(after.map((entry) => entry.id)).size !== after.length) {
+    return false;
+  }
+  const now = new Map(after.map((entry) => [entry.id, entry]));
+  const kept = before.every((entry) => {
+    const current = now.get(entry.id);
+    return current !== void 0 && current.type === entry.type && current.target === entry.target && current.external === entry.external;
+  });
+  const ids = new Set(before.map((entry) => entry.id));
+  const parts = after.filter((entry) => !entry.external);
+  return kept && after.filter((entry) => !ids.has(entry.id)).every(
+    (entry) => relTypes.includes(entry.type) && !entry.external && parts.filter((other) => other.type === entry.type).length === 1
+  );
+}
+function contentTypes(bytes) {
+  if (bytes === void 0) return /* @__PURE__ */ new Map();
+  const declared = /* @__PURE__ */ new Map();
+  for (const el of elementChildren(
+    parseXml(decodeUtf8(bytes).text).documentElement
+  )) {
+    const key = el.localName === "Default" ? el.getAttribute("Extension") : el.localName === "Override" ? el.getAttribute("PartName") : null;
+    if (key !== null) declared.set(key, el.getAttribute("ContentType") ?? "");
+  }
+  return declared;
+}
+function contentTypesKept(before, after, declarable) {
+  for (const [key, type] of before) {
+    if (after.get(key) !== type) return false;
+  }
+  for (const [key, type] of after) {
+    if (!before.has(key) && !declarable.includes(type)) return false;
+  }
+  return true;
+}
+function gainedPartsAreNew(policy, before, after) {
+  const had = partPathsOf(policy, before);
+  return partPathsOf(policy, after).every(
+    (path, kind) => path === null || path === had[kind] || !before.parts.has(path)
+  );
+}
+function packageKept(policy, before, after) {
+  if (before.mainPartPath !== after.mainPartPath) {
+    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+  }
+  const relsPath = relsPathOf(before.mainPartPath);
+  const untouched = /* @__PURE__ */ new Set([
+    before.mainPartPath,
+    relsPath,
+    CONTENT_TYPES_PATH,
+    ...excusedPaths(policy, before),
+    ...excusedPaths(policy, after)
+  ]);
+  for (const path of /* @__PURE__ */ new Set([...before.parts.keys(), ...after.parts.keys()])) {
+    if (untouched.has(path)) continue;
+    const was = before.parts.get(path);
+    const now = after.parts.get(path);
+    if (was === void 0 || now === void 0 || !sameBytes(was, now)) {
+      return { ok: false, reason: "part-changed", part: path };
+    }
+  }
+  if (!relationshipsKept(
+    readRelationships(before.parts, relsPath),
+    readRelationships(after.parts, relsPath),
+    policy.parts.map((kind) => kind.relType)
+  ) || !gainedPartsAreNew(policy, before, after)) {
+    return { ok: false, reason: "relationship-changed", part: relsPath };
+  }
+  if (!contentTypesKept(
+    contentTypes(before.parts.get(CONTENT_TYPES_PATH)),
+    contentTypes(after.parts.get(CONTENT_TYPES_PATH)),
+    policy.parts.map((kind) => kind.contentType)
+  )) {
+    return { ok: false, reason: "part-changed", part: CONTENT_TYPES_PATH };
+  }
+  if (aroundTheStory(before) !== aroundTheStory(after)) {
+    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+  }
+  return { ok: true };
+}
+function partKept(kind, before, after, authorId, options) {
+  const arrived = kind.entriesIn(before.session, "arrived") ?? /* @__PURE__ */ new Map();
+  const submitted = kind.entriesIn(after.session, "submitted");
+  if (submitted === null) return false;
+  if (!kind.rootKept(before.session, after.session)) return false;
+  const stoodBehindNow = kind.referents(after);
+  for (const [id, entry] of submitted) {
+    const original = arrived.get(id);
+    if (original && original.xml === entry.xml) continue;
+    if (!stoodBehindNow.has(id)) return false;
+    if (original && kind.anyonesChange(entry.el, original.el)) continue;
+    if (!kind.wellFormed(entry.el) || !kind.allowed(
+      entry.el,
+      original?.el ?? null,
+      authorId,
+      options,
+      after.session
+    )) {
+      return false;
+    }
+  }
+  const stoodBehindBefore = kind.referents(before);
+  return Array.from(arrived.keys()).every(
+    (id) => stoodBehindBefore.has(id) || submitted.has(id)
+  );
+}
+function partsKept(policy, before, after, authorId, options) {
+  for (const kind of policy.parts) {
+    const path = kind.pathIn(after.session) ?? kind.pathIn(before.session);
+    if (path === null) continue;
+    if (!partKept(kind, before, after, authorId, options)) {
+      return { ok: false, reason: policy.rejectedMarkup, part: path };
+    }
+  }
+  return { ok: true };
+}
+function verifyChange(policy, original, submitted, authorId, { xmlParser, ...options }) {
+  return withXmlParser(xmlParser, () => {
+    const before = importDocx(original);
+    const after = importDocx(submitted);
+    const packaged = packageKept(policy, before.session, after.session);
+    if (!packaged.ok) return packaged;
+    const story = policy.storyKept(before, after, authorId, options);
+    return story.ok ? partsKept(policy, before, after, authorId, options) : story;
+  });
+}
+export {
+  partsKept,
+  protectionPolicyFor,
+  registerProtectionPolicy,
+  verifyChange
+};

package/dist/docx/relationships.d.ts

@@ -20,7 +20,7 @@ export interface Relationship {
     /** Set when the target is a file outside the package */
     external: boolean;
 }
-export declare function readRelationships(parts: Map<string, Uint8Array>, relsPath: string): Relationship[];
+export declare function readRelationships(parts: ReadonlyMap<string, Uint8Array>, relsPath: string): Relationship[];
 /** A relationship an export puts in. The target is escaped here, so hand it in as it reads */
 export interface NewRelationship {
     type: string;

package/dist/docx/relationships.js

@@ -1,10 +1,10 @@
 // src/docx/relationships.ts
-import { DocxExportError } from "../ooxml/errors.js";
+import { elementXml } from "../ooxml/element.js";
+import { rootPrefixOf, splicePart } from "../ooxml/partSplice.js";
 import {
   decodeUtf8,
   elementChildren,
   encodeUtf8,
-  escapeXml,
   parseXml
 } from "../ooxml/xml.js";
 var RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
@@ -47,28 +47,28 @@ 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}/>`;
+function relationshipXml(added, prefix) {
+  const mode = added.external ? [["TargetMode", "External"]] : [];
+  return elementXml(`${prefix}Relationship`, [
+    ["Id", added.id],
+    ["Type", added.type],
+    ["Target", added.target],
+    ...mode
+  ]);
 }
 function relationshipsPart(original, added) {
-  const entries = added.map(relationshipXml).join("");
   if (!original) {
+    const entries2 = added.map((entry) => relationshipXml(entry, "")).join("");
     return encodeUtf8(
-      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS_NS}">${entries}</Relationships>`,
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS_NS}">${entries2}</Relationships>`,
       false
     );
   }
   const { text, hadBom } = decodeUtf8(original);
-  const closing = text.lastIndexOf("</Relationships>");
-  if (closing === -1) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "the relationships part has no closing tag"
-    );
-  }
+  const prefix = rootPrefixOf(text);
+  const entries = added.map((entry) => relationshipXml(entry, prefix)).join("");
   return encodeUtf8(
-    text.slice(0, closing) + entries + text.slice(closing),
+    splicePart(text, { root: "Relationships", append: entries }),
     hadBom
   );
 }

package/dist/docx/runProps.d.ts

@@ -5,30 +5,18 @@
  * even things we do not know about). So instead of building a new fragment we swap out just the one
  * child. It is the same principle `tableFormatting` applies to `w:tcPr`.
  *
+ * Which children a job swaps, and what it swaps them for, is the run property table's to say
+ * (`formatting/runProperties`); this module holds the surgery around it.
+ *
  * The display values produced here are used on screen only. What goes back into the document is
  * always the rPr string.
  */
 import { type RunFormat } from "../model/format";
+import { type EditableRunKey, type RunEdit } from "./formatting";
+export type { RunEdit } from "./formatting";
+export { matchesRunEdit } from "./formatting";
 /** The character formatting that is toggled on and off */
 export type RunToggle = "bold" | "italic" | "underline" | "strike";
-/** A job that changes one piece of character formatting. A null value means withdrawing the setting */
-export type RunEdit = {
-    kind: "toggle";
-    toggle: RunToggle;
-    on: boolean;
-} | {
-    kind: "fontSize";
-    pt: number | null;
-} | {
-    kind: "fontFamily";
-    name: string | null;
-} | {
-    kind: "color";
-    hex: string | null;
-} | {
-    kind: "background";
-    hex: string | null;
-};
 /** The formatting a run holds. The original XML and the display values derived from that XML form a pair */
 export interface RunProps {
     /** The whole `<w:rPr>...</w:rPr>` XML. null for a run with no formatting */
@@ -40,12 +28,11 @@ export declare function readRunProps(rPr: string | null): RunFormat | null;
 /**
  * The rPr and display values after changing one piece of character formatting.
  *
- * `pPr` is used only to see whether the paragraph points at a style.
+ * `inherited` is everything the layers below the run lay down (`inheritedRunFormat` in
+ * `formatting`), which decides whether an off is pinned down or the element simply removed.
  * null for an rPr whose shape could not be made out, or for a value that cannot be written into
  * the document, in which case the original is left untouched.
  */
-export declare function editRunProps(current: RunProps, pPr: string | null, edit: RunEdit): RunProps | null;
+export declare function editRunProps<K extends EditableRunKey>(current: RunProps, inherited: RunFormat, edit: RunEdit<K>): RunProps | null;
 /** Whether one of the toggled formats is on in these display values */
 export declare function isRunToggleOn(format: RunFormat | null, toggle: RunToggle): boolean;
-/** Whether this text is already in the state the job wants. If it already is, we leave it untouched */
-export declare function matchesRunEdit(format: RunFormat | null, edit: RunEdit): boolean;

package/dist/docx/runProps.js

@@ -1,140 +1,20 @@
 // src/docx/runProps.ts
 import { toRunFormat } from "../model/format.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 {
   parseProps,
   parsePropsXml,
-  propsChild,
-  RUN_PR_ORDER,
-  renderProps,
-  setPropsChild
-} from "./propsXml.js";
-import { THEME_ATTRS } from "./theme.js";
-var TOGGLE_CHILDREN = {
-  bold: ["b", "bCs"],
-  italic: ["i", "iCs"],
-  underline: ["u"],
-  strike: ["strike"]
-};
-var TOGGLE_ON_VALUE = {
-  bold: null,
-  italic: null,
-  underline: "single",
-  strike: null
-};
-var TOGGLE_OFF_VALUE = {
-  bold: "0",
-  italic: "0",
-  underline: "none",
-  strike: "0"
-};
-var MAX_FONT_SIZE_PT = 819;
-function elementXml(name, value) {
-  return value === null ? `<w:${name}/>` : `<w:${name} w:val="${value}"/>`;
-}
-function shadingXml(fill) {
-  return `<w:shd w:val="clear" w:color="auto" w:fill="${fill}"/>`;
-}
-function halfPoints(pt) {
-  if (!Number.isFinite(pt) || pt <= 0 || pt > MAX_FONT_SIZE_PT) return null;
-  const half = pt * 2;
-  return Number.isInteger(half) ? half : null;
-}
-var LATIN_SLOTS = ["ascii", "hAnsi"];
-var EAST_ASIAN_SLOTS = [...LATIN_SLOTS, "eastAsia"];
-function fontSlots(name, hasComplexScript) {
-  const slots = isEastAsianFontName(name) ? EAST_ASIAN_SLOTS : LATIN_SLOTS;
-  return hasComplexScript ? [...slots, "cs"] : slots;
-}
-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 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]),
-    ...kept
-  ].map(([attr, value]) => `${attr}="${escapeXml(value)}"`).join(" ");
-  return `<w:rFonts ${text}/>`;
-}
-function hasChild(xml, name) {
-  if (xml === null) return false;
-  const props = parseProps(xml);
-  return props !== null && propsChild(props.children, name) !== void 0;
-}
+  renderProps
+} from "../ooxml/props.js";
+import {
+  EMPTY_RUN_PROPS,
+  RUN_PROPERTIES,
+  readRunFormat,
+  runChildEdits,
+  withChildEdits
+} from "./formatting.js";
+import { matchesRunEdit } from "./formatting.js";
 function propsOf(rPr) {
-  if (rPr === null) return { tag: "w:rPr", attrs: null, children: [] };
-  return parseProps(rPr);
-}
-function offEdit(name, value, inherited) {
-  return [name, inherited ? elementXml(name, value) : null];
-}
-function childEdits(edit, inherited, rFonts) {
-  switch (edit.kind) {
-    case "toggle": {
-      const names = TOGGLE_CHILDREN[edit.toggle];
-      if (edit.on) {
-        const value = TOGGLE_ON_VALUE[edit.toggle];
-        return names.map((name) => [name, elementXml(name, value)]);
-      }
-      const off = TOGGLE_OFF_VALUE[edit.toggle];
-      return names.map((name) => offEdit(name, off, inherited));
-    }
-    case "fontSize": {
-      if (edit.pt === null) {
-        return [
-          ["sz", null],
-          ["szCs", null]
-        ];
-      }
-      const half = halfPoints(edit.pt);
-      if (half === null) return null;
-      return [
-        ["sz", elementXml("sz", `${half}`)],
-        ["szCs", elementXml("szCs", `${half}`)]
-      ];
-    }
-    case "fontFamily": {
-      if (edit.name === null) return [["rFonts", null]];
-      const name = fontName(edit.name);
-      if (name === null) return null;
-      const xml = rFontsXml(rFonts, name);
-      return xml === null ? null : [["rFonts", xml]];
-    }
-    case "color": {
-      if (edit.hex === null) return [offEdit("color", "auto", inherited)];
-      const hex = normalizeHex(edit.hex);
-      return hex === null ? null : [["color", elementXml("color", hex)]];
-    }
-    case "background": {
-      const highlight = offEdit("highlight", "none", inherited);
-      if (edit.hex === null) {
-        return [["shd", inherited ? shadingXml("auto") : null], highlight];
-      }
-      const hex = normalizeHex(edit.hex);
-      return hex === null ? null : [["shd", shadingXml(hex)], highlight];
-    }
-  }
+  return rPr === null ? EMPTY_RUN_PROPS : parseProps(rPr);
 }
 function readRunProps(rPr) {
   return rPr === null ? null : readRunFormat(parsePropsXml(rPr));
@@ -155,49 +35,16 @@ function nextProps(rPr, previous) {
   }
   return { rPr, format };
 }
-function editRunProps(current, pPr, edit) {
+function editRunProps(current, inherited, edit) {
   const props = propsOf(current.rPr);
   if (!props) return null;
-  const inherited = propsChild(props.children, "rStyle") !== void 0 || hasChild(pPr, "pStyle");
-  const rFonts = propsChild(props.children, "rFonts")?.xml ?? null;
-  const edits = childEdits(edit, inherited, rFonts);
+  const edits = runChildEdits(edit, { rPr: props, inherited });
   if (!edits) return null;
-  const children = edits.reduce(
-    (kept, [name, xml]) => setPropsChild(kept, name, xml, RUN_PR_ORDER),
-    props.children
-  );
-  const rPr = renderProps({ ...props, children });
+  const rPr = renderProps(withChildEdits(props, edits));
   return nextProps(rPr === "" ? null : rPr, current);
 }
 function isRunToggleOn(format, toggle) {
-  if (!format) return false;
-  if (toggle === "bold") return format.bold === true;
-  if (toggle === "italic") return format.italic === true;
-  if (toggle === "strike") return format.strike === true;
-  return format.underline !== void 0;
-}
-function matchesRunEdit(format, edit) {
-  switch (edit.kind) {
-    case "toggle":
-      return isRunToggleOn(format, edit.toggle) === edit.on;
-    case "fontSize":
-      return (format?.fontSizePt ?? null) === edit.pt;
-    case "fontFamily": {
-      const names = fontNamesOf(format?.fontFamily);
-      if (edit.name === null) return names.length === 0;
-      return names.length === 1 && names[0] === fontName(edit.name);
-    }
-    case "color": {
-      const current = format?.color ?? null;
-      if (current === null || edit.hex === null) return current === edit.hex;
-      return normalizeHex(current) === normalizeHex(edit.hex);
-    }
-    case "background": {
-      if (format?.highlight !== void 0) return false;
-      const fill = format?.background ? normalizeHex(format.background) : null;
-      return fill === (edit.hex === null ? null : normalizeHex(edit.hex));
-    }
-  }
+  return RUN_PROPERTIES[toggle].isOn(format ?? {});
 }
 export {
   editRunProps,