@pixerate/editor 0.24.0 → 0.26.0

package/dist/{chunk-ITBSKI26.js → chunk-Q2OHWD2A.js}

@@ -1,6 +1,13 @@
 import {
   compareDocuments
-} from "./chunk-FODNLX5N.js";
+} from "./chunk-QJSOZFCZ.js";
+import {
+  DEFAULT_STYLES,
+  NORMAL_STYLE_ID,
+  createStyleRegistry,
+  isValidStyleId,
+  readZip
+} from "./chunk-MR2764X2.js";
 import {
   INSTRUCTION_REGEX,
   TEMPLATE_REGEX,
@@ -16,20 +23,29 @@ import {
   rtfToPlainText,
   sanitizeImportedHtml,
   serializeRichClipboardPayload
-} from "./chunk-3LV6RRPH.js";
+} from "./chunk-MHEPLBFB.js";
+import {
+  MAX_TABLE_COLUMNS,
+  MAX_TABLE_ROWS,
+  TABLE_ACTIONS,
+  createTableExtensions,
+  getTableActionState,
+  getTableState,
+  runTableAction
+} from "./chunk-UBCFIABU.js";
 import {
   escapeHtml,
   htmlToPlainText,
   markdownToTipTapHtml,
   plainTextToSlice
-} from "./chunk-PGNZKFQS.js";
+} from "./chunk-JOIREKL7.js";
 import {
   CommentStore,
   TRACK_CHANGES_SKIP_META,
   TrackChanges,
   createReviewId,
   trackChangesPluginKey
-} from "./chunk-5S3Z4PPF.js";
+} from "./chunk-SWE3NPOU.js";
 
 // src/extensions/gradient-text.ts
 import { Mark } from "@tiptap/core";
@@ -601,10 +617,47 @@ var Mention = BaseMention.extend({
           if (!attributes.color) return {};
           return { "data-color": attributes.color };
         }
+      },
+      // Role of an asset mention (`reference`, `style`, `start_frame`, …). The
+      // node attribute is `assetRole` so entities that already carry a `role`
+      // (e.g. a user's job title) passed as suggestion props do not set it.
+      assetRole: {
+        default: null,
+        parseHTML: (element) => {
+          const role = element.getAttribute("data-role");
+          return role && MENTION_ROLE_PATTERN.test(role) ? role : null;
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.assetRole) return {};
+          return { "data-role": attributes.assetRole };
+        }
       }
     };
   }
 });
