@portone/docx-editor 0.2.1 → 0.4.0

package/dist/docx/importTable.js

@@ -1,8 +1,4 @@
 // src/docx/importTable.ts
-import {
-  toCellMargins,
-  toInsideBorders
-} from "../model/format.js";
 import { childValue, wAttr } from "../ooxml/units.js";
 import {
   attrString,
@@ -13,7 +9,10 @@ import {
 import { docxSchema } from "../schema/index.js";
 import {
   layerTableFormat,
-  NO_STYLES
+  NO_FORMATTING,
+  styledParagraph,
+  tableStyleAttrs,
+  tableStyleFor
 } from "./formatting.js";
 import {
   buildParagraph,
@@ -21,18 +20,22 @@ import {
 } from "./importParagraph.js";
 import { readSdtWrapper } from "./sdt.js";
 import {
-  cellBorderDefaults,
-  gridEdgesOf,
+  cellConditionsOf,
+  cellDefaultsFor,
+  layerBandSizes,
   layerCellMargins,
   layerInsideBorders,
+  NO_BAND_SIZES,
   NO_CELL_MARGINS,
   NO_INSIDE_BORDERS,
+  readBandSizes,
   readCellFormat,
   readCellMarginsOf,
   readGridCols,
   readInsideBorders,
   readRowFormat,
   readTableFormat,
+  readTableLook,
   readTableWidth,
   tblStyleIdOf
 } from "./tableFormatting.js";
@@ -86,9 +89,23 @@ function readRow(el) {
   }
   return cells.length > 0 ? { el, tblPrEx, cells } : null;
 }
+function gridRevisionXml(grid) {
+  const revision = childByLocalName(grid, "tblGridChange");
+  if (revision === null) return null;
+  const declarations = Array.from(grid.attributes).filter(
+    (attr) => attr.namespaceURI === "http://www.w3.org/2000/xmlns/" && !revision.hasAttribute(attr.name)
+  );
+  if (declarations.length === 0) return serializeXml(revision);
+  const preserved = revision.ownerDocument.importNode(revision, true);
+  for (const attr of declarations) {
+    preserved.setAttributeNS(attr.namespaceURI, attr.name, attr.value);
+  }
+  return serializeXml(preserved);
+}
 function readTableParts(el) {
   let tblPr = null;
   let tblGrid = null;
+  let gridChange = null;
   const rows = [];
   for (const child of elementChildren(el)) {
     if (child.localName === "tblPr") {
@@ -97,6 +114,7 @@ function readTableParts(el) {
     }
     if (child.localName === "tblGrid") {
       tblGrid = child;
+      gridChange = gridRevisionXml(child);
       continue;
     }
     if (child.localName !== "tr") return null;
@@ -104,7 +122,7 @@ function readTableParts(el) {
     if (!row) return null;
     rows.push(row);
   }
-  return rows.length > 0 ? { tblPr, tblGrid, rows } : null;
+  return rows.length > 0 ? { tblPr, tblGrid, gridChange, rows } : null;
 }
 function resolveVerticalMerges(rows, width) {
   const drafts = [];
@@ -147,37 +165,31 @@ function gridWidthOf(rows) {
   const first = widths[0];
   return widths.every((width) => width === first) ? first : null;
 }
-function buildCellBlock(el, sources) {
+function buildCellBlock(el, sources, context, placement) {
   if (el.localName === "p") {
     const paragraph = buildParagraph(el, null, sources);
-    if (paragraph) return paragraph;
+    if (paragraph) return styledParagraph(paragraph, context, placement);
   }
   return docxSchema.nodes.rawBlock.create({
     xml: serializeXml(el),
     name: el.nodeName
   });
 }
-function cellBorderDefaultsFor(draft, lines) {
-  return cellBorderDefaults(
-    gridEdgesOf(
-      {
-        top: draft.row,
-        bottom: draft.row + draft.rowspan,
-        left: draft.col,
-        right: draft.col + draft.colspan
-      },
-      lines
-    ),
-    lines.outer,
-    lines.inside
-  );
+function cellRect(draft) {
+  return {
+    top: draft.row,
+    bottom: draft.row + draft.rowspan,
+    left: draft.col,
+    right: draft.col + draft.colspan
+  };
 }
-function buildCell(draft, lines, sources) {
+function buildCell(draft, table, sources, context) {
   const tcPr = childByLocalName(draft.el, "tcPr");
+  const defaults = cellDefaultsFor(cellRect(draft), table.grid, table.sources);
   const blocks = [];
   for (const child of elementChildren(draft.el)) {
     if (child.localName === "tcPr") continue;
-    blocks.push(buildCellBlock(child, sources));
+    blocks.push(buildCellBlock(child, sources, context, defaults.placement));
   }
   if (blocks.length === 0) return null;
   return docxSchema.nodes.tableCell.create(
@@ -188,11 +200,7 @@ function buildCell(draft, lines, sources) {
       tcAttrs: attrString(draft.el),
       tcPr: tcPr ? serializeXml(tcPr) : null,
       tcW: readTableWidth(tcPr, "tcW"),
-      format: readCellFormat(
-        tcPr,
-        cellBorderDefaultsFor(draft, lines),
-        lines.margins
-      ),
+      format: readCellFormat(tcPr, defaults),
       sdtPrefix: draft.control?.prefix ?? null,
       sdtContentsLocked: draft.control?.contentsLocked ?? false,
       sdtDeletionLocked: draft.control?.deletionLocked ?? false
@@ -200,10 +208,10 @@ function buildCell(draft, lines, sources) {
     blocks
   );
 }
-function buildRow(row, drafts, lines, sources) {
+function buildRow(row, drafts, table, sources, context) {
   const cells = [];
   for (const draft of drafts) {
-    const cell = buildCell(draft, lines, sources);
+    const cell = buildCell(draft, table, sources, context);
     if (!cell) return null;
     cells.push(cell);
   }
@@ -218,11 +226,7 @@ function buildRow(row, drafts, lines, sources) {
     cells
   );
 }
-function tableStyleOf(tblPr, styles, defaultTableStyleId) {
-  const styleId = tblStyleIdOf(tblPr);
-  return (styleId !== null ? styles.get(styleId) : void 0) ?? (defaultTableStyleId !== null ? styles.get(defaultTableStyleId) : void 0);
-}
-function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES, defaultTableStyleId = null) {
+function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, context = NO_FORMATTING) {
   const parts = readTableParts(el);
   if (!parts) return null;
   const gridCols = readGridCols(parts.tblGrid);
@@ -231,27 +235,38 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES,
   if (gridCols.length > 0 && gridCols.length !== width) return null;
   const drafts = resolveVerticalMerges(parts.rows, width);
   if (!drafts) return null;
-  const style = tableStyleOf(parts.tblPr, styles, defaultTableStyleId);
+  const styleId = tblStyleIdOf(parts.tblPr);
+  const style = tableStyleFor(styleId, context);
   const tableFormat = layerTableFormat(
     style?.table ?? {},
     readTableFormat(parts.tblPr)
   );
-  const lines = {
-    rows: parts.rows.length,
-    cols: width,
-    outer: tableFormat,
-    inside: layerInsideBorders(
-      style?.tableInside ?? NO_INSIDE_BORDERS,
-      readInsideBorders(parts.tblPr)
-    ),
-    margins: layerCellMargins(
-      style?.tableCellMargins ?? NO_CELL_MARGINS,
-      readCellMarginsOf(parts.tblPr, "tblCellMar")
-    )
+  const bands = layerBandSizes(
+    style?.tableBands ?? NO_BAND_SIZES,
+    readBandSizes(parts.tblPr)
+  );
+  const conditions = cellConditionsOf(style?.tableConditions ?? {});
+  const table = {
+    grid: { rows: parts.rows.length, cols: width },
+    sources: {
+      outer: tableFormat,
+      inside: layerInsideBorders(
+        style?.tableInside ?? NO_INSIDE_BORDERS,
+        readInsideBorders(parts.tblPr)
+      ),
+      margins: layerCellMargins(
+        style?.tableCellMargins ?? NO_CELL_MARGINS,
+        readCellMarginsOf(parts.tblPr, "tblCellMar")
+      ),
+      look: readTableLook(parts.tblPr),
+      bands,
+      conditions,
+      styleId
+    }
   };
   const rows = [];
   for (const [index, row] of parts.rows.entries()) {
-    const built = buildRow(row, drafts[index], lines, sources);
+    const built = buildRow(row, drafts[index], table, sources, context);
     if (!built) return null;
     rows.push(built);
   }
@@ -262,10 +277,8 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES,
       tblPr: parts.tblPr ? serializeXml(parts.tblPr) : null,
       tblW: readTableWidth(parts.tblPr, "tblW"),
       gridCols,
-      format: tableFormat,
-      // The cells need these again whenever an edit derives their display values afresh
-      styleInside: toInsideBorders(style?.tableInside),
-      styleCellMargins: toCellMargins(style?.tableCellMargins)
+      gridChange: parts.gridChange,
+      ...tableStyleAttrs(parts.tblPr, context)
     },
     rows
   );

package/dist/docx/invariants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Known export refusals, asked of the document before anything is written.
+ *
+ * Each invariant reads what the writer would refuse over and reports it with the code the writer
+ * would throw, so a screen can ask at edit time what `exportDocx` would say. The list is walked in
+ * order and `exportDocx` throws its first entry, which is what keeps the two from disagreeing.
+ *
+ * The checks inspect model attrs and preserved XML without running the writers. Bookmark
+ * fragments and list definitions use the export parser. `assertBookmarkPairs` in `./exportDocx`
+ * and `assertPartsParse` in `./partPlan` remain the final checks over the parts as actually written.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { DocxExportErrorCode } from "../ooxml/errors";
+import type { ExportOptions } from "./exportDocx";
+import { type DocxSession, type SessionStore } from "./session";
+/** One reason the document cannot be written back, with the code `exportDocx` would throw it under */
+export interface ExportProblem {
+    readonly code: DocxExportErrorCode;
+    readonly message: string;
+    /** Where the problem stands in the document. Absent for a problem of the package or of the session */
+    readonly pos?: number;
+}
+/** The problems as the writer sees them, for a caller already inside the writer's parser scope */
+export declare function problemsOf(doc: PMNode, session: SessionStore): readonly ExportProblem[];
+/**
+ * Known reasons writing this document back would be refused, in the order `exportDocx` would
+ * raise them. An empty list does not rule out failures while writing. Each entry carries the code and message the
+ * `DocxExportError` would carry, and the position in the document where there is one.
+ *
+ * The list definitions are read to tell a new list from one the document already had, so this
+ * needs an XML parser the way `exportDocx` does and takes the same option.
+ */
+export declare function exportProblems(doc: PMNode, session: DocxSession, options?: ExportOptions): readonly ExportProblem[];

package/dist/docx/invariants.js

@@ -0,0 +1,269 @@
+// src/docx/invariants.ts
+import { spanCount, toParagraphFormat } from "../model/format.js";
+import {
+  attributeByLocalName,
+  parseXml,
+  W_NS,
+  withXmlParser
+} from "../ooxml/xml.js";
+import {
+  commentReferencesIn,
+  commentsChanged,
+  commentsRootProblem,
+  extensionsChanged,
+  extensionsRootProblem
+} from "./comments.js";
+import {
+  commentsExtendedPart,
+  commentsPart,
+  peoplePart
+} from "./comments/parts.js";
+import { unrecordedAuthors } from "./comments/people.js";
+import { currentCommentBodies } from "./comments/writing.js";
+import { identityProblems } from "./identities.js";
+import { insertedImageSrcs } from "./media.js";
+import { canDefineNewList, newNumIds, startedLists } from "./newLists.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import { lostOriginal } from "./serializeBlock.js";
+import {
+  originalBlock,
+  sessionOf
+} from "./session.js";
+function markerSourceOf(node, session) {
+  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+    return typeof node.attrs.xml === "string" ? node.attrs.xml : null;
+  }
+  if (node.type.isInGroup("preserved")) {
+    return originalBlock(node, session)?.xml ?? null;
+  }
+  return null;
+}
+var bookmarkPairs = {
+  name: "bookmarkPairs",
+  check(doc, session) {
+    const problems = [];
+    const open = /* @__PURE__ */ new Map();
+    const used = /* @__PURE__ */ new Set();
+    doc.descendants((node, pos) => {
+      const source = markerSourceOf(node, session);
+      if (source === null) return true;
+      if (!source.includes("bookmark")) return true;
+      let root;
+      try {
+        root = parseXml(
+          session.documentPrefix + source + session.documentSuffix
+        ).documentElement;
+      } catch {
+        problems.push({
+          code: "malformed-xml",
+          message: "preserved bookmark XML could not be parsed",
+          pos
+        });
+        return true;
+      }
+      for (const marker of Array.from(root.getElementsByTagName("*"))) {
+        if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
+          continue;
+        const kind = marker.localName.slice("bookmark".length);
+        const value = attributeByLocalName(marker, "id");
+        if (value === null || value === "") {
+          problems.push({
+            code: "malformed-xml",
+            message: `a bookmark${kind} has no id`,
+            pos
+          });
+        } else if (kind === "Start") {
+          if (used.has(value)) {
+            problems.push({
+              code: "malformed-xml",
+              message: `bookmark ${value} has more than one start marker`,
+              pos
+            });
+          } else {
+            open.set(value, pos);
+            used.add(value);
+          }
+        } else if (!open.delete(value)) {
+          problems.push({
+            code: "malformed-xml",
+            message: `bookmark ${value} ends without an earlier start marker`,
+            pos
+          });
+        }
+      }
+      return true;
+    });
+    for (const [id, pos] of open) {
+      problems.push({
+        code: "malformed-xml",
+        message: `bookmark ${id} has no end marker`,
+        pos
+      });
+    }
+    return problems;
+  }
+};
+function mergeReachesPastLastRow(table) {
+  let overlong = false;
+  table.forEach((row, _offset, at) => {
+    row.forEach((cell) => {
+      if (at + spanCount(cell.attrs.rowspan) > table.childCount) {
+        overlong = true;
+      }
+    });
+  });
+  return overlong;
+}
+var tableGrids = {
+  name: "tableGrids",
+  check(doc) {
+    const problems = [];
+    doc.descendants((node, pos) => {
+      if (node.type.name !== "table") return true;
+      if (mergeReachesPastLastRow(node)) {
+        problems.push({
+          code: "invalid-table",
+          message: "a vertical merge in the table reaches past the last row",
+          pos
+        });
+      }
+      return true;
+    });
+    return problems;
+  }
+};
+function lostOriginalOf(node, session) {
+  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+    return typeof node.attrs.xml === "string" ? null : "a preserved element has lost its original XML";
+  }
+  if (node.type.isInGroup("preserved")) {
+    return originalBlock(node, session) ? null : lostOriginal(node, session);
+  }
+  return null;
+}
+var preservedOriginals = {
+  name: "preservedOriginals",
+  check(doc, session) {
+    const problems = [];
+    doc.descendants((node, pos) => {
+      const message = lostOriginalOf(node, session);
+      if (message !== null)
+        problems.push({ code: "lost-original", message, pos });
+      return true;
+    });
+    return problems;
+  }
+};
+var uniqueIdentities = {
+  name: "uniqueIdentities",
+  check(doc) {
+    return identityProblems(doc);
+  }
+};
+var listDefinitions = {
+  name: "listDefinitions",
+  check(doc, session) {
+    const undefinedIds = new Set(startedLists(doc, session).unregistered);
+    if (undefinedIds.size === 0) return [];
+    const problems = [];
+    doc.descendants((node, pos) => {
+      if (node.type.name !== "paragraph") return true;
+      const numId = toParagraphFormat(node.attrs.format)?.numbering?.numId;
+      if (numId === void 0 || !undefinedIds.delete(numId)) return false;
+      problems.push({
+        code: "unsupported-content",
+        message: `the list numbered ${numId} has no definition to be written`,
+        pos
+      });
+      return false;
+    });
+    return problems;
+  }
+};
+function addsCommentsPart(doc, session) {
+  const bodyChanged = commentsChanged(doc, session);
+  const threadChanged = extensionsChanged(doc, session);
+  if (!bodyChanged && !threadChanged) return false;
+  if (commentsPart.pathIn(session) === null || session.comments.xml === null)
+    return true;
+  const references = commentReferencesIn(doc);
+  if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null) && (commentsExtendedPart.pathIn(session) === null || session.comments.extendedXml === null))
+    return true;
+  return bodyChanged && (peoplePart.pathIn(session) === null || session.comments.people.xml === null) && unrecordedAuthors(
+    currentCommentBodies(references).values(),
+    session.comments.people
+  ).size > 0;
+}
+var mediaContentTypes = {
+  name: "mediaContentTypes",
+  check(doc, session) {
+    if (session.parts.has(CONTENT_TYPES_PATH)) return [];
+    const problems = [];
+    if (insertedImageSrcs(doc).length > 0) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
+    if (!canDefineNewList(session) && newNumIds(doc, session).length > 0) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
+    if (addsCommentsPart(doc, session)) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
+    return problems;
+  }
+};
+var commentPartRoots = {
+  name: "commentPartRoots",
+  check(doc, session) {
+    const problems = [];
+    const { xml, extendedXml, extendedPartPath } = session.comments;
+    if (xml !== null && commentsChanged(doc, session)) {
+      const problem = commentsRootProblem(xml);
+      if (problem !== null)
+        problems.push({ code: "malformed-xml", message: problem });
+    }
+    if (extendedXml !== null && extensionsChanged(doc, session) && (commentReferencesIn(doc).size > 0 || extendedPartPath !== null)) {
+      const problem = extensionsRootProblem(extendedXml);
+      if (problem !== null)
+        problems.push({ code: "malformed-xml", message: problem });
+    }
+    return problems;
+  }
+};
+var EXPORT_INVARIANTS = [
+  bookmarkPairs,
+  tableGrids,
+  preservedOriginals,
+  uniqueIdentities,
+  listDefinitions,
+  mediaContentTypes,
+  commentPartRoots
+];
+var answered = /* @__PURE__ */ new WeakMap();
+function problemsOf(doc, session) {
+  const known = answered.get(doc);
+  if (known && known.session === session) return known.problems;
+  const problems = EXPORT_INVARIANTS.flatMap(
+    (invariant) => invariant.check(doc, session)
+  );
+  answered.set(doc, { session, problems });
+  return problems;
+}
+function exportProblems(doc, session, options) {
+  return withXmlParser(
+    options?.xmlParser,
+    () => problemsOf(doc, sessionOf(session))
+  );
+}
+export {
+  exportProblems,
+  problemsOf
+};

package/dist/docx/media.d.ts

@@ -3,7 +3,7 @@
  * bytes without blob-URL lifetime management; `MAX_IMAGE_BYTES` bounds the memory tradeoff.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { type RelationshipWriter } from "./relationships";
+import type { PartPlanContext } from "./partPlan";
 import type { SessionStore } from "./session";
 /** The images the body can refer to, as data URLs keyed by relationship id */
 export type ImageSources = ReadonlyMap<string, string>;
@@ -46,10 +46,12 @@ export interface MediaAdditions {
     /** The parts to write into the zip alongside the body */
     parts: ReadonlyMap<string, Uint8Array>;
 }
+/** The srcs of the images that were not in the document when it was opened, in document order */
+export declare function insertedImageSrcs(doc: PMNode): string[];
 /**
  * What the package needs for the images that were inserted during editing: the media parts,
- * the relationships pointing at them, and the content types declaring them.
- * null when every image in the document came out of the document itself.
+ * with the relationships pointing at them and the content types declaring them asked of the
+ * context. null when every image in the document came out of the document itself.
  *
  * The relationships go through the writer the export shares between its writers
  * (`docx/relationships`), so the part is written once with everything in it.
@@ -57,4 +59,4 @@ export interface MediaAdditions {
  * Bytes that are already in the package are not written a second time: an inserted image
  * whose fingerprint matches one that is already there reuses its relationship.
  */
-export declare function planImageMedia(doc: PMNode, session: SessionStore, relationships: RelationshipWriter): MediaAdditions | null;
+export declare function planImageMedia(doc: PMNode, session: SessionStore, context: PartPlanContext): MediaAdditions | null;

package/dist/docx/media.js

@@ -5,7 +5,7 @@ import {
   imageMimeOf,
   toImageSrc
 } from "../ooxml/image.js";
-import { decodeUtf8, encodeUtf8, R_NS } from "../ooxml/xml.js";
+import { R_NS } from "../ooxml/xml.js";
 import {
   directoryOf,
   readRelationships,
@@ -13,7 +13,6 @@ import {
   resolveTarget
 } from "./relationships.js";
 var IMAGE_REL_TYPE = `${R_NS}/image`;
-var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var EXTENSION_BY_MIME = {
   "image/png": "png",
   "image/jpeg": "jpeg",
@@ -114,6 +113,7 @@ function decodeImage(src) {
     const bytes = fromBase64(imageBase64Of(src));
     return {
       bytes,
+      mime,
       extension: EXTENSION_BY_MIME[mime],
       key: contentKey(bytes)
     };
@@ -148,42 +148,14 @@ function maxDocPrId(session) {
   }
   return max;
 }
-var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
-function withImageContentTypes(parts, extensions) {
-  const original = parts.get(CONTENT_TYPES_PATH);
-  if (!original) {
-    throw new DocxExportError(
-      "missing-content-types",
-      `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
-    );
-  }
-  const { text, hadBom } = decodeUtf8(original);
-  const missing = Array.from(extensions).filter(
-    (extension) => !new RegExp(`<Default[^>]+Extension="${extension}"`, "i").test(text)
-  );
-  if (missing.length === 0) return null;
-  const open = TYPES_OPEN_TAG.exec(text);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      `${CONTENT_TYPES_PATH} has no Types element`
-    );
-  }
-  const declarations = missing.map((extension) => {
-    const mime = MIME_BY_EXTENSION.get(extension);
-    return `<Default Extension="${extension}" ContentType="${mime}"/>`;
-  }).join("");
-  const at = open.index + open[0].length;
-  return encodeUtf8(text.slice(0, at) + declarations + text.slice(at), hadBom);
-}
-function planImageMedia(doc, session, relationships) {
+function planImageMedia(doc, session, context) {
   const srcs = insertedImageSrcs(doc);
   if (srcs.length === 0) return null;
+  const { relationships, contentTypes } = context;
   const relIdByContent = imageRelIdsByContent(session, relationships.opened);
   const directory = directoryOf(session.mainPartPath);
   const relIdBySrc = /* @__PURE__ */ new Map();
   const parts = /* @__PURE__ */ new Map();
-  const extensions = /* @__PURE__ */ new Set();
   for (const src of srcs) {
     const image = decodeImage(src);
     const reused = relIdByContent.get(image.key);
@@ -194,20 +166,17 @@ function planImageMedia(doc, session, relationships) {
     const target = `media/image-${image.key}.${image.extension}`;
     const relId = relationships.add({ type: IMAGE_REL_TYPE, target });
     parts.set(directory + target, image.bytes);
-    extensions.add(image.extension);
+    contentTypes.addDefault(image.extension, image.mime);
     relIdByContent.set(image.key, relId);
     relIdBySrc.set(src, relId);
   }
-  if (extensions.size > 0) {
-    const contentTypes = withImageContentTypes(session.parts, extensions);
-    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
-  }
   return { refs: imageRefs(relIdBySrc, maxDocPrId(session) + 1), parts };
 }
 export {
   MAX_IMAGE_BYTES,
   NO_IMAGES,
   NO_IMAGE_REFS,
+  insertedImageSrcs,
   planImageMedia,
   readImageSources
 };