@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/packageParts.js

@@ -0,0 +1,135 @@
+// src/docx/packageParts.ts
+import { elementXml } from "../ooxml/element.js";
+import { DocxExportError } from "../ooxml/errors.js";
+import { rootPrefixOf, splicePart } from "../ooxml/partSplice.js";
+import {
+  decodeUtf8,
+  elementChildren,
+  encodeUtf8,
+  parseXml
+} from "../ooxml/xml.js";
+import {
+  directoryOf,
+  readRelationships,
+  relsPathOf,
+  resolveTarget
+} from "./relationships.js";
+var CONTENT_TYPES_PATH = "[Content_Types].xml";
+function relatedPartPath(parts, mainPartPath, type) {
+  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
+    (entry) => entry.type === type && !entry.external
+  );
+  return relationship === void 0 ? null : resolveTarget(mainPartPath, relationship.target);
+}
+function readPart(parts, path) {
+  const bytes = path === null ? void 0 : parts.get(path);
+  return bytes ? decodeUtf8(bytes).text : null;
+}
+function availablePartPath(parts, mainPartPath, stem) {
+  const directory = directoryOf(mainPartPath);
+  const taken = new Set(Array.from(parts.keys(), (path) => path.toLowerCase()));
+  for (let suffix = 0; ; suffix += 1) {
+    const path = `${directory}${stem}${suffix === 0 ? "" : suffix + 1}.xml`;
+    if (!taken.has(path.toLowerCase())) return path;
+  }
+}
+function declaredIn(text) {
+  let root;
+  try {
+    root = parseXml(text).documentElement;
+  } catch (cause) {
+    throw new DocxExportError(
+      "malformed-xml",
+      `${CONTENT_TYPES_PATH} could not be parsed`,
+      { cause }
+    );
+  }
+  const defaults = /* @__PURE__ */ new Set();
+  const overrides = /* @__PURE__ */ new Set();
+  const xmlDefaults = /* @__PURE__ */ new Set();
+  const xmlOverrides = /* @__PURE__ */ new Set();
+  for (const el of elementChildren(root)) {
+    const extension = el.getAttribute("Extension");
+    const partName = el.getAttribute("PartName");
+    const contentType = (el.getAttribute("ContentType") ?? "").split(";")[0].trim().toLowerCase();
+    const xml = contentType === "application/xml" || contentType === "text/xml" || contentType.endsWith("+xml");
+    if (el.localName === "Default" && extension !== null) {
+      defaults.add(extension.toLowerCase());
+      if (xml) xmlDefaults.add(extension.toLowerCase());
+    }
+    if (el.localName === "Override" && partName !== null) {
+      overrides.add(partName.toLowerCase());
+      if (xml) xmlOverrides.add(partName.toLowerCase());
+    }
+  }
+  return { defaults, overrides, xmlDefaults, xmlOverrides };
+}
+function declaredXmlParts(types, paths) {
+  const declared = declaredIn(decodeUtf8(types).text);
+  return new Set(
+    Array.from(paths).filter((path) => {
+      const name = `/${path}`.toLowerCase();
+      if (declared.overrides.has(name)) return declared.xmlOverrides.has(name);
+      const extension = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+      return declared.xmlDefaults.has(extension);
+    })
+  );
+}
+function contentTypeWriter(parts) {
+  const overrides = /* @__PURE__ */ new Map();
+  const defaults = /* @__PURE__ */ new Map();
+  return {
+    addOverride: (partPath, contentType) => {
+      const key = partPath.toLowerCase();
+      if (!overrides.has(key)) overrides.set(key, [partPath, contentType]);
+    },
+    addDefault: (extension, contentType) => {
+      const key = extension.toLowerCase();
+      if (!defaults.has(key)) defaults.set(key, [extension, contentType]);
+    },
+    part: () => {
+      if (overrides.size === 0 && defaults.size === 0) return null;
+      const original = parts.get(CONTENT_TYPES_PATH);
+      if (!original) {
+        throw new DocxExportError(
+          "missing-content-types",
+          `cannot declare a part in a package that has no ${CONTENT_TYPES_PATH}`
+        );
+      }
+      const { text, hadBom } = decodeUtf8(original);
+      const declared = declaredIn(text);
+      const prefix = rootPrefixOf(text);
+      const declarations = [
+        ...Array.from(defaults.values()).filter(
+          ([extension]) => !declared.defaults.has(extension.toLowerCase())
+        ).map(
+          ([extension, contentType]) => elementXml(`${prefix}Default`, [
+            ["Extension", extension],
+            ["ContentType", contentType]
+          ])
+        ),
+        ...Array.from(overrides.values()).filter(
+          ([partPath]) => !declared.overrides.has(`/${partPath}`.toLowerCase())
+        ).map(
+          ([partPath, contentType]) => elementXml(`${prefix}Override`, [
+            ["PartName", `/${partPath}`],
+            ["ContentType", contentType]
+          ])
+        )
+      ];
+      if (declarations.length === 0) return null;
+      return encodeUtf8(
+        splicePart(text, { root: "Types", prepend: declarations.join("") }),
+        hadBom
+      );
+    }
+  };
+}
+export {
+  CONTENT_TYPES_PATH,
+  availablePartPath,
+  contentTypeWriter,
+  declaredXmlParts,
+  readPart,
+  relatedPartPath
+};

