@portone/docx-editor 0.1.0

package/dist/docx/comments/reading.js

@@ -0,0 +1,149 @@
+// src/docx/comments/reading.ts
+import {
+  decodeUtf8,
+  elementChildren,
+  parseXml,
+  serializeXml,
+  W_NS
+} from "../../ooxml/xml.js";
+import { readRelationships, relsPathOf, resolveTarget } from "../relationships.js";
+import { COMMENTS_EXTENDED_REL_TYPE, COMMENTS_REL_TYPE } from "./constants.js";
+function attribute(el, localName) {
+  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
+}
+function inlineCommentText(node) {
+  if (node.localName === "t") return node.textContent ?? "";
+  if (node.localName === "tab") return "	";
+  if (node.localName === "br" || node.localName === "cr") return "\n";
+  return elementChildren(node).map(inlineCommentText).join("");
+}
+function commentText(el) {
+  const paragraphs = Array.from(el.getElementsByTagNameNS(W_NS, "p"));
+  return paragraphs.map(inlineCommentText).join("\n");
+}
+var NO_COMMENTS = {
+  partPath: null,
+  xml: null,
+  hadBom: false,
+  ordered: [],
+  byId: /* @__PURE__ */ new Map(),
+  repliesByParentId: /* @__PURE__ */ new Map(),
+  extendedPartPath: null,
+  extendedXml: null,
+  extendedHadBom: false,
+  extendedOrdered: []
+};
+function lastParagraphId(comment) {
+  const paragraphs = Array.from(comment.getElementsByTagNameNS(W_NS, "p"));
+  return paragraphs.length === 0 ? null : attribute(paragraphs[paragraphs.length - 1], "paraId");
+}
+function readCommentExtensions(parts, mainPartPath) {
+  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
+    (entry) => entry.type === COMMENTS_EXTENDED_REL_TYPE && !entry.external
+  );
+  if (!relationship) {
+    return {
+      partPath: null,
+      xml: null,
+      hadBom: false,
+      byParaId: /* @__PURE__ */ new Map(),
+      ordered: []
+    };
+  }
+  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const bytes = parts.get(partPath);
+  if (!bytes) {
+    return {
+      partPath,
+      xml: null,
+      hadBom: false,
+      byParaId: /* @__PURE__ */ new Map(),
+      ordered: []
+    };
+  }
+  const { text, hadBom } = decodeUtf8(bytes);
+  const root = parseXml(text).documentElement;
+  const byParaId = /* @__PURE__ */ new Map();
+  const ordered = [];
+  for (const el of elementChildren(root)) {
+    if (el.localName !== "commentEx") continue;
+    const paraId = attribute(el, "paraId");
+    if (paraId === null) continue;
+    const extension = {
+      paraId,
+      parentParaId: attribute(el, "paraIdParent"),
+      resolved: ["1", "true", "on"].includes(
+        attribute(el, "done")?.toLowerCase() ?? ""
+      ),
+      xml: serializeXml(el)
+    };
+    ordered.push(extension);
+    if (!byParaId.has(paraId)) byParaId.set(paraId, extension);
+  }
+  return { partPath, xml: text, hadBom, byParaId, ordered };
+}
+function readComments(parts, mainPartPath) {
+  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
+    (entry) => entry.type === COMMENTS_REL_TYPE && !entry.external
+  );
+  if (!relationship) return NO_COMMENTS;
+  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const bytes = parts.get(partPath);
+  if (!bytes) return { ...NO_COMMENTS, partPath };
+  const { text, hadBom } = decodeUtf8(bytes);
+  const root = parseXml(text).documentElement;
+  const extensions = readCommentExtensions(parts, mainPartPath);
+  const base = elementChildren(root).filter((el) => el.localName === "comment").flatMap((el) => {
+    const id = attribute(el, "id");
+    if (id === null) return [];
+    const paraId = lastParagraphId(el);
+    const extension = paraId ? extensions.byParaId.get(paraId) : void 0;
+    return [
+      {
+        id,
+        author: attribute(el, "author"),
+        initials: attribute(el, "initials"),
+        date: attribute(el, "date"),
+        text: commentText(el),
+        xml: serializeXml(el),
+        paraId,
+        parentParaId: extension?.parentParaId ?? null,
+        resolved: extension?.resolved ?? false,
+        extensionXml: extension?.xml ?? null
+      }
+    ];
+  });
+  const idByParaId = new Map(
+    base.flatMap(
+      (comment) => comment.paraId === null ? [] : [[comment.paraId, comment.id]]
+    )
+  );
+  const ordered = base;
+  const byId = /* @__PURE__ */ new Map();
+  const repliesByParentId = /* @__PURE__ */ new Map();
+  for (const comment of ordered) {
+    if (!byId.has(comment.id)) byId.set(comment.id, comment);
+    const parentId = comment.parentParaId === null ? null : idByParaId.get(comment.parentParaId) ?? null;
+    if (parentId !== null) {
+      const replies = repliesByParentId.get(parentId) ?? [];
+      replies.push(comment);
+      repliesByParentId.set(parentId, replies);
+    }
+  }
+  return {
+    partPath,
+    xml: text,
+    hadBom,
+    ordered,
+    byId,
+    repliesByParentId,
+    extendedPartPath: extensions.partPath,
+    extendedXml: extensions.xml,
+    extendedHadBom: extensions.hadBom,
+    extendedOrdered: extensions.ordered
+  };
+}
+export {
+  NO_COMMENTS,
+  readComments
+};

