@pixerate/editor 0.21.0 → 0.22.0

package/dist/{chunk-4QPLEUL2.cjs → chunk-GVSMRPHB.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
 
 
 
@@ -13,7 +13,7 @@ var _chunkAXV2ZW34cjs = require('./chunk-AXV2ZW34.cjs');
 
 
 
-var _chunkLA7PEGU3cjs = require('./chunk-LA7PEGU3.cjs');
+var _chunkCL37JGFWcjs = require('./chunk-CL37JGFW.cjs');
 
 
 
@@ -21,7 +21,8 @@ var _chunkLA7PEGU3cjs = require('./chunk-LA7PEGU3.cjs');
 
 
 
-var _chunkTVRC4KVTcjs = require('./chunk-TVRC4KVT.cjs');
+
+var _chunkAA4ZEVCCcjs = require('./chunk-AA4ZEVCC.cjs');
 
 // src/extensions/gradient-text.ts
 var _core = require('@tiptap/core');
@@ -1862,7 +1863,7 @@ var Comments = _core.Mark.create({
   },
   addStorage() {
     return {
-      store: _nullishCoalesce(this.options.store, () => ( new (0, _chunkTVRC4KVTcjs.CommentStore)())),
+      store: _nullishCoalesce(this.options.store, () => ( new (0, _chunkAA4ZEVCCcjs.CommentStore)())),
       // tiptap-markdown: comments are not part of the exported markdown.
       markdown: { serialize: { open: "", close: "" }, parse: {} }
     };
@@ -1889,7 +1890,7 @@ var Comments = _core.Mark.create({
         const { from, to, empty } = state.selection;
         if (empty) return false;
         if (dispatch) {
-          const id = _nullishCoalesce(options.id, () => ( _chunkTVRC4KVTcjs.createReviewId.call(void 0, "comment")));
+          const id = _nullishCoalesce(options.id, () => ( _chunkAA4ZEVCCcjs.createReviewId.call(void 0, "comment")));
           tr.addMark(from, to, this.type.create({ commentId: id }));
           tr.setMeta(commentsPluginKey, "refresh");
           store().createThread({
@@ -2192,11 +2193,15 @@ var ImportAdapterRegistry = (_class = class {constructor() { _class.prototype.__
         { fileName }
       );
     }
-    const context = createImportContext(input, { fileName, mimeType, target: adapter.target });
+    const context = createImportContext(input, { fileName, mimeType, target: adapter.target, registry: this });
     try {
       const result = await adapter.import(input, context);
       return { adapterId: adapter.id, target: adapter.target, fileName, mimeType, result };
     } catch (error) {
+      if (error instanceof ImportError) {
+        if (error.fileName !== void 0 || fileName === void 0) throw error;
+        throw new ImportError(error.code, error.message, { fileName, cause: error.cause });
+      }
       throw new ImportError(
         "adapter_failed",
         `Import adapter "${adapter.id}" failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -2206,6 +2211,980 @@ var ImportAdapterRegistry = (_class = class {constructor() { _class.prototype.__
   }
 }, _class);
 
+// src/import/zip.ts
+var ZipError = class extends Error {
+  
+  
+  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 = (_class2 = class {
+  constructor(bytes, entries, maxTotalSize) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+    this.bytes = bytes;
+    this.maxTotalSize = maxTotalSize;
+    this.entries = entries;
+    entries.forEach((entry) => {
+      if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry);
+    });
+  }
+  
+  
+  /** Entries in central-directory order. */
+  
+  __init2() {this.byName = /* @__PURE__ */ new Map()}
+  __init3() {this.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;
+  }
+}, _class2);
+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 = _nullishCoalesce(options.maxEntries, () => ( DEFAULT_ZIP_MAX_ENTRIES));
+  const maxTotalSize = _nullishCoalesce(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",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+  "application/vnd.ms-word.document.macroenabled.12"
+];
+var DEFAULT_DOCX_MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+var W_NAMESPACES = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  "http://purl.oclc.org/ooxml/wordprocessingml/main"
+]);
+var IMAGE_MIME_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  jpe: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp"
+};
+function isW(node, localName) {
+  if (!node || node.nodeType !== 1) return false;
+  const el = node;
+  if (localName !== void 0 && el.localName !== localName) return false;
+  return W_NAMESPACES.has(_nullishCoalesce(el.namespaceURI, () => ( ""))) || el.prefix === "w";
+}
+function childElements(el) {
+  const out = [];
+  for (let node = el.firstChild; node; node = node.nextSibling) {
+    if (node.nodeType === 1) out.push(node);
+  }
+  return out;
+}
+function wChild(el, localName) {
+  if (!el) return void 0;
+  return childElements(el).find((child) => isW(child, localName));
+}
+function attr(el, localName) {
+  if (!el) return void 0;
+  for (const a of Array.from(el.attributes)) {
+    if (a.localName === localName) return a.value;
+  }
+  return void 0;
+}
+function descendants(el, localName) {
+  return Array.from(el.getElementsByTagName("*")).filter((node) => node.localName === localName);
+}
+function toggle(el) {
+  if (!el) return void 0;
+  const value = _optionalChain([attr, 'call', _68 => _68(el, "val"), 'optionalAccess', _69 => _69.toLowerCase, 'call', _70 => _70()]);
+  return value === void 0 || !["0", "false", "off", "none"].includes(value);
+}
+function parseXml(Parser, xml, partName) {
+  const doc = new Parser().parseFromString(xml, "application/xml");
+  if (!doc.documentElement || doc.getElementsByTagName("parsererror").length > 0) {
+    throw new ImportError("invalid_file", `DOCX part "${partName}" is not well-formed XML.`);
+  }
+  return doc;
+}
+function dirname(path) {
+  const index = path.lastIndexOf("/");
+  return index === -1 ? "" : path.slice(0, index + 1);
+}
+function resolvePartPath(baseDir, target) {
+  const raw = target.startsWith("/") ? target.slice(1) : baseDir + target;
+  const out = [];
+  for (const segment of raw.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") out.pop();
+    else out.push(segment);
+  }
+  return out.join("/");
+}
+function relsPathFor(partPath) {
+  return `${dirname(partPath)}_rels/${partPath.slice(dirname(partPath).length)}.rels`;
+}
+async function readXmlPart(zip, Parser, path) {
+  const entry = _nullishCoalesce(zip.get(path), () => ( zip.entries.find((e) => e.name.toLowerCase() === path.toLowerCase())));
+  if (!entry) return null;
+  return parseXml(Parser, await zip.readText(entry), path);
+}
+async function readRelationships(zip, Parser, partPath) {
+  const rels = /* @__PURE__ */ new Map();
+  const doc = await readXmlPart(zip, Parser, relsPathFor(partPath));
+  if (!doc) return rels;
+  const baseDir = dirname(partPath);
+  descendants(doc, "Relationship").forEach((rel) => {
+    const id = attr(rel, "Id");
+    const target = _nullishCoalesce(attr(rel, "Target"), () => ( ""));
+    if (!id) return;
+    const external = _optionalChain([attr, 'call', _71 => _71(rel, "TargetMode"), 'optionalAccess', _72 => _72.toLowerCase, 'call', _73 => _73()]) === "external";
+    rels.set(id, {
+      type: _nullishCoalesce(attr(rel, "Type"), () => ( "")),
+      target: external ? target : resolvePartPath(baseDir, target),
+      external
+    });
+  });
+  return rels;
+}
+function toBase64(bytes) {
+  let binary = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK)));
+  }
+  return btoa(binary);
+}
+async function loadImages(zip, root, rels, options) {
+  const images = /* @__PURE__ */ new Map();
+  if (options.images === false) return images;
+  const maxSize = _nullishCoalesce(options.maxImageSize, () => ( DEFAULT_DOCX_MAX_IMAGE_SIZE));
+  const ids = /* @__PURE__ */ new Set();
+  descendants(root, "blip").forEach((blip) => {
+    const id = attr(blip, "embed");
+    if (id) ids.add(id);
+  });
+  descendants(root, "imagedata").forEach((data) => {
+    const id = attr(data, "id");
+    if (id) ids.add(id);
+  });
+  for (const id of ids) {
+    const rel = rels.get(id);
+    if (!rel || rel.external) continue;
+    const mime = IMAGE_MIME_TYPES[_nullishCoalesce(_optionalChain([rel, 'access', _74 => _74.target, 'access', _75 => _75.split, 'call', _76 => _76("."), 'access', _77 => _77.pop, 'call', _78 => _78(), 'optionalAccess', _79 => _79.toLowerCase, 'call', _80 => _80()]), () => ( ""))];
+    const entry = zip.get(rel.target);
+    if (!mime || !entry || entry.size > maxSize) continue;
+    images.set(id, `data:${mime};base64,${toBase64(await zip.read(entry))}`);
+  }
+  return images;
+}
+function readFormat(rPr) {
+  const format = {};
+  if (!rPr) return format;
+  const set = (key, value) => {
+    if (value !== void 0) format[key] = value;
+  };
+  set("b", toggle(wChild(rPr, "b")));
+  set("i", toggle(wChild(rPr, "i")));
+  set("u", toggle(wChild(rPr, "u")));
+  const strike = toggle(wChild(rPr, "strike"));
+  const dstrike = toggle(wChild(rPr, "dstrike"));
+  if (strike !== void 0 || dstrike !== void 0) format.s = !!(strike || dstrike);
+  const vertAlign = attr(wChild(rPr, "vertAlign"), "val");
+  if (vertAlign) {
+    format.sup = vertAlign === "superscript";
+    format.sub = vertAlign === "subscript";
+  }
+  return format;
+}
+function readNumPr(pPr) {
+  const numPr = wChild(pPr, "numPr");
+  if (!numPr) return void 0;
+  const numId = attr(wChild(numPr, "numId"), "val");
+  if (numId === void 0) return void 0;
+  return { numId, ilvl: Number(_nullishCoalesce(attr(wChild(numPr, "ilvl"), "val"), () => ( 0))) || 0 };
+}
+function readStyles(doc) {
+  const styles = /* @__PURE__ */ new Map();
+  if (!doc) return styles;
+  descendants(doc, "style").forEach((style) => {
+    const id = attr(style, "styleId");
+    if (!id) return;
+    const pPr = wChild(style, "pPr");
+    const outline = attr(wChild(pPr, "outlineLvl"), "val");
+    styles.set(id, {
+      name: _nullishCoalesce(attr(wChild(style, "name"), "val"), () => ( id)),
+      basedOn: attr(wChild(style, "basedOn"), "val"),
+      outlineLevel: outline !== void 0 ? Number(outline) : void 0,
+      numPr: readNumPr(pPr),
+      format: readFormat(wChild(style, "rPr"))
+    });
+  });
+  return styles;
+}
+function styleChain(styles, id) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (id && !seen.has(id)) {
+    seen.add(id);
+    const style = styles.get(id);
+    if (!style) break;
+    chain.push(style);
+    id = style.basedOn;
+  }
+  return chain;
+}
+function styleHeadingLevel(styles, id) {
+  if (id && /^heading([1-6])$/i.test(id)) return Number(id.slice(-1));
+  for (const style of styleChain(styles, id)) {
+    const byName = /^heading\s*([1-6])$/i.exec(style.name);
+    if (byName) return Number(byName[1]);
+    if (/^title$/i.test(style.name)) return 1;
+    if (style.outlineLevel !== void 0) {
+      return style.outlineLevel >= 0 && style.outlineLevel <= 5 ? style.outlineLevel + 1 : void 0;
+    }
+  }
+  if (id && /^title$/i.test(id)) return 1;
+  return void 0;
+}
+function readNumbering(doc) {
+  const numbering = { abstracts: /* @__PURE__ */ new Map(), nums: /* @__PURE__ */ new Map() };
+  if (!doc) return numbering;
+  descendants(doc, "abstractNum").forEach((abstract) => {
+    const id = attr(abstract, "abstractNumId");
+    if (id === void 0) return;
+    const levels = /* @__PURE__ */ new Map();
+    childElements(abstract).filter((el) => isW(el, "lvl")).forEach((lvl) => {
+      const format = _nullishCoalesce(attr(wChild(lvl, "numFmt"), "val"), () => ( "bullet"));
+      levels.set(Number(_nullishCoalesce(attr(lvl, "ilvl"), () => ( 0))), {
+        ordered: format !== "bullet" && format !== "none",
+        start: Number(_nullishCoalesce(attr(wChild(lvl, "start"), "val"), () => ( 1))) || 1
+      });
+    });
+    numbering.abstracts.set(id, levels);
+  });
+  descendants(doc, "num").forEach((num) => {
+    const id = attr(num, "numId");
+    const abstractId = attr(wChild(num, "abstractNumId"), "val");
+    if (id === void 0 || abstractId === void 0) return;
+    const starts = /* @__PURE__ */ new Map();
+    childElements(num).filter((el) => isW(el, "lvlOverride")).forEach((override) => {
+      const start2 = attr(wChild(override, "startOverride"), "val");
+      if (start2 !== void 0) starts.set(Number(_nullishCoalesce(attr(override, "ilvl"), () => ( 0))), Number(start2));
+    });
+    numbering.nums.set(id, { abstractId, starts });
+  });
+  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}|${_nullishCoalesce(f.href, () => ( ""))}`;
+function wrapFormat(inner, f) {
+  let html = inner;
+  if (f.sup) html = `<sup>${html}</sup>`;
+  else if (f.sub) html = `<sub>${html}</sub>`;
+  if (f.s) html = `<s>${html}</s>`;
+  if (f.u) html = `<u>${html}</u>`;
+  if (f.i) html = `<em>${html}</em>`;
+  if (f.b) html = `<strong>${html}</strong>`;
+  if (f.href) html = `<a href="${_chunkAA4ZEVCCcjs.escapeHtml.call(void 0, f.href)}">${html}</a>`;
+  return html;
+}
+function renderSegments(segments) {
+  let html = "";
+  let i = 0;
+  while (i < segments.length) {
+    const key = formatKey(segments[i].format);
+    let inner = "";
+    let j = i;
+    for (; j < segments.length && formatKey(segments[j].format) === key; j++) {
+      const seg = segments[j];
+      if (seg.kind === "text") inner += _chunkAA4ZEVCCcjs.escapeHtml.call(void 0, seg.text);
+      else if (seg.kind === "br") inner += "<br>";
+      else if (seg.kind === "img") inner += `<img src="${_chunkAA4ZEVCCcjs.escapeHtml.call(void 0, seg.src)}" alt="${_chunkAA4ZEVCCcjs.escapeHtml.call(void 0, seg.alt)}">`;
+      else inner += `<sup>${seg.n}</sup>`;
+    }
+    html += wrapFormat(inner, segments[i].format);
+    i = j;
+  }
+  return html;
+}
+function parseHyperlinkInstruction(instr) {
+  const match = /^\s*HYPERLINK\b(.*)$/i.exec(instr);
+  if (!match) return void 0;
+  const rest = match[1];
+  const anchor = _optionalChain([/\\l\s+"([^"]*)"/, 'access', _81 => _81.exec, 'call', _82 => _82(rest), 'optionalAccess', _83 => _83[1]]);
+  const target = /^\s*(?:"([^"]*)"|([^\s\\]+))/.exec(rest);
+  const url = _nullishCoalesce(_optionalChain([target, 'optionalAccess', _84 => _84[1]]), () => ( _optionalChain([target, 'optionalAccess', _85 => _85[2]])));
+  if (url) return anchor ? `${url}#${anchor}` : url;
+  return anchor ? `#${anchor}` : void 0;
+}
+var ParagraphRenderer = (_class3 = class {
+  constructor(ctx, part) {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);
+    this.ctx = ctx;
+    this.part = part;
+  }
+  
+  
+  __init4() {this.segments = []}
+  /** Open complex fields (`w:fldChar`), innermost last. */
+  __init5() {this.fields = []}
+  render(p) {
+    this.walk(p, {});
+    return renderSegments(this.segments);
+  }
+  fieldHref() {
+    for (let i = this.fields.length - 1; i >= 0; i--) {
+      if (this.fields[i].separated && this.fields[i].href) return this.fields[i].href;
+    }
+    return void 0;
+  }
+  inFieldInstruction() {
+    return this.fields.some((field) => !field.separated);
+  }
+  walk(el, base) {
+    const accepted = this.ctx.tracked === "accepted";
+    for (const child of childElements(el)) {
+      if (!isW(child)) {
+        continue;
+      }
+      switch (child.localName) {
+        case "r":
+          this.run(child, base);
+          break;
+        case "hyperlink": {
+          const relId = attr(child, "id");
+          const rel = relId ? this.part.rels.get(relId) : void 0;
+          const anchor = attr(child, "anchor");
+          const href = rel ? rel.target + (anchor ? `#${anchor}` : "") : anchor ? `#${anchor}` : void 0;
+          this.walk(child, href ? { ...base, href } : base);
+          break;
+        }
+        case "fldSimple": {
+          const href = parseHyperlinkInstruction(_nullishCoalesce(attr(child, "instr"), () => ( "")));
+          this.walk(child, href ? { ...base, href } : base);
+          break;
+        }
+        case "ins":
+        case "moveTo":
+          if (accepted) this.walk(child, base);
+          break;
+        case "del":
+        case "moveFrom":
+          if (!accepted) this.walk(child, base);
+          break;
+        case "sdt":
+          this.walk(_nullishCoalesce(wChild(child, "sdtContent"), () => ( child)), base);
+          break;
+        case "smartTag":
+        case "customXml":
+        case "dir":
+        case "bdo":
+        case "sdtContent":
+          this.walk(child, base);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  run(r, base) {
+    const rPr = wChild(r, "rPr");
+    const styleFormat = _nullishCoalesce(_optionalChain([this, 'access', _86 => _86.ctx, 'access', _87 => _87.styles, 'access', _88 => _88.get, 'call', _89 => _89(_nullishCoalesce(attr(wChild(rPr, "rStyle"), "val"), () => ( ""))), 'optionalAccess', _90 => _90.format]), () => ( {}));
+    const own = readFormat(rPr);
+    const format = { ...base, ...styleFormat, ...own };
+    for (const child of childElements(r)) {
+      this.runChild(child, format);
+    }
+  }
+  runChild(child, format) {
+    const push = (segment) => {
+      if (this.inFieldInstruction()) return;
+      const href = _nullishCoalesce(format.href, () => ( this.fieldHref()));
+      this.segments.push(href && !format.href ? { ...segment, format: { ...format, href } } : segment);
+    };
+    if (child.localName === "AlternateContent") {
+      const branch = childElements(child).find(
+        (b) => descendants(b, "blip").length || descendants(b, "imagedata").length
+      );
+      if (branch) this.image(branch, format, push);
+      return;
+    }
+    if (!isW(child)) return;
+    switch (child.localName) {
+      case "t":
+        push({ kind: "text", text: _nullishCoalesce(child.textContent, () => ( "")), format });
+        break;
+      case "delText":
+        if (this.ctx.tracked === "original") push({ kind: "text", text: _nullishCoalesce(child.textContent, () => ( "")), format });
+        break;
+      case "tab":
+      case "ptab":
+        push({ kind: "text", text: "	", format });
+        break;
+      case "br": {
+        const type = attr(child, "type");
+        if (type !== "page" && type !== "column") push({ kind: "br", format });
+        break;
+      }
+      case "cr":
+        push({ kind: "br", format });
+        break;
+      case "noBreakHyphen":
+        push({ kind: "text", text: "\u2011", format });
+        break;
+      case "drawing":
+      case "pict":
+      case "object":
+        this.image(child, format, push);
+        break;
+      case "footnoteReference":
+      case "endnoteReference": {
+        const kind = child.localName === "footnoteReference" ? "footnote" : "endnote";
+        const key = `${kind}:${attr(child, "id")}`;
+        if (!this.ctx.notes.has(key)) break;
+        let index = this.ctx.noteOrder.indexOf(key);
+        if (index === -1) index = this.ctx.noteOrder.push(key) - 1;
+        push({ kind: "note", n: index + 1, format: { ...format, sup: false, sub: false } });
+        break;
+      }
+      case "fldChar": {
+        const type = attr(child, "fldCharType");
+        if (type === "begin") this.fields.push({ instr: "", separated: false });
+        else if (type === "separate") {
+          const field = this.fields[this.fields.length - 1];
+          if (field) {
+            field.separated = true;
+            field.href = parseHyperlinkInstruction(field.instr);
+          }
+        } else if (type === "end") this.fields.pop();
+        break;
+      }
+      case "instrText": {
+        const field = this.fields[this.fields.length - 1];
+        if (field && !field.separated) field.instr += _nullishCoalesce(child.textContent, () => ( ""));
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  image(container, format, push) {
+    const blip = descendants(container, "blip")[0];
+    const imageData = descendants(container, "imagedata")[0];
+    const id = blip ? attr(blip, "embed") : attr(imageData, "id");
+    const src = id ? this.part.images.get(id) : void 0;
+    if (!src) return;
+    const docPr = descendants(container, "docPr")[0];
+    const alt = attr(docPr, "descr") || attr(docPr, "title") || attr(imageData, "title") || "";
+    push({ kind: "img", src, alt, format });
+  }
+}, _class3);
+function flattenBlocks(container, ctx, out = []) {
+  const accepted = ctx.tracked === "accepted";
+  for (const child of childElements(container)) {
+    if (!isW(child)) continue;
+    switch (child.localName) {
+      case "p":
+      case "tbl":
+        out.push(child);
+        break;
+      case "sdt":
+        flattenBlocks(_nullishCoalesce(wChild(child, "sdtContent"), () => ( child)), ctx, out);
+        break;
+      case "sdtContent":
+      case "customXml":
+        flattenBlocks(child, ctx, out);
+        break;
+      case "ins":
+      case "moveTo":
+        if (accepted) flattenBlocks(child, ctx, out);
+        break;
+      case "del":
+      case "moveFrom":
+        if (!accepted) flattenBlocks(child, ctx, out);
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function paragraphInfo(p, ctx) {
+  const pPr = wChild(p, "pPr");
+  const styleId = attr(wChild(pPr, "pStyle"), "val");
+  const outline = attr(wChild(pPr, "outlineLvl"), "val");
+  let heading;
+  if (outline !== void 0) {
+    const level = Number(outline);
+    heading = level >= 0 && level <= 5 ? level + 1 : void 0;
+  } else {
+    heading = styleHeadingLevel(ctx.styles, styleId);
+  }
+  let numPr = readNumPr(pPr);
+  if (!numPr) numPr = _optionalChain([styleChain, 'call', _91 => _91(ctx.styles, styleId), 'access', _92 => _92.find, 'call', _93 => _93((style) => style.numPr), 'optionalAccess', _94 => _94.numPr]);
+  let list;
+  if (numPr && numPr.numId !== "0" && heading === void 0) {
+    const num = ctx.numbering.nums.get(numPr.numId);
+    const def = num ? _optionalChain([ctx, 'access', _95 => _95.numbering, 'access', _96 => _96.abstracts, 'access', _97 => _97.get, 'call', _98 => _98(num.abstractId), 'optionalAccess', _99 => _99.get, 'call', _100 => _100(numPr.ilvl)]) : void 0;
+    list = {
+      level: Math.max(0, Math.min(numPr.ilvl, 8)),
+      ordered: _nullishCoalesce(_optionalChain([def, 'optionalAccess', _101 => _101.ordered]), () => ( false)),
+      start: _nullishCoalesce(_nullishCoalesce(_optionalChain([num, 'optionalAccess', _102 => _102.starts, 'access', _103 => _103.get, 'call', _104 => _104(numPr.ilvl)]), () => ( _optionalChain([def, 'optionalAccess', _105 => _105.start]))), () => ( 1))
+    };
+  }
+  return { heading, list };
+}
+function renderBlocks(container, ctx, part) {
+  let html = "";
+  const stack = [];
+  const closeList = () => {
+    const top = stack.pop();
+    html += `</li></${top.tag}>`;
+  };
+  const closeAll = () => {
+    while (stack.length) closeList();
+  };
+  for (const block of flattenBlocks(container, ctx)) {
+    if (block.localName === "tbl") {
+      closeAll();
+      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>`;
+    if (!list) {
+      closeAll();
+      html += blockHtml;
+      continue;
+    }
+    const tag = list.ordered ? "ol" : "ul";
+    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>";
+    } 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 });
+    }
+    html += blockHtml;
+  }
+  closeAll();
+  return html;
+}
+function renderTable(tbl, ctx, part) {
+  const rows = [];
+  const collectRows = (container) => {
+    for (const child of childElements(container)) {
+      if (isW(child, "tr")) {
+        const header = !!toggle(wChild(wChild(child, "trPr"), "tblHeader"));
+        const cells = [];
+        let col = 0;
+        const collectCells = (row) => {
+          for (const cellEl of childElements(row)) {
+            if (isW(cellEl, "tc")) {
+              const tcPr = wChild(cellEl, "tcPr");
+              const span = Math.max(1, Number(_nullishCoalesce(attr(wChild(tcPr, "gridSpan"), "val"), () => ( 1))) || 1);
+              const vMerge = wChild(tcPr, "vMerge");
+              const merge = vMerge ? attr(vMerge, "val") === "restart" ? "restart" : "continue" : void 0;
+              cells.push({ el: cellEl, col, span, merge, header });
+              col += span;
+            } else if (isW(cellEl, "sdt")) {
+              collectCells(_nullishCoalesce(wChild(cellEl, "sdtContent"), () => ( cellEl)));
+            }
+          }
+        };
+        collectCells(child);
+        rows.push(cells);
+      } else if (isW(child, "sdt")) {
+        collectRows(_nullishCoalesce(wChild(child, "sdtContent"), () => ( child)));
+      }
+    }
+  };
+  collectRows(tbl);
+  let html = "<table><tbody>";
+  rows.forEach((cells, rowIndex) => {
+    html += "<tr>";
+    for (const cell of cells) {
+      if (cell.merge === "continue") continue;
+      let rowspan = 1;
+      if (cell.merge === "restart") {
+        for (let r = rowIndex + 1; r < rows.length; r++) {
+          const below = rows[r].find((c) => c.col === cell.col);
+          if (_optionalChain([below, 'optionalAccess', _106 => _106.merge]) !== "continue") break;
+          rowspan++;
+        }
+      }
+      const tag = cell.header ? "th" : "td";
+      const attrs = `${cell.span > 1 ? ` colspan="${cell.span}"` : ""}${rowspan > 1 ? ` rowspan="${rowspan}"` : ""}`;
+      html += `<${tag}${attrs}>${renderBlocks(cell.el, ctx, part) || "<p></p>"}</${tag}>`;
+    }
+    html += "</tr>";
+  });
+  return `${html}</tbody></table>`;
+}
+function getDomParser(options) {
+  const Parser = _nullishCoalesce(_nullishCoalesce(options.DOMParser, () => ( globalThis.DOMParser)), () => ( _optionalChain([globalThis, 'access', _107 => _107.window, 'optionalAccess', _108 => _108.DOMParser])));
+  if (typeof Parser !== "function") {
+    throw new ImportError(
+      "unsupported_environment",
+      "DOCX import needs a DOMParser. In Node, pass one with createDocxImportAdapter({ DOMParser }) (e.g. from jsdom)."
+    );
+  }
+  return Parser;
+}
+async function docxToDocumentImport(data, options = {}) {
+  const Parser = getDomParser(options);
+  let zip;
+  try {
+    zip = await readZip(data, { maxTotalSize: 100 * 1024 * 1024, maxEntries: 5e3, ...options.zip });
+  } catch (error) {
+    if (_optionalChain([error, 'optionalAccess', _109 => _109.code]) === "invalid_archive") {
+      throw new ImportError("invalid_file", "Not a DOCX file (the file is not a ZIP package).", { cause: error });
+    }
+    throw error;
+  }
+  let mainPath = "word/document.xml";
+  const packageRels = await readXmlPart(zip, Parser, "_rels/.rels");
+  if (packageRels) {
+    const office = descendants(packageRels, "Relationship").find(
+      (rel) => /\/officeDocument$/.test(_nullishCoalesce(attr(rel, "Type"), () => ( "")))
+    );
+    const target = attr(office, "Target");
+    if (target) mainPath = resolvePartPath("", target);
+  }
+  const documentXml = await readXmlPart(zip, Parser, mainPath);
+  const body = documentXml ? descendants(documentXml, "body").find((el) => isW(el)) : void 0;
+  if (!documentXml || !body) {
+    throw new ImportError("invalid_file", "Not a Word document (no main document part with a body).");
+  }
+  const rels = await readRelationships(zip, Parser, mainPath);
+  const partByType = (suffix) => _optionalChain([Array, 'access', _110 => _110.from, 'call', _111 => _111(rels.values()), 'access', _112 => _112.find, 'call', _113 => _113((rel) => !rel.external && rel.type.endsWith(`/${suffix}`)), 'optionalAccess', _114 => _114.target]);
+  const baseDir = dirname(mainPath);
+  const stylesPath = _nullishCoalesce(partByType("styles"), () => ( `${baseDir}styles.xml`));
+  const numberingPath = _nullishCoalesce(partByType("numbering"), () => ( `${baseDir}numbering.xml`));
+  const ctx = {
+    styles: readStyles(await readXmlPart(zip, Parser, stylesPath)),
+    numbering: readNumbering(await readXmlPart(zip, Parser, numberingPath)),
+    notes: /* @__PURE__ */ new Map(),
+    noteOrder: [],
+    tracked: _nullishCoalesce(options.trackedChanges, () => ( "accepted"))
+  };
+  for (const kind of ["footnote", "endnote"]) {
+    const path = _nullishCoalesce(partByType(`${kind}s`), () => ( `${baseDir}${kind}s.xml`));
+    const notesXml = await readXmlPart(zip, Parser, path);
+    if (!notesXml) continue;
+    const noteRels = await readRelationships(zip, Parser, path);
+    const part2 = { rels: noteRels, images: await loadImages(zip, notesXml, noteRels, options) };
+    descendants(notesXml, kind).filter((note) => isW(note)).forEach((note) => {
+      const type = attr(note, "type");
+      if (type && type !== "normal") return;
+      ctx.notes.set(`${kind}:${attr(note, "id")}`, { element: note, part: part2 });
+    });
+  }
+  const part = { rels, images: await loadImages(zip, documentXml, rels, options) };
+  let html = renderBlocks(body, ctx, part);
+  if (ctx.noteOrder.length) {
+    let notesHtml = "";
+    for (let i = 0; i < ctx.noteOrder.length; i++) {
+      const note = ctx.notes.get(ctx.noteOrder[i]);
+      notesHtml += `<li>${renderBlocks(note.element, ctx, note.part) || "<p></p>"}</li>`;
+    }
+    html += `<hr><ol>${notesHtml}</ol>`;
+  }
+  const sanitized = _chunkCL37JGFWcjs.sanitizeImportedHtml.call(void 0, html);
+  return { html: sanitized, text: _chunkAA4ZEVCCcjs.htmlToPlainText.call(void 0, sanitized) };
+}
+function createDocxImportAdapter(options = {}) {
+  return {
+    id: _nullishCoalesce(options.id, () => ( "docx")),
+    label: "Word document",
+    mimeTypes: DOCX_MIME_TYPES,
+    extensions: [".docx", ".docm", ".dotx"],
+    target: "document",
+    async import(_input, context) {
+      return docxToDocumentImport(await context.readArrayBuffer(), options);
+    }
+  };
+}
+var docxImportAdapter = createDocxImportAdapter();
+
 // src/import/adapters.ts
 var markdownImportAdapter = {
   id: "markdown",
@@ -2215,7 +3194,7 @@ var markdownImportAdapter = {
   target: "document",
   async import(_input, context) {
     const text = await context.readText();
-    return { html: _chunkTVRC4KVTcjs.markdownToTipTapHtml.call(void 0, text), text };
+    return { html: _chunkAA4ZEVCCcjs.markdownToTipTapHtml.call(void 0, text), text };
   }
 };
 var htmlImportAdapter = {
@@ -2225,8 +3204,8 @@ var htmlImportAdapter = {
   extensions: [".html", ".htm", ".xhtml"],
   target: "document",
   async import(_input, context) {
-    const html = _chunkLA7PEGU3cjs.sanitizeImportedHtml.call(void 0, await context.readText());
-    return { html, text: _chunkTVRC4KVTcjs.htmlToPlainText.call(void 0, html) };
+    const html = _chunkCL37JGFWcjs.sanitizeImportedHtml.call(void 0, await context.readText());
+    return { html, text: _chunkAA4ZEVCCcjs.htmlToPlainText.call(void 0, html) };
   }
 };
 var plainTextImportAdapter = {
@@ -2237,7 +3216,7 @@ var plainTextImportAdapter = {
   target: "document",
   async import(_input, context) {
     const text = (await context.readText()).replace(/\r\n?/g, "\n");
-    return { html: _chunkLA7PEGU3cjs.plainTextToParagraphHtml.call(void 0, text), text };
+    return { html: _chunkCL37JGFWcjs.plainTextToParagraphHtml.call(void 0, text), text };
   }
 };
 var rtfImportAdapter = {
@@ -2247,15 +3226,16 @@ var rtfImportAdapter = {
   extensions: [".rtf"],
   target: "document",
   async import(_input, context) {
-    const text = _chunkLA7PEGU3cjs.rtfToPlainText.call(void 0, await context.readText());
-    return { html: _chunkLA7PEGU3cjs.plainTextToParagraphHtml.call(void 0, text), text };
+    const text = _chunkCL37JGFWcjs.rtfToPlainText.call(void 0, await context.readText());
+    return { html: _chunkCL37JGFWcjs.plainTextToParagraphHtml.call(void 0, text), text };
   }
 };
 var BUILT_IN_IMPORT_ADAPTERS = [
   markdownImportAdapter,
   htmlImportAdapter,
   plainTextImportAdapter,
-  rtfImportAdapter
+  rtfImportAdapter,
+  docxImportAdapter
 ];
 function createImportAdapterRegistry(options = {}) {
   const registry = new ImportAdapterRegistry();
@@ -2286,7 +3266,7 @@ function getImportAccept(target) {
 
 var toView = (target) => "state" in target && "dispatch" in target ? target : target.view;
 function htmlToSlice(html, schema) {
-  const Parser = _nullishCoalesce(globalThis.DOMParser, () => ( _optionalChain([globalThis, 'access', _68 => _68.window, 'optionalAccess', _69 => _69.DOMParser])));
+  const Parser = _nullishCoalesce(globalThis.DOMParser, () => ( _optionalChain([globalThis, 'access', _115 => _115.window, 'optionalAccess', _116 => _116.DOMParser])));
   if (!Parser) return null;
   const body = new Parser().parseFromString(`<body>${html}</body>`, "text/html").body;
   return new (0, _model.Slice)(_model.DOMParser.fromSchema(schema).parse(body).content, 0, 0);
@@ -2301,7 +3281,7 @@ function insertImportedDocument(target, content, options = {}) {
   if (!htmlSlice && from === to && !state.doc.resolve(from).parent.inlineContent) {
     from = to = _state.Selection.near(state.doc.resolve(from)).from;
   }
-  const tr = htmlSlice ? state.tr.replaceRange(from, to, htmlSlice) : state.tr.replace(from, to, _chunkTVRC4KVTcjs.plainTextToSlice.call(void 0, content.text, state.schema));
+  const tr = htmlSlice ? state.tr.replaceRange(from, to, htmlSlice) : state.tr.replace(from, to, _chunkAA4ZEVCCcjs.plainTextToSlice.call(void 0, content.text, state.schema));
   const end = tr.mapping.map(to, 1);
   view.dispatch(tr.scrollIntoView().setMeta("uiEvent", "drop"));
   return end;
@@ -2317,7 +3297,7 @@ async function importFilesIntoEditor(target, files, options = {}) {
       if (view.isDestroyed) break;
       at = insertImportedDocument(view, outcome.result, { at, asPlainText: options.asPlainText });
       outcomes.push(outcome);
-      _optionalChain([options, 'access', _70 => _70.onImport, 'optionalCall', _71 => _71(outcome, file)]);
+      _optionalChain([options, 'access', _117 => _117.onImport, 'optionalCall', _118 => _118(outcome, file)]);
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       if (options.onError) options.onError(err, file);
@@ -2336,7 +3316,7 @@ function getImportableFiles(files, registry) {
 }
 function dropPosition(view, event) {
   try {
-    return _optionalChain([view, 'access', _72 => _72.posAtCoords, 'call', _73 => _73({ left: event.clientX, top: event.clientY }), 'optionalAccess', _74 => _74.pos]);
+    return _optionalChain([view, 'access', _119 => _119.posAtCoords, 'call', _120 => _120({ left: event.clientX, top: event.clientY }), 'optionalAccess', _121 => _121.pos]);
   } catch (e2) {
     return void 0;
   }
@@ -2371,7 +3351,7 @@ var FileImport = _core.Extension.create({
         props: {
           handleDrop(view, event, _slice, moved) {
             if (!options.enableDrop || moved) return false;
-            const files = getImportableFiles(_optionalChain([event, 'access', _75 => _75.dataTransfer, 'optionalAccess', _76 => _76.files]), registry());
+            const files = getImportableFiles(_optionalChain([event, 'access', _122 => _122.dataTransfer, 'optionalAccess', _123 => _123.files]), registry());
             if (!files) return false;
             event.preventDefault();
             run(view, files, dropPosition(view, event));
@@ -2379,7 +3359,7 @@ var FileImport = _core.Extension.create({
           },
           handlePaste(view, event) {
             if (!options.enablePaste) return false;
-            const files = getImportableFiles(_optionalChain([event, 'access', _77 => _77.clipboardData, 'optionalAccess', _78 => _78.files]), registry());
+            const files = getImportableFiles(_optionalChain([event, 'access', _124 => _124.clipboardData, 'optionalAccess', _125 => _125.files]), registry());
             if (!files) return false;
             event.preventDefault();
             run(view, files);
@@ -2398,15 +3378,15 @@ var richClipboardPluginKey = new (0, _state.PluginKey)("richClipboard");
 function writeRichClipboard(view, event, options = {}) {
   const { state } = view;
   if (state.selection.empty) return false;
-  const data = _chunkLA7PEGU3cjs.getClipboardData.call(void 0, event);
+  const data = _chunkCL37JGFWcjs.getClipboardData.call(void 0, event);
   if (!data || typeof data.setData !== "function") return false;
   const slice = state.selection.content();
   const { dom, text } = view.serializeForClipboard(slice);
   event.preventDefault();
-  _optionalChain([data, 'access', _79 => _79.clearData, 'optionalCall', _80 => _80()]);
+  _optionalChain([data, 'access', _126 => _126.clearData, 'optionalCall', _127 => _127()]);
   data.setData("text/html", dom.innerHTML);
   data.setData("text/plain", text);
-  data.setData(_nullishCoalesce(options.mimeType, () => ( _chunkLA7PEGU3cjs.PIXERATE_DOCUMENT_MIME)), _chunkLA7PEGU3cjs.serializeRichClipboardPayload.call(void 0, slice, state.schema));
+  data.setData(_nullishCoalesce(options.mimeType, () => ( _chunkCL37JGFWcjs.PIXERATE_DOCUMENT_MIME)), _chunkCL37JGFWcjs.serializeRichClipboardPayload.call(void 0, slice, state.schema));
   if (options.cut && view.editable) {
     view.dispatch(state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
   }
@@ -2416,7 +3396,7 @@ var RichClipboard = _core.Extension.create({
   name: "richClipboard",
   addOptions() {
     return {
-      mimeType: _chunkLA7PEGU3cjs.PIXERATE_DOCUMENT_MIME,
+      mimeType: _chunkCL37JGFWcjs.PIXERATE_DOCUMENT_MIME,
       plainTextMode: false
     };
   },
@@ -2424,7 +3404,7 @@ var RichClipboard = _core.Extension.create({
     return { plainTextMode: !!this.options.plainTextMode };
   },
   addProseMirrorPlugins() {
-    const mimeType = _nullishCoalesce(this.options.mimeType, () => ( _chunkLA7PEGU3cjs.PIXERATE_DOCUMENT_MIME));
+    const mimeType = _nullishCoalesce(this.options.mimeType, () => ( _chunkCL37JGFWcjs.PIXERATE_DOCUMENT_MIME));
     const storage = this.storage;
     return [
       new (0, _state.Plugin)({
@@ -2436,7 +3416,7 @@ var RichClipboard = _core.Extension.create({
           },
           handlePaste(view, event) {
             if (storage.plainTextMode) return false;
-            const slice = _chunkLA7PEGU3cjs.readRichClipboard.call(void 0, event, view.state.schema, mimeType);
+            const slice = _chunkCL37JGFWcjs.readRichClipboard.call(void 0, event, view.state.schema, mimeType);
             if (!slice) return false;
             event.preventDefault();
             view.dispatch(
@@ -2631,7 +3611,7 @@ var Autocorrect = _core.Extension.create({
   addCommands() {
     return {
       undoAutocorrect: () => ({ state, tr, dispatch }) => {
-        const last = _optionalChain([autocorrectPluginKey, 'access', _81 => _81.getState, 'call', _82 => _82(state), 'optionalAccess', _83 => _83.last]);
+        const last = _optionalChain([autocorrectPluginKey, 'access', _128 => _128.getState, 'call', _129 => _129(state), 'optionalAccess', _130 => _130.last]);
         if (!last) return false;
         if (state.doc.textBetween(last.from, last.to) !== last.replacement) return false;
         if (dispatch) {
@@ -2681,7 +3661,7 @@ var Autocorrect = _core.Extension.create({
       }
       const insertTyped = () => {
         const tr2 = state.tr.insertText(text, from, to);
-        if (_optionalChain([pluginState, 'optionalAccess', _84 => _84.closePending])) _history.closeHistory.call(void 0, tr2);
+        if (_optionalChain([pluginState, 'optionalAccess', _131 => _131.closePending])) _history.closeHistory.call(void 0, tr2);
         view.dispatch(tr2);
       };
       if (isIgnored(state, from, to)) return false;
@@ -2689,7 +3669,7 @@ var Autocorrect = _core.Extension.create({
       if (extension.options.ignorePromptTokens && isInsidePromptToken(textBefore)) {
         return false;
       }
-      const currentWord = _nullishCoalesce(_optionalChain([/\S*$/, 'access', _85 => _85.exec, 'call', _86 => _86(textBefore), 'optionalAccess', _87 => _87[0]]), () => ( ""));
+      const currentWord = _nullishCoalesce(_optionalChain([/\S*$/, 'access', _132 => _132.exec, 'call', _133 => _133(textBefore), 'optionalAccess', _134 => _134[0]]), () => ( ""));
       if (/:\/\/|^www\./i.test(currentWord)) return false;
       const exceptions = extension.storage.exceptions;
       const found = findAutocorrection(textBefore, extension.options.rules, {
@@ -2697,7 +3677,7 @@ var Autocorrect = _core.Extension.create({
         isException: (value) => exceptions.has(value.toLowerCase())
       });
       if (!found) {
-        if (!_optionalChain([pluginState, 'optionalAccess', _88 => _88.closePending])) return false;
+        if (!_optionalChain([pluginState, 'optionalAccess', _135 => _135.closePending])) return false;
         insertTyped();
         return true;
       }
@@ -2734,7 +3714,7 @@ var Autocorrect = _core.Extension.create({
       _history.closeHistory.call(void 0, tr);
       tr.setMeta(autocorrectPluginKey, { correction });
       view.dispatch(tr);
-      _optionalChain([extension, 'access', _89 => _89.options, 'access', _90 => _90.onCorrection, 'optionalCall', _91 => _91(correction)]);
+      _optionalChain([extension, 'access', _136 => _136.options, 'access', _137 => _137.onCorrection, 'optionalCall', _138 => _138(correction)]);
       return true;
     };
     return [
@@ -2744,8 +3724,8 @@ var Autocorrect = _core.Extension.create({
           init: () => ({ last: null, closePending: false }),
           apply: (tr, prev) => {
             const meta = tr.getMeta(autocorrectPluginKey);
-            if (_optionalChain([meta, 'optionalAccess', _92 => _92.correction])) return { last: meta.correction, closePending: true };
-            if (_optionalChain([meta, 'optionalAccess', _93 => _93.undo])) return { last: null, closePending: true };
+            if (_optionalChain([meta, 'optionalAccess', _139 => _139.correction])) return { last: meta.correction, closePending: true };
+            if (_optionalChain([meta, 'optionalAccess', _140 => _140.undo])) return { last: null, closePending: true };
             if (!tr.docChanged) return prev;
             if (!prev.last && !prev.closePending) return prev;
             return { last: null, closePending: false };
@@ -2826,7 +3806,7 @@ function arraysEqual(a, b, eq) {
 }
 function scrollDomAtPos(view, pos, behavior = "smooth") {
   try {
-    const dom = _optionalChain([view, 'optionalAccess', _94 => _94.nodeDOM, 'optionalCall', _95 => _95(pos)]);
+    const dom = _optionalChain([view, 'optionalAccess', _141 => _141.nodeDOM, 'optionalCall', _142 => _142(pos)]);
     if (dom && typeof dom.scrollIntoView === "function") {
       dom.scrollIntoView({ block: "start", behavior });
     }
@@ -2841,7 +3821,7 @@ function syncInitialContent(editor, sync) {
       errorOnInvalidContent: false
     });
     const tr = sync(_state.EditorState.create({ doc }));
-    if (_optionalChain([tr, 'optionalAccess', _96 => _96.docChanged])) editor.options.content = tr.doc;
+    if (_optionalChain([tr, 'optionalAccess', _143 => _143.docChanged])) editor.options.content = tr.doc;
   } catch (e4) {
   }
 }
@@ -2922,7 +3902,7 @@ function createOutlineStore(editor) {
   const compute = () => {
     if (!editor || editor.isDestroyed) return EMPTY_SNAPSHOT;
     const headings = getOutline(editor);
-    const activeId = _nullishCoalesce(_optionalChain([getActiveHeading, 'call', _97 => _97(editor, headings), 'optionalAccess', _98 => _98.id]), () => ( null));
+    const activeId = _nullishCoalesce(_optionalChain([getActiveHeading, 'call', _144 => _144(editor, headings), 'optionalAccess', _145 => _145.id]), () => ( null));
     const sameStructure = arraysEqual(snapshot.headings, headings, sameHeading);
     if (sameStructure && snapshot.activeId === activeId) return snapshot;
     return {
@@ -2947,16 +3927,16 @@ function createOutlineStore(editor) {
     subscribe(listener) {
       if (!listeners.size) {
         snapshot = compute();
-        _optionalChain([editor, 'optionalAccess', _99 => _99.on, 'call', _100 => _100("transaction", onTransaction)]);
+        _optionalChain([editor, 'optionalAccess', _146 => _146.on, 'call', _147 => _147("transaction", onTransaction)]);
       }
       listeners.add(listener);
       return () => {
         listeners.delete(listener);
-        if (!listeners.size) _optionalChain([editor, 'optionalAccess', _101 => _101.off, 'call', _102 => _102("transaction", onTransaction)]);
+        if (!listeners.size) _optionalChain([editor, 'optionalAccess', _148 => _148.off, 'call', _149 => _149("transaction", onTransaction)]);
       };
     },
     destroy() {
-      _optionalChain([editor, 'optionalAccess', _103 => _103.off, 'call', _104 => _104("transaction", onTransaction)]);
+      _optionalChain([editor, 'optionalAccess', _150 => _150.off, 'call', _151 => _151("transaction", onTransaction)]);
       listeners.clear();
     }
   };
@@ -3031,7 +4011,7 @@ var Outline = _core.Extension.create({
           if (options.focus !== false) {
             tr.setSelection(_state.TextSelection.create(tr.doc, heading.pos + 1));
             tr.scrollIntoView();
-            _optionalChain([view, 'optionalAccess', _105 => _105.focus, 'optionalCall', _106 => _106()]);
+            _optionalChain([view, 'optionalAccess', _152 => _152.focus, 'optionalCall', _153 => _153()]);
           }
           scrollDomAtPos(view, heading.pos, options.behavior);
         }
@@ -3063,7 +4043,7 @@ var Outline = _core.Extension.create({
             const next = computeOutline(newState.doc, types);
             if (arraysEqual(prev, next, sameHeading)) return prev;
             storage.headings = next;
-            _optionalChain([onUpdate, 'call', _107 => _107(), 'optionalCall', _108 => _108(next)]);
+            _optionalChain([onUpdate, 'call', _154 => _154(), 'optionalCall', _155 => _155(next)]);
             return next;
           }
         }
@@ -3382,7 +4362,7 @@ var TableOfContents = _core.Node.create({
           handleDOMEvents: {
             click: (view, event) => {
               const target = event.target;
-              const link = _optionalChain([target, 'optionalAccess', _109 => _109.closest, 'optionalCall', _110 => _110(
+              const link = _optionalChain([target, 'optionalAccess', _156 => _156.closest, 'optionalCall', _157 => _157(
                 'nav[data-type="table-of-contents"] a[data-heading-id]'
               )]);
               if (!link) return false;
@@ -3455,7 +4435,7 @@ function getFootnotes(doc) {
       number: index + 1,
       text: footnote ? footnoteText(footnote.node) : "",
       referencePos: ref.pos,
-      footnotePos: _nullishCoalesce(_optionalChain([footnote, 'optionalAccess', _111 => _111.pos]), () => ( null))
+      footnotePos: _nullishCoalesce(_optionalChain([footnote, 'optionalAccess', _158 => _158.pos]), () => ( null))
     };
   });
 }
@@ -3497,7 +4477,7 @@ function syncFootnotes(tr, options = {}) {
   });
   const desiredItems = desiredRefs.map(({ id, number, copyOf }) => {
     const source = _nullishCoalesce(existing.get(id), () => ( (copyOf ? existing.get(copyOf) : void 0)));
-    const content = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _112 => _112.content]), () => ( paragraphsFromText(schema, _nullishCoalesce(_optionalChain([options, 'access', _113 => _113.contents, 'optionalAccess', _114 => _114[id]]), () => ( "")))));
+    const content = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _159 => _159.content]), () => ( paragraphsFromText(schema, _nullishCoalesce(_optionalChain([options, 'access', _160 => _160.contents, 'optionalAccess', _161 => _161[id]]), () => ( "")))));
     if (source && source.attrs.id === id && source.attrs.number === number) {
       return source;
     }
@@ -3700,7 +4680,7 @@ var FootnoteReference = _core.Node.create({
           handleClickOn: (_view, _pos, node, _nodePos, event) => {
             if (node.type.name !== REFERENCE || !node.attrs.id) return false;
             const target = event.target;
-            if (!_optionalChain([target, 'optionalAccess', _115 => _115.closest, 'optionalCall', _116 => _116("a")])) return false;
+            if (!_optionalChain([target, 'optionalAccess', _162 => _162.closest, 'optionalCall', _163 => _163("a")])) return false;
             event.preventDefault();
             return editor.commands.goToFootnote(node.attrs.id);
           }
@@ -3898,7 +4878,7 @@ var Bookmark = _core.Mark.create({
         }
         if (!dispatch) return true;
         const sameName = getBookmarks(state.doc).find((b) => b.name === name);
-        const bookmarkId = _nullishCoalesce(_nullishCoalesce(id, () => ( _optionalChain([sameName, 'optionalAccess', _117 => _117.id]))), () => ( this.options.generateId()));
+        const bookmarkId = _nullishCoalesce(_nullishCoalesce(id, () => ( _optionalChain([sameName, 'optionalAccess', _164 => _164.id]))), () => ( this.options.generateId()));
         if (sameName) {
           forEachBookmarkRange(
             tr.doc,
@@ -4140,7 +5120,7 @@ var CrossReference = _core.Node.create({
 // src/extensions/document-structure/command-items.ts
 var start = (editor, args) => {
   const chain = editor.chain().focus();
-  return _optionalChain([args, 'optionalAccess', _118 => _118.range]) ? chain.deleteRange(args.range) : chain;
+  return _optionalChain([args, 'optionalAccess', _165 => _165.range]) ? chain.deleteRange(args.range) : chain;
 };
 var documentStructureCommandItems = [
   {
@@ -4157,7 +5137,7 @@ var documentStructureCommandItems = [
     description: "Insert a numbered footnote",
     keywords: ["footnote", "note", "fn", "citation"],
     extension: "footnoteReference",
-    run: (editor, args) => start(editor, args).insertFootnote({ content: _optionalChain([args, 'optionalAccess', _119 => _119.content]) }).run()
+    run: (editor, args) => start(editor, args).insertFootnote({ content: _optionalChain([args, 'optionalAccess', _166 => _166.content]) }).run()
   },
   {
     id: "bookmark",
@@ -4166,7 +5146,7 @@ var documentStructureCommandItems = [
     keywords: ["bookmark", "anchor", "name"],
     extension: "bookmark",
     requires: "name",
-    run: (editor, args) => !!_optionalChain([args, 'optionalAccess', _120 => _120.name]) && start(editor, args).setBookmark({ name: args.name }).run()
+    run: (editor, args) => !!_optionalChain([args, 'optionalAccess', _167 => _167.name]) && start(editor, args).setBookmark({ name: args.name }).run()
   },
   {
     id: "cross-reference",
@@ -4175,7 +5155,7 @@ var documentStructureCommandItems = [
     keywords: ["cross", "reference", "xref", "link", "ref"],
     extension: "crossReference",
     requires: "target",
-    run: (editor, args) => !!_optionalChain([args, 'optionalAccess', _121 => _121.targetType]) && !!args.targetId && start(editor, args).insertCrossReference({ targetType: args.targetType, targetId: args.targetId }).run()
+    run: (editor, args) => !!_optionalChain([args, 'optionalAccess', _168 => _168.targetType]) && !!args.targetId && start(editor, args).insertCrossReference({ targetType: args.targetType, targetId: args.targetId }).run()
   }
 ];
 function getDocumentStructureCommandItems(editor, query = "") {
@@ -4190,7 +5170,7 @@ function getDocumentStructureCommandItems(editor, query = "") {
 }
 
 // src/extensions/rich-text-preset.ts
-var resolveExt3 = (mod, name) => _optionalChain([mod, 'optionalAccess', _122 => _122[name]]) || _optionalChain([mod, 'optionalAccess', _123 => _123.default, 'optionalAccess', _124 => _124[name]]) || _optionalChain([mod, 'optionalAccess', _125 => _125.default, 'optionalAccess', _126 => _126.default]) || _optionalChain([mod, 'optionalAccess', _127 => _127.default]) || mod;
+var resolveExt3 = (mod, name) => _optionalChain([mod, 'optionalAccess', _169 => _169[name]]) || _optionalChain([mod, 'optionalAccess', _170 => _170.default, 'optionalAccess', _171 => _171[name]]) || _optionalChain([mod, 'optionalAccess', _172 => _172.default, 'optionalAccess', _173 => _173.default]) || _optionalChain([mod, 'optionalAccess', _174 => _174.default]) || mod;
 var StarterKit = resolveExt3(_StarterKit, "StarterKit");
 var Color = resolveExt3(_Color, "Color");
 var Highlight = resolveExt3(_Highlight, "Highlight");
@@ -4271,7 +5251,7 @@ function createRichTextPreset(options = {}) {
             find: /^\s*(\[([ |x])?\])\s$/i,
             type: this.type,
             getAttributes: (match) => ({
-              checked: _optionalChain([match, 'access', _128 => _128[2], 'optionalAccess', _129 => _129.toLowerCase, 'call', _130 => _130()]) === "x"
+              checked: _optionalChain([match, 'access', _175 => _175[2], 'optionalAccess', _176 => _176.toLowerCase, 'call', _177 => _177()]) === "x"
             })
           })
         ];
@@ -4345,7 +5325,7 @@ function createRichTextPreset(options = {}) {
   }
   if (options.trackChanges) {
     extensions2.push(
-      typeof options.trackChanges === "object" ? _chunkTVRC4KVTcjs.TrackChanges.configure(options.trackChanges) : _chunkTVRC4KVTcjs.TrackChanges
+      typeof options.trackChanges === "object" ? _chunkAA4ZEVCCcjs.TrackChanges.configure(options.trackChanges) : _chunkAA4ZEVCCcjs.TrackChanges
     );
   }
   if (options.fileImport) {
@@ -4476,5 +5456,17 @@ function createRichTextPreset(options = {}) {
 
 
 
-exports.GradientText = GradientText; exports.SlashCommands = SlashCommands; exports.TemplateSuggestions = TemplateSuggestions; exports.LoadingNode = LoadingNode; exports.SMILIE_REPLACEMENTS = SMILIE_REPLACEMENTS; exports.smilieAutocorrectRules = smilieAutocorrectRules; exports.SmilieReplacer = SmilieReplacer; exports.findHexColors = findHexColors; exports.ColorHighlighter = ColorHighlighter; exports.FontSize = FontSize; exports.Mention = Mention; exports.createMentionExtension = createMentionExtension; exports.Markdown = Markdown2; exports.imagePastePluginKey = imagePastePluginKey; exports.insertImageNode = insertImageNode; exports.updateImageSrc = updateImageSrc; exports.removeImageNode = removeImageNode; exports.handleImageInsertion = handleImageInsertion; exports.Image = Image2; exports.commentsPluginKey = commentsPluginKey; exports.COMMENT_MARK_NAME = COMMENT_MARK_NAME; exports.findCommentRanges = findCommentRanges; exports.getCommentAnchors = getCommentAnchors; exports.getCommentIdsAt = getCommentIdsAt; exports.getCommentStore = getCommentStore; exports.Comments = Comments; exports.getCommentAuthor = getCommentAuthor; exports.ImportError = ImportError; exports.createImportContext = createImportContext; exports.ImportAdapterRegistry = ImportAdapterRegistry; exports.markdownImportAdapter = markdownImportAdapter; exports.htmlImportAdapter = htmlImportAdapter; exports.plainTextImportAdapter = plainTextImportAdapter; exports.rtfImportAdapter = rtfImportAdapter; exports.BUILT_IN_IMPORT_ADAPTERS = BUILT_IN_IMPORT_ADAPTERS; exports.createImportAdapterRegistry = createImportAdapterRegistry; exports.defaultImportRegistry = defaultImportRegistry; exports.registerImportAdapter = registerImportAdapter; exports.unregisterImportAdapter = unregisterImportAdapter; exports.findImportAdapter = findImportAdapter; exports.importFile = importFile; exports.getImportAccept = getImportAccept; exports.htmlToSlice = htmlToSlice; exports.insertImportedDocument = insertImportedDocument; exports.importFilesIntoEditor = importFilesIntoEditor; exports.fileImportPluginKey = fileImportPluginKey; exports.FileImport = FileImport; exports.richClipboardPluginKey = richClipboardPluginKey; exports.writeRichClipboard = writeRichClipboard; exports.RichClipboard = RichClipboard; exports.smartQuoteRules = smartQuoteRules; exports.symbolRules = symbolRules; exports.fractionRules = fractionRules; exports.capitalizeSentenceRules = capitalizeSentenceRules; exports.twoInitialCapitalsRules = twoInitialCapitalsRules; exports.defaultAutocorrectRules = defaultAutocorrectRules; exports.DEFAULT_AUTOCORRECT_EXCEPTIONS = DEFAULT_AUTOCORRECT_EXCEPTIONS; exports.autocorrectPluginKey = autocorrectPluginKey; exports.findAutocorrection = findAutocorrection; exports.isInsidePromptToken = isInsidePromptToken; exports.Autocorrect = Autocorrect; exports.outlinePluginKey = outlinePluginKey; exports.computeOutline = computeOutline; exports.buildOutlineTree = buildOutlineTree; exports.getOutline = getOutline; exports.getActiveHeading = getActiveHeading; exports.createOutlineStore = createOutlineStore; exports.navigateToHeading = navigateToHeading; exports.Outline = Outline; exports.tableOfContentsMarkdownIt = tableOfContentsMarkdownIt; exports.footnotesMarkdownIt = footnotesMarkdownIt; exports.tableOfContentsPluginKey = tableOfContentsPluginKey; exports.getTableOfContentsEntries = getTableOfContentsEntries; exports.TableOfContents = TableOfContents; exports.footnotesPluginKey = footnotesPluginKey; exports.getFootnotes = getFootnotes; exports.syncFootnotes = syncFootnotes; exports.FootnoteReference = FootnoteReference; exports.Footnotes = Footnotes; exports.Footnote = Footnote; exports.getBookmarks = getBookmarks; exports.Bookmark = Bookmark; exports.crossReferencePluginKey = crossReferencePluginKey; exports.getCrossReferenceTargets = getCrossReferenceTargets; exports.CrossReference = CrossReference; exports.documentStructureCommandItems = documentStructureCommandItems; exports.getDocumentStructureCommandItems = getDocumentStructureCommandItems; exports.createRichTextPreset = createRichTextPreset;
-//# sourceMappingURL=chunk-4QPLEUL2.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+exports.GradientText = GradientText; exports.SlashCommands = SlashCommands; exports.TemplateSuggestions = TemplateSuggestions; exports.LoadingNode = LoadingNode; exports.SMILIE_REPLACEMENTS = SMILIE_REPLACEMENTS; exports.smilieAutocorrectRules = smilieAutocorrectRules; exports.SmilieReplacer = SmilieReplacer; exports.findHexColors = findHexColors; exports.ColorHighlighter = ColorHighlighter; exports.FontSize = FontSize; exports.Mention = Mention; exports.createMentionExtension = createMentionExtension; exports.Markdown = Markdown2; exports.imagePastePluginKey = imagePastePluginKey; exports.insertImageNode = insertImageNode; exports.updateImageSrc = updateImageSrc; exports.removeImageNode = removeImageNode; exports.handleImageInsertion = handleImageInsertion; exports.Image = Image2; exports.commentsPluginKey = commentsPluginKey; exports.COMMENT_MARK_NAME = COMMENT_MARK_NAME; exports.findCommentRanges = findCommentRanges; exports.getCommentAnchors = getCommentAnchors; exports.getCommentIdsAt = getCommentIdsAt; exports.getCommentStore = getCommentStore; exports.Comments = Comments; exports.getCommentAuthor = getCommentAuthor; exports.ImportError = ImportError; exports.createImportContext = createImportContext; exports.ImportAdapterRegistry = ImportAdapterRegistry; exports.ZipError = ZipError; exports.DEFAULT_ZIP_MAX_ENTRIES = DEFAULT_ZIP_MAX_ENTRIES; exports.DEFAULT_ZIP_MAX_TOTAL_SIZE = DEFAULT_ZIP_MAX_TOTAL_SIZE; exports.zipCrc32 = zipCrc32; exports.isUnsafeZipPath = isUnsafeZipPath; exports.ZipArchive = ZipArchive; exports.readZip = readZip; exports.DOCX_MIME_TYPES = DOCX_MIME_TYPES; exports.DEFAULT_DOCX_MAX_IMAGE_SIZE = DEFAULT_DOCX_MAX_IMAGE_SIZE; exports.docxToDocumentImport = docxToDocumentImport; exports.createDocxImportAdapter = createDocxImportAdapter; exports.docxImportAdapter = docxImportAdapter; exports.markdownImportAdapter = markdownImportAdapter; exports.htmlImportAdapter = htmlImportAdapter; exports.plainTextImportAdapter = plainTextImportAdapter; exports.rtfImportAdapter = rtfImportAdapter; exports.BUILT_IN_IMPORT_ADAPTERS = BUILT_IN_IMPORT_ADAPTERS; exports.createImportAdapterRegistry = createImportAdapterRegistry; exports.defaultImportRegistry = defaultImportRegistry; exports.registerImportAdapter = registerImportAdapter; exports.unregisterImportAdapter = unregisterImportAdapter; exports.findImportAdapter = findImportAdapter; exports.importFile = importFile; exports.getImportAccept = getImportAccept; exports.htmlToSlice = htmlToSlice; exports.insertImportedDocument = insertImportedDocument; exports.importFilesIntoEditor = importFilesIntoEditor; exports.fileImportPluginKey = fileImportPluginKey; exports.FileImport = FileImport; exports.richClipboardPluginKey = richClipboardPluginKey; exports.writeRichClipboard = writeRichClipboard; exports.RichClipboard = RichClipboard; exports.smartQuoteRules = smartQuoteRules; exports.symbolRules = symbolRules; exports.fractionRules = fractionRules; exports.capitalizeSentenceRules = capitalizeSentenceRules; exports.twoInitialCapitalsRules = twoInitialCapitalsRules; exports.defaultAutocorrectRules = defaultAutocorrectRules; exports.DEFAULT_AUTOCORRECT_EXCEPTIONS = DEFAULT_AUTOCORRECT_EXCEPTIONS; exports.autocorrectPluginKey = autocorrectPluginKey; exports.findAutocorrection = findAutocorrection; exports.isInsidePromptToken = isInsidePromptToken; exports.Autocorrect = Autocorrect; exports.outlinePluginKey = outlinePluginKey; exports.computeOutline = computeOutline; exports.buildOutlineTree = buildOutlineTree; exports.getOutline = getOutline; exports.getActiveHeading = getActiveHeading; exports.createOutlineStore = createOutlineStore; exports.navigateToHeading = navigateToHeading; exports.Outline = Outline; exports.tableOfContentsMarkdownIt = tableOfContentsMarkdownIt; exports.footnotesMarkdownIt = footnotesMarkdownIt; exports.tableOfContentsPluginKey = tableOfContentsPluginKey; exports.getTableOfContentsEntries = getTableOfContentsEntries; exports.TableOfContents = TableOfContents; exports.footnotesPluginKey = footnotesPluginKey; exports.getFootnotes = getFootnotes; exports.syncFootnotes = syncFootnotes; exports.FootnoteReference = FootnoteReference; exports.Footnotes = Footnotes; exports.Footnote = Footnote; exports.getBookmarks = getBookmarks; exports.Bookmark = Bookmark; exports.crossReferencePluginKey = crossReferencePluginKey; exports.getCrossReferenceTargets = getCrossReferenceTargets; exports.CrossReference = CrossReference; exports.documentStructureCommandItems = documentStructureCommandItems; exports.getDocumentStructureCommandItems = getDocumentStructureCommandItems; exports.createRichTextPreset = createRichTextPreset;
+//# sourceMappingURL=chunk-GVSMRPHB.cjs.map