package/dist/docx/pageGeometry.d.ts

@@ -21,6 +21,8 @@ export interface PageGeometry {
     marginTopTwips: number;
     marginBottomTwips: number;
 }
+/** CSS calls an inch 96 pixels, and a point is a 72nd of one */
+export declare const PX_PER_PT: number;
 export declare function twipsToPx(twips: number): number;
 /**
  * The paper a document that says nothing is drawn on: A4 portrait with the margins this

package/dist/docx/pageGeometry.js

@@ -1,8 +1,15 @@
 // src/docx/pageGeometry.ts
-import { toNumber, wAttr } from "../ooxml/units.js";
+import {
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure,
+  TWIPS_PER_INCH,
+  TWIPS_PER_PT
+} from "../ooxml/simpleTypes.js";
+import { wAttr } from "../ooxml/units.js";
 import { childByLocalName } from "../ooxml/xml.js";
-var TWIPS_PER_CM = 1440 / 2.54;
-var PX_PER_TWIP = 96 / 1440;
+var TWIPS_PER_CM = TWIPS_PER_INCH / 2.54;
+var PX_PER_PT = 96 / 72;
+var PX_PER_TWIP = PX_PER_PT / TWIPS_PER_PT;
 function cm(value) {
   return Math.round(value * TWIPS_PER_CM);
 }
@@ -34,13 +41,14 @@ function readPageGeometry(sectPr) {
   if (!sectPr) return A4_PORTRAIT;
   const pgSz = childByLocalName(sectPr, "pgSz");
   const pgMar = childByLocalName(sectPr, "pgMar");
-  const width = pgSz ? readSize(toNumber(wAttr(pgSz, "w"))) : null;
-  const height = pgSz ? readSize(toNumber(wAttr(pgSz, "h"))) : null;
+  const width = pgSz ? readSize(ST_TwipsMeasure.parse(wAttr(pgSz, "w"))) : null;
+  const height = pgSz ? readSize(ST_TwipsMeasure.parse(wAttr(pgSz, "h"))) : null;
   const readable = width !== null && height !== null;
-  const marginLeft = pgMar ? toNumber(wAttr(pgMar, "left")) : null;
-  const marginRight = pgMar ? toNumber(wAttr(pgMar, "right")) : null;
-  const marginTop = pgMar ? toNumber(wAttr(pgMar, "top")) : null;
-  const marginBottom = pgMar ? toNumber(wAttr(pgMar, "bottom")) : null;
+  const margin = (side) => pgMar ? ST_SignedTwipsMeasure.parse(wAttr(pgMar, side)) : null;
+  const marginLeft = margin("left");
+  const marginRight = margin("right");
+  const marginTop = margin("top");
+  const marginBottom = margin("bottom");
   const geometry = {
     widthTwips: readable ? width : A4_PORTRAIT.widthTwips,
     heightTwips: readable ? height : A4_PORTRAIT.heightTwips,
@@ -79,6 +87,7 @@ function firstSectPrIn(root) {
 export {
   A4_BODY_WIDTH,
   A4_PORTRAIT,
+  PX_PER_PT,
   bodyHeightTwips,
   bodyWidth,
   bodyWidthTwips,

package/dist/docx/paraProps.d.ts

@@ -5,14 +5,12 @@
  * When one paragraph is changed, the formatting we do not touch, such as tab stops and borders,
  * must stay as the original text wrote it. So we never rebuild the fragment; we change it one child
  * at a time, and within a child one attribute at a time.
- * The fragment we operated on is read back with the parser used when opening the document to build
- * the display values, and the style the paragraph points at is layered in the same order as it was
- * then. That way a changed paragraph's display values are the same as they would be after saving
- * and reopening.
+ * What the edited fragment is drawn with is not decided here: the caller hands the fragment to the
+ * resolver (`formatting/resolve`), the same one opening the document uses, so a changed paragraph's
+ * display values are the same as they would be after saving and reopening.
  */