+var MENTION_ROLE_PATTERN = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/;
+function getMentionNodes(editor) {
+  const result = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type?.name !== "mention") return;
+    result.push({
+      pos,
+      id: node.attrs.id ?? "",
+      label: node.attrs.label ?? "",
+      ...node.attrs.type ? { type: node.attrs.type } : {},
+      ...node.attrs.assetRole ? { role: node.attrs.assetRole } : {}
+    });
+  });
+  return result;
+}
+function setMentionRoleAt(editor, pos, role) {
+  const node = editor?.state?.doc?.nodeAt(pos);
+  if (!node || node.type.name !== "mention") return false;
+  if (role !== null && !MENTION_ROLE_PATTERN.test(role)) return false;
+  const tr = editor.state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, assetRole: role });
+  editor.view.dispatch(tr);
+  return true;
+}
 function createMentionExtension(options = {}) {
   const { HTMLAttributes = {}, ...rest } = options;
   return Mention.configure({
@@ -2249,7 +2302,13 @@ var ImportAdapterRegistry = class {
         { fileName }
       );
     }
-    const context = createImportContext(input, { fileName, mimeType, target: adapter.target, registry: this });
+    const context = createImportContext(input, {
+      fileName,
+      mimeType,
+      target: adapter.target,
+      registry: this,
+      options: options.adapterOptions?.[adapter.id]
+    });
     try {
       const result = await adapter.import(input, context);
       return { adapterId: adapter.id, target: adapter.target, fileName, mimeType, result };
@@ -2267,319 +2326,6 @@ var ImportAdapterRegistry = class {
   }
 };
 
-// src/import/zip.ts
-var ZipError = class extends Error {
-  code;
-  entryName;
-  constructor(code, message, details = {}) {
-    super(message, details.cause !== void 0 ? { cause: details.cause } : void 0);
-    this.name = "ZipError";
-    this.code = code;
-    this.entryName = details.entryName;
-  }
-};
-var DEFAULT_ZIP_MAX_ENTRIES = 1e4;
-var DEFAULT_ZIP_MAX_TOTAL_SIZE = 256 * 1024 * 1024;
-var SIG_EOCD = 101010256;
-var SIG_ZIP64_EOCD = 101075792;
-var SIG_ZIP64_LOCATOR = 117853008;
-var SIG_CENTRAL = 33639248;
-var SIG_LOCAL = 67324752;
-var EOCD_SIZE = 22;
-var MAX_COMMENT = 65535;
-var crcTable = null;
-function zipCrc32(data) {
-  if (!crcTable) {
-    crcTable = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-      let c = n;
-      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-      crcTable[n] = c >>> 0;
-    }
-  }
-  let crc = 4294967295;
-  for (let i = 0; i < data.length; i++) crc = crcTable[(crc ^ data[i]) & 255] ^ crc >>> 8;
-  return (crc ^ 4294967295) >>> 0;
-}
-function toBytes(data) {
-  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  return new Uint8Array(data);
-}
-function isUnsafeZipPath(name) {
-  if (!name || name.includes("\0")) return true;
-  const normalized = name.replace(/\\/g, "/");
-  if (normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized)) return true;
-  return normalized.split("/").some((segment) => segment === "..");
-}
-var utf8 = new TextDecoder("utf-8");
-var CP437_HIGH = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
-function decodeName(bytes, isUtf8) {
-  if (isUtf8 || bytes.every((b) => b < 128)) return utf8.decode(bytes);
-  let out = "";
-  for (const b of bytes) out += b < 128 ? String.fromCharCode(b) : CP437_HIGH[b - 128];
-  return out;
-}
-var ZipArchive = class {
-  constructor(bytes, entries, maxTotalSize) {
-    this.bytes = bytes;
-    this.maxTotalSize = maxTotalSize;
-    this.entries = entries;
-    entries.forEach((entry) => {
-      if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry);
-    });
-  }
-  bytes;
-  maxTotalSize;
-  /** Entries in central-directory order. */
-  entries;
-  byName = /* @__PURE__ */ new Map();
-  extracted = 0;
-  /** Looks up an entry by exact name (a leading `/` is ignored). */
-  get(name) {
-    return this.byName.get(name.replace(/^\/+/, ""));
-  }
-  has(name) {
-    return !!this.get(name);
-  }
-  /** Uncompressed bytes extracted so far (counted against `maxTotalSize`). */
-  get extractedSize() {
-    return this.extracted;
-  }
-  /** Extracts an entry's data, verifying its size and CRC-32. */
-  async read(entryOrName) {
-    const entry = typeof entryOrName === "string" ? this.get(entryOrName) : entryOrName;
-    if (!entry) {
-      throw new ZipError("entry_not_found", `ZIP entry "${String(entryOrName)}" not found.`, {
-        entryName: String(entryOrName)
-      });
-    }
-    const name = entry.name;
-    if (entry.encrypted) {
-      throw new ZipError("encrypted", `ZIP entry "${name}" is encrypted; encrypted archives are not supported.`, {
-        entryName: name
-      });
-    }
-    if (entry.isDirectory) return new Uint8Array(0);
-    const remaining = this.maxTotalSize - this.extracted;
-    if (entry.size > remaining) {
-      throw new ZipError(
-        "too_large",
-        `Extracting "${name}" (${entry.size} bytes) would exceed the ${this.maxTotalSize}-byte limit.`,
-        { entryName: name }
-      );
-    }
-    const { bytes } = this;
-    const offset = entry.localHeaderOffset;
-    if (offset + 30 > bytes.length || readU32(bytes, offset) !== SIG_LOCAL) {
-      throw new ZipError("corrupt_entry", `ZIP entry "${name}" has no valid local header.`, { entryName: name });
-    }
-    const dataStart = offset + 30 + readU16(bytes, offset + 26) + readU16(bytes, offset + 28);
-    const dataEnd = dataStart + entry.compressedSize;
-    if (dataEnd > bytes.length) {
-      throw new ZipError("corrupt_entry", `ZIP entry "${name}" is truncated.`, { entryName: name });
-    }
-    const raw = bytes.subarray(dataStart, dataEnd);
-    let data;
-    if (entry.method === 0) {
-      if (entry.compressedSize !== entry.size) {
-        throw new ZipError("corrupt_entry", `Stored ZIP entry "${name}" has inconsistent sizes.`, { entryName: name });
-      }
-      data = raw.slice();
-    } else if (entry.method === 8) {
-      data = await inflateRaw(raw, entry.size, name);
-    } else {
-      throw new ZipError(
-        "unsupported_feature",
-        `ZIP entry "${name}" uses unsupported compression method ${entry.method}; only stored and deflate are supported.`,
-        { entryName: name }
-      );
-    }
-    if (data.length !== entry.size) {
-      throw new ZipError("corrupt_entry", `ZIP entry "${name}" size does not match the directory.`, { entryName: name });
-    }
-    this.extracted += data.length;
-    if (zipCrc32(data) !== entry.crc32) {
-      throw new ZipError("corrupt_entry", `ZIP entry "${name}" failed its CRC-32 check.`, { entryName: name });
-    }
-    return data;
-  }
-  /** Extracts an entry and decodes it as UTF-8 (a leading BOM is removed). */
-  async readText(entryOrName) {
-    const text = utf8.decode(await this.read(entryOrName));
-    return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-  }
-};
-function readU16(bytes, offset) {
-  return bytes[offset] | bytes[offset + 1] << 8;
-}
-function readU32(bytes, offset) {
-  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
-}
-function readU64(bytes, offset) {
-  const value = readU32(bytes, offset) + readU32(bytes, offset + 4) * 4294967296;
-  if (!Number.isSafeInteger(value)) {
-    throw new ZipError("unsupported_feature", "ZIP64 value exceeds the supported range.");
-  }
-  return value;
-}
-async function inflateRaw(raw, limit, entryName) {
-  const Stream = globalThis.DecompressionStream;
-  if (typeof Stream !== "function") {
-    throw new ZipError(
-      "unsupported_environment",
-      "Inflating ZIP entries needs DecompressionStream (modern browsers, Node 18+).",
-      { entryName }
-    );
-  }
-  const stream = new Stream("deflate-raw");
-  const writer = stream.writable.getWriter();
-  const reader = stream.readable.getReader();
-  const CHUNK = 64 * 1024;
-  const feeding = (async () => {
-    for (let i = 0; i < raw.length; i += CHUNK) await writer.write(raw.subarray(i, i + CHUNK));
-    await writer.close();
-  })();
-  feeding.catch(() => {
-  });
-  const chunks = [];
-  let total = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.length;
-      if (total > limit) {
-        throw new ZipError(
-          "corrupt_entry",
-          `ZIP entry "${entryName}" inflates beyond its declared size of ${limit} bytes.`,
-          { entryName }
-        );
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    reader.cancel().catch(() => {
-    });
-    writer.abort().catch(() => {
-    });
-    if (error instanceof ZipError) throw error;
-    throw new ZipError("corrupt_entry", `ZIP entry "${entryName}" has an invalid deflate stream.`, {
-      entryName,
-      cause: error
-    });
-  }
-  await feeding.catch(() => {
-  });
-  const out = new Uint8Array(total);
-  let pos = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, pos);
-    pos += chunk.length;
-  }
-  return out;
-}
-function findEndOfCentralDirectory(bytes) {
-  const min = Math.max(0, bytes.length - EOCD_SIZE - MAX_COMMENT);
-  for (let i = bytes.length - EOCD_SIZE; i >= min; i--) {
-    if (readU32(bytes, i) === SIG_EOCD && i + EOCD_SIZE + readU16(bytes, i + 20) <= bytes.length) return i;
-  }
-  return -1;
-}
-async function readZip(data, options = {}) {
-  const bytes = toBytes(data);
-  const maxEntries = options.maxEntries ?? DEFAULT_ZIP_MAX_ENTRIES;
-  const maxTotalSize = options.maxTotalSize ?? DEFAULT_ZIP_MAX_TOTAL_SIZE;
-  const eocd = findEndOfCentralDirectory(bytes);
-  if (eocd < 0) throw new ZipError("invalid_archive", "Not a ZIP archive (no end of central directory record).");
-  let diskNumber = readU16(bytes, eocd + 4);
-  let cdDisk = readU16(bytes, eocd + 6);
-  let count = readU16(bytes, eocd + 10);
-  let cdSize = readU32(bytes, eocd + 12);
-  let cdOffset = readU32(bytes, eocd + 16);
-  if (count === 65535 || cdSize === 4294967295 || cdOffset === 4294967295) {
-    const locator = eocd - 20;
-    if (locator < 0 || readU32(bytes, locator) !== SIG_ZIP64_LOCATOR) {
-      throw new ZipError("invalid_archive", "ZIP64 archive is missing its end of central directory locator.");
-    }
-    const record = readU64(bytes, locator + 8);
-    if (record + 56 > bytes.length || readU32(bytes, record) !== SIG_ZIP64_EOCD) {
-      throw new ZipError("invalid_archive", "ZIP64 end of central directory record not found.");
-    }
-    diskNumber = readU32(bytes, record + 16);
-    cdDisk = readU32(bytes, record + 20);
-    count = readU64(bytes, record + 32);
-    cdSize = readU64(bytes, record + 40);
-    cdOffset = readU64(bytes, record + 48);
-  }
-  if (diskNumber !== 0 || cdDisk !== 0) {
-    throw new ZipError("unsupported_feature", "Multi-disk (spanned) ZIP archives are not supported.");
-  }
-  if (count > maxEntries) {
-    throw new ZipError("too_many_entries", `ZIP archive has ${count} entries; the limit is ${maxEntries}.`);
-  }
-  if (cdOffset + cdSize > bytes.length) {
-    throw new ZipError("invalid_archive", "ZIP central directory lies outside the file.");
-  }
-  const entries = [];
-  let p = cdOffset;
-  for (let i = 0; i < count; i++) {
-    if (p + 46 > bytes.length || readU32(bytes, p) !== SIG_CENTRAL) {
-      throw new ZipError("invalid_archive", "ZIP central directory is corrupt.");
-    }
-    const flags = readU16(bytes, p + 8);
-    const method = readU16(bytes, p + 10);
-    const crc32 = readU32(bytes, p + 16);
-    let compressedSize = readU32(bytes, p + 20);
-    let size = readU32(bytes, p + 24);
-    const nameLength = readU16(bytes, p + 28);
-    const extraLength = readU16(bytes, p + 30);
-    const commentLength = readU16(bytes, p + 32);
-    let localHeaderOffset = readU32(bytes, p + 42);
-    const nameStart = p + 46;
-    const extraStart = nameStart + nameLength;
-    const next = extraStart + extraLength + commentLength;
-    if (next > bytes.length) throw new ZipError("invalid_archive", "ZIP central directory is truncated.");
-    for (let e = extraStart; e + 4 <= extraStart + extraLength; ) {
-      const id = readU16(bytes, e);
-      const len = readU16(bytes, e + 2);
-      if (id === 1) {
-        let f = e + 4;
-        const end = f + len;
-        if (size === 4294967295 && f + 8 <= end) {
-          size = readU64(bytes, f);
-          f += 8;
-        }
-        if (compressedSize === 4294967295 && f + 8 <= end) {
-          compressedSize = readU64(bytes, f);
-          f += 8;
-        }
-        if (localHeaderOffset === 4294967295 && f + 8 <= end) localHeaderOffset = readU64(bytes, f);
-      }
-      e += 4 + len;
-    }
-    const rawName = decodeName(bytes.subarray(nameStart, extraStart), (flags & 2048) !== 0);
-    const name = rawName.replace(/\\/g, "/");
-    p = next;
-    if (isUnsafeZipPath(rawName)) {
-      if (options.unsafePaths === "skip") continue;
-      throw new ZipError("unsafe_path", `ZIP entry name "${rawName}" is absolute or escapes the archive root.`, {
-        entryName: rawName
-      });
-    }
-    entries.push({
-      name,
-      isDirectory: name.endsWith("/"),
-      encrypted: (flags & 1) !== 0,
-      method,
-      compressedSize,
-      size,
-      crc32,
-      localHeaderOffset
-    });
-  }
-  return new ZipArchive(bytes, entries, maxTotalSize);
-}
-
 // src/import/docx.ts
 var DOCX_MIME_TYPES = [
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -2587,6 +2333,8 @@ var DOCX_MIME_TYPES = [
   "application/vnd.ms-word.document.macroenabled.12"
 ];
 var DEFAULT_DOCX_MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+var MAX_COMMENTS = 5e3;
+var MAX_PARENT_CHAIN = 64;
 var W_NAMESPACES = /* @__PURE__ */ new Set([
   "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
   "http://purl.oclc.org/ooxml/wordprocessingml/main"
@@ -2599,6 +2347,7 @@ var IMAGE_MIME_TYPES = {
   gif: "image/gif",
   webp: "image/webp"
 };
+var TASK_GLYPHS = { "\u2610": false, "\u2612": true, "\u2611": true };
 function isW(node, localName) {
   if (!node || node.nodeType !== 1) return false;
   const el = node;
@@ -2735,6 +2484,65 @@ function readNumPr(pPr) {
   if (numId === void 0) return void 0;
   return { numId, ilvl: Number(attr(wChild(numPr, "ilvl"), "val") ?? 0) || 0 };
 }
+function twipsToCss(value) {
+  const n = Number(value);
+  return value !== void 0 && value !== "" && Number.isFinite(n) ? `${Math.round(n / 20 * 100) / 100}pt` : void 0;
+}
+var ALIGNMENTS = {
+  left: "left",
+  start: "left",
+  center: "center",
+  right: "right",
+  end: "right",
+  both: "justify",
+  distribute: "justify"
+};
+function readParagraphFormat(pPr) {
+  const format = {};
+  if (!pPr) return format;
+  const jc = attr(wChild(pPr, "jc"), "val");
+  if (jc && ALIGNMENTS[jc]) format.textAlign = ALIGNMENTS[jc];
+  const spacing = wChild(pPr, "spacing");
+  const before = twipsToCss(attr(spacing, "before"));
+  const after = twipsToCss(attr(spacing, "after"));
+  if (before) format.spaceBefore = before;
+  if (after) format.spaceAfter = after;
+  const line = Number(attr(spacing, "line"));
+  if (Number.isFinite(line) && line > 0) {
+    const rule = attr(spacing, "lineRule") ?? "auto";
+    format.lineHeight = rule === "auto" ? String(Math.round(line / 240 * 100) / 100) : twipsToCss(String(line));
+  }
+  const ind = wChild(pPr, "ind");
+  const left = twipsToCss(attr(ind, "left") ?? attr(ind, "start"));
+  const right = twipsToCss(attr(ind, "right") ?? attr(ind, "end"));
+  const first = attr(ind, "firstLine");
+  const hanging = attr(ind, "hanging");
+  if (left) format.indentLeft = left;
+  if (right) format.indentRight = right;
+  if (first !== void 0) format.indentFirstLine = twipsToCss(first);
+  else if (hanging !== void 0 && Number.isFinite(Number(hanging))) format.indentFirstLine = twipsToCss(String(-Number(hanging)));
+  return format;
+}
+function readCharacterFormat(rPr) {
+  const format = {};
+  if (!rPr) return format;
+  const f = readFormat(rPr);
+  if (f.b !== void 0) format.bold = f.b;
+  if (f.i !== void 0) format.italic = f.i;
+  if (f.u !== void 0) format.underline = f.u;
+  if (f.s !== void 0) format.strike = f.s;
+  const fonts = wChild(rPr, "rFonts");
+  const font = attr(fonts, "ascii") ?? attr(fonts, "hAnsi");
+  if (font && /^[\w .-]{1,64}$/.test(font)) format.fontFamily = font;
+  const size = Number(attr(wChild(rPr, "sz"), "val"));
+  if (Number.isFinite(size) && size > 0 && size < 3300) format.fontSize = `${size / 2}pt`;
+  const color = attr(wChild(rPr, "color"), "val");
+  if (color && /^[0-9a-f]{6}$/i.test(color)) format.color = `#${color.toLowerCase()}`;
+  if (toggle(wChild(rPr, "caps"))) format.textTransform = "uppercase";
+  const smallCaps = toggle(wChild(rPr, "smallCaps"));
+  if (smallCaps !== void 0) format.smallCaps = smallCaps;
+  return format;
+}
 function readStyles(doc) {
   const styles = /* @__PURE__ */ new Map();
   if (!doc) return styles;
@@ -2742,17 +2550,85 @@ function readStyles(doc) {
     const id = attr(style, "styleId");
     if (!id) return;
     const pPr = wChild(style, "pPr");
+    const rPr = wChild(style, "rPr");
     const outline = attr(wChild(pPr, "outlineLvl"), "val");
+    const priority = Number(attr(wChild(style, "uiPriority"), "val"));
     styles.set(id, {
       name: attr(wChild(style, "name"), "val") ?? id,
+      type: attr(style, "type") ?? "paragraph",
       basedOn: attr(wChild(style, "basedOn"), "val"),
+      next: attr(wChild(style, "next"), "val"),
+      link: attr(wChild(style, "link"), "val"),
+      priority: Number.isFinite(priority) && attr(wChild(style, "uiPriority"), "val") !== void 0 ? priority : void 0,
+      quick: toggle(wChild(style, "qFormat")),
+      hidden: toggle(wChild(style, "semiHidden")) || toggle(wChild(style, "hidden")),
       outlineLevel: outline !== void 0 ? Number(outline) : void 0,
       numPr: readNumPr(pPr),
-      format: readFormat(wChild(style, "rPr"))
+      format: readFormat(rPr),
+      paragraph: readParagraphFormat(pPr),
+      character: readCharacterFormat(rPr)
     });
   });
   return styles;
 }
+function displayStyleName(name) {
+  const heading = /^heading ([1-9])$/.exec(name);
+  return heading ? `Heading ${heading[1]}` : name;
+}
+function mapStyleIds(styles) {
+  const ids = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  styles.forEach((style, fileId) => {
+    if (style.type !== "paragraph" && style.type !== "character") return;
+    let id = fileId.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 60);
+    if (!/^[A-Za-z]/.test(id)) id = `S${id}`;
+    let unique = id;
+    for (let n = 2; used.has(unique); n++) unique = `${id}${n}`;
+    if (!isValidStyleId(unique)) return;
+    used.add(unique);
+    ids.set(fileId, unique);
+  });
+  return ids;
+}
+var styleKind = (style) => style?.type === "character" ? "character" : "paragraph";
+function styleDefinitions(styles, ids) {
+  const out = [];
+  styles.forEach((style, fileId) => {
+    const id = ids.get(fileId);
+    if (!id) return;
+    const kind = styleKind(style);
+    const sameKind = (other) => other && ids.has(other) && styleKind(styles.get(other)) === kind ? ids.get(other) : void 0;
+    const definition = { id, name: displayStyleName(style.name || fileId), kind };
+    const basedOn = sameKind(style.basedOn);
+    if (basedOn) definition.basedOn = basedOn;
+    if (kind === "paragraph") {
+      const next = sameKind(style.next);
+      if (next) definition.next = next;
+    }
+    const linked = style.link ? ids.get(style.link) : void 0;
+    if (linked) definition.linked = linked;
+    if (kind === "paragraph" && Object.keys(style.paragraph).length) definition.paragraph = style.paragraph;
+    if (Object.keys(style.character).length) definition.character = style.character;
+    if (kind === "paragraph") {
+      const heading = /^heading([1-6])$/i.exec(fileId) ?? /^heading ([1-6])$/i.exec(style.name);
+      if (heading) definition.block = { type: "heading", attrs: { level: Number(heading[1]) } };
+      else if (style.outlineLevel !== void 0 && style.outlineLevel >= 0 && style.outlineLevel <= 5) {
+        definition.block = { type: "heading", attrs: { level: style.outlineLevel + 1 } };
+      } else if (id === "Code") definition.block = { type: "codeBlock" };
+      else if (id === NORMAL_STYLE_ID) definition.block = { type: "paragraph" };
+    }
+    if (style.priority !== void 0) definition.priority = style.priority;
+    if (style.quick) definition.quick = true;
+    if (style.hidden) definition.hidden = true;
+    const builtin = DEFAULT_STYLES.find((s) => s.id === id && s.kind === kind);
+    if (builtin) {
+      definition.builtin = true;
+      definition.block ??= builtin.block;
+    }
+    out.push(definition);
+  });
+  return out;
+}
 function styleChain(styles, id) {
   const chain = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2778,6 +2654,16 @@ function styleHeadingLevel(styles, id) {
   if (id && /^title$/i.test(id)) return 1;
   return void 0;
 }
+function specialStyle(styles, id) {
+  if (!id) return void 0;
+  for (const style of styleChain(styles, id)) {
+    if (/^block ?text$/i.test(style.name)) return "quote";
+    if (/^code$/i.test(style.name)) return "code";
+  }
+  if (/^blocktext$/i.test(id)) return "quote";
+  if (id === "Code") return "code";
+  return void 0;
+}
 function readNumbering(doc) {
   const numbering = { abstracts: /* @__PURE__ */ new Map(), nums: /* @__PURE__ */ new Map() };
   if (!doc) return numbering;
@@ -2807,7 +2693,184 @@ function readNumbering(doc) {
   });
   return numbering;
 }
-var formatKey = (f) => `${f.b ? 1 : 0}${f.i ? 1 : 0}${f.u ? 1 : 0}${f.s ? 1 : 0}${f.sup ? 1 : 0}${f.sub ? 1 : 0}|${f.href ?? ""}`;
+function readPeople(doc) {
+  const people = /* @__PURE__ */ new Map();
+  if (!doc) return people;
+  descendants(doc, "person").forEach((person) => {
+    const author = attr(person, "author");
+    const userId = attr(descendants(person, "presenceInfo")[0], "userId");
+    if (author && userId && !people.has(author)) people.set(author, userId);
+  });
+  return people;
+}
+function dateOf(value) {
+  const ms = value ? Date.parse(value) : NaN;
+  return Number.isFinite(ms) ? ms : 0;
+}
+function authorOf(ctx, name) {
+  const authorName = (name ?? "").trim() || "Unknown";
+  return { id: ctx.people.get(authorName) ?? authorName, name: authorName };
+}
+function commentBody(comment) {
+  const lines = [];
+  const walk = (el, line) => {
+    for (const child of childElements(el)) {
+      if (!isW(child)) continue;
+      switch (child.localName) {
+        case "t":
+          line.push(child.textContent ?? "");
+          break;
+        case "tab":
+          line.push("	");
+          break;
+        case "br":
+        case "cr":
+          line.push("\n");
+          break;
+        case "delText":
+        case "del":
+        case "moveFrom":
+          break;
+        default:
+          walk(child, line);
+      }
+    }
+  };
+  for (const block of childElements(comment)) {
+    if (!isW(block)) continue;
+    const paragraphs = block.localName === "p" ? [block] : descendants(block, "p").filter((p) => isW(p));
+    for (const p of paragraphs) {
+      const line = [];
+      walk(p, line);
+      lines.push(line.join(""));
+    }
+  }
+  return lines.join("\n").trim();
+}
+function readComments(commentsXml, extendedXml, people) {
+  const byFileId = /* @__PURE__ */ new Map();
+  if (!commentsXml) return { threads: [], byFileId };
+  const entries = /* @__PURE__ */ new Map();
+  const byParaId = /* @__PURE__ */ new Map();
+  for (const comment of descendants(commentsXml, "comment").filter((el) => isW(el))) {
+    if (entries.size >= MAX_COMMENTS) break;
+    const fileId = attr(comment, "id");
+    if (fileId === void 0 || entries.has(fileId)) continue;
+    entries.set(fileId, {
+      fileId,
+      author: authorOf({ people }, attr(comment, "author")),
+      createdAt: dateOf(attr(comment, "date")),
+      body: commentBody(comment),
+      done: false
+    });
+    const paragraphs = descendants(comment, "p");
+    const paraId = attr(paragraphs[paragraphs.length - 1], "paraId");
+    if (paraId) byParaId.set(paraId, fileId);
+  }
+  if (extendedXml) {
+    for (const ex of descendants(extendedXml, "commentEx")) {
+      const fileId = byParaId.get(attr(ex, "paraId") ?? "");
+      const entry = fileId !== void 0 ? entries.get(fileId) : void 0;
+      if (!entry) continue;
+      const parent = byParaId.get(attr(ex, "paraIdParent") ?? "");
+      if (parent !== void 0 && parent !== fileId) entry.parent = parent;
+      const done = attr(ex, "done");
+      entry.done = done === "1" || done === "true";
+    }
+  }
+  const rootOf = (entry) => {
+    let current = entry;
+    for (let i = 0; i < MAX_PARENT_CHAIN && current.parent !== void 0; i++) {
+      const parent = entries.get(current.parent);
+      if (!parent || parent === entry) break;
+      current = parent;
+    }
+    return current;
+  };
+  const threads = /* @__PURE__ */ new Map();
+  for (const entry of entries.values()) {
+    if (rootOf(entry) !== entry) continue;
+    const id = createReviewId("comment");
+    byFileId.set(entry.fileId, id);
+    threads.set(entry.fileId, {
+      id,
+      anchor: null,
+      author: entry.author,
+      createdAt: entry.createdAt,
+      body: entry.body,
+      replies: [],
+      resolved: entry.done,
+      orphaned: false
+    });
+  }
+  for (const entry of entries.values()) {
+    const root = rootOf(entry);
+    if (root === entry) continue;
+    const thread = threads.get(root.fileId);
+    if (!thread) continue;
+    byFileId.set(entry.fileId, thread.id);
+    const reply = {
+      id: createReviewId("reply"),
+      author: entry.author,
+      body: entry.body,
+      createdAt: entry.createdAt
+    };
+    thread.replies.push(reply);
+  }
+  return { threads: Array.from(threads.values()), byFileId };
+}
+function applyMarker(el, ctx) {
+  switch (el.localName) {
+    case "commentRangeStart": {
+      const thread = ctx.commentThreads.get(attr(el, "id") ?? "");
+      if (thread) ctx.openComments.set(thread, (ctx.openComments.get(thread) ?? 0) + 1);
+      return true;
+    }
+    case "commentRangeEnd": {
+      const thread = ctx.commentThreads.get(attr(el, "id") ?? "");
+      const open = thread ? ctx.openComments.get(thread) : void 0;
+      if (thread && open !== void 0) {
+        if (open <= 1) ctx.openComments.delete(thread);
+        else ctx.openComments.set(thread, open - 1);
+      }
+      return true;
+    }
+    case "moveFromRangeStart":
+    case "moveToRangeStart": {
+      const id = attr(el, "id");
+      const name = attr(el, "name") ?? `range-${id}`;
+      let moveId = ctx.moveIds.get(name);
+      if (!moveId) {
+        moveId = createReviewId("move");
+        ctx.moveIds.set(name, moveId);
+      }
+      if (id !== void 0) {
+        ctx.moveRanges.delete(id);
+        ctx.moveRanges.set(id, { moveId, to: el.localName === "moveToRangeStart" });
+      }
+      return true;
+    }
+    case "moveFromRangeEnd":
+    case "moveToRangeEnd":
+      ctx.moveRanges.delete(attr(el, "id") ?? "");
+      return true;
+    default:
+      return false;
+  }
+}
+var FORMAT_MARK_TYPES = [
+  ["b", "bold"],
+  ["i", "italic"],
+  ["u", "underline"],
+  ["s", "strike"],
+  ["sub", "subscript"],
+  ["sup", "superscript"]
+];
+var formatMarks = (f) => FORMAT_MARK_TYPES.filter(([key]) => f[key]).map(([, type]) => ({ type }));
+var formatKey = (f) => `${f.b ? 1 : 0}${f.i ? 1 : 0}${f.u ? 1 : 0}${f.s ? 1 : 0}${f.sup ? 1 : 0}${f.sub ? 1 : 0}|${f.href ?? ""}` + (f.rev ? `|${f.rev.kind}:${f.rev.changeId}:${f.rev.moveId ?? ""}` : "") + (f.fmt ? `|f:${f.fmt.changeId}` : "") + (f.comments ? `|c:${f.comments.join(",")}` : "");
+function changeAttrs(change) {
+  return ` data-change-id="${escapeHtml(change.changeId)}" data-author-id="${escapeHtml(change.authorId)}" data-author-name="${escapeHtml(change.authorName)}" data-created-at="${change.createdAt}"`;
+}
 function wrapFormat(inner, f) {
   let html = inner;
   if (f.sup) html = `<sup>${html}</sup>`;
@@ -2816,10 +2879,19 @@ function wrapFormat(inner, f) {
   if (f.u) html = `<u>${html}</u>`;
   if (f.i) html = `<em>${html}</em>`;
   if (f.b) html = `<strong>${html}</strong>`;
+  if (f.fmt) {
+    html = `<span data-change-type="format"${changeAttrs(f.fmt)} data-format-before="${escapeHtml(JSON.stringify(f.fmt.before))}" data-format-after="${escapeHtml(JSON.stringify(f.fmt.after))}">${html}</span>`;
+  }
+  if (f.rev) {
+    const tag = f.rev.kind === "insertion" ? "ins" : "del";
+    const move = f.rev.moveId ? ` data-move-id="${escapeHtml(f.rev.moveId)}"` : "";
+    html = `<${tag} data-change-type="${f.rev.kind}"${changeAttrs(f.rev)}${move}>${html}</${tag}>`;
+  }
+  for (const id of [...f.comments ?? []].reverse()) html = `<span data-comment-id="${escapeHtml(id)}">${html}</span>`;
   if (f.href) html = `<a href="${escapeHtml(f.href)}">${html}</a>`;
   return html;
 }
-function renderSegments(segments) {
+function renderSegments(segments, code = false) {
   let html = "";
   let i = 0;
   while (i < segments.length) {
@@ -2829,11 +2901,12 @@ function renderSegments(segments) {
     for (; j < segments.length && formatKey(segments[j].format) === key; j++) {
       const seg = segments[j];
       if (seg.kind === "text") inner += escapeHtml(seg.text);
-      else if (seg.kind === "br") inner += "<br>";
-      else if (seg.kind === "img") inner += `<img src="${escapeHtml(seg.src)}" alt="${escapeHtml(seg.alt)}">`;
+      else if (seg.kind === "br") inner += code ? "\n" : "<br>";
+      else if (seg.kind === "img") inner += code ? "" : `<img src="${escapeHtml(seg.src)}" alt="${escapeHtml(seg.alt)}">`;
       else inner += `<sup>${seg.n}</sup>`;
     }
-    html += wrapFormat(inner, segments[i].format);
+    const format = segments[i].format;
+    html += wrapFormat(inner, code ? { rev: format.rev, comments: format.comments } : format);
     i = j;
   }
   return html;
@@ -2858,9 +2931,33 @@ var ParagraphRenderer = class {
   segments = [];
   /** Open complex fields (`w:fldChar`), innermost last. */
   fields = [];
-  render(p) {
+  collect(p) {
     this.walk(p, {});
-    return renderSegments(this.segments);
+    return this;
+  }
+  render(p) {
+    return this.collect(p).html();
+  }
+  html(code = false) {
+    return renderSegments(this.segments, code);
+  }
+  /** Removes a leading task-list glyph (`☐ ` / `☒ `) and returns its checked state. */
+  takeTaskGlyph() {
+    const first = this.segments[0];
+    if (!first || first.kind !== "text") return void 0;
+    const glyph = first.text.charAt(0);
+    if (!(glyph in TASK_GLYPHS)) return void 0;
+    const rest = first.text.slice(1).replace(/^ /, "");
+    if (rest) first.text = rest;
+    else {
+      this.segments.shift();
+      const next = this.segments[0];
+      if (next?.kind === "text") {
+        next.text = next.text.replace(/^ /, "");
+        if (!next.text) this.segments.shift();
+      }
+    }
+    return TASK_GLYPHS[glyph];
   }
   fieldHref() {
     for (let i = this.fields.length - 1; i >= 0; i--) {
@@ -2871,8 +2968,38 @@ var ParagraphRenderer = class {
   inFieldInstruction() {
     return this.fields.some((field) => !field.separated);
   }
+  /** A tracked change id shared with the previous change when adjacent and by the same author at the same time. */
+  changeId(key) {
+    const last = this.ctx.lastChange;
+    if (last && last.key === key && last.end === this.ctx.segmentCount) return last.changeId;
+    return createReviewId("change");
+  }
+  change(el, kind, extra = "") {
+    const author = authorOf(this.ctx, attr(el, "author"));
+    const createdAt = dateOf(attr(el, "date"));
+    const key = `${kind}|${author.name}|${createdAt}|${extra}`;
+    return {
+      key,
+      info: { changeId: this.changeId(key), authorId: author.id, authorName: author.name, createdAt }
+    };
+  }
+  revision(el, kind) {
+    let moveId;
+    if (el.localName === "moveFrom" || el.localName === "moveTo") {
+      const to = el.localName === "moveTo";
+      for (const range of this.ctx.moveRanges.values()) if (range.to === to) moveId = range.moveId;
+      moveId ??= createReviewId("move");
+    }
+    const { info, key } = this.change(el, kind, moveId ?? "");
+    return { rev: { ...info, kind, ...moveId ? { moveId } : {} }, key };
+  }
+  walkChange(el, base, kind) {
+    const { rev, key } = this.revision(el, kind);
+    this.walk(el, { ...base, rev });
+    this.ctx.lastChange = { key, changeId: rev.changeId, end: this.ctx.segmentCount };
+  }
   walk(el, base) {
-    const accepted = this.ctx.tracked === "accepted";
+    const tracked = this.ctx.tracked;
     for (const child of childElements(el)) {
       if (!isW(child)) {
         continue;
@@ -2896,11 +3023,13 @@ var ParagraphRenderer = class {
         }
         case "ins":
         case "moveTo":
-          if (accepted) this.walk(child, base);
+          if (tracked === "accepted") this.walk(child, base);
+          else if (tracked === "marks") this.walkChange(child, base, "insertion");
           break;
         case "del":
         case "moveFrom":
-          if (!accepted) this.walk(child, base);
+          if (tracked === "original") this.walk(child, base);
+          else if (tracked === "marks") this.walkChange(child, base, "deletion");
           break;
         case "sdt":
           this.walk(wChild(child, "sdtContent") ?? child, base);
@@ -2913,24 +3042,42 @@ var ParagraphRenderer = class {
           this.walk(child, base);
           break;
         default:
+          applyMarker(child, this.ctx);
           break;
       }
     }
   }
   run(r, base) {
     const rPr = wChild(r, "rPr");
-    const styleFormat = this.ctx.styles.get(attr(wChild(rPr, "rStyle"), "val") ?? "")?.format ?? {};
+    const runStyle = this.ctx.styles.get(attr(wChild(rPr, "rStyle"), "val") ?? "");
+    const styleFormat = base.href && runStyle && /^hyperlink$/i.test(runStyle.name) ? {} : runStyle?.format ?? {};
     const own = readFormat(rPr);
     const format = { ...base, ...styleFormat, ...own };
+    const rPrChange = wChild(rPr, "rPrChange");
+    let changeKey;
+    if (rPrChange && this.ctx.tracked === "marks") {
+      const { info, key } = this.change(rPrChange, "format");
+      const before = { ...styleFormat, ...readFormat(wChild(rPrChange, "rPr")) };
+      format.fmt = { ...info, before: formatMarks(before), after: formatMarks(format) };
+      changeKey = key;
+    }
     for (const child of childElements(r)) {
       this.runChild(child, format);
     }
+    if (format.fmt && changeKey) {
+      this.ctx.lastChange = { key: changeKey, changeId: format.fmt.changeId, end: this.ctx.segmentCount };
+    }
   }
   runChild(child, format) {
     const push = (segment) => {
       if (this.inFieldInstruction()) return;
       const href = format.href ?? this.fieldHref();
-      this.segments.push(href && !format.href ? { ...segment, format: { ...format, href } } : segment);
+      let out = href && !format.href ? { ...segment, format: { ...format, href } } : segment;
+      if (this.ctx.openComments.size) {
+        out = { ...out, format: { ...out.format, comments: Array.from(this.ctx.openComments.keys()) } };
+      }
+      this.segments.push(out);
+      this.ctx.segmentCount++;
     };
     if (child.localName === "AlternateContent") {
       const branch = childElements(child).find(
@@ -2945,7 +3092,7 @@ var ParagraphRenderer = class {
         push({ kind: "text", text: child.textContent ?? "", format });
         break;
       case "delText":
-        if (this.ctx.tracked === "original") push({ kind: "text", text: child.textContent ?? "", format });
+        if (this.ctx.tracked !== "accepted") push({ kind: "text", text: child.textContent ?? "", format });
         break;
       case "tab":
       case "ptab":
@@ -3009,8 +3156,16 @@ var ParagraphRenderer = class {
     push({ kind: "img", src, alt, format });
   }
 };
+var MARKERS = /* @__PURE__ */ new Set([
+  "commentRangeStart",
+  "commentRangeEnd",
+  "moveFromRangeStart",
+  "moveFromRangeEnd",
+  "moveToRangeStart",
+  "moveToRangeEnd"
+]);
 function flattenBlocks(container, ctx, out = []) {
-  const accepted = ctx.tracked === "accepted";
+  const tracked = ctx.tracked;
   for (const child of childElements(container)) {
     if (!isW(child)) continue;
     switch (child.localName) {
@@ -3027,13 +3182,14 @@ function flattenBlocks(container, ctx, out = []) {
         break;
       case "ins":
       case "moveTo":
-        if (accepted) flattenBlocks(child, ctx, out);
+        if (tracked !== "original") flattenBlocks(child, ctx, out);
         break;
       case "del":
       case "moveFrom":
-        if (!accepted) flattenBlocks(child, ctx, out);
+        if (tracked !== "accepted") flattenBlocks(child, ctx, out);
         break;
       default:
+        if (MARKERS.has(child.localName)) out.push(child);
         break;
     }
   }
@@ -3062,9 +3218,30 @@ function paragraphInfo(p, ctx) {
       start: num?.starts.get(numPr.ilvl) ?? def?.start ?? 1
     };
   }
-  return { heading, list };
+  const special = heading === void 0 && !list ? specialStyle(ctx.styles, styleId) : void 0;
+  return { heading, list, styleId, special, pPr };
+}
+function blockChangeAttr(pPr, ctx) {
+  const change = wChild(pPr, "pPrChange");
+  if (!change) return "";
+  const oldPPr = wChild(change, "pPr");
+  const oldStyle = attr(wChild(oldPPr, "pStyle"), "val");
+  const oldOutline = attr(wChild(oldPPr, "outlineLvl"), "val");
+  const level = oldOutline !== void 0 ? Number(oldOutline) >= 0 && Number(oldOutline) <= 5 ? Number(oldOutline) + 1 : void 0 : styleHeadingLevel(ctx.styles, oldStyle);
+  const mappedStyle = oldStyle ? ctx.styleIds.get(oldStyle) : void 0;
+  const previous = level !== void 0 ? { type: "heading", attrs: { level }, wrappers: [] } : specialStyle(ctx.styles, oldStyle) === "code" ? { type: "codeBlock", attrs: {}, wrappers: [] } : { type: "paragraph", attrs: mappedStyle && mappedStyle !== NORMAL_STYLE_ID ? { styleId: mappedStyle } : {}, wrappers: [] };
+  const author = authorOf(ctx, attr(change, "author"));
+  const record = {
+    changeId: createReviewId("change"),
+    authorId: author.id,
+    authorName: author.name,
+    authorColor: null,
+    createdAt: dateOf(attr(change, "date")),
+    previous
+  };
+  return ` data-block-change="${escapeHtml(JSON.stringify(record))}"`;
 }
-function renderBlocks(container, ctx, part) {
+function renderBlocks(container, ctx, part, topLevel = false) {
   let html = "";
   const stack = [];
   const closeList = () => {
@@ -3074,34 +3251,62 @@ function renderBlocks(container, ctx, part) {
   const closeAll = () => {
     while (stack.length) closeList();
   };
+  let group = null;
+  const flush = () => {
+    if (!group) return;
+    html += group.kind === "quote" ? `<blockquote>${group.parts.join("")}</blockquote>` : `<pre><code>${group.parts.join("\n")}</code></pre>`;
+    group = null;
+  };
   for (const block of flattenBlocks(container, ctx)) {
+    if (MARKERS.has(block.localName)) {
+      applyMarker(block, ctx);
+      continue;
+    }
     if (block.localName === "tbl") {
       closeAll();
+      flush();
       html += renderTable(block, ctx, part);
       continue;
     }
-    const { heading, list } = paragraphInfo(block, ctx);
-    const inner = new ParagraphRenderer(ctx, part).render(block);
-    const blockHtml = heading ? `<h${heading}>${inner}</h${heading}>` : `<p>${inner}</p>`;
+    const { heading, list, styleId, special, pPr } = paragraphInfo(block, ctx);
+    const renderer = new ParagraphRenderer(ctx, part).collect(block);
+    if (special) {
+      closeAll();
+      if (group && group.kind !== special) flush();
+      group ??= { kind: special, parts: [] };
+      group.parts.push(special === "code" ? renderer.html(true) : `<p>${renderer.html()}</p>`);
+      continue;
+    }
+    flush();
+    const task = list && !list.ordered ? renderer.takeTaskGlyph() : void 0;
+    const inner = renderer.html();
+    const mappedStyle = styleId ? ctx.styleIds.get(styleId) : void 0;
+    const styleAttr = !heading && !list && mappedStyle && mappedStyle !== NORMAL_STYLE_ID ? ` data-style="${escapeHtml(mappedStyle)}"` : "";
+    const changeAttr = topLevel && !list && ctx.tracked === "marks" ? blockChangeAttr(pPr, ctx) : "";
+    const blockHtml = heading ? `<h${heading}${changeAttr}>${inner}</h${heading}>` : `<p${styleAttr}${changeAttr}>${inner}</p>`;
     if (!list) {
       closeAll();
       html += blockHtml;
       continue;
     }
     const tag = list.ordered ? "ol" : "ul";
+    const isTask = task !== void 0;
+    const item = isTask ? `<li data-type="taskItem" data-checked="${task ? "true" : "false"}">` : "<li>";
     while (stack.length && stack[stack.length - 1].level > list.level) closeList();
     const top = stack[stack.length - 1];
-    if (top && top.level === list.level && top.tag === tag) {
-      html += "</li><li>";
+    if (top && top.level === list.level && top.tag === tag && top.task === isTask) {
+      html += `</li>${item}`;
     } else {
       if (top && top.level === list.level) closeList();
       const start2 = tag === "ol" && list.start !== 1 ? ` start="${list.start}"` : "";
-      html += `<${tag}${start2}><li>`;
-      stack.push({ level: list.level, tag });
+      const type = isTask ? ' data-type="taskList"' : "";
+      html += `<${tag}${type}${start2}>${item}`;
+      stack.push({ level: list.level, tag, task: isTask });
     }
     html += blockHtml;
   }
   closeAll();
+  flush();
   return html;
 }
 function renderTable(tbl, ctx, part) {
@@ -3195,12 +3400,38 @@ async function docxToDocumentImport(data, options = {}) {
   const baseDir = dirname(mainPath);
   const stylesPath = partByType("styles") ?? `${baseDir}styles.xml`;
   const numberingPath = partByType("numbering") ?? `${baseDir}numbering.xml`;
+  const styles = readStyles(await readXmlPart(zip, Parser, stylesPath));
+  const useStyles = options.paragraphStyles !== false;
+  const styleIds = useStyles ? mapStyleIds(styles) : /* @__PURE__ */ new Map();
+  const peoplePath = partByType("people");
+  const people = readPeople(peoplePath ? await readXmlPart(zip, Parser, peoplePath) : null);
+  let threads = [];
+  let commentThreads = /* @__PURE__ */ new Map();
+  if (options.comments !== false) {
+    const commentsPath = partByType("comments");
+    const extendedPath = partByType("commentsExtended");
+    const read = readComments(
+      commentsPath ? await readXmlPart(zip, Parser, commentsPath) : null,
+      extendedPath ? await readXmlPart(zip, Parser, extendedPath) : null,
+      people
+    );
+    threads = read.threads;
+    commentThreads = read.byFileId;
+  }
   const ctx = {
-    styles: readStyles(await readXmlPart(zip, Parser, stylesPath)),
+    styles,
     numbering: readNumbering(await readXmlPart(zip, Parser, numberingPath)),
     notes: /* @__PURE__ */ new Map(),
     noteOrder: [],
-    tracked: options.trackedChanges ?? "accepted"
+    tracked: options.trackedChanges ?? "accepted",
+    styleIds,
+    people,
+    commentThreads,
+    openComments: /* @__PURE__ */ new Map(),
+    moveRanges: /* @__PURE__ */ new Map(),
+    moveIds: /* @__PURE__ */ new Map(),
+    segmentCount: 0,
+    lastChange: null
   };
   for (const kind of ["footnote", "endnote"]) {
     const path = partByType(`${kind}s`) ?? `${baseDir}${kind}s.xml`;
@@ -3215,7 +3446,7 @@ async function docxToDocumentImport(data, options = {}) {
     });
   }
   const part = { rels, images: await loadImages(zip, documentXml, rels, options) };
-  let html = renderBlocks(body, ctx, part);
+  let html = renderBlocks(body, ctx, part, true);
   if (ctx.noteOrder.length) {
     let notesHtml = "";
     for (let i = 0; i < ctx.noteOrder.length; i++) {
@@ -3225,7 +3456,13 @@ async function docxToDocumentImport(data, options = {}) {
     html += `<hr><ol>${notesHtml}</ol>`;
   }
   const sanitized = sanitizeImportedHtml(html);
-  return { html: sanitized, text: htmlToPlainText(sanitized) };
+  const result = { html: sanitized, text: htmlToPlainText(sanitized) };
+  if (threads.length) result.comments = { version: 1, threads };
+  if (useStyles) {
+    const definitions = styleDefinitions(styles, styleIds);
+    if (definitions.length) result.styles = createStyleRegistry({ styles: definitions });
+  }
+  return result;
 }
 function createDocxImportAdapter(options = {}) {
   return {
@@ -3342,16 +3579,46 @@ function insertImportedDocument(target, content, options = {}) {
   view.dispatch(tr.scrollIntoView().setMeta("uiEvent", "drop"));
   return end;
 }
+function applyImportedReviewData(editor, content) {
+  const storage = editor?.storage ?? {};
+  let comments = 0;
+  let styles = 0;
+  const store = storage.comment?.store;
+  const threads = content.comments?.threads ?? [];
+  if (store && threads.length) {
+    const existing = store.toJSON().threads;
+    const fresh = threads.filter((thread) => !existing.some((t) => t.id === thread.id));
+    if (fresh.length) {
+      store.load({ version: 1, threads: [...existing, ...fresh] });
+      comments = fresh.length;
+    }
+  }
+  const registry = storage.paragraphStyles?.registry;
+  if (registry && content.styles) {
+    for (const style of content.styles.list()) {
+      if (registry.get(style.id)) continue;
+      registry.upsert(style);
+      styles++;
+    }
+  }
+  return { comments, styles };
+}
 async function importFilesIntoEditor(target, files, options = {}) {
   const registry = options.registry ?? defaultImportRegistry;
   const outcomes = [];
   let at = options.at;
   for (const file of Array.from(files)) {
     try {
-      const outcome = await registry.importFile(file, { target: "document" });
+      const outcome = await registry.importFile(file, {
+        target: "document",
+        adapterOptions: options.adapterOptions
+      });
       const view = toView(target);
       if (view.isDestroyed) break;
       at = insertImportedDocument(view, outcome.result, { at, asPlainText: options.asPlainText });
+      if (!options.asPlainText && "storage" in target) {
+        applyImportedReviewData(target, outcome.result);
+      }
       outcomes.push(outcome);
       options.onImport?.(outcome, file);
     } catch (error) {
@@ -3382,6 +3649,7 @@ var FileImport = Extension8.create({
   addOptions() {
     return {
       registry: void 0,
+      adapterOptions: void 0,
       asPlainText: false,
       enableDrop: true,
       enablePaste: true,
@@ -3397,6 +3665,7 @@ var FileImport = Extension8.create({
         registry: registry(),
         at,
         asPlainText: options.asPlainText,
+        adapterOptions: options.adapterOptions,
         onImport: options.onImport,
         onError: options.onImportError
       });
@@ -6469,6 +6738,365 @@ function safeClipboard(get) {
   }
 }
 
+// src/extensions/paragraph-styles/extension.ts
+import { Extension as Extension13, Mark as Mark5, mergeAttributes as mergeAttributes7 } from "@tiptap/core";
+import { Plugin as Plugin15, PluginKey as PluginKey12 } from "@tiptap/pm/state";
+var STYLE_ID_ATTRIBUTE = "styleId";
+var CHARACTER_STYLE_MARK_NAME = "characterStyle";
+var paragraphStylesPluginKey = new PluginKey12("paragraphStyles");
+function getStyleRegistry(editor) {
+  return editor?.storage?.paragraphStyles?.registry ?? null;
+}
+function headingLevels(editor) {
+  const heading = editor?.extensionManager?.extensions.find((e) => e.name === "heading");
+  const levels = heading?.options?.levels;
+  return Array.isArray(levels) ? levels : null;
+}
+function isParagraphStyleAvailable(editor, registry, id) {
+  const style = registry.get(id);
+  if (!style || style.kind !== "paragraph") return false;
+  const block = registry.resolve(id).block;
+  if (!editor.schema.nodes[block.type]) return false;
+  if (block.type === "heading") {
+    const levels = headingLevels(editor);
+    if (levels && !levels.includes(Number(block.attrs?.level))) return false;
+  }
+  return true;
+}
+function getParagraphStyleAt(state, registry, pos = state.selection.from) {
+  const $pos = state.doc.resolve(Math.max(0, Math.min(pos, state.doc.content.size)));
+  const block = $pos.parent;
+  if (!block.isTextblock) return null;
+  return registry.styleOfBlock(block.type.name, block.attrs);
+}
+var MARK_FORMAT = {
+  bold: "bold",
+  italic: "italic",
+  underline: "underline",
+  strike: "strike"
+};
+function selectionMarks(state) {
+  const { from, to, empty, $from } = state.selection;
+  if (empty) return state.storedMarks ?? $from.marks();
+  let common = null;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (!node.isText) return true;
+    common = common === null ? node.marks : common.filter((m) => m.isInSet(node.marks));
+    return false;
+  });
+  return common ?? $from.marks();
+}
+function captureSelectionFormat(state) {
+  const character = {};
+  selectionMarks(state).forEach((mark) => {
+    const name = mark.type.name;
+    if (MARK_FORMAT[name]) character[MARK_FORMAT[name]] = true;
+    if (name === "textStyle") {
+      if (mark.attrs.fontFamily) character.fontFamily = mark.attrs.fontFamily;
+      if (mark.attrs.fontSize) character.fontSize = mark.attrs.fontSize;
+      if (mark.attrs.color) character.color = mark.attrs.color;
+    }
+    if (name === "highlight") character.backgroundColor = mark.attrs.color || "#fef08a";
+  });
+  const paragraph = {};
+  const align = state.selection.$from.parent.attrs?.textAlign;
+  if (align && align !== "left") paragraph.textAlign = align;
+  return { paragraph, character };
+}
+function carriedAttributes(node, type) {
+  const spec = type.spec.attrs ?? {};
+  return Object.fromEntries(Object.entries(node.attrs).filter(([key]) => key in spec));
+}
+function applyStyleToBlock(tr, pos, id, registry) {
+  const node = tr.doc.nodeAt(pos);
+  if (!node || !node.isTextblock) return false;
+  const resolved = registry.resolve(id);
+  const type = tr.doc.type.schema.nodes[resolved.block.type];
+  if (!type) return false;
+  const blockAttrs = resolved.block.attrs ?? {};
+  const isDefault = registry.defaultStyleFor(resolved.block.type, blockAttrs) === id;
+  const attrs = { ...carriedAttributes(node, type), ...blockAttrs };
+  if (STYLE_ID_ATTRIBUTE in (type.spec.attrs ?? {})) attrs[STYLE_ID_ATTRIBUTE] = isDefault ? null : id;
+  if ("textAlign" in (type.spec.attrs ?? {})) {
+    const fallback = type.spec.attrs.textAlign.default ?? null;
+    attrs.textAlign = fallback === null ? null : resolved.paragraph.textAlign ?? fallback;
+  }
+  if (node.type === type && Object.entries(attrs).every(([k, v]) => node.attrs[k] === v)) return false;
+  try {
+    tr.setNodeMarkup(pos, type, attrs);
+  } catch {
+    try {
+      tr.setBlockType(pos + 1, pos + 1, type, attrs);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function selectedBlocks(state) {
+  const { from, to } = state.selection;
+  const positions = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isTextblock) {
+      positions.push(pos);
+      return false;
+    }
+    return true;
+  });
+  if (positions.length === 0 && state.selection.$from.parent.isTextblock) {
+    positions.push(state.selection.$from.before());
+  }
+  return positions;
+}
+function setParagraphStyle(tr, state, id, registry) {
+  const start2 = tr.steps.length;
+  selectedBlocks(state).forEach((pos) => {
+    applyStyleToBlock(tr, tr.mapping.slice(start2).map(pos), id, registry);
+  });
+}
+function nextStyleTransaction(transactions, oldState, newState, registry) {
+  if (transactions.length !== 1) return null;
+  const [tr] = transactions;
+  if (!tr.docChanged || tr.getMeta("uiEvent") || tr.getMeta("history$") || tr.getMeta("y-sync$")) {
+    return null;
+  }
+  const old = oldState.selection;
+  const $old = old.$from;
+  if (!old.empty || !$old.parent.isTextblock || $old.parent.type.spec.code) return null;
+  if ($old.parentOffset !== $old.parent.content.size) return null;
+  if (newState.doc.content.size !== oldState.doc.content.size + 2) return null;
+  const $new = newState.selection.$from;
+  if (!newState.selection.empty || !$new.parent.isTextblock || $new.parent.content.size !== 0) return null;
+  const depth = $new.depth;
+  const index = $new.index(depth - 1);
+  if (index === 0 || $new.depth !== $old.depth) return null;
+  const previous = $new.node(depth - 1).child(index - 1);
+  if (!previous.isTextblock || !previous.eq($old.parent)) return null;
+  const style = registry.styleOfBlock($old.parent.type.name, $old.parent.attrs);
+  if (!style) return null;
+  const next = registry.nextStyleId(style);
+  const current = registry.styleOfBlock($new.parent.type.name, $new.parent.attrs);
+  const target = registry.resolve(next).block;
+  const typeMatches = $new.parent.type.name === target.type && Object.entries(target.attrs ?? {}).every(([k, v]) => $new.parent.attrs[k] === v);
+  if (current === next && typeMatches) return null;
+  const out = newState.tr;
+  if (!applyStyleToBlock(out, $new.before(), next, registry)) return null;
+  return out;
+}
+var CharacterStyle = Mark5.create({
+  name: CHARACTER_STYLE_MARK_NAME,
+  addAttributes() {
+    return {
+      [STYLE_ID_ATTRIBUTE]: {
+        default: null,
+        parseHTML: (el) => {
+          const id = el.getAttribute("data-char-style");
+          return isValidStyleId(id) ? id : null;
+        },
+        renderHTML: (attrs) => attrs[STYLE_ID_ATTRIBUTE] ? { "data-char-style": attrs[STYLE_ID_ATTRIBUTE] } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-char-style]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes7(HTMLAttributes), 0];
+  }
+});
+var ParagraphStyles = Extension13.create({
+  name: "paragraphStyles",
+  addOptions() {
+    return {
+      registry: null,
+      types: ["paragraph", "heading", "codeBlock"],
+      injectCSS: true,
+      cssScope: ".ProseMirror",
+      cssNonce: void 0,
+      linkedCharacterStyles: true
+    };
+  },
+  addStorage() {
+    return { registry: this.options.registry ?? createStyleRegistry() };
+  },
+  addExtensions() {
+    return [CharacterStyle];
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          [STYLE_ID_ATTRIBUTE]: {
+            default: null,
+            keepOnSplit: true,
+            parseHTML: (el) => {
+              const id = el.getAttribute("data-style");
+              return isValidStyleId(id) ? id : null;
+            },
+            renderHTML: (attrs) => {
+              const id = attrs[STYLE_ID_ATTRIBUTE];
+              return isValidStyleId(id) ? { "data-style": id, class: `pixerate-style-${id}` } : {};
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    const registry = () => this.storage.registry;
+    const editor = () => this.editor;
+    return {
+      setParagraphStyle: (id) => ({ state, tr, dispatch }) => {
+        const reg = registry();
+        if (!isParagraphStyleAvailable(editor(), reg, id)) return false;
+        const { $from, $to, empty } = state.selection;
+        const linked = this.options.linkedCharacterStyles ? reg.linkedCharacterStyle(id) : void 0;
+        const partial = !empty && $from.sameParent($to) && $from.parent.isTextblock && ($from.parentOffset > 0 || $to.parentOffset < $from.parent.content.size);
+        const markType = state.schema.marks[CHARACTER_STYLE_MARK_NAME];
+        if (partial && linked && markType) {
+          if (dispatch) {
+            tr.addMark($from.pos, $to.pos, markType.create({ [STYLE_ID_ATTRIBUTE]: linked.id }));
+          }
+          return true;
+        }
+        if (dispatch) setParagraphStyle(tr, state, id, reg);
+        return true;
+      },
+      clearParagraphStyle: () => ({ commands }) => commands.setParagraphStyle(NORMAL_STYLE_ID),
+      setCharacterStyle: (id) => ({ commands }) => {
+        if (registry().get(id)?.kind !== "character") return false;
+        return commands.setMark(CHARACTER_STYLE_MARK_NAME, { [STYLE_ID_ATTRIBUTE]: id });
+      },
+      unsetCharacterStyle: () => ({ commands }) => commands.unsetMark(CHARACTER_STYLE_MARK_NAME),
+      updateParagraphStyleFromSelection: (id) => ({ state, dispatch }) => {
+        const reg = registry();
+        const target = id ?? getParagraphStyleAt(state, reg);
+        const style = target ? reg.get(target) : void 0;
+        if (!style || style.kind !== "paragraph") return false;
+        if (dispatch) {
+          const captured = captureSelectionFormat(state);
+          reg.update(style.id, captured);
+        }
+        return true;
+      },
+      createParagraphStyleFromSelection: (name, options = {}) => ({ state, tr, dispatch }) => {
+        const reg = registry();
+        const trimmed = name.trim();
+        if (!trimmed) return false;
+        const id = options.id ?? reg.newId(trimmed);
+        if (!isValidStyleId(id) || reg.get(id)) return false;
+        const basedOn = options.basedOn === void 0 ? getParagraphStyleAt(state, reg) : options.basedOn;
+        if (dispatch) {
+          const captured = captureSelectionFormat(state);
+          const definition = {
+            id,
+            name: trimmed,
+            kind: "paragraph",
+            basedOn: basedOn ?? NORMAL_STYLE_ID,
+            paragraph: captured.paragraph,
+            character: captured.character,
+            priority: 50,
+            quick: true
+          };
+          reg.upsert(definition);
+          if (options.apply !== false) setParagraphStyle(tr, state, id, reg);
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const registry = this.storage.registry;
+    return [
+      new Plugin15({
+        key: paragraphStylesPluginKey,
+        appendTransaction: (transactions, oldState, newState) => nextStyleTransaction(transactions, oldState, newState, registry)
+      })
+    ];
+  },
+  onBeforeCreate() {
+    if (!this.options.injectCSS || typeof document === "undefined") return;
+    const element = document.createElement("style");
+    element.setAttribute("data-pixerate-paragraph-styles", "");
+    if (this.options.cssNonce) element.nonce = this.options.cssNonce;
+    document.head.appendChild(element);
+    const scope = this.options.cssScope;
+    const unsubscribe = this.storage.registry.subscribe(() => {
+      element.textContent = this.storage.registry.toCSS({ scope });
+    });
+    this.storage.cleanup = () => {
+      unsubscribe();
+      element.remove();
+    };
+  },
+  onDestroy() {
+    this.storage.cleanup?.();
+  }
+});
+var EMPTY_STYLES = Object.freeze({
+  gallery: [],
+  styles: [],
+  characterStyles: [],
+  currentStyleId: null,
+  version: -1
+});
+function createParagraphStylesStore(editor) {
+  const registry = getStyleRegistry(editor);
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = EMPTY_STYLES;
+  let unsubscribeRegistry = null;
+  const compute = () => {
+    if (!editor || editor.isDestroyed || !registry) return EMPTY_STYLES;
+    const { version } = registry.getSnapshot();
+    const currentStyleId = getParagraphStyleAt(editor.state, registry);
+    if (snapshot.version === version && snapshot.currentStyleId === currentStyleId) return snapshot;
+    if (snapshot.version === version) return { ...snapshot, currentStyleId };
+    const styles = registry.list("paragraph").filter((style) => !style.hidden && isParagraphStyleAvailable(editor, registry, style.id));
+    return {
+      gallery: styles.filter((style) => style.quick),
+      styles,
+      characterStyles: registry.list("character").filter((style) => !style.hidden),
+      currentStyleId,
+      version
+    };
+  };
+  const update = () => {
+    const next = compute();
+    if (next !== snapshot) {
+      snapshot = next;
+      listeners.forEach((listener) => listener());
+    }
+  };
+  const detach = () => {
+    editor?.off("transaction", update);
+    unsubscribeRegistry?.();
+    unsubscribeRegistry = null;
+  };
+  return {
+    getSnapshot: () => {
+      if (!listeners.size) snapshot = compute();
+      return snapshot;
+    },
+    subscribe(listener) {
+      if (!listeners.size) {
+        snapshot = compute();
+        editor?.on("transaction", update);
+        unsubscribeRegistry = registry ? registry.subscribe(update) : null;
+      }
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (!listeners.size) detach();
+      };
+    },
+    destroy() {
+      detach();
+      listeners.clear();
+    }
+  };
+}
+
 // src/extensions/rich-text-preset.ts
 var resolveExt3 = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
 var StarterKit = resolveExt3(_StarterKit, "StarterKit");
@@ -6491,7 +7119,7 @@ function createRichTextPreset(options = {}) {
     openLinksOnClick = false,
     enableSmilies = true,
     enableColorHighlighter = true,
-    headingLevels = [1, 2, 3, 4]
+    headingLevels: headingLevels2 = [1, 2, 3, 4]
   } = options;
   const extensions2 = [
     StarterKit.configure({
@@ -6506,7 +7134,7 @@ function createRichTextPreset(options = {}) {
         }
       },
       heading: {
-        levels: headingLevels,
+        levels: headingLevels2,
         HTMLAttributes: {
           class: "font-bold tracking-tight"
         }
@@ -6565,6 +7193,9 @@ function createRichTextPreset(options = {}) {
       placeholder: typeof placeholder === "function" ? placeholder : () => placeholder
     })
   ];
+  if (options.table !== false) {
+    extensions2.push(...createTableExtensions(optionObject(options.table)));
+  }
   if (characterLimit) {
     extensions2.push(
       CharacterCount.configure({
@@ -6668,6 +7299,9 @@ function createRichTextPreset(options = {}) {
   if (options.findReplace) {
     extensions2.push(FindReplace.configure(optionObject(options.findReplace)));
   }
+  if (options.paragraphStyles) {
+    extensions2.push(ParagraphStyles.configure(optionObject(options.paragraphStyles)));
+  }
   return extensions2;
 }
 
@@ -6808,6 +7442,69 @@ function validateFindPattern(query, options = {}) {
   return result.ok ? null : result.error;
 }
 
+// src/extensions/table/commands.ts
+var PARAMS = {
+  insertTable: {
+    type: "object",
+    properties: {
+      rows: { type: "integer", minimum: 1, maximum: MAX_TABLE_ROWS, description: "Rows (default 3)." },
+      cols: { type: "integer", minimum: 1, maximum: MAX_TABLE_COLUMNS, description: "Columns (default 3)." },
+      withHeaderRow: { type: "boolean", description: "Make the first row a header row (default true)." }
+    },
+    additionalProperties: false
+  },
+  setCellAlignment: {
+    type: "object",
+    properties: {
+      align: {
+        type: ["string", "null"],
+        enum: ["left", "center", "right", "justify", null],
+        description: "Horizontal alignment; null clears it."
+      }
+    },
+    required: ["align"],
+    additionalProperties: false
+  },
+  setCellBackground: {
+    type: "object",
+    properties: {
+      color: { type: ["string", "null"], description: "CSS color (e.g. #fde68a); null clears it." }
+    },
+    required: ["color"],
+    additionalProperties: false
+  }
+};
+function createTableCommands(editor, options = {}) {
+  const prefix = options.prefix ?? "table.";
+  const group = options.group ?? "Table";
+  const scope = options.scope ? { scope: options.scope } : {};
+  const focus = options.focus ?? true;
+  return TABLE_ACTIONS.map(({ action, label, description, keywords }) => {
+    const params = PARAMS[action];
+    return {
+      id: `${prefix}${action}`,
+      label,
+      group,
+      keywords: [...keywords],
+      description,
+      ...params ? { params } : {},
+      ...scope,
+      enabled: (_ctx, p) => getTableActionState(editor, action, p ?? {}),
+      run: (_ctx, p) => {
+        if (!runTableAction(editor, action, p ?? {}, { focus })) {
+          const reason = getTableActionState(editor, action, p ?? {});
+          throw new Error(reason === true ? `${label} did not change the document.` : reason);
+        }
+        const state = getTableState(editor);
+        return {
+          done: true,
+          table: state.inTable ? { rows: state.rows, columns: state.columns, row: state.row, column: state.column } : null
+        };
+      }
+    };
+  });
+}
+
 export {
   GradientText,
   SlashCommands,
@@ -6820,6 +7517,8 @@ export {
   ColorHighlighter,
   FontSize,
   Mention,
+  getMentionNodes,
+  setMentionRoleAt,
   createMentionExtension,
   Markdown2 as Markdown,
   imagePastePluginKey,
@@ -6842,13 +7541,6 @@ export {
   ImportError,
   createImportContext,
   ImportAdapterRegistry,
-  ZipError,
-  DEFAULT_ZIP_MAX_ENTRIES,
-  DEFAULT_ZIP_MAX_TOTAL_SIZE,
-  zipCrc32,
-  isUnsafeZipPath,
-  ZipArchive,
-  readZip,
   DOCX_MIME_TYPES,
   DEFAULT_DOCX_MAX_IMAGE_SIZE,
   docxToDocumentImport,
@@ -6868,6 +7560,7 @@ export {
   getImportAccept,
   htmlToSlice,
   insertImportedDocument,
+  applyImportedReviewData,
   importFilesIntoEditor,
   fileImportPluginKey,
   FileImport,
@@ -6929,8 +7622,19 @@ export {
   FIND_OPTION_TOGGLES,
   formatFindStatus,
   FindReplace,
+  STYLE_ID_ATTRIBUTE,
+  CHARACTER_STYLE_MARK_NAME,
+  paragraphStylesPluginKey,
+  getStyleRegistry,
+  isParagraphStyleAvailable,
+  getParagraphStyleAt,
+  captureSelectionFormat,
+  CharacterStyle,
+  ParagraphStyles,
+  createParagraphStylesStore,
   createRichTextPreset,
   createFindReplaceCommands,
-  validateFindPattern
+  validateFindPattern,
+  createTableCommands
 };
-//# sourceMappingURL=chunk-ITBSKI26.js.map
+//# sourceMappingURL=chunk-Q2OHWD2A.js.map