@pixerate/editor 0.25.0 → 0.26.0

package/dist/chunk-KRGXUQ2Y.js

@@ -0,0 +1,1696 @@
+import {
+  DEFAULT_STYLES,
+  NORMAL_STYLE_ID,
+  isValidStyleId,
+  zipCrc32
+} from "./chunk-MR2764X2.js";
+
+// src/export/images.ts
+var DOCX_IMAGE_TYPES = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/jpg": "jpeg",
+  "image/gif": "gif",
+  "image/bmp": "bmp",
+  "image/webp": "webp",
+  "image/tiff": "tiff"
+};
+var DOCX_IMAGE_CONTENT_TYPES = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  webp: "image/webp",
+  tiff: "image/tiff"
+};
+var MAX_DATA_URL = 64 * 1024 * 1024;
+function decodeDataUrl(src) {
+  if (src.length > MAX_DATA_URL) return null;
+  const comma = src.indexOf(",");
+  if (comma === -1) return null;
+  const header = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+)((?:;[a-z0-9-]+=[^;,]*)*);base64$/i.exec(src.slice(0, comma));
+  if (!header) return null;
+  const payload = src.slice(comma + 1).replace(/\s+/g, "");
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(payload)) return null;
+  try {
+    const binary = atob(payload);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return { mime: header[1].toLowerCase(), bytes };
+  } catch {
+    return null;
+  }
+}
+var u16be = (b, i) => b[i] << 8 | b[i + 1];
+var u16le = (b, i) => b[i] | b[i + 1] << 8;
+var u32be = (b, i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+var i32le = (b, i) => b[i] | b[i + 1] << 8 | b[i + 2] << 16 | b[i + 3] << 24;
+function imagePixelSize(b) {
+  const ok = (width, height) => width > 0 && height > 0 && width < 1e6 && height < 1e6 ? { width, height } : null;
+  if (b.length >= 24 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) {
+    return ok(u32be(b, 16), u32be(b, 20));
+  }
+  if (b.length >= 10 && b[0] === 71 && b[1] === 73 && b[2] === 70) return ok(u16le(b, 6), u16le(b, 8));
+  if (b.length >= 26 && b[0] === 66 && b[1] === 77) return ok(Math.abs(i32le(b, 18)), Math.abs(i32le(b, 22)));
+  if (b.length >= 30 && b[0] === 82 && b[1] === 73 && b[8] === 87 && b[9] === 69) {
+    const chunk = String.fromCharCode(b[12], b[13], b[14], b[15]);
+    if (chunk === "VP8 ") return ok(u16le(b, 26) & 16383, u16le(b, 28) & 16383);
+    if (chunk === "VP8L") {
+      const bits = b[21] | b[22] << 8 | b[23] << 16 | b[24] << 24;
+      return ok((bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+    }
+    if (chunk === "VP8X") return ok((b[24] | b[25] << 8 | b[26] << 16) + 1, (b[27] | b[28] << 8 | b[29] << 16) + 1);
+    return null;
+  }
+  if (b.length >= 4 && b[0] === 255 && b[1] === 216) {
+    let i = 2;
+    while (i + 9 < b.length) {
+      if (b[i] !== 255) return null;
+      const marker = b[i + 1];
+      if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+        i += 2;
+        continue;
+      }
+      const length = u16be(b, i + 2);
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        return ok(u16be(b, i + 7), u16be(b, i + 5));
+      }
+      if (length < 2) return null;
+      i += 2 + length;
+    }
+  }
+  return null;
+}
+function pixelAttr(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
+  if (typeof value !== "string") return void 0;
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(px)?\s*$/i.exec(value);
+  return match ? Number(match[1]) || void 0 : void 0;
+}
+
+// src/export/units.ts
+var DOCX_BASE_FONT_PT = 11;
+var MAX_LEN_PT = 1584;
+var UNIT_PT = {
+  pt: 1,
+  px: 0.75,
+  in: 72,
+  cm: 72 / 2.54,
+  mm: 72 / 25.4,
+  pc: 12
+};
+function cssLengthToPt(value, basePt = DOCX_BASE_FONT_PT) {
+  if (typeof value === "number") return Number.isFinite(value) ? clampPt(value * UNIT_PT.px) : void 0;
+  if (typeof value !== "string") return void 0;
+  const match = /^\s*(-?\d+(?:\.\d+)?|-?\.\d+)\s*([a-z%]*)\s*$/i.exec(value);
+  if (!match) return void 0;
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase() || "px";
+  let pt;
+  if (unit === "em" || unit === "rem") pt = n * basePt;
+  else if (unit === "%") pt = n / 100 * basePt;
+  else if (unit in UNIT_PT) pt = n * UNIT_PT[unit];
+  return pt === void 0 || !Number.isFinite(pt) ? void 0 : clampPt(pt);
+}
+function clampPt(pt) {
+  return Math.max(-MAX_LEN_PT, Math.min(MAX_LEN_PT, pt));
+}
+var ptToTwips = (pt) => Math.round(pt * 20);
+var ptToHalfPoints = (pt) => Math.max(1, Math.min(3276, Math.round(pt * 2)));
+var pxToEmu = (px) => Math.round(px * 9525);
+var pxToTwips = (px) => Math.round(px * 15);
+var NAMED_COLORS = {
+  black: "000000",
+  white: "FFFFFF",
+  red: "FF0000",
+  green: "008000",
+  lime: "00FF00",
+  blue: "0000FF",
+  yellow: "FFFF00",
+  cyan: "00FFFF",
+  aqua: "00FFFF",
+  magenta: "FF00FF",
+  fuchsia: "FF00FF",
+  gray: "808080",
+  grey: "808080",
+  silver: "C0C0C0",
+  maroon: "800000",
+  navy: "000080",
+  olive: "808000",
+  purple: "800080",
+  teal: "008080",
+  orange: "FFA500",
+  pink: "FFC0CB"
+};
+function cssColorToHex(value) {
+  if (typeof value !== "string") return void 0;
+  const color = value.trim().toLowerCase();
+  if (color in NAMED_COLORS) return NAMED_COLORS[color];
+  let match = /^#([0-9a-f]{3,4})$/.exec(color);
+  if (match) return match[1].slice(0, 3).split("").map((c) => c + c).join("").toUpperCase();
+  match = /^#([0-9a-f]{6})(?:[0-9a-f]{2})?$/.exec(color);
+  if (match) return match[1].toUpperCase();
+  match = /^rgba?\(\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*[, ]\s*(\d{1,3})\s*(?:[,/]\s*[\d.]+%?\s*)?\)$/.exec(color);
+  if (match) {
+    return match.slice(1, 4).map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0")).join("").toUpperCase();
+  }
+  return void 0;
+}
+var WORD_HIGHLIGHTS = {
+  FFFF00: "yellow",
+  "00FF00": "green",
+  "00FFFF": "cyan",
+  FF00FF: "magenta",
+  "0000FF": "blue",
+  FF0000: "red",
+  "000080": "darkBlue",
+  "008080": "darkCyan",
+  "008000": "darkGreen",
+  "800080": "darkMagenta",
+  "800000": "darkRed",
+  "808000": "darkYellow",
+  "808080": "darkGray",
+  C0C0C0: "lightGray",
+  "000000": "black",
+  FFFFFF: "white"
+};
+
+// src/export/xml.ts
+var INVALID_XML_CHARS = /[^\t\n\r -퟿-�\u{10000}-\u{10FFFF}]/gu;
+function stripInvalidXmlChars(value) {
+  return value.replace(INVALID_XML_CHARS, "");
+}
+function escapeXmlText(value) {
+  return stripInvalidXmlChars(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlAttr(value) {
+  return escapeXmlText(value).replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/\t/g, "&#9;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;");
+}
+function attrs(values) {
+  if (!values) return "";
+  let out = "";
+  for (const [name, value] of Object.entries(values)) {
+    if (value === void 0 || value === null || value === false) continue;
+    out += ` ${name}="${escapeXmlAttr(String(value))}"`;
+  }
+  return out;
+}
+var XmlWriter = class {
+  parts;
+  /** `declaration: false` writes a fragment (e.g. one paragraph). */
+  constructor(declaration = true) {
+    this.parts = declaration ? ['<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n'] : [];
+  }
+  open(name, values) {
+    this.parts.push(`<${name}${attrs(values)}>`);
+    return this;
+  }
+  empty(name, values) {
+    this.parts.push(`<${name}${attrs(values)}/>`);
+    return this;
+  }
+  close(name) {
+    this.parts.push(`</${name}>`);
+    return this;
+  }
+  text(value) {
+    this.parts.push(escapeXmlText(value));
+    return this;
+  }
+  /** `<name attrs>text</name>`. */
+  leaf(name, values, text) {
+    return this.open(name, values).text(text).close(name);
+  }
+  /** `<name w:val="value"/>`. */
+  val(name, value) {
+    return this.empty(name, { "w:val": value });
+  }
+  /** Appends markup produced by another writer. */
+  raw(markup) {
+    this.parts.push(markup);
+    return this;
+  }
+  toString() {
+    return this.parts.join("");
+  }
+};
+
+// src/export/zip-writer.ts
+var encoder = new TextEncoder();
+var MAX_SIZE = 4294967295;
+async function readAll(readable) {
+  const reader = readable.getReader();
+  const chunks = [];
+  let length = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    length += value.length;
+  }
+  const out = new Uint8Array(length);
+  let pos = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return out;
+}
+async function deflateRaw(data) {
+  const Stream = globalThis.CompressionStream;
+  if (typeof Stream !== "function") return null;
+  let stream;
+  try {
+    stream = new Stream("deflate-raw");
+  } catch {
+    return null;
+  }
+  const writer = stream.writable.getWriter();
+  const written = writer.write(data).then(() => writer.close()).catch(() => {
+  });
+  const out = await readAll(stream.readable);
+  await written;
+  return out;
+}
+function dosDateTime(date) {
+  const year = Math.min(Math.max(date.getUTCFullYear(), 1980), 2107);
+  return {
+    time: date.getUTCHours() << 11 | date.getUTCMinutes() << 5 | Math.floor(date.getUTCSeconds() / 2),
+    date: year - 1980 << 9 | date.getUTCMonth() + 1 << 5 | date.getUTCDate()
+  };
+}
+var ByteSink = class {
+  chunks = [];
+  length = 0;
+  bytes(data) {
+    this.chunks.push(data);
+    this.length += data.length;
+  }
+  header(fields) {
+    const size = fields.reduce((n, [, width]) => n + width, 0);
+    const buffer = new Uint8Array(size);
+    const view = new DataView(buffer.buffer);
+    let pos = 0;
+    for (const [value, width] of fields) {
+      if (width === 2) view.setUint16(pos, value, true);
+      else view.setUint32(pos, value >>> 0, true);
+      pos += width;
+    }
+    this.bytes(buffer);
+  }
+  toUint8Array() {
+    const out = new Uint8Array(this.length);
+    let pos = 0;
+    for (const chunk of this.chunks) {
+      out.set(chunk, pos);
+      pos += chunk.length;
+    }
+    return out;
+  }
+};
+async function writeZip(entries, options = {}) {
+  if (entries.length > 65535) throw new RangeError("Too many ZIP entries (no ZIP64 support).");
+  const { time, date } = dosDateTime(options.modified ?? new Date(Date.UTC(1980, 0, 1)));
+  const out = new ByteSink();
+  const central = new ByteSink();
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const name = entry.name;
+    if (!name || name.startsWith("/") || name.includes("\\") || name.split("/").includes("..") || name.includes("\0")) {
+      throw new Error(`Unsafe ZIP entry name: ${JSON.stringify(name)}`);
+    }
+    if (seen.has(name)) throw new Error(`Duplicate ZIP entry name: ${JSON.stringify(name)}`);
+    seen.add(name);
+    const raw = typeof entry.data === "string" ? encoder.encode(entry.data) : entry.data;
+    const deflated = options.compression === "store" || raw.length === 0 ? null : await deflateRaw(raw);
+    const useDeflate = !!deflated && deflated.length < raw.length;
+    const body = useDeflate ? deflated : raw;
+    const method = useDeflate ? 8 : 0;
+    const nameBytes = encoder.encode(name);
+    const crc = zipCrc32(raw);
+    const offset = out.length;
+    if (body.length > MAX_SIZE || raw.length > MAX_SIZE || offset > MAX_SIZE) {
+      throw new RangeError("ZIP archive too large (no ZIP64 support).");
+    }
+    const flags = 2048;
+    out.header([
+      [67324752, 4],
+      [20, 2],
+      [flags, 2],
+      [method, 2],
+      [time, 2],
+      [date, 2],
+      [crc, 4],
+      [body.length, 4],
+      [raw.length, 4],
+      [nameBytes.length, 2],
+      [0, 2]
+    ]);
+    out.bytes(nameBytes);
+    out.bytes(body);
+    central.header([
+      [33639248, 4],
+      [20, 2],
+      [20, 2],
+      [flags, 2],
+      [method, 2],
+      [time, 2],
+      [date, 2],
+      [crc, 4],
+      [body.length, 4],
+      [raw.length, 4],
+      [nameBytes.length, 2],
+      [0, 2],
+      [0, 2],
+      [0, 2],
+      [0, 2],
+      [0, 4],
+      [offset, 4]
+    ]);
+    central.bytes(nameBytes);
+  }
+  const cdOffset = out.length;
+  const cd = central.toUint8Array();
+  out.bytes(cd);
+  out.header([
+    [101010256, 4],
+    [0, 2],
+    [0, 2],
+    [entries.length, 2],
+    [entries.length, 2],
+    [cd.length, 4],
+    [cdOffset, 4],
+    [0, 2]
+  ]);
+  return out.toUint8Array();
+}
+
+// src/export/docx.ts
+var DOCX_EXPORT_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var NS = {
+  w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+  mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+  w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+  w15: "http://schemas.microsoft.com/office/word/2012/wordml"
+};
+var BODY_NS = {
+  "xmlns:w": NS.w,
+  "xmlns:r": NS.r,
+  "xmlns:wp": NS.wp,
+  "xmlns:a": NS.a,
+  "xmlns:pic": NS.pic,
+  "xmlns:mc": NS.mc,
+  "xmlns:w14": NS.w14,
+  "xmlns:w15": NS.w15,
+  "mc:Ignorable": "w14 w15"
+};
+var REL = {
+  officeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+  core: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+  app: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+  styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+  numbering: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering",
+  settings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings",
+  comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+  commentsExtended: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+  people: "http://schemas.microsoft.com/office/2011/relationships/people",
+  image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+  hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+};
+var CT_WML = "application/vnd.openxmlformats-officedocument.wordprocessingml.";
+var CONTENT_WIDTH_TWIPS = 9360;
+var MAX_IMAGE_WIDTH_PX = 624;
+var INDENT_STEP = 720;
+var DOCX_ANONYMOUS_AUTHOR = "Author";
+var ANONYMOUS_INITIALS = "A";
+var MAX_DEPTH = 64;
+var BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+var BULLET_FONTS = ["Symbol", "Courier New", "Wingdings"];
+var TASK_UNCHECKED = "\u2610";
+var TASK_CHECKED = "\u2612";
+var FORMAT_MARKS = /* @__PURE__ */ new Set([
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "subscript",
+  "superscript",
+  "code",
+  "textStyle",
+  "highlight",
+  "characterStyle"
+]);
+var STRUCTURAL_MARKS = /* @__PURE__ */ new Set(["link", "insertion", "deletion", "formatChange", "comment", "bookmark"]);
+var isEditorLike = (value) => !!value && typeof value.getJSON === "function";
+function threadsOf(source) {
+  if (!source) return [];
+  if (Array.isArray(source)) return [...source];
+  const value = source;
+  if (typeof value.toJSON === "function") return [...value.toJSON()?.threads ?? []];
+  if (typeof value.getSnapshot === "function") return [...value.getSnapshot()?.threads ?? []];
+  return Array.isArray(value.threads) ? [...value.threads] : [];
+}
+function stylesOf(source) {
+  if (!source) return { styles: DEFAULT_STYLES.map((s) => ({ ...s })), defaults: {} };
+  if (Array.isArray(source)) return { styles: [...source], defaults: {} };
+  const value = source;
+  const json = typeof value.toJSON === "function" ? value.toJSON() : value;
+  return { styles: [...json.styles ?? []], defaults: json.defaults ?? {} };
+}
+function authorOf(author) {
+  if (!author) return void 0;
+  return typeof author === "string" ? { id: author, name: author } : author;
+}
+function isoDate(ms) {
+  const n = typeof ms === "number" ? ms : Number(ms);
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  const date = new Date(n);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function initialsOf(name) {
+  const letters = name.split(/\s+/).filter(Boolean).map((word) => Array.from(word)[0] ?? "").join("").slice(0, 3).toUpperCase();
+  return letters || ANONYMOUS_INITIALS;
+}
+function fileStyleName(name) {
+  const heading = /^Heading ([1-9])$/.exec(name);
+  return heading ? `heading ${heading[1]}` : name;
+}
+var truncate = (value, max = 80) => value.length > max ? `${value.slice(0, max - 1)}\u2026` : value;
+function runFormatOf(marks) {
+  const format = {};
+  for (const mark of marks ?? []) {
+    const attrs2 = mark.attrs ?? {};
+    switch (mark.type) {
+      case "bold":
+        format.bold = true;
+        break;
+      case "italic":
+        format.italic = true;
+        break;
+      case "underline":
+        format.underline = true;
+        break;
+      case "strike":
+        format.strike = true;
+        break;
+      case "subscript":
+        format.vertAlign = "subscript";
+        break;
+      case "superscript":
+        format.vertAlign = "superscript";
+        break;
+      case "code":
+        format.font = "Consolas";
+        break;
+      case "textStyle": {
+        const color = cssColorToHex(attrs2.color);
+        if (color) format.color = color;
+        const pt = cssLengthToPt(attrs2.fontSize);
+        if (pt !== void 0 && pt > 0) format.halfPoints = ptToHalfPoints(pt);
+        if (typeof attrs2.fontFamily === "string" && attrs2.fontFamily.trim()) {
+          format.font = attrs2.fontFamily.split(",")[0].trim().replace(/^["']|["']$/g, "");
+        }
+        break;
+      }
+      case "highlight": {
+        const color = attrs2.color ? cssColorToHex(attrs2.color) : "FFFF00";
+        if (color && WORD_HIGHLIGHTS[color]) format.highlight = WORD_HIGHLIGHTS[color];
+        else if (color) format.shading = color;
+        break;
+      }
+      case "characterStyle":
+        if (isValidStyleId(attrs2.styleId)) format.charStyle = attrs2.styleId;
+        break;
+      case "link":
+        format.charStyle ??= "Hyperlink";
+        break;
+      default:
+        break;
+    }
+  }
+  return format;
+}
+function writeRunProps(w, f) {
+  if (f.charStyle) w.val("w:rStyle", f.charStyle);
+  if (f.font) w.empty("w:rFonts", { "w:ascii": f.font, "w:hAnsi": f.font, "w:cs": f.font, "w:eastAsia": f.font });
+  if (f.bold) w.empty("w:b");
+  if (f.italic) w.empty("w:i");
+  if (f.strike) w.empty("w:strike");
+  if (f.color) w.val("w:color", f.color);
+  if (f.halfPoints) {
+    w.val("w:sz", f.halfPoints);
+    w.val("w:szCs", f.halfPoints);
+  }
+  if (f.highlight) w.val("w:highlight", f.highlight);
+  if (f.underline) w.val("w:u", "single");
+  if (f.shading) w.empty("w:shd", { "w:val": "clear", "w:color": "auto", "w:fill": f.shading });
+  if (f.vertAlign) w.val("w:vertAlign", f.vertAlign);
+}
+var hasRunProps = (f) => Object.values(f).some((v) => v !== void 0 && v !== false);
+function characterFormatToRun(c) {
+  const f = {};
+  if (!c) return f;
+  if (c.fontFamily) f.font = c.fontFamily.split(",")[0].trim().replace(/^["']|["']$/g, "");
+  if (c.bold) f.bold = true;
+  if (c.italic) f.italic = true;
+  if (c.underline) f.underline = true;
+  if (c.strike) f.strike = true;
+  const color = cssColorToHex(c.color);
+  if (color) f.color = color;
+  const pt = cssLengthToPt(c.fontSize);
+  if (pt !== void 0 && pt > 0) f.halfPoints = ptToHalfPoints(pt);
+  const background = cssColorToHex(c.backgroundColor);
+  if (background) f.shading = background;
+  return f;
+}
+function writeParagraphFormat(w, p, outline) {
+  if (!p && outline === void 0) return;
+  const before = cssLengthToPt(p?.spaceBefore);
+  const after = cssLengthToPt(p?.spaceAfter);
+  const lineValue = p?.lineHeight;
+  let line;
+  let lineRule;
+  if (typeof lineValue === "string" && /^\s*\d+(\.\d+)?\s*$/.test(lineValue)) {
+    line = Math.round(Number(lineValue) * 240);
+    lineRule = "auto";
+  } else if (lineValue) {
+    const pt = cssLengthToPt(lineValue);
+    if (pt !== void 0 && pt > 0) {
+      line = ptToTwips(pt);
+      lineRule = "atLeast";
+    }
+  }
+  if (before !== void 0 || after !== void 0 || line !== void 0) {
+    w.empty("w:spacing", {
+      "w:before": before !== void 0 ? Math.max(0, ptToTwips(before)) : void 0,
+      "w:after": after !== void 0 ? Math.max(0, ptToTwips(after)) : void 0,
+      "w:line": line,
+      "w:lineRule": lineRule
+    });
+  }
+  const left = cssLengthToPt(p?.indentLeft);
+  const right = cssLengthToPt(p?.indentRight);
+  const first = cssLengthToPt(p?.indentFirstLine);
+  if (left !== void 0 || right !== void 0 || first !== void 0) {
+    w.empty("w:ind", {
+      "w:left": left !== void 0 ? ptToTwips(left) : void 0,
+      "w:right": right !== void 0 ? ptToTwips(right) : void 0,
+      "w:firstLine": first !== void 0 && first >= 0 ? ptToTwips(first) : void 0,
+      "w:hanging": first !== void 0 && first < 0 ? ptToTwips(-first) : void 0
+    });
+  }
+  const jc = alignment(p?.textAlign);
+  if (jc) w.val("w:jc", jc);
+  if (outline !== void 0) w.val("w:outlineLvl", outline);
+}
+function alignment(value) {
+  switch (value) {
+    case "left":
+      return "left";
+    case "center":
+      return "center";
+    case "right":
+      return "right";
+    case "justify":
+      return "both";
+    default:
+      return void 0;
+  }
+}
+var Relationships = class {
+  list = [];
+  index = /* @__PURE__ */ new Map();
+  add(type, target, external = false) {
+    const key = `${type}
+${target}
+${external}`;
+    const existing = this.index.get(key);
+    if (existing) return existing;
+    const id = `rId${this.list.length + 1}`;
+    this.list.push({ id, type, target, external });
+    this.index.set(key, id);
+    return id;
+  }
+  get size() {
+    return this.list.length;
+  }
+  xml() {
+    const w = new XmlWriter();
+    w.open("Relationships", { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" });
+    for (const rel of this.list) {
+      w.empty("Relationship", {
+        Id: rel.id,
+        Type: rel.type,
+        Target: rel.target,
+        TargetMode: rel.external ? "External" : void 0
+      });
+    }
+    w.close("Relationships");
+    return w.toString();
+  }
+};
+var DocxBuilder = class {
+  constructor(doc, options, threads, styles) {
+    this.doc = doc;
+    this.options = options;
+    this.threads = threads;
+    this.styles = styles;
+    this.anonymous = options.privacy === "strip-authors";
+    this.defaultAuthor = authorOf(options.author);
+    this.styleIds = new Set(styles.styles.filter((s) => isValidStyleId(s.id)).map((s) => s.id));
+  }
+  doc;
+  options;
+  threads;
+  styles;
+  report = {
+    dropped: [],
+    written: { paragraphs: 0, tables: 0, images: 0, comments: 0, replies: 0, trackedChanges: 0 }
+  };
+  rels = new Relationships();
+  media = [];
+  mediaTypes = /* @__PURE__ */ new Set();
+  nums = [];
+  revisionId = 0;
+  docPrId = 0;
+  paraIdCounter = 268435456;
+  comments = /* @__PURE__ */ new Map();
+  /** Thread id → JSON node carrying its last comment mark. */
+  commentEnds = /* @__PURE__ */ new Map();
+  /** JSON node → threads whose range ends after it (so ends are found in O(1) per node). */
+  endsByNode = /* @__PURE__ */ new Map();
+  people = /* @__PURE__ */ new Map();
+  styleIds;
+  extraStyles = /* @__PURE__ */ new Set();
+  anonymous;
+  defaultAuthor;
+  drop(kind, name, reason) {
+    const issue = this.report.dropped.find((i) => i.kind === kind && i.name === name && i.reason === reason);
+    if (issue) issue.count++;
+    else this.report.dropped.push({ kind, name: truncate(name), reason, count: 1 });
+  }
+  // -- Authors and revisions ------------------------------------------------
+  authorName(name, id) {
+    if (this.anonymous) return DOCX_ANONYMOUS_AUTHOR;
+    const author = typeof name === "string" && name.trim() || typeof id === "string" && id.trim() || this.defaultAuthor?.name || "Unknown";
+    const authorId = typeof id === "string" && id.trim() || this.defaultAuthor?.id;
+    if (authorId && authorId !== author && !this.people.has(author)) this.people.set(author, authorId);
+    return author;
+  }
+  changeAttrs(attrs2) {
+    return {
+      "w:id": ++this.revisionId,
+      "w:author": this.authorName(attrs2.authorName, attrs2.authorId),
+      "w:date": isoDate(attrs2.createdAt)
+    };
+  }
+  // -- Comments ---------------------------------------------------------------
+  prepareComments() {
+    const marked = /* @__PURE__ */ new Set();
+    const visit = (node, depth) => {
+      if (depth > MAX_DEPTH) return;
+      for (const mark of node.marks ?? []) {
+        if (mark.type === "comment" && typeof mark.attrs?.commentId === "string") {
+          marked.add(mark.attrs.commentId);
+          this.commentEnds.set(mark.attrs.commentId, node);
+        }
+      }
+      node.content?.forEach((child) => visit(child, depth + 1));
+    };
+    visit(this.doc, 0);
+    let next = 0;
+    for (const thread of this.threads) {
+      if (!thread || typeof thread.id !== "string") continue;
+      if (!marked.has(thread.id)) {
+        this.drop("comment", thread.id, "comment text is not in the document");
+        continue;
+      }
+      if (!thread.body?.trim()) {
+        this.drop("comment", thread.id, "draft comment without text");
+        this.commentEnds.delete(thread.id);
+        continue;
+      }
+      const replies = (thread.replies ?? []).filter((reply) => reply && reply.body?.trim());
+      const ids = [next++, ...replies.map(() => next++)];
+      this.comments.set(thread.id, { thread: { ...thread, replies }, ids, started: false, ended: false });
+    }
+    for (const [threadId, node] of this.commentEnds) {
+      if (!this.comments.has(threadId)) continue;
+      const list = this.endsByNode.get(node) ?? [];
+      list.push(threadId);
+      this.endsByNode.set(node, list);
+    }
+  }
+  // -- Document ---------------------------------------------------------------
+  documentXml() {
+    this.prepareComments();
+    const body = new XmlWriter(false);
+    const blocks = this.doc.type === "doc" || !this.doc.type ? this.doc.content ?? [] : [this.doc];
+    this.blocks(body, blocks, { depth: 0, quoteLevel: 0 });
+    if (!blocks.length || blocks[blocks.length - 1].type === "table") body.empty("w:p");
+    for (const [id, entry] of this.comments) if (entry.started && !entry.ended) this.endComment(body, id);
+    const w = new XmlWriter();
+    w.open("w:document", BODY_NS).open("w:body").raw(body.toString());
+    w.open("w:sectPr").empty("w:pgSz", { "w:w": 12240, "w:h": 15840 }).empty("w:pgMar", {
+      "w:top": 1440,
+      "w:right": 1440,
+      "w:bottom": 1440,
+      "w:left": 1440,
+      "w:header": 720,
+      "w:footer": 720,
+      "w:gutter": 0
+    }).close("w:sectPr");
+    w.close("w:body").close("w:document");
+    return w.toString();
+  }
+  blocks(w, nodes, ctx) {
+    if (ctx.depth > MAX_DEPTH) {
+      this.drop("node", "nesting", `content nested deeper than ${MAX_DEPTH} levels`);
+      return;
+    }
+    let first = true;
+    nodes.forEach((node, i) => {
+      const itemCtx = { ...ctx, depth: ctx.depth + 1, listItemFirst: ctx.list ? first : void 0 };
+      this.block(w, node, itemCtx);
+      if (node.type !== "bulletList" && node.type !== "orderedList" && node.type !== "taskList") first = false;
+      if (node.type === "table" && nodes[i + 1]?.type === "table") w.empty("w:p");
+    });
+  }
+  block(w, node, ctx) {
+    const type = node.type ?? "";
+    switch (type) {
+      case "paragraph":
+        this.paragraph(w, node, ctx);
+        return;
+      case "heading":
+        this.paragraph(w, node, ctx, { heading: Math.max(1, Math.min(6, Number(node.attrs?.level) || 1)) });
+        return;
+      case "codeBlock":
+        this.paragraph(w, node, ctx, { code: true });
+        return;
+      case "blockquote":
+        this.blocks(w, node.content ?? [], { ...ctx, quoteLevel: ctx.quoteLevel + 1 });
+        return;
+      case "bulletList":
+      case "orderedList":
+      case "taskList":
+        this.list(w, node, ctx);
+        return;
+      case "table":
+        this.table(w, node, ctx);
+        return;
+      case "horizontalRule":
+        w.open("w:p").open("w:pPr").open("w:pBdr");
+        w.empty("w:bottom", { "w:val": "single", "w:sz": 6, "w:space": 1, "w:color": "auto" });
+        w.close("w:pBdr").close("w:pPr").close("w:p");
+        this.report.written.paragraphs++;
+        return;
+      case "pageBreak":
+        w.open("w:p").open("w:r").empty("w:br", { "w:type": "page" }).close("w:r").close("w:p");
+        return;
+      case "image":
+        this.paragraph(w, { type: "paragraph", content: [node] }, ctx);
+        return;
+      default:
+        break;
+    }
+    const content = node.content ?? [];
+    if (content.some((child) => child.type === "text" || isInlineType(child.type))) {
+      this.drop("node", type || "unknown", "written as a plain paragraph");
+      this.paragraph(w, { type: "paragraph", content }, ctx);
+    } else if (content.length) {
+      this.drop("node", type || "unknown", "container flattened");
+      this.blocks(w, content, ctx);
+    } else {
+      this.drop("node", type || "unknown", "unsupported node");
+    }
+  }
+  // -- Lists --------------------------------------------------------------------
+  list(w, node, ctx) {
+    const level = Math.min(8, ctx.list ? ctx.list.level + 1 : 0);
+    const abstractId = node.type === "orderedList" ? 2 : node.type === "taskList" ? 3 : 1;
+    const numId = this.nums.length + 1;
+    const start = node.type === "orderedList" ? Number(node.attrs?.start ?? 1) : void 0;
+    this.nums.push({ numId, abstractId, level, start: start !== void 0 && start !== 1 && Number.isFinite(start) ? start : void 0 });
+    for (const item of node.content ?? []) {
+      const task = item.type === "taskItem";
+      this.blocks(w, item.content ?? [], {
+        ...ctx,
+        list: { numId, level, task, checked: task ? !!item.attrs?.checked : void 0 }
+      });
+    }
+  }
+  // -- Paragraphs -----------------------------------------------------------------
+  styleFor(node, ctx, opts) {
+    const own = node.attrs?.styleId;
+    if (own) {
+      if (isValidStyleId(own) && this.styleIds.has(own)) return own;
+      this.drop("style", String(own), "style is not in the registry");
+    }
+    if (opts.heading) return this.needStyle(`Heading${opts.heading}`);
+    if (opts.code) return this.needStyle("Code");
+    if (ctx.quoteLevel > 0) return this.needStyle("BlockText");
+    if (ctx.list) return this.needStyle("ListParagraph");
+    return void 0;
+  }
+  /** Uses a style the registry may not define (it is then written with defaults). */
+  needStyle(id) {
+    if (!this.styleIds.has(id)) this.extraStyles.add(id);
+    return id;
+  }
+  previousStyle(previous) {
+    if (!previous) return void 0;
+    const id = previous.attrs?.styleId;
+    if (isValidStyleId(id) && this.styleIds.has(id)) return id;
+    if (previous.type === "heading") return this.needStyle(`Heading${Math.max(1, Math.min(6, Number(previous.attrs?.level) || 1))}`);
+    if (previous.type === "codeBlock") return this.needStyle("Code");
+    return void 0;
+  }
+  paragraph(w, node, ctx, opts = {}) {
+    this.report.written.paragraphs++;
+    const style = this.styleFor(node, ctx, opts);
+    const change = node.attrs?.blockChange ?? null;
+    const operation = change?.operation;
+    const list = ctx.list;
+    const numbered = list && ctx.listItemFirst;
+    const indent = ctx.quoteLevel * INDENT_STEP + (list && !numbered ? (list.level + 1) * INDENT_STEP : 0);
+    const jc = alignment(node.attrs?.textAlign);
+    w.open("w:p");
+    const ppr = new XmlWriter(false);
+    if (style) ppr.val("w:pStyle", style);
+    if (numbered) {
+      ppr.open("w:numPr").val("w:ilvl", list.level).val("w:numId", list.numId).close("w:numPr");
+    }
+    if (indent && !(ctx.quoteLevel > 0 && !list && ctx.quoteLevel === 1)) ppr.empty("w:ind", { "w:left": indent });
+    if (jc) ppr.val("w:jc", jc);
+    if (change && operation) {
+      ppr.open("w:rPr").empty(operation === "insert" ? "w:ins" : "w:del", this.changeAttrs(change)).close("w:rPr");
+      this.report.written.trackedChanges++;
+    } else if (change?.previous) {
+      ppr.open("w:pPrChange", this.changeAttrs(change)).open("w:pPr");
+      const old = this.previousStyle(change.previous);
+      if (old) ppr.val("w:pStyle", old);
+      const oldJc = alignment(change.previous.attrs?.textAlign);
+      if (oldJc) ppr.val("w:jc", oldJc);
+      ppr.close("w:pPr").close("w:pPrChange");
+      this.report.written.trackedChanges++;
+    }
+    const pprXml = ppr.toString();
+    if (pprXml) w.open("w:pPr").raw(pprXml).close("w:pPr");
+    if (list?.task && numbered) {
+      w.open("w:r").leaf("w:t", { "xml:space": "preserve" }, `${list.checked ? TASK_CHECKED : TASK_UNCHECKED} `).close("w:r");
+    }
+    const synthetic = change && operation ? { kind: operation === "insert" ? "ins" : "del", attrs: change } : void 0;
+    this.inline(w, this.pieces(node.content ?? [], opts.code === true), synthetic);
+    w.close("w:p");
+  }
+  /** Flattens inline content into runs of text, tabs, breaks and images. */
+  pieces(nodes, code, out = [], depth = 0) {
+    if (depth > MAX_DEPTH) return out;
+    for (const node of nodes) {
+      const marks = node.marks ?? [];
+      switch (node.type) {
+        case "text": {
+          const text = node.text ?? "";
+          const parts = text.split(/(\t|\r\n|\n|\r)/);
+          const pieces = [];
+          for (const part of parts) {
+            if (!part) continue;
+            if (part === "	") pieces.push({ kind: "tab", node, last: false, marks });
+            else if (part === "\n" || part === "\r\n" || part === "\r") pieces.push({ kind: "br", node, last: false, marks });
+            else pieces.push({ kind: "text", text: part, node, last: false, marks });
+          }
+          if (!pieces.length) pieces.push({ kind: "text", text: "", node, last: false, marks });
+          pieces[pieces.length - 1].last = true;
+          out.push(...pieces);
+          break;
+        }
+        case "hardBreak":
+          out.push({ kind: "br", node, last: true, marks });
+          break;
+        case "image":
+          out.push({ kind: "image", node, last: true, marks });
+          break;
+        case "mention": {
+          const label = node.attrs?.label ?? node.attrs?.id ?? "";
+          out.push({ kind: "text", text: label ? `@${label}` : "", node, last: true, marks });
+          break;
+        }
+        default:
+          if (node.content?.length) {
+            this.pieces(node.content, code, out, depth + 1);
+          } else if (typeof node.attrs?.label === "string" || typeof node.attrs?.text === "string") {
+            this.drop("node", node.type ?? "unknown", "written as text");
+            out.push({ kind: "text", text: String(node.attrs.label ?? node.attrs.text), node, last: true, marks });
+          } else {
+            this.drop("node", node.type ?? "unknown", "unsupported inline node");
+          }
+      }
+    }
+    return out;
+  }
+  revisionsOf(marks, synthetic) {
+    const out = [];
+    const ins = marks.find((m) => m.type === "insertion");
+    const del = marks.find((m) => m.type === "deletion");
+    if (ins) out.push({ kind: "ins", attrs: ins.attrs ?? {}, moveId: ins.attrs?.moveId || void 0 });
+    if (del) out.push({ kind: "del", attrs: del.attrs ?? {}, moveId: del.attrs?.moveId || void 0 });
+    if (!out.length && synthetic) out.push(synthetic);
+    return out;
+  }
+  linkOf(marks) {
+    const link = marks.find((m) => m.type === "link");
+    const href = typeof link?.attrs?.href === "string" ? link.attrs.href.trim() : "";
+    if (!href) return void 0;
+    if (href.startsWith("#") || /^(https?|mailto|tel|ftp):/i.test(href) || !/^[a-z][a-z0-9+.-]*:/i.test(href)) return href;
+    this.drop("link", href, "unsafe URL scheme");
+    return void 0;
+  }
+  /** Writes pieces grouped into hyperlinks (outer) and tracked-change wrappers (inner). */
+  inline(w, pieces, synthetic) {
+    let openLink;
+    let openRevs = null;
+    const closeRevs = () => {
+      const open = openRevs;
+      if (!open) return;
+      for (const tag of [...open.tags].reverse()) w.close(tag);
+      for (const range of open.moveRanges) w.empty(range.tag, { "w:id": range.id });
+      openRevs = null;
+    };
+    const closeLink = () => {
+      closeRevs();
+      if (openLink !== void 0) w.close("w:hyperlink");
+      openLink = void 0;
+    };
+    for (const piece of pieces) {
+      const href = this.linkOf(piece.marks);
+      if (href !== openLink) {
+        closeLink();
+        if (href !== void 0) {
+          if (href.startsWith("#")) w.open("w:hyperlink", { "w:anchor": href.slice(1), "w:history": 1 });
+          else w.open("w:hyperlink", { "r:id": this.rels.add(REL.hyperlink, href, true), "w:history": 1 });
+          openLink = href;
+        }
+      }
+      const revs = this.revisionsOf(piece.marks, synthetic);
+      const key = revs.map((r) => `${r.kind}:${r.attrs.changeId ?? ""}:${r.moveId ?? ""}:${r.attrs.authorName ?? ""}`).join("|");
+      if (key !== (openRevs?.key ?? "")) {
+        closeRevs();
+        if (revs.length) {
+          const state = { key, tags: [], moveRanges: [] };
+          for (const rev of revs) {
+            const attrs2 = this.changeAttrs(rev.attrs);
+            this.report.written.trackedChanges++;
+            if (rev.moveId) {
+              const rangeTag = rev.kind === "ins" ? "w:moveToRange" : "w:moveFromRange";
+              const rangeId = ++this.revisionId;
+              w.empty(`${rangeTag}Start`, { "w:id": rangeId, "w:name": rev.moveId, "w:author": attrs2["w:author"], "w:date": attrs2["w:date"] });
+              state.moveRanges.push({ tag: `${rangeTag}End`, id: rangeId });
+            }
+            const tag = rev.moveId ? rev.kind === "ins" ? "w:moveTo" : "w:moveFrom" : rev.kind === "ins" ? "w:ins" : "w:del";
+            w.open(tag, attrs2);
+            state.tags.push(tag);
+          }
+          openRevs = state;
+        }
+      }
+      this.commentStarts(w, piece.marks);
+      this.run(w, piece, revs);
+      if (piece.last) this.commentEndsAfter(w, piece.node);
+    }
+    closeLink();
+  }
+  commentStarts(w, marks) {
+    for (const mark of marks) {
+      if (mark.type !== "comment") continue;
+      const entry = this.comments.get(mark.attrs?.commentId);
+      if (!entry || entry.started) continue;
+      entry.started = true;
+      for (const id of entry.ids) w.empty("w:commentRangeStart", { "w:id": id });
+    }
+  }
+  commentEndsAfter(w, node) {
+    for (const threadId of this.endsByNode.get(node) ?? []) {
+      const entry = this.comments.get(threadId);
+      if (entry?.started && !entry.ended) this.endComment(w, threadId);
+    }
+  }
+  endComment(w, threadId) {
+    const entry = this.comments.get(threadId);
+    entry.ended = true;
+    for (const id of entry.ids) {
+      w.empty("w:commentRangeEnd", { "w:id": id });
+      w.open("w:r").open("w:rPr").val("w:rStyle", "CommentReference").close("w:rPr");
+      w.empty("w:commentReference", { "w:id": id }).close("w:r");
+    }
+    this.needStyle("CommentReference");
+    this.needStyle("CommentText");
+  }
+  run(w, piece, revs) {
+    for (const mark of piece.marks) {
+      if (!FORMAT_MARKS.has(mark.type) && !STRUCTURAL_MARKS.has(mark.type)) this.drop("mark", mark.type, "formatting not supported");
+      if (mark.type === "characterStyle" && mark.attrs?.styleId && !this.styleIds.has(mark.attrs.styleId)) {
+        this.drop("style", String(mark.attrs.styleId), "character style is not in the registry");
+      }
+    }
+    if (piece.kind === "image") {
+      const drawing = this.image(piece.node);
+      if (!drawing) return;
+      w.open("w:r");
+      const format2 = runFormatOf(piece.marks);
+      delete format2.charStyle;
+      if (hasRunProps(format2)) {
+        w.open("w:rPr");
+        writeRunProps(w, format2);
+        w.close("w:rPr");
+      }
+      w.raw(drawing).close("w:r");
+      return;
+    }
+    const format = runFormatOf(piece.marks.filter((m) => m.type !== "characterStyle" || this.styleIds.has(m.attrs?.styleId)));
+    if (format.charStyle === "Hyperlink") this.needStyle("Hyperlink");
+    const formatChange = piece.marks.find((m) => m.type === "formatChange");
+    w.open("w:r");
+    if (hasRunProps(format) || formatChange) {
+      w.open("w:rPr");
+      writeRunProps(w, format);
+      if (formatChange) {
+        const attrs2 = formatChange.attrs ?? {};
+        w.open("w:rPrChange", this.changeAttrs(attrs2)).open("w:rPr");
+        writeRunProps(w, runFormatOf(Array.isArray(attrs2.before) ? attrs2.before : []));
+        w.close("w:rPr").close("w:rPrChange");
+        this.report.written.trackedChanges++;
+      }
+      w.close("w:rPr");
+    }
+    const deleted = revs.some((r) => r.kind === "del" && !r.moveId);
+    if (piece.kind === "tab") w.empty("w:tab");
+    else if (piece.kind === "br") w.empty("w:br");
+    else if (piece.text) w.leaf(deleted ? "w:delText" : "w:t", { "xml:space": "preserve" }, piece.text);
+    w.close("w:r");
+  }
+  // -- Images -----------------------------------------------------------------
+  image(node) {
+    const src = typeof node.attrs?.src === "string" ? node.attrs.src.trim() : "";
+    const alt = typeof node.attrs?.alt === "string" ? node.attrs.alt : "";
+    const title = typeof node.attrs?.title === "string" ? node.attrs.title : "";
+    let relId;
+    let natural = null;
+    let linked = false;
+    if (src.startsWith("data:")) {
+      const decoded = decodeDataUrl(src);
+      const ext = decoded ? DOCX_IMAGE_TYPES[decoded.mime] : void 0;
+      if (!decoded || !ext) {
+        this.drop("image", decoded?.mime ?? "data URL", "unsupported image type");
+        return null;
+      }
+      const name = `image${this.media.length + 1}.${ext}`;
+      this.media.push({ name, bytes: decoded.bytes });
+      this.mediaTypes.add(ext);
+      relId = this.rels.add(REL.image, `media/${name}`);
+      natural = imagePixelSize(decoded.bytes);
+    } else if (/^https?:\/\//i.test(src)) {
+      if (this.options.remoteImages !== "link") {
+        this.drop("image", src, 'remote image skipped (use remoteImages: "link")');
+        return null;
+      }
+      relId = this.rels.add(REL.image, src, true);
+      linked = true;
+    } else {
+      this.drop("image", src || "image", "image source is neither a data URL nor http(s)");
+      return null;
+    }
+    let width = pixelAttr(node.attrs?.width) ?? natural?.width ?? 400;
+    let height = pixelAttr(node.attrs?.height) ?? (natural ? natural.height * width / natural.width : 300);
+    if (width > MAX_IMAGE_WIDTH_PX) {
+      height = height * MAX_IMAGE_WIDTH_PX / width;
+      width = MAX_IMAGE_WIDTH_PX;
+    }
+    const cx = pxToEmu(width);
+    const cy = pxToEmu(height);
+    const id = ++this.docPrId;
+    this.report.written.images++;
+    const w = new XmlWriter(false);
+    w.open("w:drawing").open("wp:inline", { distT: 0, distB: 0, distL: 0, distR: 0 });
+    w.empty("wp:extent", { cx, cy }).empty("wp:effectExtent", { l: 0, t: 0, r: 0, b: 0 });
+    w.empty("wp:docPr", { id, name: `Picture ${id}`, descr: alt || void 0, title: title || void 0 });
+    w.open("wp:cNvGraphicFramePr").empty("a:graphicFrameLocks", { noChangeAspect: 1 }).close("wp:cNvGraphicFramePr");
+    w.open("a:graphic").open("a:graphicData", { uri: "http://schemas.openxmlformats.org/drawingml/2006/picture" });
+    w.open("pic:pic").open("pic:nvPicPr").empty("pic:cNvPr", { id: 0, name: `Picture ${id}`, descr: alt || void 0 });
+    w.empty("pic:cNvPicPr").close("pic:nvPicPr");
+    w.open("pic:blipFill").empty("a:blip", linked ? { "r:link": relId } : { "r:embed": relId });
+    w.open("a:stretch").empty("a:fillRect").close("a:stretch").close("pic:blipFill");
+    w.open("pic:spPr").open("a:xfrm").empty("a:off", { x: 0, y: 0 }).empty("a:ext", { cx, cy }).close("a:xfrm");
+    w.open("a:prstGeom", { prst: "rect" }).empty("a:avLst").close("a:prstGeom").close("pic:spPr");
+    w.close("pic:pic").close("a:graphicData").close("a:graphic").close("wp:inline").close("w:drawing");
+    return w.toString();
+  }
+  // -- Tables -------------------------------------------------------------------
+  table(w, node, ctx) {
+    const rows = (node.content ?? []).filter((row) => row.type === "tableRow" || row.content?.length);
+    if (!rows.length) {
+      this.drop("node", "table", "empty table");
+      return;
+    }
+    const grid = rows.map(() => []);
+    rows.forEach((row, r) => {
+      let col = 0;
+      for (const cell of row.content ?? []) {
+        while (grid[r][col]) col++;
+        const colspan = Math.max(1, Math.min(63, Number(cell.attrs?.colspan) || 1));
+        const rowspan = Math.max(1, Math.min(rows.length - r, Number(cell.attrs?.rowspan) || 1));
+        for (let i = 0; i < rowspan; i++) {
+          for (let j = 0; j < colspan; j++) {
+            grid[r + i][col + j] = { cell, rowOffset: i, colOffset: j, colspan, rowspan };
+          }
+        }
+        col += colspan;
+      }
+    });
+    const cols = Math.max(1, Math.min(63, ...grid.map((row) => row.length)));
+    const widths = [];
+    for (let c = 0; c < cols; c++) {
+      const slot = grid[0][c];
+      const colwidth = slot?.cell.attrs?.colwidth;
+      const px = Array.isArray(colwidth) ? Number(colwidth[slot.colOffset]) : NaN;
+      widths.push(Number.isFinite(px) && px > 0 ? pxToTwips(px) : 0);
+    }
+    const known = widths.reduce((n, v) => n + v, 0);
+    const unknown = widths.filter((v) => !v).length;
+    const fill = unknown ? Math.max(360, Math.floor(Math.max(0, CONTENT_WIDTH_TWIPS - known) / unknown)) : 0;
+    for (let c = 0; c < cols; c++) if (!widths[c]) widths[c] = fill;
+    this.report.written.tables++;
+    w.open("w:tbl").open("w:tblPr");
+    w.empty("w:tblW", { "w:w": 0, "w:type": "auto" });
+    w.open("w:tblBorders");
+    for (const side of ["top", "left", "bottom", "right", "insideH", "insideV"]) {
+      w.empty(`w:${side}`, { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" });
+    }
+    w.close("w:tblBorders");
+    w.empty("w:tblLook", { "w:val": "04A0", "w:firstRow": 1, "w:lastRow": 0, "w:firstColumn": 1, "w:lastColumn": 0, "w:noHBand": 0, "w:noVBand": 1 });
+    w.close("w:tblPr");
+    w.open("w:tblGrid");
+    widths.forEach((width) => w.empty("w:gridCol", { "w:w": width }));
+    w.close("w:tblGrid");
+    const cellCtx = { depth: ctx.depth + 1, quoteLevel: 0 };
+    rows.forEach((row, r) => {
+      w.open("w:tr");
+      const cells = row.content ?? [];
+      if (cells.length && cells.every((cell) => cell.type === "tableHeader")) {
+        w.open("w:trPr").empty("w:tblHeader").close("w:trPr");
+      }
+      for (let c = 0; c < cols; c++) {
+        const slot = grid[r][c];
+        if (slot && slot.colOffset > 0) continue;
+        const span = slot?.colspan ?? 1;
+        const width = widths.slice(c, c + span).reduce((n, v) => n + v, 0);
+        w.open("w:tc").open("w:tcPr").empty("w:tcW", { "w:w": width, "w:type": "dxa" });
+        if (span > 1) w.val("w:gridSpan", span);
+        if (slot && slot.rowspan > 1) {
+          if (slot.rowOffset === 0) w.val("w:vMerge", "restart");
+          else w.empty("w:vMerge");
+        }
+        w.close("w:tcPr");
+        const content = slot && slot.rowOffset === 0 ? slot.cell.content ?? [] : [];
+        if (content.length) this.blocks(w, content, cellCtx);
+        const lastType = content[content.length - 1]?.type;
+        if (!content.length || lastType === "table") w.empty("w:p");
+        w.close("w:tc");
+      }
+      w.close("w:tr");
+    });
+    w.close("w:tbl");
+  }
+  // -- Other parts --------------------------------------------------------------
+  numberingXml() {
+    if (!this.nums.length) return null;
+    const w = new XmlWriter();
+    w.open("w:numbering", BODY_NS);
+    const abstract = (id, kind) => {
+      w.open("w:abstractNum", { "w:abstractNumId": id }).val("w:multiLevelType", "hybridMultilevel");
+      for (let level = 0; level < 9; level++) {
+        w.open("w:lvl", { "w:ilvl": level }).val("w:start", 1);
+        if (kind === "decimal") {
+          const formats = ["decimal", "lowerLetter", "lowerRoman"];
+          w.val("w:numFmt", formats[level % 3]).val("w:lvlText", `%${level + 1}.`);
+        } else if (kind === "bullet") {
+          w.val("w:numFmt", "bullet").val("w:lvlText", BULLETS[level % 3]);
+        } else {
+          w.val("w:numFmt", "none").val("w:lvlText", "");
+        }
+        w.val("w:lvlJc", "left");
+        w.open("w:pPr").empty("w:ind", { "w:left": (level + 1) * INDENT_STEP, "w:hanging": kind === "task" ? 0 : 360 }).close("w:pPr");
+        if (kind === "bullet") {
+          const font = BULLET_FONTS[level % 3] === "Symbol" ? "Arial" : BULLET_FONTS[level % 3];
+          w.open("w:rPr").empty("w:rFonts", { "w:ascii": font, "w:hAnsi": font, "w:hint": "default" }).close("w:rPr");
+        }
+        w.close("w:lvl");
+      }
+      w.close("w:abstractNum");
+    };
+    abstract(1, "bullet");
+    abstract(2, "decimal");
+    abstract(3, "task");
+    for (const num of this.nums) {
+      w.open("w:num", { "w:numId": num.numId }).val("w:abstractNumId", num.abstractId);
+      if (num.start !== void 0) {
+        w.open("w:lvlOverride", { "w:ilvl": num.level }).val("w:startOverride", num.start).close("w:lvlOverride");
+      }
+      w.close("w:num");
+    }
+    w.close("w:numbering");
+    return w.toString();
+  }
+  stylesXml() {
+    const w = new XmlWriter();
+    w.open("w:styles", BODY_NS);
+    const defaults = this.styles.defaults;
+    const defaultRun = characterFormatToRun(defaults.character);
+    w.open("w:docDefaults").open("w:rPrDefault").open("w:rPr");
+    const font = defaultRun.font ?? "Calibri";
+    w.empty("w:rFonts", { "w:ascii": font, "w:hAnsi": font, "w:eastAsia": font, "w:cs": font });
+    const size = defaultRun.halfPoints ?? 22;
+    w.val("w:sz", size).val("w:szCs", size);
+    w.val("w:lang", "en-US");
+    w.close("w:rPr").close("w:rPrDefault");
+    w.open("w:pPrDefault").open("w:pPr");
+    if (defaults.paragraph && Object.keys(defaults.paragraph).length) writeParagraphFormat(w, defaults.paragraph);
+    else w.empty("w:spacing", { "w:after": 160, "w:line": 259, "w:lineRule": "auto" });
+    w.close("w:pPr").close("w:pPrDefault").close("w:docDefaults");
+    const byId = new Map(this.styles.styles.filter((s) => isValidStyleId(s.id)).map((s) => [s.id, s]));
+    const written = /* @__PURE__ */ new Set();
+    const blockOf = (style) => {
+      let current = style;
+      for (let i = 0; current && i < 32; i++) {
+        if (current.block) return current.block;
+        current = current.basedOn ? byId.get(current.basedOn) : void 0;
+      }
+      return null;
+    };
+    const writeStyle = (style) => {
+      if (written.has(style.id)) return;
+      written.add(style.id);
+      const isNormal = style.kind === "paragraph" && style.id === NORMAL_STYLE_ID;
+      w.open("w:style", {
+        "w:type": style.kind === "character" ? "character" : "paragraph",
+        "w:default": isNormal ? 1 : void 0,
+        "w:customStyle": style.builtin ? void 0 : 1,
+        "w:styleId": style.id
+      });
+      w.val("w:name", fileStyleName(style.name || style.id));
+      const base = style.basedOn && byId.has(style.basedOn) && byId.get(style.basedOn).kind === style.kind ? style.basedOn : void 0;
+      if (base) w.val("w:basedOn", base);
+      if (style.kind === "paragraph" && style.next && byId.get(style.next)?.kind === "paragraph") w.val("w:next", style.next);
+      if (style.linked && byId.has(style.linked)) w.val("w:link", style.linked);
+      if (style.priority !== void 0 && Number.isFinite(style.priority)) w.val("w:uiPriority", Math.max(0, Math.round(style.priority)));
+      if (style.hidden) w.empty("w:semiHidden").empty("w:unhideWhenUsed");
+      if (style.quick) w.empty("w:qFormat");
+      const block = style.kind === "paragraph" ? blockOf(style) : null;
+      const ownBlock = style.kind === "paragraph" ? style.block : null;
+      const outline = ownBlock?.type === "heading" ? Math.max(0, Math.min(8, (Number(ownBlock.attrs?.level) || 1) - 1)) : void 0;
+      if (style.kind === "paragraph" && (style.paragraph || outline !== void 0)) {
+        const p = new XmlWriter(false);
+        writeParagraphFormat(p, style.paragraph, outline);
+        const xml = p.toString();
+        if (xml) w.open("w:pPr").raw(xml).close("w:pPr");
+      }
+      const run = characterFormatToRun(style.character);
+      if (block?.type === "codeBlock" && !run.font) run.font = "Consolas";
+      if (hasRunProps(run)) {
+        w.open("w:rPr");
+        writeRunProps(w, run);
+        w.close("w:rPr");
+      }
+      w.close("w:style");
+    };
+    const visit = (style, depth = 0) => {
+      if (depth > 32 || written.has(style.id)) return;
+      const base = style.basedOn ? byId.get(style.basedOn) : void 0;
+      if (base) visit(base, depth + 1);
+      writeStyle(style);
+    };
+    byId.forEach((style) => visit(style));
+    for (const id of this.extraStyles) {
+      if (written.has(id)) continue;
+      const extra = EXTRA_STYLES[id] ?? { id, name: id, kind: "paragraph", basedOn: NORMAL_STYLE_ID };
+      byId.set(id, extra);
+      writeStyle(extra);
+    }
+    w.close("w:styles");
+    return w.toString();
+  }
+  settingsXml() {
+    const w = new XmlWriter();
+    w.open("w:settings", BODY_NS).empty("w:zoom", { "w:percent": 100 });
+    if (this.anonymous) w.empty("w:removePersonalInformation");
+    w.val("w:defaultTabStop", 720);
+    w.val("w:characterSpacingControl", "doNotCompress");
+    w.open("w:compat").empty("w:compatSetting", {
+      "w:name": "compatibilityMode",
+      "w:uri": "http://schemas.microsoft.com/office/word",
+      "w:val": 15
+    });
+    w.close("w:compat").close("w:settings");
+    return w.toString();
+  }
+  commentParts() {
+    if (!this.comments.size) return null;
+    const w = new XmlWriter();
+    const ext = new XmlWriter();
+    w.open("w:comments", BODY_NS);
+    ext.open("w15:commentsEx", { "xmlns:w15": NS.w15, "xmlns:mc": NS.mc, "mc:Ignorable": "w15" });
+    for (const entry of this.comments.values()) {
+      if (!entry.started) continue;
+      const { thread } = entry;
+      const parentPara = this.comment(w, entry.ids[0], thread.author, thread.createdAt, thread.body);
+      ext.empty("w15:commentEx", { "w15:paraId": parentPara, "w15:done": thread.resolved ? 1 : 0 });
+      this.report.written.comments++;
+      thread.replies.forEach((reply, i) => {
+        const para = this.comment(w, entry.ids[i + 1], reply.author, reply.createdAt, reply.body);
+        ext.empty("w15:commentEx", { "w15:paraId": para, "w15:paraIdParent": parentPara, "w15:done": thread.resolved ? 1 : 0 });
+        this.report.written.replies++;
+      });
+    }
+    w.close("w:comments");
+    ext.close("w15:commentsEx");
+    return { comments: w.toString(), extended: ext.toString() };
+  }
+  comment(w, id, author, createdAt, body) {
+    const name = this.authorName(author?.name, author?.id);
+    w.open("w:comment", {
+      "w:id": id,
+      "w:author": name,
+      "w:date": isoDate(createdAt),
+      "w:initials": this.anonymous ? ANONYMOUS_INITIALS : initialsOf(name)
+    });
+    const lines = String(body ?? "").replace(/\r\n?/g, "\n").split("\n");
+    let paraId = "";
+    lines.forEach((line, i) => {
+      const last = i === lines.length - 1;
+      if (last) paraId = (this.paraIdCounter++).toString(16).toUpperCase().padStart(8, "0");
+      w.open("w:p", last ? { "w14:paraId": paraId, "w14:textId": "77777777" } : void 0);
+      w.open("w:pPr").val("w:pStyle", "CommentText").close("w:pPr");
+      if (i === 0) {
+        w.open("w:r").open("w:rPr").val("w:rStyle", "CommentReference").close("w:rPr").empty("w:annotationRef").close("w:r");
+      }
+      if (line) w.open("w:r").leaf("w:t", { "xml:space": "preserve" }, line).close("w:r");
+      w.close("w:p");
+    });
+    w.close("w:comment");
+    return paraId;
+  }
+  peopleXml() {
+    if (this.anonymous || !this.people.size) return null;
+    const w = new XmlWriter();
+    w.open("w15:people", { "xmlns:w15": NS.w15, "xmlns:mc": NS.mc, "mc:Ignorable": "w15" });
+    for (const [name, id] of this.people) {
+      w.open("w15:person", { "w15:author": name });
+      w.empty("w15:presenceInfo", { "w15:providerId": "None", "w15:userId": id });
+      w.close("w15:person");
+    }
+    w.close("w15:people");
+    return w.toString();
+  }
+  coreXml(now) {
+    const w = new XmlWriter();
+    w.open("cp:coreProperties", {
+      "xmlns:cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+      "xmlns:dc": "http://purl.org/dc/elements/1.1/",
+      "xmlns:dcterms": "http://purl.org/dc/terms/",
+      "xmlns:dcmitype": "http://purl.org/dc/dcmitype/",
+      "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance"
+    });
+    if (this.options.title) w.leaf("dc:title", void 0, this.options.title);
+    const creator = this.anonymous ? void 0 : this.defaultAuthor?.name;
+    if (creator) w.leaf("dc:creator", void 0, creator).leaf("cp:lastModifiedBy", void 0, creator);
+    const date = isoDate(now.getTime()) ?? "2026-01-01T00:00:00Z";
+    w.leaf("dcterms:created", { "xsi:type": "dcterms:W3CDTF" }, date);
+    w.leaf("dcterms:modified", { "xsi:type": "dcterms:W3CDTF" }, date);
+    w.close("cp:coreProperties");
+    return w.toString();
+  }
+  /** Assembles every part; `[Content_Types].xml` first. */
+  parts(now) {
+    const document2 = this.documentXml();
+    const parts = [];
+    const overrides = [];
+    const add = (name, data, contentType) => {
+      parts.push({ name, data });
+      overrides.push([`/${name}`, contentType]);
+    };
+    this.rels.add(REL.styles, "styles.xml");
+    this.rels.add(REL.settings, "settings.xml");
+    const numbering = this.numberingXml();
+    if (numbering) this.rels.add(REL.numbering, "numbering.xml");
+    const comments = this.commentParts();
+    if (comments) {
+      this.rels.add(REL.comments, "comments.xml");
+      this.rels.add(REL.commentsExtended, "commentsExtended.xml");
+    }
+    const people = this.peopleXml();
+    if (people) this.rels.add(REL.people, "people.xml");
+    const styles = this.stylesXml();
+    add("word/document.xml", document2, `${CT_WML}document.main+xml`);
+    add("word/styles.xml", styles, `${CT_WML}styles+xml`);
+    add("word/settings.xml", this.settingsXml(), `${CT_WML}settings+xml`);
+    if (numbering) add("word/numbering.xml", numbering, `${CT_WML}numbering+xml`);
+    if (comments) {
+      add("word/comments.xml", comments.comments, `${CT_WML}comments+xml`);
+      add("word/commentsExtended.xml", comments.extended, `${CT_WML}commentsExtended+xml`);
+    }
+    if (people) add("word/people.xml", people, `${CT_WML}people+xml`);
+    parts.push({ name: "word/_rels/document.xml.rels", data: this.rels.xml() });
+    for (const file of this.media) parts.push({ name: `word/media/${file.name}`, data: file.bytes });
+    add("docProps/core.xml", this.coreXml(now), "application/vnd.openxmlformats-package.core-properties+xml");
+    const app = new XmlWriter();
+    app.open("Properties", { xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" });
+    app.leaf("Application", void 0, "@pixerate/editor").close("Properties");
+    add("docProps/app.xml", app.toString(), "application/vnd.openxmlformats-officedocument.extended-properties+xml");
+    const root = new Relationships();
+    root.add(REL.officeDocument, "word/document.xml");
+    root.add(REL.core, "docProps/core.xml");
+    root.add(REL.app, "docProps/app.xml");
+    const types = new XmlWriter();
+    types.open("Types", { xmlns: "http://schemas.openxmlformats.org/package/2006/content-types" });
+    types.empty("Default", { Extension: "rels", ContentType: "application/vnd.openxmlformats-package.relationships+xml" });
+    types.empty("Default", { Extension: "xml", ContentType: "application/xml" });
+    for (const ext of this.mediaTypes) types.empty("Default", { Extension: ext, ContentType: DOCX_IMAGE_CONTENT_TYPES[ext] });
+    for (const [name, contentType] of overrides) types.empty("Override", { PartName: name, ContentType: contentType });
+    types.close("Types");
+    return [
+      { name: "[Content_Types].xml", data: types.toString() },
+      { name: "_rels/.rels", data: root.xml() },
+      ...parts
+    ];
+  }
+};
+var isInlineType = (type) => type === "hardBreak" || type === "image" || type === "mention" || type === "text";
+var EXTRA_STYLES = {
+  BlockText: {
+    id: "BlockText",
+    name: "Block Text",
+    kind: "paragraph",
+    basedOn: NORMAL_STYLE_ID,
+    paragraph: { indentLeft: "0.5in", indentRight: "0.5in" },
+    character: { italic: true },
+    priority: 99,
+    builtin: true
+  },
+  ListParagraph: {
+    id: "ListParagraph",
+    name: "List Paragraph",
+    kind: "paragraph",
+    basedOn: NORMAL_STYLE_ID,
+    paragraph: { indentLeft: "0.5in" },
+    priority: 34,
+    quick: true,
+    builtin: true
+  },
+  Code: {
+    id: "Code",
+    name: "Code",
+    kind: "paragraph",
+    basedOn: NORMAL_STYLE_ID,
+    block: { type: "codeBlock" },
+    character: { fontFamily: "Consolas", fontSize: "10pt" },
+    paragraph: { spaceAfter: "0pt", lineHeight: "1" },
+    priority: 30
+  },
+  Hyperlink: {
+    id: "Hyperlink",
+    name: "Hyperlink",
+    kind: "character",
+    character: { color: "#0563C1", underline: true },
+    priority: 99,
+    hidden: true,
+    builtin: true
+  },
+  CommentReference: {
+    id: "CommentReference",
+    name: "annotation reference",
+    kind: "character",
+    character: { fontSize: "8pt" },
+    priority: 99,
+    hidden: true,
+    builtin: true
+  },
+  CommentText: {
+    id: "CommentText",
+    name: "annotation text",
+    kind: "paragraph",
+    basedOn: NORMAL_STYLE_ID,
+    character: { fontSize: "10pt" },
+    priority: 99,
+    hidden: true,
+    builtin: true
+  }
+};
+for (let level = 1; level <= 6; level++) {
+  EXTRA_STYLES[`Heading${level}`] = {
+    id: `Heading${level}`,
+    name: `Heading ${level}`,
+    kind: "paragraph",
+    basedOn: NORMAL_STYLE_ID,
+    next: NORMAL_STYLE_ID,
+    block: { type: "heading", attrs: { level } },
+    character: { bold: true },
+    priority: 9,
+    quick: true,
+    builtin: true
+  };
+}
+function resolveInput(input, options) {
+  if (!isEditorLike(input)) return { doc: input, options };
+  const storage = input.storage ?? {};
+  return {
+    doc: input.getJSON(),
+    options: {
+      ...options,
+      comments: options.comments !== void 0 ? options.comments : storage.comment?.store ?? null,
+      styles: options.styles ?? storage.paragraphStyles?.registry ?? void 0
+    }
+  };
+}
+function createDocxParts(input, options = {}) {
+  const resolved = resolveInput(input, options);
+  const builder = new DocxBuilder(
+    resolved.doc ?? { type: "doc", content: [] },
+    resolved.options,
+    threadsOf(resolved.options.comments),
+    stylesOf(resolved.options.styles)
+  );
+  const parts = builder.parts(resolved.options.now?.() ?? /* @__PURE__ */ new Date());
+  return { parts, report: builder.report };
+}
+async function exportDocx(input, options = {}) {
+  const { parts, report } = createDocxParts(input, options);
+  const data = await writeZip(parts, { compression: options.compression });
+  return { data, report };
+}
+async function exportDocxBlob(input, options = {}) {
+  const { data, report } = await exportDocx(input, options);
+  return { blob: new Blob([data], { type: DOCX_EXPORT_MIME_TYPE }), report };
+}
+
+// src/export/controller.ts
+function downloadBlob(blob, fileName) {
+  if (typeof document === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+    return false;
+  }
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = fileName;
+  link.rel = "noopener";
+  link.style.display = "none";
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+  return true;
+}
+function docxFileName(name) {
+  const base = (name ?? "").replace(/[\u0000-\u001f\u007f<>:"/\\|?*]+/g, " ").replace(/\s+/g, " ").trim().replace(/\.docx$/i, "").slice(0, 120);
+  return `${base || "document"}.docx`;
+}
+var DocxExportController = class {
+  constructor(getSource, options = {}) {
+    this.getSource = getSource;
+    this.options = options;
+  }
+  getSource;
+  options;
+  state = { isExporting: false, error: null, lastReport: null };
+  listeners = /* @__PURE__ */ new Set();
+  pending = 0;
+  setOptions(options) {
+    this.options = options;
+  }
+  getState = () => this.state;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  setState(patch) {
+    this.state = { ...this.state, ...patch };
+    this.listeners.forEach((listener) => listener(this.state));
+  }
+  /** Builds the `.docx` without downloading it. Resolves with `null` when there is no editor or it fails. */
+  async exportBlob() {
+    const source = this.getSource();
+    if (!source) return null;
+    this.pending++;
+    this.setState({ isExporting: true, error: null });
+    try {
+      const { fileName: _fileName, onExport: _onExport, onError: _onError, ...exportOptions } = this.options;
+      const result = await exportDocxBlob(source, exportOptions);
+      this.setState({ lastReport: result.report });
+      this.options.onExport?.(result.report, result.blob);
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.setState({ error: err });
+      if (this.options.onError) this.options.onError(err);
+      else console.error("[Editor] DOCX export failed:", err);
+      return null;
+    } finally {
+      this.pending--;
+      if (this.pending === 0) this.setState({ isExporting: false });
+    }
+  }
+  /** Exports and downloads the document. Resolves with the report, or `null`. */
+  async download(fileName) {
+    const result = await this.exportBlob();
+    if (!result) return null;
+    downloadBlob(result.blob, docxFileName(fileName ?? this.options.fileName ?? this.options.title));
+    return result.report;
+  }
+};
+function createDocxExportController(getSource, options) {
+  return new DocxExportController(getSource, options);
+}
+
+export {
+  stripInvalidXmlChars,
+  escapeXmlText,
+  escapeXmlAttr,
+  XmlWriter,
+  deflateRaw,
+  writeZip,
+  DOCX_EXPORT_MIME_TYPE,
+  DOCX_ANONYMOUS_AUTHOR,
+  createDocxParts,
+  exportDocx,
+  exportDocxBlob,
+  downloadBlob,
+  docxFileName,
+  DocxExportController,
+  createDocxExportController
+};
+//# sourceMappingURL=chunk-KRGXUQ2Y.js.map