-import type { LineSpacing, NumberingRef, ParagraphAlign, ParagraphFormat, RunFormat } from "../model/format";
+import type { LineSpacing, NumberingRef, ParagraphAlign } from "../model/format";
 import type { LevelIndent } from "../numbering/parseNumbering";
-import { type StyleTable } from "./formatting";
 /** What to do with the indents */
 export type IndentChange = 
 /** Leaves the indents the paragraph wrote down as they are */
@@ -33,32 +31,22 @@ export interface ListChange {
     numbering: NumberingRef | null;
     indent: IndentChange;
 }
-/** The paragraph formatting we operated on, and the display values read back out of it */
+/** The paragraph formatting we operated on. A null `pPr` is a fragment with nothing left in it */
 export interface ParagraphProps {
     pPr: string | null;
-    format: ParagraphFormat | null;
-    /** The character formatting the style the paragraph now wears lays down (`styleRun` in `schema`) */
-    styleRun: RunFormat | null;
 }
-/**
- * Reads the fragment we operated on back along the same path used when opening the document.
- *
- * The values of the style the paragraph wears are laid down underneath (the same order as import),
- * which for a paragraph pointing at no style of its own is the document's default paragraph style.
- */
-export declare function readParagraphProps(pPr: string | null, styles?: StyleTable, defaultStyleId?: string | null): ParagraphFormat | null;
-export declare function withListNumbering(pPr: string | null, change: ListChange, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withListNumbering(pPr: string | null, change: ListChange): ParagraphProps | null;
 /**
  * The result of moving the paragraph's own left indent to `leftTwips`.
  * Everything else the indent recorded - the hanging or first-line indent, the right indent -
  * stays as it was.
  */
-export declare function withLeftIndent(pPr: string | null, leftTwips: number, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withLeftIndent(pPr: string | null, leftTwips: number): ParagraphProps | null;
 /**
  * The result of changing the line spacing. The space above and below the paragraph is left as it was.
  * `auto` states the multiple in 240ths of a line; the other rules pin the height down in twips.
  */
-export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing): ParagraphProps | null;
 /**
  * The result of pointing the paragraph at a named style.
  * A null id takes the pStyle away, which is how the default style is worn.
@@ -66,9 +54,9 @@ export declare function withLineSpacing(pPr: string | null, spacing: LineSpacing
  * Nothing else in the fragment moves: as in Word, a style is applied by naming it and not by
  * copying its values into the paragraph, so the direct formatting written here keeps beating it.
  */
-export declare function withParagraphStyle(pPr: string | null, styleId: string | null, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withParagraphStyle(pPr: string | null, styleId: string | null): ParagraphProps | null;
 /**
  * The result of changing the paragraph alignment.
  * One alignment is always on, so we provide no way to withdraw the setting (the same as Word).
  */
-export declare function withParagraphAlign(pPr: string | null, align: ParagraphAlign, styles?: StyleTable, defaultStyleId?: string | null): ParagraphProps | null;
+export declare function withParagraphAlign(pPr: string | null, align: ParagraphAlign): ParagraphProps | null;

package/dist/docx/paraProps.js

@@ -1,19 +1,23 @@
 // src/docx/paraProps.ts
-import { childByLocalName, escapeXml, localPart } from "../ooxml/xml.js";
 import {
-  layerParagraphFormat,
-  layerRunFormat,
-  NO_STYLES,
-  paragraphStyleFormat,
-  readParagraphFormat
-} from "./formatting.js";
+  elementXml,
+  wAttrValue,
+  withoutAttrs
+} from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
+import { setAttr } from "../ooxml/precedence.js";
 import {
-  P_PR_ORDER,
+  childElement,
   parseProps,
-  parsePropsXml,
   renderProps,
-  setPropsChild
-} from "./propsXml.js";
+  setChild
+} from "../ooxml/props.js";
+import {
+  ST_DecimalNumber,
+  ST_SignedTwipsMeasure,
+  TWIPS_PER_PT
+} from "../ooxml/simpleTypes.js";
+import { LINE_UNITS_PER_LINE } from "./formatting.js";
 var LEFT_IND_ATTRS = ["left", "start", "leftChars", "startChars"];
 var LEFT_TWIPS_IND_ATTRS = ["left", "start"];
 var HANGING_IND_ATTRS = ["hanging", "hangingChars"];
@@ -22,130 +26,103 @@ var FIRST_LINE_IND_ATTRS = [
   "firstLine",
   "firstLineChars"
 ];