package/dist/docx/comments/writing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Plans changed comment package parts while preserving untouched XML.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type RelationshipWriter } from "../relationships";
+import type { SessionStore } from "../session";
+export interface CommentPartChanges {
+    parts: ReadonlyMap<string, Uint8Array>;
+}
+/** Plans the Comments part, relationship and content type only when comment state changed. */
+export declare function planCommentParts(doc: PMNode, session: SessionStore, relationships: RelationshipWriter, currentContentTypes?: Uint8Array): CommentPartChanges | null;

package/dist/docx/comments/writing.js

@@ -0,0 +1,327 @@
+// src/docx/comments/writing.ts
+import { DocxExportError } from "../../ooxml/errors.js";
+import { decodeUtf8, encodeUtf8, escapeXml, W_NS } from "../../ooxml/xml.js";
+import { directoryOf } from "../relationships.js";
+import {
+  COMMENTS_CONTENT_TYPE,
+  COMMENTS_EXTENDED_CONTENT_TYPE,
+  COMMENTS_EXTENDED_REL_TYPE,
+  COMMENTS_REL_TYPE,
+  CONTENT_TYPES_PATH,
+  MC_NS,
+  W14_NS,
+  W15_NS
+} from "./constants.js";
+import {
+  commentReferencesIn
+} from "./model.js";
+function commentsChanged(doc, session) {
+  const current = commentReferencesIn(doc);
+  if (current.size !== session.commentReferenceIds.size) return true;
+  const currentBodies = currentCommentBodies(current);
+  const originalBodies = originalThreadIds(
+    session.comments,
+    session.commentReferenceIds
+  );
+  if (currentBodies.size !== originalBodies.size) return true;
+  for (const id of originalBodies) {
+    if (!currentBodies.has(id)) return true;
+  }
+  for (const id of session.commentReferenceIds) {
+    const comment = current.get(id);
+    if (!comment?.imported) return true;
+  }
+  for (const comment of current.values()) {
+    if (comment.replies.some((reply) => !reply.imported)) return true;
+  }
+  return false;
+}
+function renderedExtension(comment) {
+  if (comment.extensionXml !== null) return comment.extensionXml;
+  const parent = "parentParaId" in comment ? ` w15:paraIdParent="${escapeXml(comment.parentParaId)}"` : "";
+  const done = "resolved" in comment ? ` w15:done="${comment.resolved ? "1" : "0"}"` : "";
+  return `<w15:commentEx w15:paraId="${escapeXml(comment.paraId)}"${parent}${done}/>`;
+}
+function extensionsXml(references, comments, originallyReferenced) {
+  const current = currentCommentBodies(references);
+  const originalThreads = originalThreadIds(comments, originallyReferenced);
+  const pieces = [];
+  const written = /* @__PURE__ */ new Set();
+  const idByParaId = new Map(
+    comments.ordered.flatMap(
+      (comment) => comment.paraId === null ? [] : [[comment.paraId, comment.id]]
+    )
+  );
+  for (const original of comments.extendedOrdered) {
+    const id = idByParaId.get(original.paraId);
+    const item = id === void 0 ? void 0 : current.get(id);
+    if (id !== void 0 && item && !written.has(id)) {
+      pieces.push(renderedExtension(item));
+      written.add(id);
+    } else if (id === void 0 || !originalThreads.has(id)) {
+      pieces.push(original.xml);
+    }
+  }
+  for (const [id, comment] of current) {
+    if (!written.has(id)) pieces.push(renderedExtension(comment));
+  }
+  if (comments.extendedXml === null) {
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx xmlns:w15="${W15_NS}">${pieces.join("")}</w15:commentsEx>`;
+  }
+  const open = /<(?:[\w.-]+:)?commentsEx\b[^>]*>/.exec(comments.extendedXml);
+  if (!open) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the Comments Extended part has no commentsEx root element"
+    );
+  }
+  const name = /^<([^\s>]+)/.exec(open[0])?.[1];
+  const close = name ? comments.extendedXml.lastIndexOf(`</${name}>`) : -1;
+  if (close === -1) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the Comments Extended part has no closing commentsEx tag"
+    );
+  }
+  const bodyAt = open.index + open[0].length;
+  return comments.extendedXml.slice(0, bodyAt) + pieces.join("") + comments.extendedXml.slice(close);
+}
+function extensionsChanged(doc, session) {
+  const current = commentReferencesIn(doc);
+  for (const [id, comment] of current) {
+    if (!comment.threadImported) return true;
+    if (!session.commentReferenceIds.has(id)) continue;
+  }
+  for (const id of session.commentReferenceIds) {
+    if (current.has(id)) continue;
+    const original = session.comments.byId.get(id);
+    if (original?.extensionXml != null || (session.comments.repliesByParentId.get(id)?.length ?? 0) > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function commentTextXml(text) {
+  const lines = text.split("\n");
+  const pieces = [];
+  lines.forEach((line, index) => {
+    if (index > 0) pieces.push("<w:br/>");
+    if (line.length > 0 || lines.length === 1) {
+      pieces.push(`<w:t xml:space="preserve">${escapeXml(line)}</w:t>`);
+    }
+  });
+  return `<w:r>${pieces.join("")}</w:r>`;
+}
+function carriesThreadMetadata(comment) {
+  return comment.extensionXml !== null || "threadImported" in comment && !comment.threadImported || "parentParaId" in comment;
+}
+function renderedComment(comment) {
+  if (comment.imported && comment.commentXml !== null) {
+    return comment.commentXml;
+  }
+  const attrs = [
+    `w:id="${escapeXml(comment.id)}"`,
+    comment.author === null ? null : `w:author="${escapeXml(comment.author)}"`,
+    comment.date === null ? null : `w:date="${escapeXml(comment.date)}"`,
+    comment.initials === null ? null : `w:initials="${escapeXml(comment.initials)}"`
+  ].filter((entry) => entry !== null).join(" ");
+  const threaded = carriesThreadMetadata(comment);
+  const paragraphAttrs = threaded ? ` xmlns:w14="${W14_NS}" w14:paraId="${escapeXml(comment.paraId)}"` : "";
+  return `<w:comment xmlns:w="${W_NS}" ${attrs}><w:p${paragraphAttrs}>${commentTextXml(comment.text)}</w:p></w:comment>`;
+}
+function withThreadMarkupCompatibility(openTag) {
+  let updated = openTag;
+  if (!/\sxmlns:w14\s*=/.test(updated)) {
+    updated = updated.replace(/>$/, ` xmlns:w14="${W14_NS}">`);
+  }
+  if (!/\sxmlns:mc\s*=/.test(updated)) {
+    updated = updated.replace(/>$/, ` xmlns:mc="${MC_NS}">`);
+  }
+  const ignorable = /\smc:Ignorable\s*=\s*(["'])([^"']*)\1/.exec(updated);
+  if (!ignorable) {
+    return updated.replace(/>$/, ' mc:Ignorable="w14">');
+  }
+  const tokens = ignorable[2].split(/\s+/).filter(Boolean);
+  if (tokens.includes("w14")) return updated;
+  const replacement = ` mc:Ignorable=${ignorable[1]}${[...tokens, "w14"].join(" ")}${ignorable[1]}`;
+  return updated.slice(0, ignorable.index) + replacement + updated.slice(ignorable.index + ignorable[0].length);
+}
+function currentCommentBodies(references) {
+  const comments = /* @__PURE__ */ new Map();
+  for (const [id, comment] of references) {
+    comments.set(id, comment);
+    for (const reply of comment.replies) comments.set(reply.id, reply);
+  }
+  return comments;
+}
+function originalThreadIds(comments, rootIds) {
+  const ids = new Set(rootIds);
+  const pending = Array.from(rootIds);
+  while (pending.length > 0) {
+    const parent = pending.shift();
+    if (parent === void 0) break;
+    for (const reply of comments.repliesByParentId.get(parent) ?? []) {
+      if (ids.has(reply.id)) continue;
+      ids.add(reply.id);
+      pending.push(reply.id);
+    }
+  }
+  return ids;
+}
+function commentsXml(references, comments, originallyReferenced) {
+  const currentBodies = currentCommentBodies(references);
+  const hasThreadMetadata = Array.from(currentBodies.values()).some(
+    carriesThreadMetadata
+  );
+  const originalThreads = originalThreadIds(comments, originallyReferenced);
+  const pieces = [];
+  const written = /* @__PURE__ */ new Set();
+  for (const original of comments.ordered) {
+    const current = currentBodies.get(original.id);
+    if (current) {
+      pieces.push(renderedComment(current));
+      written.add(original.id);
+      continue;
+    }
+    if (!originalThreads.has(original.id)) {
+      pieces.push(original.xml);
+      written.add(original.id);
+    }
+  }
+  for (const [id, comment] of currentBodies) {
+    if (!written.has(id)) pieces.push(renderedComment(comment));
+  }
+  if (comments.xml === null) {
+    const compatibility = hasThreadMetadata ? ` xmlns:w14="${W14_NS}" xmlns:mc="${MC_NS}" mc:Ignorable="w14"` : "";
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:comments xmlns:w="${W_NS}"${compatibility}>${pieces.join("")}</w:comments>`;
+  }
+  const open = /<(?:[\w.-]+:)?comments\b[^>]*>/.exec(comments.xml);
+  if (!open) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the Comments part has no comments root element"
+    );
+  }
+  const name = /^<([^\s>]+)/.exec(open[0])?.[1];
+  const close = name ? comments.xml.lastIndexOf(`</${name}>`) : -1;
+  if (close === -1) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the Comments part has no closing comments tag"
+    );
+  }
+  const openTag = hasThreadMetadata ? withThreadMarkupCompatibility(open[0]) : open[0];
+  return comments.xml.slice(0, open.index) + openTag + pieces.join("") + comments.xml.slice(close);
+}
+var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
+function withContentType(parts, partPath, contentType, current) {
+  const original = current ?? parts.get(CONTENT_TYPES_PATH);
+  if (!original) {
+    throw new DocxExportError(
+      "missing-content-types",
+      `cannot add a Comments part to a package that has no ${CONTENT_TYPES_PATH}`
+    );
+  }
+  const { text, hadBom } = decodeUtf8(original);
+  const partName = `/${partPath}`;
+  if (new RegExp(
+    `<(?:[\\w.-]+:)?Override[^>]+PartName=["']${partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`,
+    "i"
+  ).test(text)) {
+    return null;
+  }
+  const open = TYPES_OPEN_TAG.exec(text);
+  if (!open) {
+    throw new DocxExportError(
+      "malformed-xml",
+      `${CONTENT_TYPES_PATH} has no Types element`
+    );
+  }
+  const rootName = /^<([^\s>]+)/.exec(open[0])?.[1] ?? "Types";
+  const separator = rootName.indexOf(":");
+  const prefix = separator < 0 ? "" : `${rootName.slice(0, separator)}:`;
+  const declaration = `<${prefix}Override PartName="${partName}" ContentType="${contentType}"/>`;
+  const at = open.index + open[0].length;
+  return encodeUtf8(text.slice(0, at) + declaration + text.slice(at), hadBom);
+}
+function availableCommentsPath(session) {
+  const directory = directoryOf(session.mainPartPath);
+  for (let suffix = 0; ; suffix += 1) {
+    const name = suffix === 0 ? "comments.xml" : `comments${suffix + 1}.xml`;
+    const path = directory + name;
+    if (!session.parts.has(path)) return path;
+  }
+}
+function availableCommentsExtendedPath(session) {
+  const directory = directoryOf(session.mainPartPath);
+  for (let suffix = 0; ; suffix += 1) {
+    const name = suffix === 0 ? "commentsExtended.xml" : `commentsExtended${suffix + 1}.xml`;
+    const path = directory + name;
+    if (!session.parts.has(path)) return path;
+  }
+}
+function planCommentParts(doc, session, relationships, currentContentTypes) {
+  const bodyChanged = commentsChanged(doc, session);
+  const threadChanged = extensionsChanged(doc, session);
+  if (!bodyChanged && !threadChanged) return null;
+  const references = commentReferencesIn(doc);
+  const addingPart = session.comments.partPath === null;
+  const partPath = session.comments.partPath ?? availableCommentsPath(session);
+  const parts = /* @__PURE__ */ new Map();
+  if (addingPart) {
+    const target = partPath.slice(directoryOf(session.mainPartPath).length);
+    relationships.add({ type: COMMENTS_REL_TYPE, target });
+  }
+  if (bodyChanged) {
+    parts.set(
+      partPath,
+      encodeUtf8(
+        commentsXml(references, session.comments, session.commentReferenceIds),
+        session.comments.hadBom
+      )
+    );
+  }
+  if (addingPart || session.comments.xml === null) {
+    const contentTypes = withContentType(
+      session.parts,
+      partPath,
+      COMMENTS_CONTENT_TYPE,
+      currentContentTypes
+    );
+    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
+  }
+  if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null)) {
+    const addingExtendedPart = session.comments.extendedPartPath === null;
+    const extendedPartPath = session.comments.extendedPartPath ?? availableCommentsExtendedPath(session);
+    if (addingExtendedPart) {
+      const target = extendedPartPath.slice(
+        directoryOf(session.mainPartPath).length
+      );
+      relationships.add({ type: COMMENTS_EXTENDED_REL_TYPE, target });
+    }
+    parts.set(
+      extendedPartPath,
+      encodeUtf8(
+        extensionsXml(
+          references,
+          session.comments,
+          session.commentReferenceIds
+        ),
+        session.comments.extendedHadBom
+      )
+    );
+    if (addingExtendedPart || session.comments.extendedXml === null) {
+      const contentTypes = withContentType(
+        session.parts,
+        extendedPartPath,
+        COMMENTS_EXTENDED_CONTENT_TYPE,
+        parts.get(CONTENT_TYPES_PATH) ?? currentContentTypes
+      );
+      if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
+    }
+  }
+  return { parts };
+}
+export {
+  planCommentParts
+};