-function readParagraphProps(pPr, styles = NO_STYLES, defaultStyleId = null) {
-  const direct = pPr === null ? null : readParagraphFormat(parsePropsXml(pPr));
-  const style = paragraphStyleFormat(pPr, styles, defaultStyleId);
-  return layerParagraphFormat(style?.paragraph ?? {}, direct);
-}
-function readParagraphStyleRun(pPr, styles = NO_STYLES, defaultStyleId = null) {
-  const style = paragraphStyleFormat(pPr, styles, defaultStyleId);
-  return layerRunFormat(style?.run ?? {}, 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(ind, HANGING_IND_ATTRS));
   }
   const dropped = [...LEFT_IND_ATTRS, ...FIRST_LINE_IND_ATTRS];
   return indXml([
     ...levelIndAttrs(change.indent),
-    ...keptIndAttrs(ind, dropped)
+    ...withoutAttrs(ind, dropped)
   ]);
 }
-function leftIndAttrs(ind, leftTwips) {
-  const original = ind ? Array.from(ind.attributes) : [];
-  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;
+function leftIndAttrs(original, leftTwips) {
+  const slot = LEFT_TWIPS_IND_ATTRS.find(
+    (name) => wAttrValue(original, name) !== null
+  );
+  const written = leftTwips > 0 ? `${leftTwips}` : null;
+  const kept = withoutAttrs(
+    original,
+    LEFT_IND_ATTRS.filter((name) => name !== slot)
+  );
+  if (slot !== void 0) return setAttr(kept, "ind", 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) {
+function editParagraphProps(pPr, 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
+  if (!props) return null;
+  const edits = plan(props);
+  if (!edits) return null;
+  const rendered = renderProps(
+    edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), props)
   );
-  const rendered = renderProps({ ...props, children });
-  const next = rendered === "" ? null : rendered;
-  return {
-    pPr: next,
-    format: readParagraphProps(next, styles, defaultStyleId),
-    styleRun: readParagraphStyleRun(next, styles, defaultStyleId)
-  };
+  return { pPr: rendered === "" ? null : rendered };
 }
-function withListNumbering(pPr, change, styles = NO_STYLES, defaultStyleId = null) {
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const ind = nextIndXml(
-      element ? childByLocalName(element, "ind") : null,
-      change.indent
-    );
+function withListNumbering(pPr, change) {
+  return editParagraphProps(pPr, (props) => {
+    const current = childElement(props, "ind");
+    if (!current) return null;
+    const ind = nextIndXml(current.attrs, change.indent);
     const numPr = ["numPr", numPrXml(change.numbering)];
     return ind === void 0 ? [numPr] : [numPr, ["ind", ind]];
   });
 }
-function withLeftIndent(pPr, leftTwips, styles = NO_STYLES, defaultStyleId = null) {
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const ind = element ? childByLocalName(element, "ind") : null;
-    return [["ind", indXml(leftIndAttrs(ind, leftTwips))]];
+function withLeftIndent(pPr, leftTwips) {
+  return editParagraphProps(pPr, (props) => {
+    const ind = childElement(props, "ind");
+    if (!ind) return null;
+    return [["ind", indXml(leftIndAttrs(ind.attrs, leftTwips))]];
   });
 }
 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)
+  return edits.reduce(
+    (attrs, [name, value]) => setAttr(attrs, "spacing", name, value),
+    spacing
   );
-  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);
-  return editParagraphProps(pPr, styles, defaultStyleId, (element) => {
-    const current = element ? childByLocalName(element, "spacing") : null;
-    const attrs = spacingAttrs(current, [
-      ["line", `${line}`],
+function withLineSpacing(pPr, spacing) {
+  const line = spacing.rule === "auto" ? ST_DecimalNumber.format(Math.round(spacing.lines * LINE_UNITS_PER_LINE)) : ST_SignedTwipsMeasure.format(Math.round(spacing.pt * TWIPS_PER_PT));
+  if (line === null) return null;
+  return editParagraphProps(pPr, (props) => {
+    const current = childElement(props, "spacing");
+    if (!current) return null;
+    const attrs = spacingAttrs(current.attrs, [
+      ["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)}"/>`;
-  return editParagraphProps(pPr, styles, defaultStyleId, () => [
-    ["pStyle", pStyle]
-  ]);
+function withParagraphStyle(pPr, styleId) {
+  const pStyle = styleId === null ? null : elementXml(wName("pStyle"), [[wName("val"), styleId]]);
+  return editParagraphProps(pPr, () => [["pStyle", pStyle]]);
 }
 var JC_BY_ALIGN = {
   left: "left",
@@ -153,12 +130,11 @@ var JC_BY_ALIGN = {
   right: "right",
   justify: "both"
 };
-function withParagraphAlign(pPr, align, styles = NO_STYLES, defaultStyleId = null) {
-  const jc = `<w:jc w:val="${JC_BY_ALIGN[align]}"/>`;
-  return editParagraphProps(pPr, styles, defaultStyleId, () => [["jc", jc]]);
+function withParagraphAlign(pPr, align) {
+  const jc = elementXml(wName("jc"), [[wName("val"), JC_BY_ALIGN[align]]]);
+  return editParagraphProps(pPr, () => [["jc", jc]]);
 }
 export {
-  readParagraphProps,
   withLeftIndent,
   withLineSpacing,
   withListNumbering,

package/dist/docx/partPlan.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The contract every part an export writes beside the body is written under.
+ *
+ * A planner answers with the parts it rewrites, keyed by path, and declares what a part it adds
+ * needs through the two writers the context carries: a relationship from the main part and a
+ * content type. Those two parts are written once at the end from everything every planner asked
+ * for, so no planner writes either of them itself and none can write over what another declared.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ContentTypeWriter } from "./packageParts";
+import { type RelationshipWriter } from "./relationships";
+import type { SessionStore } from "./session";
+export interface PartPlanContext {
+    readonly relationships: RelationshipWriter;
+    readonly contentTypes: ContentTypeWriter;
+}
+export interface PartPlanner {
+    readonly name: string;
+    /** The parts to write, keyed by path, and null when the document gives this planner nothing to write */
+    plan(doc: PMNode, session: SessionStore, context: PartPlanContext): ReadonlyMap<string, Uint8Array> | null;
+}
+/**
+ * Every part the planners write, folded into one map in planner order.
+ *
+ * The body and context-owned parts are reserved. Earlier writes include media planned before
+ * the body, so no later planner can overwrite those bytes either. Part names are compared
+ * without regard to case, as package part names are.
+ */
+export declare function runPartPlanners(planners: readonly PartPlanner[], doc: PMNode, session: SessionStore, context: PartPlanContext, prior?: ReadonlyMap<string, Uint8Array>): Map<string, Uint8Array>;
+/**
+ * Every rewritten XML part has to read back as XML, and a refusal names the part.
+ *
+ * The parts are spliced as text, so this is where a splice that cut in the wrong place shows up:
+ * before the package is repacked rather than when somebody opens it.
+ */
+export declare function assertPartsParse(replacements: ReadonlyMap<string, Uint8Array>, contentTypes?: Uint8Array): void;

package/dist/docx/partPlan.js

@@ -0,0 +1,59 @@
+// src/docx/partPlan.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { decodeUtf8, parseXml } from "../ooxml/xml.js";
+import {
+  CONTENT_TYPES_PATH,
+  declaredXmlParts
+} from "./packageParts.js";
+import { relsPathOf } from "./relationships.js";
+function runPartPlanners(planners, doc, session, context, prior = /* @__PURE__ */ new Map()) {
+  const owned = new Set(
+    [
+      CONTENT_TYPES_PATH,
+      relsPathOf(session.mainPartPath),
+      session.mainPartPath
+    ].map((path) => path.toLowerCase())
+  );
+  const parts = new Map(prior);
+  const written = new Set(
+    Array.from(prior.keys(), (path) => path.toLowerCase())
+  );
+  for (const planner of planners) {
+    for (const [path, bytes] of planner.plan(doc, session, context) ?? []) {
+      if (owned.has(path.toLowerCase())) {
+        throw new Error(
+          `the ${planner.name} planner wrote ${path}, which another export writer owns`
+        );
+      }
+      if (written.has(path.toLowerCase())) {
+        throw new Error(
+          `the ${planner.name} planner wrote ${path}, which an earlier writer wrote already`
+        );
+      }
+      parts.set(path, bytes);
+      written.add(path.toLowerCase());
+    }
+  }
+  return parts;
+}
+var XML_PART = /\.(?:xml|rels)$/i;
+function assertPartsParse(replacements, contentTypes) {
+  const paths = [...replacements.keys()];
+  const declared = contentTypes && paths.some((path) => !XML_PART.test(path)) ? declaredXmlParts(contentTypes, paths) : /* @__PURE__ */ new Set();
+  for (const [path, bytes] of replacements) {
+    if (!XML_PART.test(path) && !declared.has(path)) continue;
+    try {
+      parseXml(decodeUtf8(bytes).text);
+    } catch (cause) {
+      throw new DocxExportError(
+        "malformed-xml",
+        `${path} as written could not be parsed`,
+        { cause }
+      );
+    }
+  }
+}
+export {
+  assertPartsParse,
+  runPartPlanners
+};