package/dist/docx/comments.d.ts

@@ -0,0 +1,3 @@
+export * from "./comments/model";
+export * from "./comments/reading";
+export * from "./comments/writing";

package/dist/docx/comments.js

@@ -0,0 +1,4 @@
+// src/docx/comments.ts
+export * from "./comments/model.js";
+export * from "./comments/reading.js";
+export * from "./comments/writing.js";

package/dist/docx/container.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Caps on one part and on the whole package. The bytes are untrusted and a zip chooses its own
+ * inflated size (a few hundred KB of zeros reach hundreds of MB), so both the stored size and the
+ * declared inflated size are checked off the directory before any entry is inflated. The caps sit
+ * far above a real document (low megabytes), so nothing legitimate is refused.
+ */
+export declare const MAX_PART_BYTES: number;
+export declare const MAX_PACKAGE_BYTES: number;
+/** Collects every part in the zip, keeping the original order */
+export declare function openParts(bytes: Uint8Array): Map<string, Uint8Array>;
+/** Builds a zip that swaps in only the rewritten parts and keeps every other part's original bytes as they were */
+export declare function repackParts(parts: Map<string, Uint8Array>, replacements: Map<string, Uint8Array>): Uint8Array;

package/dist/docx/container.js

@@ -0,0 +1,130 @@
+// src/docx/container.ts
+import { inflateSync, zipSync } from "fflate";
+import { DocxImportError } from "../ooxml/errors.js";
+var MAX_PART_BYTES = 32 * 1024 * 1024;
+var MAX_PACKAGE_BYTES = 64 * 1024 * 1024;
+function escapesPackage(name) {
+  const segments = name.split(/[/\\]/);
+  return segments[0] === "" || /^[A-Za-z]:$/.test(segments[0]) || segments.includes("..");
+}
+var END_OF_DIRECTORY = 101010256;
+var DIRECTORY_ENTRY = 33639248;
+var LOCAL_HEADER = 67324752;
+var END_RECORD_SEARCH = 22 + 65535;
+var STORED = 0;
+var DEFLATED = 8;
+var nameDecoder = new TextDecoder("utf-8");
+function unreadable(why) {
+  throw new DocxImportError("not-a-docx", why);
+}
+function endOfDirectory(view) {
+  const earliest = Math.max(0, view.byteLength - END_RECORD_SEARCH);
+  for (let at = view.byteLength - 22; at >= earliest; at -= 1) {
+    if (view.getUint32(at, true) === END_OF_DIRECTORY) return at;
+  }
+  return unreadable("the bytes are not a zip package");
+}
+function dataStart(view, headerAt) {
+  if (headerAt + 30 > view.byteLength || view.getUint32(headerAt, true) !== LOCAL_HEADER) {
+    return unreadable("an entry of the package has no readable header");
+  }
+  const nameLength = view.getUint16(headerAt + 26, true);
+  const extraLength = view.getUint16(headerAt + 28, true);
+  return headerAt + 30 + nameLength + extraLength;
+}
+function directoryEntries(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const end = endOfDirectory(view);
+  const count = view.getUint16(end + 10, true);
+  const entries = [];
+  let at = view.getUint32(end + 16, true);
+  for (let read = 0; read < count; read += 1) {
+    if (at + 46 > view.byteLength || view.getUint32(at, true) !== DIRECTORY_ENTRY) {
+      return unreadable("the package's directory does not read as one");
+    }
+    const nameLength = view.getUint16(at + 28, true);
+    const extraLength = view.getUint16(at + 30, true);
+    const commentLength = view.getUint16(at + 32, true);
+    entries.push({
+      name: nameDecoder.decode(bytes.subarray(at + 46, at + 46 + nameLength)),
+      compression: view.getUint16(at + 10, true),
+      storedSize: view.getUint32(at + 20, true),
+      declaredSize: view.getUint32(at + 24, true),
+      dataAt: dataStart(view, view.getUint32(at + 42, true))
+    });
+    at += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+function entryBytes(bytes, entry) {
+  const end = entry.dataAt + entry.storedSize;
+  if (end > bytes.length) {
+    return unreadable("an entry of the package reaches past its end");
+  }
+  const held = bytes.subarray(entry.dataAt, end);
+  if (entry.storedSize === 0) {
+    if (entry.declaredSize !== 0) {
+      return unreadable("an empty entry of the package declares a size");
+    }
+    return held;
+  }
+  if (entry.compression === STORED) {
+    if (entry.storedSize !== entry.declaredSize) {
+      return unreadable("a stored entry does not hold the size it declares");
+    }
+    return held.slice();
+  }
+  if (entry.compression !== DEFLATED) {
+    return unreadable(
+      "the package holds an entry compressed in a way we cannot read"
+    );
+  }
+  const inflated = inflateSync(held, {
+    out: new Uint8Array(entry.declaredSize + 1)
+  });
+  if (inflated.length !== entry.declaredSize) {
+    return unreadable("an entry does not inflate to the size it declares");
+  }
+  return inflated;
+}
+function openParts(bytes) {
+  const parts = /* @__PURE__ */ new Map();
+  let packageBytes = 0;
+  try {
+    for (const entry of directoryEntries(bytes)) {
+      if (escapesPackage(entry.name)) {
+        unreadable("the package holds an entry whose name reaches outside it");
+      }
+      packageBytes += Math.max(entry.storedSize, entry.declaredSize);
+      if (entry.storedSize > MAX_PART_BYTES || entry.declaredSize > MAX_PART_BYTES || packageBytes > MAX_PACKAGE_BYTES) {
+        throw new DocxImportError(
+          "too-large",
+          "the docx file asks to inflate to more than we open"
+        );
+      }
+      parts.set(entry.name, entryBytes(bytes, entry));
+    }
+    return parts;
+  } catch (error) {
+    if (error instanceof DocxImportError) throw error;
+    throw new DocxImportError("not-a-docx", "could not open the docx file", {
+      cause: error
+    });
+  }
+}
+function repackParts(parts, replacements) {
+  const zippable = {};
+  for (const [name, data] of parts) {
+    zippable[name] = replacements.get(name) ?? data;
+  }
+  for (const [name, data] of replacements) {
+    if (!parts.has(name)) zippable[name] = data;
+  }
+  return zipSync(zippable, { level: 6, mtime: new Date(1980, 0, 1) });
+}
+export {
+  MAX_PACKAGE_BYTES,
+  MAX_PART_BYTES,
+  openParts,
+  repackParts
+};

package/dist/docx/documentSettings.d.ts

@@ -0,0 +1,4 @@
+/** The interval OOXML assigns when settings.xml does not declare one. */
+export declare const DEFAULT_TAB_STOP_PT = 36;
+/** Reads the document-wide automatic tab interval from settings.xml. */
+export declare function readDefaultTabStop(settings: Document | null): number | null;

package/dist/docx/documentSettings.js

@@ -0,0 +1,14 @@
+// src/docx/documentSettings.ts
+import { twipsToPt, wAttr } from "../ooxml/units.js";
+import { childByLocalName } from "../ooxml/xml.js";
+var DEFAULT_TAB_STOP_PT = 36;
+function readDefaultTabStop(settings) {
+  if (!settings) return null;
+  const setting = childByLocalName(settings.documentElement, "defaultTabStop");
+  const value = setting ? twipsToPt(wAttr(setting, "val")) : null;
+  return value !== null && value > 0 ? value : null;
+}
+export {
+  DEFAULT_TAB_STOP_PT,
+  readDefaultTabStop
+};

package/dist/docx/exportDocx.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turns the edited document back into docx bytes.
+ *
+ * The body (document.xml) is always rebuilt from preserved and edited blocks. numbering.xml is
+ * rewritten only when a list was newly started, media parts only when an image was inserted, and
+ * the Comments part only when comments changed. Content types and relationships change only when
+ * one of those additions needs them.
+ *
+ * The body is written before that relationships part, because a link asks for its relationship as
+ * it is written (`docx/hyperlink`), and both writers hand out ids through the one writer so that
+ * they cannot pick the same one.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type DocxSession } from "./session";
+export declare function exportDocx(doc: PMNode, session: DocxSession): Uint8Array;