npm - @coding01/docsjs - Versions diffs - 0.1.0 - Mend

@coding01/docsjs 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,1609 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DocsWordElement: () => DocsWordElement,
+  WordFidelityEditorReact: () => WordFidelityEditorReact,
+  WordFidelityEditorVue: () => WordFidelityEditorVue,
+  defineDocsWordElement: () => defineDocsWordElement
+});
+module.exports = __toCommonJS(index_exports);
+// src/lib/htmlSnapshot.ts
+var SNAPSHOT_SHELL_START = '<!DOCTYPE html><html><head><meta charset="utf-8"/>';
+var SNAPSHOT_SHELL_END = "</head><body></body></html>";
+function buildHtmlSnapshot(rawHtml) {
+  if (!rawHtml.trim()) {
+    return `${SNAPSHOT_SHELL_START}${SNAPSHOT_SHELL_END}`;
+  }
+  const hasHtmlTag = /<html[\s>]/i.test(rawHtml);
+  if (hasHtmlTag) {
+    return rawHtml;
+  }
+  return `${SNAPSHOT_SHELL_START}${SNAPSHOT_SHELL_END}`.replace(
+    "<body></body>",
+    `<body>${rawHtml}</body>`
+  );
+}
+// src/lib/docxHtml.ts
+var import_jszip = __toESM(require("jszip"), 1);
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function parseXml(xmlText) {
+  const parser = new DOMParser();
+  return parser.parseFromString(xmlText, "application/xml");
+}
+function queryAllByLocalName(root, localName) {
+  return Array.from(root.querySelectorAll("*")).filter((el) => el.localName === localName);
+}
+function queryByLocalName(root, localName) {
+  return queryAllByLocalName(root, localName)[0] ?? null;
+}
+function getAttr(node, name) {
+  if (!node) return null;
+  return node.getAttribute(name);
+}
+function emuToPx(emu) {
+  return emu * 96 / 914400;
+}
+function parseDrawingSizePx(drawing) {
+  const extentNode = queryAllByLocalName(drawing, "extent").find((node) => {
+    const parent = node.parentElement;
+    return parent?.localName === "inline" || parent?.localName === "anchor";
+  }) ?? null;
+  if (!extentNode) {
+    return { widthPx: null, heightPx: null };
+  }
+  const rawCx = getAttr(extentNode, "cx");
+  const rawCy = getAttr(extentNode, "cy");
+  const cx = rawCx ? Number.parseInt(rawCx, 10) : Number.NaN;
+  const cy = rawCy ? Number.parseInt(rawCy, 10) : Number.NaN;
+  const widthPx = Number.isFinite(cx) && cx > 0 ? emuToPx(cx) : null;
+  const heightPx = Number.isFinite(cy) && cy > 0 ? emuToPx(cy) : null;
+  return { widthPx, heightPx };
+}
+function imageDimensionAttributes(sizePx) {
+  const attrs = [];
+  if (sizePx.widthPx !== null) attrs.push(`width="${Math.round(sizePx.widthPx)}"`);
+  if (sizePx.heightPx !== null) attrs.push(`height="${Math.round(sizePx.heightPx)}"`);
+  if (sizePx.widthPx !== null || sizePx.heightPx !== null) {
+    const style = ["max-width:100%"];
+    if (sizePx.widthPx !== null) style.push(`width:${sizePx.widthPx.toFixed(2)}px`);
+    if (sizePx.heightPx !== null) style.push(`height:${sizePx.heightPx.toFixed(2)}px`);
+    attrs.push(`style="${style.join(";")}"`);
+  }
+  return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+}
+function parseDocRelsMap(relsXmlText) {
+  if (!relsXmlText) return {};
+  const rels = parseXml(relsXmlText);
+  const relationNodes = queryAllByLocalName(rels, "Relationship");
+  const map = {};
+  for (const rel of relationNodes) {
+    const id = getAttr(rel, "Id");
+    const target = getAttr(rel, "Target");
+    if (!id || !target) continue;
+    map[id] = target;
+  }
+  return map;
+}
+function extToMime(ext) {
+  const lower = ext.toLowerCase();
+  if (lower === "png") return "image/png";
+  if (lower === "jpg" || lower === "jpeg") return "image/jpeg";
+  if (lower === "gif") return "image/gif";
+  if (lower === "webp") return "image/webp";
+  if (lower === "bmp") return "image/bmp";
+  if (lower === "svg") return "image/svg+xml";
+  return "application/octet-stream";
+}
+async function imageRidToDataUrl(zip, relMap, rid) {
+  const relTarget = relMap[rid];
+  if (!relTarget) return null;
+  const normalized = relTarget.replace(/^\/+/, "");
+  const path = normalized.startsWith("word/") ? normalized : `word/${normalized}`;
+  const file = zip.file(path);
+  if (!file) return null;
+  const base64 = await file.async("base64");
+  const ext = path.split(".").pop() ?? "bin";
+  const mime = extToMime(ext);
+  return `data:${mime};base64,${base64}`;
+}
+function runStyleToCss(rPr) {
+  if (!rPr) return "";
+  const declarations = [];
+  if (queryByLocalName(rPr, "b")) declarations.push("font-weight:700");
+  if (queryByLocalName(rPr, "i")) declarations.push("font-style:italic");
+  if (queryByLocalName(rPr, "u")) declarations.push("text-decoration:underline");
+  if (queryByLocalName(rPr, "strike")) declarations.push("text-decoration:line-through");
+  const color = queryByLocalName(rPr, "color");
+  const colorVal = getAttr(color, "w:val") ?? getAttr(color, "val");
+  if (colorVal && colorVal.toLowerCase() !== "auto") declarations.push(`color:#${colorVal}`);
+  const highlight = queryByLocalName(rPr, "highlight");
+  const highlightVal = (getAttr(highlight, "w:val") ?? getAttr(highlight, "val") ?? "").toLowerCase();
+  if (highlightVal === "yellow") declarations.push("background-color:#fff200");
+  const vertAlign = queryByLocalName(rPr, "vertAlign");
+  const vertVal = (getAttr(vertAlign, "w:val") ?? getAttr(vertAlign, "val") ?? "").toLowerCase();
+  if (vertVal === "superscript") declarations.push("vertical-align:super;font-size:0.83em");
+  if (vertVal === "subscript") declarations.push("vertical-align:sub;font-size:0.83em");
+  return declarations.join(";");
+}
+function paragraphTag(paragraph) {
+  const pPr = queryByLocalName(paragraph, "pPr");
+  const pStyle = pPr ? queryByLocalName(pPr, "pStyle") : null;
+  const val = (getAttr(pStyle, "w:val") ?? getAttr(pStyle, "val") ?? "").toLowerCase();
+  if (val.includes("heading1") || val === "1" || val === "heading 1") return "h1";
+  if (val.includes("heading2") || val === "2" || val === "heading 2") return "h2";
+  if (val.includes("heading3") || val === "3" || val === "heading 3") return "h3";
+  return "p";
+}
+function paragraphAlignStyle(paragraph) {
+  const pPr = queryByLocalName(paragraph, "pPr");
+  const jc = pPr ? queryByLocalName(pPr, "jc") : null;
+  const align = (getAttr(jc, "w:val") ?? getAttr(jc, "val") ?? "").toLowerCase();
+  if (align === "center" || align === "right" || align === "left") {
+    return `text-align:${align};`;
+  }
+  return "";
+}
+function paragraphDataAttr(paragraphIndex) {
+  return paragraphIndex === null ? "" : ` data-word-p-index="${paragraphIndex}"`;
+}
+async function paragraphToHtml(zip, relMap, paragraph, paragraphIndex) {
+  const tag = paragraphTag(paragraph);
+  const alignStyle = paragraphAlignStyle(paragraph);
+  const dataAttr = paragraphDataAttr(paragraphIndex);
+  const runs = queryAllByLocalName(paragraph, "r");
+  if (runs.length === 0) {
+    return `<${tag}${dataAttr}${alignStyle ? ` style="${alignStyle}"` : ""}><br/></${tag}>`;
+  }
+  const parts = [];
+  for (const run of runs) {
+    const rPr = queryByLocalName(run, "rPr");
+    const css = runStyleToCss(rPr);
+    const drawing = queryByLocalName(run, "drawing");
+    if (drawing) {
+      const blip = queryByLocalName(drawing, "blip");
+      const rid = getAttr(blip, "r:embed") ?? getAttr(blip, "embed");
+      if (rid) {
+        const src = await imageRidToDataUrl(zip, relMap, rid);
+        if (src) {
+          const imageSize = parseDrawingSizePx(drawing);
+          const dimensionAttrs = imageDimensionAttributes(imageSize);
+          parts.push(`<img src="${src}" alt="word-image"${dimensionAttrs}/>`);
+          continue;
+        }
+      }
+    }
+    const texts = queryAllByLocalName(run, "t").map((t) => t.textContent ?? "").join("");
+    const brs = queryAllByLocalName(run, "br").length;
+    const runText2 = `${escapeHtml(texts)}${"<br/>".repeat(brs)}`;
+    if (!runText2) continue;
+    if (css) {
+      parts.push(`<span style="${css}">${runText2}</span>`);
+    } else {
+      parts.push(runText2);
+    }
+  }
+  const content = parts.join("") || "<br/>";
+  return `<${tag}${dataAttr}${alignStyle ? ` style="${alignStyle}"` : ""}>${content}</${tag}>`;
+}
+function runText(run) {
+  const text = queryAllByLocalName(run, "t").map((t) => t.textContent ?? "").join("");
+  const brCount = queryAllByLocalName(run, "br").length;
+  return `${escapeHtml(text)}${"<br/>".repeat(brCount)}`;
+}
+function paragraphText(paragraph) {
+  const runs = queryAllByLocalName(paragraph, "r");
+  const content = runs.map((run) => runText(run)).join("");
+  return content || "<br/>";
+}
+function tableCellHtml(cell, paragraphIndexMap) {
+  const paragraphs = queryAllByLocalName(cell, "p");
+  if (paragraphs.length === 0) {
+    const text = queryAllByLocalName(cell, "t").map((t) => t.textContent ?? "").join("").trim();
+    return escapeHtml(text) || "<br/>";
+  }
+  return paragraphs.map((p) => {
+    const paragraphIndex = paragraphIndexMap.get(p) ?? null;
+    return `<p${paragraphDataAttr(paragraphIndex)}>${paragraphText(p)}</p>`;
+  }).join("");
+}
+function tableToHtml(table, paragraphIndexMap) {
+  const rows = queryAllByLocalName(table, "tr");
+  const htmlRows = rows.map((row) => {
+    const cells = queryAllByLocalName(row, "tc");
+    const htmlCells = cells.map((cell) => `<td style="border:1px solid #222;vertical-align:top;">${tableCellHtml(cell, paragraphIndexMap)}</td>`).join("");
+    return `<tr>${htmlCells}</tr>`;
+  });
+  return `<table style="border-collapse:collapse;table-layout:fixed;width:100%;border:1px solid #222;">${htmlRows.join("")}</table>`;
+}
+async function parseDocxToHtmlSnapshot(file) {
+  const maybeArrayBuffer = file.arrayBuffer;
+  const buffer = maybeArrayBuffer ? await maybeArrayBuffer.call(file) : await new Response(file).arrayBuffer();
+  const zip = await import_jszip.default.loadAsync(buffer);
+  const documentXmlText = await zip.file("word/document.xml")?.async("string");
+  if (!documentXmlText) {
+    throw new Error("DOCX missing document.xml");
+  }
+  const relsText = await zip.file("word/_rels/document.xml.rels")?.async("string");
+  const relMap = parseDocRelsMap(relsText ?? null);
+  const documentXml = parseXml(documentXmlText);
+  const body = queryByLocalName(documentXml, "body");
+  if (!body) {
+    throw new Error("DOCX missing body");
+  }
+  const paragraphIndexMap = /* @__PURE__ */ new Map();
+  queryAllByLocalName(documentXml, "p").forEach((paragraph, index) => {
+    paragraphIndexMap.set(paragraph, index);
+  });
+  const blockHtml = [];
+  for (const child of Array.from(body.children)) {
+    if (child.localName === "sectPr") continue;
+    if (child.localName === "p") {
+      const paragraphIndex = paragraphIndexMap.get(child) ?? null;
+      blockHtml.push(await paragraphToHtml(zip, relMap, child, paragraphIndex));
+      continue;
+    }
+    if (child.localName === "tbl") {
+      blockHtml.push(tableToHtml(child, paragraphIndexMap));
+      continue;
+    }
+  }
+  return buildHtmlSnapshot(blockHtml.join("\n"));
+}
+// src/lib/pastePipeline.ts
+function escapeAttr(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;");
+}
+async function fileToDataUrl(file) {
+  const buffer = await new Response(file).arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  const base64 = btoa(binary);
+  const mime = file.type || "application/octet-stream";
+  return `data:${mime};base64,${base64}`;
+}
+function isUnstableImageSrc(src) {
+  const normalized = src.trim().toLowerCase();
+  return normalized.startsWith("file:") || normalized.startsWith("blob:") || normalized.startsWith("cid:") || normalized.startsWith("mhtml:") || normalized.startsWith("ms-appx:") || normalized.startsWith("ms-appdata:");
+}
+async function replaceUnstableImageSrc(rawHtml, imageFiles) {
+  if (!rawHtml.trim() || imageFiles.length === 0) return rawHtml;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(rawHtml, "text/html");
+  const images = Array.from(doc.querySelectorAll("img"));
+  const replacementDataUrls = await Promise.all(imageFiles.map((file) => fileToDataUrl(file)));
+  let replacementIndex = 0;
+  for (const img of images) {
+    const src = img.getAttribute("src") ?? "";
+    if (isUnstableImageSrc(src) && replacementIndex < replacementDataUrls.length) {
+      img.setAttribute("src", replacementDataUrls[replacementIndex]);
+      replacementIndex += 1;
+    }
+  }
+  return doc.body.innerHTML;
+}
+async function buildImageOnlyHtml(imageFiles) {
+  if (imageFiles.length === 0) return "";
+  const urls = await Promise.all(imageFiles.map((f) => fileToDataUrl(f)));
+  return urls.map((url) => `<p><img src="${escapeAttr(url)}" alt="clipboard-image" /></p>`).join("\n");
+}
+async function extractFromClipboardDataTransfer(dataTransfer) {
+  const html = dataTransfer.getData("text/html") || "";
+  const text = dataTransfer.getData("text/plain") || "";
+  const imageFiles = Array.from(dataTransfer.items).filter((item) => item.kind === "file" && item.type.startsWith("image/")).map((item) => item.getAsFile()).filter((file) => file !== null);
+  const hydratedHtml = await replaceUnstableImageSrc(html, imageFiles);
+  const finalHtml = hydratedHtml.trim() ? hydratedHtml : await buildImageOnlyHtml(imageFiles);
+  return {
+    html: finalHtml,
+    text,
+    imageFiles
+  };
+}
+async function extractFromClipboardItems(items) {
+  let html = "";
+  let text = "";
+  const imageFiles = [];
+  for (const item of items) {
+    if (item.types.includes("text/html") && !html) {
+      const blob = await item.getType("text/html");
+      html = await blob.text();
+    }
+    if (item.types.includes("text/plain") && !text) {
+      const blob = await item.getType("text/plain");
+      text = await blob.text();
+    }
+    for (const type of item.types) {
+      if (!type.startsWith("image/")) continue;
+      const blob = await item.getType(type);
+      const name = `clipboard-${Date.now()}-${imageFiles.length}.${type.split("/")[1] ?? "bin"}`;
+      imageFiles.push(new File([blob], name, { type }));
+    }
+  }
+  const hydratedHtml = await replaceUnstableImageSrc(html, imageFiles);
+  const finalHtml = hydratedHtml.trim() ? hydratedHtml : await buildImageOnlyHtml(imageFiles);
+  return {
+    html: finalHtml,
+    text,
+    imageFiles
+  };
+}
+// src/lib/htmlCompat.ts
+function parseStyle(styleText) {
+  const map = /* @__PURE__ */ new Map();
+  for (const seg of styleText.split(";")) {
+    const [rawKey, ...rawValue] = seg.split(":");
+    const key = rawKey?.trim().toLowerCase();
+    const value = rawValue.join(":").trim();
+    if (!key || !value) continue;
+    map.set(key, value);
+  }
+  return map;
+}
+function serializeStyle(styleMap) {
+  return Array.from(styleMap.entries()).map(([k, v]) => `${k}: ${v}`).join("; ");
+}
+function applyMsoMappings(styleMap) {
+  const mappingPairs = [
+    ["mso-ansi-font-size", "font-size"],
+    ["mso-bidi-font-size", "font-size"],
+    ["mso-hansi-font-size", "font-size"],
+    ["mso-margin-top-alt", "margin-top"],
+    ["mso-margin-bottom-alt", "margin-bottom"],
+    ["mso-margin-left-alt", "margin-left"],
+    ["mso-margin-right-alt", "margin-right"],
+    ["mso-line-height-alt", "line-height"]
+  ];
+  for (const [msoKey, cssKey] of mappingPairs) {
+    const value = styleMap.get(msoKey);
+    if (!value) continue;
+    if (!styleMap.has(cssKey)) {
+      styleMap.set(cssKey, value);
+    }
+  }
+  const msoFore = styleMap.get("mso-foreground");
+  if (msoFore && !styleMap.has("color")) {
+    styleMap.set("color", msoFore);
+  }
+  if (styleMap.get("mso-table-lspace") && !styleMap.has("margin-left")) {
+    styleMap.set("margin-left", "0");
+  }
+  if (styleMap.get("mso-table-rspace") && !styleMap.has("margin-right")) {
+    styleMap.set("margin-right", "0");
+  }
+}
+function applyListFallback(el, styleMap) {
+  const className = (el.getAttribute("class") ?? "").toLowerCase();
+  const msoList = styleMap.get("mso-list") ?? "";
+  const maybeList = className.includes("msolist") || msoList.length > 0;
+  if (!maybeList) return;
+  if (!styleMap.has("text-indent")) {
+    styleMap.set("text-indent", "0");
+  }
+  const marginLeft = styleMap.get("margin-left");
+  if (marginLeft && !styleMap.has("padding-left")) {
+    styleMap.set("padding-left", marginLeft);
+  }
+}
+function applyTagSpecificFallback(el, styleMap) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "table") {
+    if (!styleMap.has("border-collapse")) {
+      styleMap.set("border-collapse", "collapse");
+    }
+    if (!styleMap.has("border-spacing")) {
+      styleMap.set("border-spacing", "0");
+    }
+  }
+  if ((tag === "td" || tag === "th") && !styleMap.has("vertical-align")) {
+    styleMap.set("vertical-align", "top");
+  }
+  if (tag === "p" && !styleMap.has("min-height")) {
+    styleMap.set("min-height", "1em");
+  }
+}
+function normalizeWordEmptyParagraphs(doc) {
+  const paragraphs = Array.from(doc.querySelectorAll("p"));
+  for (const p of paragraphs) {
+    const text = (p.textContent ?? "").replace(/\u00a0/g, " ").trim();
+    const hasVisibleChildren = p.querySelector("img,table,svg,canvas,br") !== null;
+    if (!hasVisibleChildren && text.length === 0) {
+      p.innerHTML = "<br/>";
+    }
+  }
+}
+function applyGlobalDocFixes(doc, options) {
+  const body = doc.body;
+  if (!body) return;
+  if (options?.forceBodyFontFamily) {
+    body.style.fontFamily = options.forceBodyFontFamily;
+  }
+  if (options?.forceHeadingFontFamily) {
+    const headings = Array.from(doc.querySelectorAll("h1,h2,h3,h4,h5,h6"));
+    for (const heading of headings) {
+      heading.style.fontFamily = options.forceHeadingFontFamily;
+    }
+  }
+}
+function applyWordHtmlCompatibility(doc, options) {
+  const elements = Array.from(doc.querySelectorAll("[style], p, table, td, th, li, div, span"));
+  for (const el of elements) {
+    const htmlEl = el;
+    const rawStyle = htmlEl.getAttribute("style") ?? "";
+    const styleMap = parseStyle(rawStyle);
+    applyMsoMappings(styleMap);
+    applyListFallback(htmlEl, styleMap);
+    applyTagSpecificFallback(htmlEl, styleMap);
+    if (styleMap.size > 0) {
+      htmlEl.setAttribute("style", serializeStyle(styleMap));
+    }
+  }
+  normalizeWordEmptyParagraphs(doc);
+  applyGlobalDocFixes(doc, options);
+}
+// src/lib/styleProfile.ts
+var import_jszip2 = __toESM(require("jszip"), 1);
+var FALLBACK_PROFILE = {
+  bodyFontPx: 14.6667,
+  bodyLineHeightRatio: 1.158333,
+  bodyLineHeightPx: null,
+  bodyLineHeightRule: "auto",
+  paragraphAfterPx: 10.67,
+  contentWidthPx: 553.73,
+  pageHeightPx: 1122.53,
+  pageMarginTopPx: 96,
+  pageMarginBottomPx: 96,
+  titleFontPx: 32,
+  titleColor: "#0F4761",
+  titleAlign: "center",
+  bodyFontFamily: '"Times New Roman", "Noto Serif SC", serif',
+  titleFontFamily: 'DengXian, "Noto Sans SC", "Microsoft YaHei", sans-serif',
+  discoveredFonts: [],
+  tableCellPaddingTopPx: 0,
+  tableCellPaddingLeftPx: 7.2,
+  tableCellPaddingBottomPx: 0,
+  tableCellPaddingRightPx: 7.2,
+  paragraphProfiles: [],
+  trailingDateText: null,
+  trailingDateAlignedRight: false,
+  trailingDateParagraphIndex: null,
+  trailingEmptyParagraphCountBeforeDate: 0
+};
+function createFallbackWordStyleProfile(sourceFileName = "snapshot") {
+  return {
+    sourceFileName,
+    ...FALLBACK_PROFILE,
+    paragraphProfiles: []
+  };
+}
+function twipToPx(twip) {
+  return twip / 15;
+}
+function getAttr2(node, attr) {
+  if (!node) return null;
+  return node.getAttribute(attr);
+}
+function getTwipAttr(node, attr) {
+  const raw = getAttr2(node, attr);
+  if (!raw) return null;
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function queryByLocalName2(root, localName) {
+  const all = Array.from(root.querySelectorAll("*"));
+  return all.find((el) => el.localName === localName) ?? null;
+}
+function queryAllByLocalName2(root, localName) {
+  const all = Array.from(root.querySelectorAll("*"));
+  return all.filter((el) => el.localName === localName);
+}
+function parseXml2(xmlText) {
+  const parser = new DOMParser();
+  return parser.parseFromString(xmlText, "application/xml");
+}
+function parsePageGeometry(documentXml) {
+  const sectPr = queryByLocalName2(documentXml, "sectPr");
+  if (!sectPr) {
+    return {
+      contentWidthPx: null,
+      pageHeightPx: null,
+      marginTopPx: null,
+      marginBottomPx: null
+    };
+  }
+  const pgSz = queryAllByLocalName2(sectPr, "pgSz")[0] ?? null;
+  const pgMar = queryAllByLocalName2(sectPr, "pgMar")[0] ?? null;
+  const pageW = getTwipAttr(pgSz, "w:w") ?? getTwipAttr(pgSz, "w") ?? null;
+  const pageH = getTwipAttr(pgSz, "w:h") ?? getTwipAttr(pgSz, "h") ?? null;
+  const left = getTwipAttr(pgMar, "w:left") ?? getTwipAttr(pgMar, "left") ?? 0;
+  const right = getTwipAttr(pgMar, "w:right") ?? getTwipAttr(pgMar, "right") ?? 0;
+  const top = getTwipAttr(pgMar, "w:top") ?? getTwipAttr(pgMar, "top") ?? null;
+  const bottom = getTwipAttr(pgMar, "w:bottom") ?? getTwipAttr(pgMar, "bottom") ?? null;
+  return {
+    contentWidthPx: pageW === null ? null : twipToPx(pageW - left - right),
+    pageHeightPx: pageH === null ? null : twipToPx(pageH),
+    marginTopPx: top === null ? null : twipToPx(top),
+    marginBottomPx: bottom === null ? null : twipToPx(bottom)
+  };
+}
+function parseHeadingAlignFromDocument(documentXml) {
+  const paragraphs = queryAllByLocalName2(documentXml, "p");
+  for (const paragraph of paragraphs) {
+    const pPr = queryAllByLocalName2(paragraph, "pPr")[0] ?? null;
+    if (!pPr) continue;
+    const pStyle = queryAllByLocalName2(pPr, "pStyle")[0] ?? null;
+    const styleVal = getAttr2(pStyle, "w:val") ?? getAttr2(pStyle, "val") ?? "";
+    const isHeading = styleVal === "1" || styleVal.toLowerCase().includes("heading");
+    if (!isHeading) continue;
+    const jc = queryAllByLocalName2(pPr, "jc")[0] ?? null;
+    const alignRaw = (getAttr2(jc, "w:val") ?? getAttr2(jc, "val") ?? "").toLowerCase();
+    if (alignRaw === "center") return "center";
+    if (alignRaw === "right") return "right";
+    return "left";
+  }
+  return null;
+}
+function parseParagraphText(paragraph) {
+  const textNodes = queryAllByLocalName2(paragraph, "t");
+  return textNodes.map((node) => node.textContent ?? "").join("").trim();
+}
+function parseParagraphAlign(paragraph) {
+  const pPr = queryAllByLocalName2(paragraph, "pPr")[0] ?? null;
+  const jc = pPr ? queryAllByLocalName2(pPr, "jc")[0] ?? null : null;
+  const alignRaw = (getAttr2(jc, "w:val") ?? getAttr2(jc, "val") ?? "").toLowerCase();
+  if (alignRaw === "center") return "center";
+  if (alignRaw === "right") return "right";
+  return "left";
+}
+function parseTrailingDateAnchor(documentXml) {
+  const paragraphs = queryAllByLocalName2(documentXml, "p");
+  if (paragraphs.length === 0) {
+    return {
+      trailingDateText: null,
+      trailingDateAlignedRight: false,
+      trailingDateParagraphIndex: null,
+      trailingEmptyParagraphCountBeforeDate: 0
+    };
+  }
+  let lastNonEmptyIndex = -1;
+  for (let i = paragraphs.length - 1; i >= 0; i -= 1) {
+    if (parseParagraphText(paragraphs[i]).length > 0) {
+      lastNonEmptyIndex = i;
+      break;
+    }
+  }
+  if (lastNonEmptyIndex < 0) {
+    return {
+      trailingDateText: null,
+      trailingDateAlignedRight: false,
+      trailingDateParagraphIndex: null,
+      trailingEmptyParagraphCountBeforeDate: 0
+    };
+  }
+  const dateParagraph = paragraphs[lastNonEmptyIndex];
+  const dateText = parseParagraphText(dateParagraph);
+  const looksLikeDate = /\d{4}\s*年\s*\d+\s*月\s*\d+\s*日/.test(dateText);
+  const align = parseParagraphAlign(dateParagraph);
+  let trailingEmpty = 0;
+  for (let i = lastNonEmptyIndex - 1; i >= 0; i -= 1) {
+    if (parseParagraphText(paragraphs[i]).length === 0) {
+      trailingEmpty += 1;
+      continue;
+    }
+    break;
+  }
+  return {
+    trailingDateText: looksLikeDate ? dateText : null,
+    trailingDateAlignedRight: looksLikeDate && align === "right",
+    trailingDateParagraphIndex: looksLikeDate ? lastNonEmptyIndex : null,
+    trailingEmptyParagraphCountBeforeDate: looksLikeDate ? trailingEmpty : 0
+  };
+}
+function toInt(value) {
+  if (!value) return null;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : null;
+}
+function parseNumberingMap(numberingXml) {
+  const levelMap = /* @__PURE__ */ new Map();
+  if (!numberingXml) return levelMap;
+  const abstractMap = /* @__PURE__ */ new Map();
+  const abstractNums = queryAllByLocalName2(numberingXml, "abstractNum");
+  for (const abs of abstractNums) {
+    const absId = toInt(getAttr2(abs, "w:abstractNumId") ?? getAttr2(abs, "abstractNumId"));
+    if (absId === null) continue;
+    const lvlNodes = queryAllByLocalName2(abs, "lvl");
+    const lvlMap = /* @__PURE__ */ new Map();
+    for (const lvl of lvlNodes) {
+      const ilvl = toInt(getAttr2(lvl, "w:ilvl") ?? getAttr2(lvl, "ilvl"));
+      if (ilvl === null) continue;
+      const numFmtNode = queryAllByLocalName2(lvl, "numFmt")[0] ?? null;
+      const lvlTextNode = queryAllByLocalName2(lvl, "lvlText")[0] ?? null;
+      lvlMap.set(ilvl, {
+        numFmt: getAttr2(numFmtNode, "w:val") ?? getAttr2(numFmtNode, "val") ?? null,
+        lvlText: getAttr2(lvlTextNode, "w:val") ?? getAttr2(lvlTextNode, "val") ?? null,
+        startAt: toInt(getAttr2(queryAllByLocalName2(lvl, "start")[0] ?? null, "w:val") ?? getAttr2(queryAllByLocalName2(lvl, "start")[0] ?? null, "val")) ?? 1
+      });
+    }
+    abstractMap.set(absId, lvlMap);
+  }
+  const nums = queryAllByLocalName2(numberingXml, "num");
+  for (const num of nums) {
+    const numId = toInt(getAttr2(num, "w:numId") ?? getAttr2(num, "numId"));
+    if (numId === null) continue;
+    const abstractRefNode = queryAllByLocalName2(num, "abstractNumId")[0] ?? null;
+    const absId = toInt(getAttr2(abstractRefNode, "w:val") ?? getAttr2(abstractRefNode, "val"));
+    if (absId === null) continue;
+    const lvlMap = abstractMap.get(absId);
+    if (!lvlMap) continue;
+    for (const [lvl, spec] of lvlMap.entries()) {
+      levelMap.set(`${numId}:${lvl}`, spec);
+    }
+  }
+  return levelMap;
+}
+function parseParagraphProfiles(documentXml, numberingMap) {
+  const paragraphs = queryAllByLocalName2(documentXml, "p");
+  return paragraphs.map((paragraph, index) => {
+    const text = parseParagraphText(paragraph);
+    const pPr = queryAllByLocalName2(paragraph, "pPr")[0] ?? null;
+    const spacing = pPr ? queryAllByLocalName2(pPr, "spacing")[0] ?? null : null;
+    const ind = pPr ? queryAllByLocalName2(pPr, "ind")[0] ?? null : null;
+    const numPr = pPr ? queryAllByLocalName2(pPr, "numPr")[0] ?? null : null;
+    const ilvlNode = numPr ? queryAllByLocalName2(numPr, "ilvl")[0] ?? null : null;
+    const numIdNode = numPr ? queryAllByLocalName2(numPr, "numId")[0] ?? null : null;
+    const listLevel = toInt(getAttr2(ilvlNode, "w:val") ?? getAttr2(ilvlNode, "val"));
+    const listNumId = toInt(getAttr2(numIdNode, "w:val") ?? getAttr2(numIdNode, "val"));
+    const listSpec = listNumId !== null && listLevel !== null ? numberingMap.get(`${listNumId}:${listLevel}`) : void 0;
+    const keepNextNode = pPr ? queryAllByLocalName2(pPr, "keepNext")[0] ?? null : null;
+    const keepLinesNode = pPr ? queryAllByLocalName2(pPr, "keepLines")[0] ?? null : null;
+    const pageBreakBeforeNode = pPr ? queryAllByLocalName2(pPr, "pageBreakBefore")[0] ?? null : null;
+    const renderedPageBreakNode = queryAllByLocalName2(paragraph, "lastRenderedPageBreak")[0] ?? null;
+    const sectionBreakNode = pPr ? queryAllByLocalName2(pPr, "sectPr")[0] ?? null : null;
+    const before = getTwipAttr(spacing, "w:before") ?? getTwipAttr(spacing, "before") ?? null;
+    const after = getTwipAttr(spacing, "w:after") ?? getTwipAttr(spacing, "after") ?? null;
+    const line = getTwipAttr(spacing, "w:line") ?? getTwipAttr(spacing, "line") ?? null;
+    const rawLineRule = (getAttr2(spacing, "w:lineRule") ?? getAttr2(spacing, "lineRule") ?? "auto").toLowerCase();
+    const lineHeightRule = line === null ? null : rawLineRule === "exact" ? "exact" : rawLineRule === "atleast" ? "atLeast" : "auto";
+    const left = getTwipAttr(ind, "w:left") ?? getTwipAttr(ind, "left") ?? null;
+    const right = getTwipAttr(ind, "w:right") ?? getTwipAttr(ind, "right") ?? null;
+    const firstLine = getTwipAttr(ind, "w:firstLine") ?? getTwipAttr(ind, "firstLine") ?? null;
+    const hanging = getTwipAttr(ind, "w:hanging") ?? getTwipAttr(ind, "hanging") ?? null;
+    const runs = parseRunProfiles(paragraph);
+    return {
+      index,
+      text,
+      isEmpty: text.length === 0,
+      align: parseParagraphAlign(paragraph),
+      beforePx: before === null ? null : twipToPx(before),
+      afterPx: after === null ? null : twipToPx(after),
+      lineHeightRatio: line === null || lineHeightRule !== "auto" ? null : line / 240,
+      lineHeightPx: line === null || lineHeightRule === "auto" ? null : twipToPx(line),
+      lineHeightRule,
+      indentLeftPx: left === null ? null : twipToPx(left),
+      indentRightPx: right === null ? null : twipToPx(right),
+      firstLinePx: firstLine === null ? null : twipToPx(firstLine),
+      hangingPx: hanging === null ? null : twipToPx(hanging),
+      listNumId,
+      listLevel,
+      listFormat: listSpec?.numFmt ?? null,
+      listTextPattern: listSpec?.lvlText ?? null,
+      listStartAt: listSpec?.startAt ?? 1,
+      keepNext: keepNextNode !== null && (getAttr2(keepNextNode, "w:val") ?? getAttr2(keepNextNode, "val") ?? "1") !== "0",
+      keepLines: keepLinesNode !== null && (getAttr2(keepLinesNode, "w:val") ?? getAttr2(keepLinesNode, "val") ?? "1") !== "0",
+      pageBreakBefore: renderedPageBreakNode !== null || pageBreakBeforeNode !== null && (getAttr2(pageBreakBeforeNode, "w:val") ?? getAttr2(pageBreakBeforeNode, "val") ?? "1") !== "0",
+      sectionBreakBefore: sectionBreakNode !== null,
+      runs
+    };
+  });
+}
+function parseTableDefaults(stylesXml) {
+  const tableStyles = queryAllByLocalName2(stylesXml, "style").filter((style) => {
+    const type = (getAttr2(style, "w:type") ?? getAttr2(style, "type") ?? "").toLowerCase();
+    return type === "table";
+  });
+  const targetStyle = tableStyles.find((style) => {
+    const styleId = (getAttr2(style, "w:styleId") ?? getAttr2(style, "styleId") ?? "").toLowerCase();
+    return styleId === "a1";
+  }) ?? tableStyles[0] ?? null;
+  if (!targetStyle) {
+    return { topPx: null, leftPx: null, bottomPx: null, rightPx: null };
+  }
+  const tblPr = queryAllByLocalName2(targetStyle, "tblPr")[0] ?? null;
+  const tblCellMar = tblPr ? queryAllByLocalName2(tblPr, "tblCellMar")[0] ?? null : null;
+  const top = tblCellMar ? queryAllByLocalName2(tblCellMar, "top")[0] ?? null : null;
+  const left = tblCellMar ? queryAllByLocalName2(tblCellMar, "left")[0] ?? null : null;
+  const bottom = tblCellMar ? queryAllByLocalName2(tblCellMar, "bottom")[0] ?? null : null;
+  const right = tblCellMar ? queryAllByLocalName2(tblCellMar, "right")[0] ?? null : null;
+  return {
+    topPx: (() => {
+      const v = getTwipAttr(top, "w:w") ?? getTwipAttr(top, "w") ?? null;
+      return v === null ? null : twipToPx(v);
+    })(),
+    leftPx: (() => {
+      const v = getTwipAttr(left, "w:w") ?? getTwipAttr(left, "w") ?? null;
+      return v === null ? null : twipToPx(v);
+    })(),
+    bottomPx: (() => {
+      const v = getTwipAttr(bottom, "w:w") ?? getTwipAttr(bottom, "w") ?? null;
+      return v === null ? null : twipToPx(v);
+    })(),
+    rightPx: (() => {
+      const v = getTwipAttr(right, "w:w") ?? getTwipAttr(right, "w") ?? null;
+      return v === null ? null : twipToPx(v);
+    })()
+  };
+}
+function parseRunProfiles(paragraph) {
+  const runNodes = queryAllByLocalName2(paragraph, "r");
+  return runNodes.map((run) => {
+    const rPr = queryAllByLocalName2(run, "rPr")[0] ?? null;
+    const textNodes = queryAllByLocalName2(run, "t");
+    const breakNodes = queryAllByLocalName2(run, "br");
+    let text = textNodes.map((node) => node.textContent ?? "").join("");
+    if (breakNodes.length > 0) {
+      text += "\n".repeat(breakNodes.length);
+    }
+    if (!text) {
+      return null;
+    }
+    const sz = rPr ? queryAllByLocalName2(rPr, "sz")[0] ?? null : null;
+    const halfPoints = getTwipAttr(sz, "w:val") ?? getTwipAttr(sz, "val") ?? null;
+    const fontSizePx = halfPoints === null ? null : halfPoints / 2 * (96 / 72);
+    const colorNode = rPr ? queryAllByLocalName2(rPr, "color")[0] ?? null : null;
+    const colorRaw = getAttr2(colorNode, "w:val") ?? getAttr2(colorNode, "val") ?? null;
+    const color = colorRaw && colorRaw.toLowerCase() !== "auto" ? `#${colorRaw}` : null;
+    const highlightNode = rPr ? queryAllByLocalName2(rPr, "highlight")[0] ?? null : null;
+    const highlightRaw = (getAttr2(highlightNode, "w:val") ?? getAttr2(highlightNode, "val") ?? "").toLowerCase();
+    const highlightMap = {
+      yellow: "#fff59d",
+      green: "#b9f6ca",
+      cyan: "#b2ebf2",
+      magenta: "#f8bbd0",
+      blue: "#bbdefb",
+      red: "#ffcdd2",
+      darkyellow: "#fbc02d",
+      darkgreen: "#66bb6a",
+      darkblue: "#64b5f6",
+      darkred: "#e57373",
+      darkcyan: "#4dd0e1",
+      darkmagenta: "#ba68c8",
+      gray: "#e0e0e0",
+      lightgray: "#f5f5f5"
+    };
+    const highlightColor = highlightRaw && highlightRaw !== "none" ? highlightMap[highlightRaw] ?? null : null;
+    const shdNode = rPr ? queryAllByLocalName2(rPr, "shd")[0] ?? null : null;
+    const shdFill = (getAttr2(shdNode, "w:fill") ?? getAttr2(shdNode, "fill") ?? "").toLowerCase();
+    const shadingColor = shdFill && shdFill !== "auto" ? `#${shdFill}` : null;
+    const spacingNode = rPr ? queryAllByLocalName2(rPr, "spacing")[0] ?? null : null;
+    const spacingVal = getTwipAttr(spacingNode, "w:val") ?? getTwipAttr(spacingNode, "val") ?? null;
+    const charSpacingPx = spacingVal === null ? null : spacingVal / 20 * (96 / 72);
+    const bNode = rPr ? queryAllByLocalName2(rPr, "b")[0] ?? null : null;
+    const iNode = rPr ? queryAllByLocalName2(rPr, "i")[0] ?? null : null;
+    const uNode = rPr ? queryAllByLocalName2(rPr, "u")[0] ?? null : null;
+    const strikeNode = rPr ? queryAllByLocalName2(rPr, "strike")[0] ?? null : null;
+    const shadowNode = rPr ? queryAllByLocalName2(rPr, "shadow")[0] ?? null : null;
+    const vertAlignNode = rPr ? queryAllByLocalName2(rPr, "vertAlign")[0] ?? null : null;
+    const bold = bNode !== null && (getAttr2(bNode, "w:val") ?? getAttr2(bNode, "val") ?? "1") !== "0";
+    const italic = iNode !== null && (getAttr2(iNode, "w:val") ?? getAttr2(iNode, "val") ?? "1") !== "0";
+    const underlineVal = (getAttr2(uNode, "w:val") ?? getAttr2(uNode, "val") ?? "").toLowerCase();
+    const underline = uNode !== null && underlineVal !== "none";
+    const strike = strikeNode !== null && (getAttr2(strikeNode, "w:val") ?? getAttr2(strikeNode, "val") ?? "1") !== "0";
+    const shadow = shadowNode !== null && (getAttr2(shadowNode, "w:val") ?? getAttr2(shadowNode, "val") ?? "1") !== "0";
+    const vertAlign = (getAttr2(vertAlignNode, "w:val") ?? getAttr2(vertAlignNode, "val") ?? "").toLowerCase();
+    const superscript = vertAlign === "superscript";
+    const subscript = vertAlign === "subscript";
+    const rFonts = rPr ? queryAllByLocalName2(rPr, "rFonts")[0] ?? null : null;
+    const fontFamily = getAttr2(rFonts, "w:eastAsia") ?? getAttr2(rFonts, "eastAsia") ?? getAttr2(rFonts, "w:ascii") ?? getAttr2(rFonts, "ascii") ?? getAttr2(rFonts, "w:hAnsi") ?? getAttr2(rFonts, "hAnsi") ?? null;
+    return {
+      text,
+      fontSizePx,
+      color,
+      highlightColor,
+      shadingColor,
+      charSpacingPx,
+      shadow,
+      bold,
+      italic,
+      underline,
+      strike,
+      superscript,
+      subscript,
+      fontFamily
+    };
+  }).filter((run) => run !== null);
+}
+function parseDefaults(stylesXml) {
+  const docDefaults = queryByLocalName2(stylesXml, "docDefaults");
+  if (!docDefaults) {
+    return { bodyFontPx: null, bodyLineHeightRatio: null, bodyLineHeightPx: null, bodyLineHeightRule: "auto", paragraphAfterPx: null };
+  }
+  const rPrDefault = queryByLocalName2(docDefaults, "rPrDefault");
+  const sz = rPrDefault ? queryByLocalName2(rPrDefault, "sz") : null;
+  const halfPoints = getTwipAttr(sz, "w:val") ?? getTwipAttr(sz, "val") ?? null;
+  const bodyFontPx = halfPoints === null ? null : halfPoints / 2 * (96 / 72);
+  const pPrDefault = queryByLocalName2(docDefaults, "pPrDefault");
+  const spacing = pPrDefault ? queryByLocalName2(pPrDefault, "spacing") : null;
+  const line = getTwipAttr(spacing, "w:line") ?? getTwipAttr(spacing, "line") ?? null;
+  const rawLineRule = (getAttr2(spacing, "w:lineRule") ?? getAttr2(spacing, "lineRule") ?? "auto").toLowerCase();
+  const bodyLineHeightRule = rawLineRule === "exact" ? "exact" : rawLineRule === "atleast" ? "atLeast" : "auto";
+  const bodyLineHeightRatio = line === null || bodyLineHeightRule !== "auto" ? null : line / 240;
+  const bodyLineHeightPx = line === null || bodyLineHeightRule === "auto" ? null : twipToPx(line);
+  const after = getTwipAttr(spacing, "w:after") ?? getTwipAttr(spacing, "after") ?? null;
+  const paragraphAfterPx = after === null ? null : twipToPx(after);
+  return { bodyFontPx, bodyLineHeightRatio, bodyLineHeightPx, bodyLineHeightRule, paragraphAfterPx };
+}
+function parseHeading1Style(stylesXml) {
+  const styles = queryAllByLocalName2(stylesXml, "style");
+  const headingStyle = styles.find((style) => {
+    const styleId = (getAttr2(style, "w:styleId") ?? getAttr2(style, "styleId") ?? "").toLowerCase();
+    const nameNode = queryByLocalName2(style, "name");
+    const nameVal = (getAttr2(nameNode, "w:val") ?? getAttr2(nameNode, "val") ?? "").toLowerCase();
+    return styleId === "1" || nameVal === "heading 1" || nameVal === "\u6807\u9898 1";
+  });
+  if (!headingStyle) {
+    return { titleFontPx: null, titleColor: null };
+  }
+  const rPr = queryByLocalName2(headingStyle, "rPr");
+  const sz = rPr ? queryByLocalName2(rPr, "sz") : null;
+  const halfPoints = getTwipAttr(sz, "w:val") ?? getTwipAttr(sz, "val") ?? null;
+  const titleFontPx = halfPoints === null ? null : halfPoints / 2 * (96 / 72);
+  const colorNode = rPr ? queryByLocalName2(rPr, "color") : null;
+  const colorRaw = getAttr2(colorNode, "w:val") ?? getAttr2(colorNode, "val") ?? null;
+  const titleColor = colorRaw ? `#${colorRaw}` : null;
+  return { titleFontPx, titleColor };
+}
+function parseFontTableFamilies(fontTableXml) {
+  if (!fontTableXml) return [];
+  const fontNodes = queryAllByLocalName2(fontTableXml, "font");
+  const families = fontNodes.map((node) => getAttr2(node, "w:name") ?? getAttr2(node, "name") ?? "").map((name) => name.trim()).filter((name) => name.length > 0);
+  return [...new Set(families)];
+}
+function hasFontLike(families, candidates) {
+  return families.some(
+    (family) => candidates.some((candidate) => family.toLowerCase().includes(candidate.toLowerCase()))
+  );
+}
+function inferBodyFontFamily(families) {
+  if (hasFontLike(families, ["times new roman"])) {
+    return '"Times New Roman", "Noto Serif SC", serif';
+  }
+  if (hasFontLike(families, ["dengxian", "\u7B49\u7EBF", "yahei", "hei", "song"])) {
+    return 'DengXian, "Microsoft YaHei", "PingFang SC", "Noto Sans SC", sans-serif';
+  }
+  return FALLBACK_PROFILE.bodyFontFamily;
+}
+function inferTitleFontFamily(families) {
+  if (hasFontLike(families, ["dengxian", "\u7B49\u7EBF"])) {
+    return 'DengXian, "Noto Sans SC", "Microsoft YaHei", sans-serif';
+  }
+  if (hasFontLike(families, ["times new roman"])) {
+    return '"Times New Roman", "Noto Serif SC", serif';
+  }
+  return FALLBACK_PROFILE.titleFontFamily;
+}
+async function parseDocxStyleProfile(file) {
+  const buffer = await file.arrayBuffer();
+  const zip = await import_jszip2.default.loadAsync(buffer);
+  const documentXmlText = await zip.file("word/document.xml")?.async("string");
+  const stylesXmlText = await zip.file("word/styles.xml")?.async("string");
+  const fontTableXmlText = await zip.file("word/fontTable.xml")?.async("string");
+  const numberingXmlText = await zip.file("word/numbering.xml")?.async("string");
+  if (!documentXmlText || !stylesXmlText) {
+    throw new Error("DOCX missing document.xml or styles.xml");
+  }
+  const documentXml = parseXml2(documentXmlText);
+  const stylesXml = parseXml2(stylesXmlText);
+  const fontTableXml = fontTableXmlText ? parseXml2(fontTableXmlText) : null;
+  const numberingXml = numberingXmlText ? parseXml2(numberingXmlText) : null;
+  const numberingMap = parseNumberingMap(numberingXml);
+  const defaults = parseDefaults(stylesXml);
+  const heading1 = parseHeading1Style(stylesXml);
+  const tableDefaults = parseTableDefaults(stylesXml);
+  const pageGeometry = parsePageGeometry(documentXml);
+  const titleAlign = parseHeadingAlignFromDocument(documentXml);
+  const trailingDate = parseTrailingDateAnchor(documentXml);
+  const discoveredFonts = parseFontTableFamilies(fontTableXml);
+  const bodyFontFamily = inferBodyFontFamily(discoveredFonts);
+  const titleFontFamily = inferTitleFontFamily(discoveredFonts);
+  const paragraphProfiles = parseParagraphProfiles(documentXml, numberingMap);
+  return {
+    sourceFileName: file.name,
+    bodyFontPx: defaults.bodyFontPx ?? FALLBACK_PROFILE.bodyFontPx,
+    bodyLineHeightRatio: defaults.bodyLineHeightRatio ?? FALLBACK_PROFILE.bodyLineHeightRatio,
+    bodyLineHeightPx: defaults.bodyLineHeightPx ?? FALLBACK_PROFILE.bodyLineHeightPx,
+    bodyLineHeightRule: defaults.bodyLineHeightRule ?? FALLBACK_PROFILE.bodyLineHeightRule,
+    paragraphAfterPx: defaults.paragraphAfterPx ?? FALLBACK_PROFILE.paragraphAfterPx,
+    contentWidthPx: pageGeometry.contentWidthPx ?? FALLBACK_PROFILE.contentWidthPx,
+    pageHeightPx: pageGeometry.pageHeightPx ?? FALLBACK_PROFILE.pageHeightPx,
+    pageMarginTopPx: pageGeometry.marginTopPx ?? FALLBACK_PROFILE.pageMarginTopPx,
+    pageMarginBottomPx: pageGeometry.marginBottomPx ?? FALLBACK_PROFILE.pageMarginBottomPx,
+    titleFontPx: heading1.titleFontPx ?? FALLBACK_PROFILE.titleFontPx,
+    titleColor: heading1.titleColor ?? FALLBACK_PROFILE.titleColor,
+    titleAlign: titleAlign ?? FALLBACK_PROFILE.titleAlign,
+    bodyFontFamily,
+    titleFontFamily,
+    discoveredFonts,
+    tableCellPaddingTopPx: tableDefaults.topPx ?? FALLBACK_PROFILE.tableCellPaddingTopPx,
+    tableCellPaddingLeftPx: tableDefaults.leftPx ?? FALLBACK_PROFILE.tableCellPaddingLeftPx,
+    tableCellPaddingBottomPx: tableDefaults.bottomPx ?? FALLBACK_PROFILE.tableCellPaddingBottomPx,
+    tableCellPaddingRightPx: tableDefaults.rightPx ?? FALLBACK_PROFILE.tableCellPaddingRightPx,
+    paragraphProfiles,
+    trailingDateText: trailingDate.trailingDateText,
+    trailingDateAlignedRight: trailingDate.trailingDateAlignedRight,
+    trailingDateParagraphIndex: trailingDate.trailingDateParagraphIndex,
+    trailingEmptyParagraphCountBeforeDate: trailingDate.trailingEmptyParagraphCountBeforeDate
+  };
+}
+// src/lib/renderApply.ts
+function setImportantStyle(el, prop, value) {
+  el.style.setProperty(prop, value, "important");
+}
+function escapeHtml2(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function runStyleToCss2(run) {
+  const declarations = [];
+  if (run.fontSizePx !== null) declarations.push(`font-size:${run.fontSizePx.toFixed(2)}px`);
+  if (run.color) declarations.push(`color:${run.color}`);
+  if (run.highlightColor) declarations.push(`background-color:${run.highlightColor}`);
+  if (run.shadingColor) declarations.push(`background-color:${run.shadingColor}`);
+  if (run.charSpacingPx !== null) declarations.push(`letter-spacing:${run.charSpacingPx.toFixed(2)}px`);
+  if (run.shadow) declarations.push("text-shadow:0.5px 0.5px 0 rgba(0,0,0,0.28)");
+  if (run.bold) declarations.push("font-weight:700");
+  if (run.italic) declarations.push("font-style:italic");
+  const textDecorations = [];
+  if (run.underline) textDecorations.push("underline");
+  if (run.strike) textDecorations.push("line-through");
+  if (textDecorations.length > 0) declarations.push(`text-decoration:${textDecorations.join(" ")}`);
+  if (run.superscript) declarations.push("vertical-align:super");
+  if (run.subscript) declarations.push("vertical-align:sub");
+  if (run.superscript || run.subscript) declarations.push("font-size:0.83em");
+  if (run.fontFamily) declarations.push(`font-family:${run.fontFamily}`);
+  return declarations.join(";");
+}
+function paragraphToRunHtml(runs) {
+  return runs.map((run) => {
+    const css = runStyleToCss2(run);
+    const parts = run.text.split("\n");
+    const html = parts.map((part) => escapeHtml2(part)).join("<br/>");
+    if (!css) return html;
+    return `<span style="${css}">${html}</span>`;
+  }).join("");
+}
+function toLowerLetter(n) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz";
+  if (n <= 0) return "a";
+  let x = n;
+  let out = "";
+  while (x > 0) {
+    x -= 1;
+    out = alphabet[x % 26] + out;
+    x = Math.floor(x / 26);
+  }
+  return out;
+}
+function toRoman(num) {
+  if (num <= 0) return "I";
+  const map = [
+    [1e3, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"]
+  ];
+  let n = num;
+  let result = "";
+  for (const [v, s] of map) {
+    while (n >= v) {
+      result += s;
+      n -= v;
+    }
+  }
+  return result;
+}
+function formatListMarker(format, counter) {
+  switch ((format ?? "").toLowerCase()) {
+    case "decimal":
+      return `${counter}.`;
+    case "lowerletter":
+      return `${toLowerLetter(counter)}.`;
+    case "upperletter":
+      return `${toLowerLetter(counter).toUpperCase()}.`;
+    case "lowerroman":
+      return `${toRoman(counter).toLowerCase()}.`;
+    case "upperroman":
+      return `${toRoman(counter)}.`;
+    case "bullet":
+    default:
+      return "\u2022";
+  }
+}
+function formatListMarkerByPattern(pattern, currentLevel, countersByLevel, currentFormat) {
+  if (!pattern || pattern.trim().length === 0) {
+    return formatListMarker(currentFormat, countersByLevel[currentLevel] ?? 1);
+  }
+  const replaced = pattern.replace(/%(\d+)/g, (_, g1) => {
+    const level1Based = Number.parseInt(g1, 10);
+    if (!Number.isFinite(level1Based) || level1Based <= 0) return "";
+    const levelIdx = level1Based - 1;
+    const n = countersByLevel[levelIdx] ?? 0;
+    if (n <= 0) return "";
+    if (levelIdx === currentLevel) {
+      return formatListMarker(currentFormat, n).replace(/\.$/, "");
+    }
+    return String(n);
+  });
+  const normalized = replaced.trim();
+  if (!normalized) {
+    return formatListMarker(currentFormat, countersByLevel[currentLevel] ?? 1);
+  }
+  return normalized;
+}
+function ensureStyleTag(doc, id) {
+  let styleEl = doc.getElementById(id);
+  if (!styleEl) {
+    styleEl = doc.createElement("style");
+    styleEl.id = id;
+    doc.head.appendChild(styleEl);
+  }
+  return styleEl;
+}
+function applyBaseProfileCss(doc, styleProfile) {
+  const styleEl = ensureStyleTag(doc, "__word_style_profile__");
+  const targetWidthPx = styleProfile.contentWidthPx.toFixed(2);
+  const topPaddingPx = styleProfile.pageMarginTopPx.toFixed(2);
+  const bottomPaddingPx = styleProfile.pageMarginBottomPx.toFixed(2);
+  const pageHeightPx = styleProfile.pageHeightPx.toFixed(2);
+  const bodyLineHeightCss = styleProfile.bodyLineHeightRule === "auto" || styleProfile.bodyLineHeightPx === null ? styleProfile.bodyLineHeightRatio.toFixed(6) : `${styleProfile.bodyLineHeightPx.toFixed(2)}px`;
+  styleEl.textContent = `
+    @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@400;700&family=Noto+Serif+SC:wght@400;700&display=swap');
+    html, body { box-sizing: border-box; }
+    body {
+      min-height: ${pageHeightPx}px !important;
+      width: ${targetWidthPx}px !important;
+      max-width: calc(100% - 24px) !important;
+      margin-left: auto !important;
+      margin-right: auto !important;
+      padding-top: ${topPaddingPx}px !important;
+      padding-bottom: ${bottomPaddingPx}px !important;
+      padding-left: 0 !important;
+      padding-right: 0 !important;
+      font-family: ${styleProfile.bodyFontFamily} !important;
+    }
+    p {
+      font-size: ${styleProfile.bodyFontPx.toFixed(4)}px !important;
+      line-height: ${bodyLineHeightCss} !important;
+      margin-bottom: ${styleProfile.paragraphAfterPx.toFixed(2)}px !important;
+    }
+    table { border-collapse: collapse !important; border-spacing: 0 !important; }
+    td, th {
+      padding-top: ${styleProfile.tableCellPaddingTopPx.toFixed(2)}px !important;
+      padding-left: ${styleProfile.tableCellPaddingLeftPx.toFixed(2)}px !important;
+      padding-bottom: ${styleProfile.tableCellPaddingBottomPx.toFixed(2)}px !important;
+      padding-right: ${styleProfile.tableCellPaddingRightPx.toFixed(2)}px !important;
+      vertical-align: top !important;
+    }
+    h1 {
+      font-size: ${styleProfile.titleFontPx.toFixed(2)}px !important;
+      color: ${styleProfile.titleColor} !important;
+      text-align: ${styleProfile.titleAlign} !important;
+      font-family: ${styleProfile.titleFontFamily} !important;
+    }
+  `;
+}
+function applyInlineLayoutGuards(doc, styleProfile) {
+  const body = doc.body;
+  const targetWidthPx = styleProfile.contentWidthPx.toFixed(2);
+  const topPaddingPx = styleProfile.pageMarginTopPx.toFixed(2);
+  const bottomPaddingPx = styleProfile.pageMarginBottomPx.toFixed(2);
+  const pageHeightPx = styleProfile.pageHeightPx.toFixed(2);
+  setImportantStyle(body, "box-sizing", "border-box");
+  setImportantStyle(body, "min-height", `${pageHeightPx}px`);
+  setImportantStyle(body, "width", `${targetWidthPx}px`);
+  setImportantStyle(body, "max-width", `${targetWidthPx}px`);
+  setImportantStyle(body, "margin-left", "auto");
+  setImportantStyle(body, "margin-right", "auto");
+  setImportantStyle(body, "padding-top", `${topPaddingPx}px`);
+  setImportantStyle(body, "padding-bottom", `${bottomPaddingPx}px`);
+  setImportantStyle(body, "padding-left", "0");
+  setImportantStyle(body, "padding-right", "0");
+  setImportantStyle(body, "font-family", styleProfile.bodyFontFamily);
+  for (const child of Array.from(body.children)) {
+    if (!(child instanceof HTMLElement)) continue;
+    const tag = child.tagName.toLowerCase();
+    if (tag === "script" || tag === "style") continue;
+    setImportantStyle(child, "box-sizing", "border-box");
+    setImportantStyle(child, "max-width", "100%");
+  }
+  for (const img of Array.from(doc.body.querySelectorAll("img"))) {
+    if (!(img instanceof HTMLElement)) continue;
+    setImportantStyle(img, "max-width", "100%");
+    setImportantStyle(img, "height", "auto");
+  }
+}
+function normalizeEmptyParagraphMarkers(paragraphs) {
+  for (const p of paragraphs) {
+    const hasVisualContent = (p.textContent ?? "").trim().length > 0 || p.querySelector("img,table,svg,canvas") !== null;
+    if (!hasVisualContent) {
+      p.setAttribute("data-word-empty", "1");
+      if (p.innerHTML.trim().length === 0) {
+        p.innerHTML = "<br/>";
+      }
+    } else {
+      p.removeAttribute("data-word-empty");
+    }
+  }
+}
+function hasMeaningfulParagraphAfter(paragraphs, index) {
+  for (let i = index + 1; i < paragraphs.length; i += 1) {
+    const p = paragraphs[i];
+    const hasText = (p.textContent ?? "").trim().length > 0;
+    const hasVisual = p.querySelector("img,table,svg,canvas") !== null;
+    if (hasText || hasVisual) return true;
+  }
+  return false;
+}
+function applyParagraphProfiles(doc, styleProfile) {
+  const fallbackParagraphs = Array.from(doc.body.querySelectorAll("p"));
+  fallbackParagraphs.forEach((p) => {
+    p.classList.remove("__word-date-anchor");
+    p.querySelectorAll("span.__word-list-marker").forEach((node) => node.remove());
+  });
+  const resolvedTargets = styleProfile.paragraphProfiles.map((profile, index) => {
+    const byIndex = doc.body.querySelector(`[data-word-p-index="${profile.index}"]`) ?? null;
+    const fallback = fallbackParagraphs[index] ?? null;
+    return {
+      profile,
+      node: byIndex ?? fallback
+    };
+  });
+  if (styleProfile.trailingDateAlignedRight && styleProfile.trailingDateText) {
+    let dateParagraph = null;
+    if (styleProfile.trailingDateParagraphIndex !== null && styleProfile.trailingDateParagraphIndex >= 0) {
+      dateParagraph = doc.body.querySelector(
+        `[data-word-p-index="${styleProfile.trailingDateParagraphIndex}"]`
+      ) ?? fallbackParagraphs[styleProfile.trailingDateParagraphIndex] ?? null;
+    } else {
+      dateParagraph = fallbackParagraphs.slice().reverse().find((p) => {
+        const text = (p.textContent ?? "").replace(/\s+/g, "");
+        const target = styleProfile.trailingDateText?.replace(/\s+/g, "") ?? "";
+        return target.length > 0 && text.includes(target);
+      }) ?? null;
+    }
+    const dateIndex = dateParagraph ? fallbackParagraphs.indexOf(dateParagraph) : -1;
+    const hasContentAfterDate = dateIndex >= 0 ? hasMeaningfulParagraphAfter(fallbackParagraphs, dateIndex) : false;
+    if (dateParagraph && !hasContentAfterDate) {
+      let existingEmptyCount = 0;
+      let cursor = dateParagraph.previousElementSibling;
+      while (cursor && cursor.tagName.toLowerCase() === "p" && (cursor.textContent ?? "").trim().length === 0) {
+        existingEmptyCount += 1;
+        cursor = cursor.previousElementSibling;
+      }
+      const needed = Math.max(0, styleProfile.trailingEmptyParagraphCountBeforeDate - existingEmptyCount);
+      for (let i = 0; i < needed; i += 1) {
+        const spacer = doc.createElement("p");
+        spacer.innerHTML = "<br/>";
+        dateParagraph.parentElement?.insertBefore(spacer, dateParagraph);
+      }
+    }
+  }
+  const paragraphs = Array.from(doc.body.querySelectorAll("p"));
+  const listCounters = /* @__PURE__ */ new Map();
+  const orderedTargets = [];
+  for (const target of resolvedTargets) {
+    const para = target.node;
+    const profile = target.profile;
+    if (!para) continue;
+    orderedTargets.push(para);
+    para.removeAttribute("data-word-list");
+    para.style.textAlign = profile.align;
+    if (profile.beforePx !== null) para.style.marginTop = `${profile.beforePx.toFixed(2)}px`;
+    if (profile.afterPx !== null) para.style.marginBottom = `${profile.afterPx.toFixed(2)}px`;
+    if (profile.lineHeightRule === "auto" && profile.lineHeightRatio !== null) {
+      para.style.lineHeight = profile.lineHeightRatio.toFixed(6);
+    } else if ((profile.lineHeightRule === "exact" || profile.lineHeightRule === "atLeast") && profile.lineHeightPx !== null) {
+      para.style.lineHeight = `${profile.lineHeightPx.toFixed(2)}px`;
+    }
+    if (profile.indentLeftPx !== null) para.style.marginLeft = `${profile.indentLeftPx.toFixed(2)}px`;
+    if (profile.indentRightPx !== null) para.style.marginRight = `${profile.indentRightPx.toFixed(2)}px`;
+    if (profile.firstLinePx !== null) para.style.textIndent = `${profile.firstLinePx.toFixed(2)}px`;
+    if (profile.hangingPx !== null) para.style.textIndent = `${(-profile.hangingPx).toFixed(2)}px`;
+    if (profile.runs.length > 0 && para.querySelector("img,table,svg,canvas") === null) {
+      const currentTextNormalized = (para.textContent ?? "").replace(/\s+/g, "");
+      const runTextNormalized = profile.runs.map((run) => run.text).join("").replace(/\s+/g, "");
+      if (runTextNormalized.length > 0 && currentTextNormalized === runTextNormalized) {
+        para.innerHTML = paragraphToRunHtml(profile.runs);
+      }
+    }
+    if (profile.listNumId !== null && profile.listLevel !== null) {
+      para.setAttribute("data-word-list", "1");
+      if (profile.sectionBreakBefore) {
+        listCounters.set(profile.listNumId, []);
+      }
+      const currentLevel = Math.max(0, profile.listLevel);
+      const levels = listCounters.get(profile.listNumId) ?? [];
+      const prevValue = levels[currentLevel] ?? profile.listStartAt - 1;
+      const nextValue = prevValue + 1;
+      levels[currentLevel] = nextValue;
+      for (let lv = currentLevel + 1; lv < levels.length; lv += 1) {
+        levels[lv] = 0;
+      }
+      listCounters.set(profile.listNumId, levels);
+      const markerText = formatListMarkerByPattern(profile.listTextPattern, currentLevel, levels, profile.listFormat);
+      const plainText = (para.textContent ?? "").replace(/\s+/g, " ").trim();
+      const alreadyHasMarker = plainText.startsWith(markerText);
+      if (!alreadyHasMarker) {
+        const marker = doc.createElement("span");
+        marker.className = "__word-list-marker";
+        marker.textContent = `${markerText} `;
+        marker.style.display = "inline-block";
+        marker.style.minWidth = "1.8em";
+        marker.style.marginLeft = currentLevel > 0 ? `${currentLevel * 1.2}em` : "0";
+        marker.style.color = "inherit";
+        marker.style.fontWeight = "inherit";
+        para.prepend(marker);
+      }
+    }
+  }
+  normalizeEmptyParagraphMarkers(paragraphs);
+  return orderedTargets;
+}
+function paragraphHeightPx(paragraph) {
+  const rect = paragraph.getBoundingClientRect();
+  if (rect.height > 0) return rect.height;
+  const lh = Number.parseFloat(getComputedStyle(paragraph).lineHeight || "0");
+  if (Number.isFinite(lh) && lh > 0) return lh;
+  return 16;
+}
+function insertPageSpacerBefore(doc, paragraph, heightPx) {
+  if (heightPx <= 0.5) return;
+  const spacer = doc.createElement("div");
+  spacer.dataset.wordPageSpacer = "1";
+  spacer.style.height = `${heightPx.toFixed(2)}px`;
+  spacer.style.width = "100%";
+  spacer.style.pointerEvents = "none";
+  spacer.style.userSelect = "none";
+  paragraph.parentElement?.insertBefore(spacer, paragraph);
+}
+function removePaginationSpacers(doc) {
+  doc.querySelectorAll("[data-word-page-spacer='1']").forEach((node) => node.remove());
+}
+function estimateGroupHeight(paragraphs, idx, profile, contentHeight) {
+  const currentH = paragraphHeightPx(paragraphs[idx]);
+  if (!profile.keepNext) return currentH;
+  const next = paragraphs[idx + 1];
+  if (!next) return currentH;
+  const nextH = paragraphHeightPx(next);
+  const sum = currentH + nextH;
+  if (sum > contentHeight) return currentH;
+  return sum;
+}
+function applyKeepPagination(doc, styleProfile, paragraphs) {
+  removePaginationSpacers(doc);
+  const contentHeight = Math.max(120, styleProfile.pageHeightPx - styleProfile.pageMarginTopPx - styleProfile.pageMarginBottomPx);
+  const count = Math.min(styleProfile.paragraphProfiles.length, paragraphs.length);
+  let used = 0;
+  for (let i = 0; i < count; i += 1) {
+    const p = paragraphs[i];
+    const profile = styleProfile.paragraphProfiles[i];
+    const h2 = paragraphHeightPx(p);
+    const forceBreak = profile.pageBreakBefore;
+    if (forceBreak && used > 0) {
+      insertPageSpacerBefore(doc, p, contentHeight - used);
+      used = 0;
+    }
+    const groupHeight = estimateGroupHeight(paragraphs, i, profile, contentHeight);
+    if ((profile.keepLines || profile.keepNext) && used > 0 && used + groupHeight > contentHeight) {
+      insertPageSpacerBefore(doc, p, contentHeight - used);
+      used = 0;
+    }
+    if (used > 0 && used + h2 > contentHeight) {
+      insertPageSpacerBefore(doc, p, contentHeight - used);
+      used = 0;
+    }
+    used += h2;
+    if (used >= contentHeight) {
+      used = used % contentHeight;
+    }
+  }
+}
+function applyFormattingMarks(doc, showFormattingMarks) {
+  const styleEl = ensureStyleTag(doc, "__word_view_options__");
+  styleEl.textContent = `
+    p[data-word-empty="1"]::before { content: "\\00a0"; }
+    ${showFormattingMarks ? `
+    p::after {
+      content: "\u21B5";
+      color: #66aef9;
+      font-size: 0.85em;
+      margin-left: 3px;
+    }
+    br::after {
+      content: "\u21B5";
+      color: #66aef9;
+    }
+    ` : ""}
+  `;
+}
+function applyWordRenderModel({ doc, styleProfile, showFormattingMarks }) {
+  const effectiveProfile = styleProfile ?? createFallbackWordStyleProfile("__default_a4__");
+  applyWordHtmlCompatibility(doc, {
+    forceBodyFontFamily: effectiveProfile.bodyFontFamily,
+    forceHeadingFontFamily: effectiveProfile.titleFontFamily
+  });
+  let paragraphs = Array.from(doc.body.querySelectorAll("p"));
+  normalizeEmptyParagraphMarkers(paragraphs);
+  applyBaseProfileCss(doc, effectiveProfile);
+  applyInlineLayoutGuards(doc, effectiveProfile);
+  if (styleProfile) {
+    paragraphs = applyParagraphProfiles(doc, styleProfile);
+    applyKeepPagination(doc, styleProfile, paragraphs);
+  }
+  applyFormattingMarks(doc, showFormattingMarks);
+}
+// src/core/DocsWordElement.ts
+var BASE_CSS = `
+:host{display:block;border:1px solid #d8deea;border-radius:12px;background:#fff;overflow:hidden;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto}
+.toolbar{display:flex;gap:8px;flex-wrap:wrap;padding:10px;border-bottom:1px solid #e8edf6;background:#f8faff}
+button{border:1px solid #c8d2eb;background:#fff;border-radius:9px;padding:6px 10px;cursor:pointer}
+.paste{width:100%;min-height:40px;border:1px dashed #95acef;border-radius:10px;background:#edf3ff;padding:8px 10px;box-sizing:border-box;resize:vertical}
+.hint{display:block;padding:0 10px 10px;color:#4b5c82;font-size:12px}
+iframe{width:100%;min-height:760px;border:0}
+`;
+var DocsWordElement = class extends HTMLElement {
+  rootRef;
+  frame;
+  pasteArea;
+  fileInput;
+  hint;
+  htmlSnapshot;
+  styleProfile = null;
+  frameHeight = 0;
+  constructor() {
+    super();
+    this.rootRef = this.attachShadow({ mode: "open" });
+    this.htmlSnapshot = buildHtmlSnapshot("<p><br/></p>");
+    const style = document.createElement("style");
+    style.textContent = BASE_CSS;
+    const toolbar = document.createElement("div");
+    toolbar.className = "toolbar";
+    const btnRead = document.createElement("button");
+    btnRead.textContent = "\u4ECE\u7CFB\u7EDF\u526A\u8D34\u677F\u8BFB\u53D6";
+    btnRead.onclick = () => void this.readClipboard();
+    const btnUpload = document.createElement("button");
+    btnUpload.textContent = "\u4E0A\u4F20 Word";
+    btnUpload.onclick = () => this.fileInput.click();
+    const btnClear = document.createElement("button");
+    btnClear.textContent = "\u6E05\u7A7A";
+    btnClear.onclick = () => this.clear();
+    this.fileInput = document.createElement("input");
+    this.fileInput.type = "file";
+    this.fileInput.accept = ".docx";
+    this.fileInput.style.display = "none";
+    this.fileInput.onchange = () => void this.onUpload();
+    toolbar.append(btnRead, btnUpload, btnClear, this.fileInput);
+    this.pasteArea = document.createElement("textarea");
+    this.pasteArea.className = "paste";
+    this.pasteArea.placeholder = "\u5728\u6B64\u5904\u7C98\u8D34 Word/WPS/Google Docs \u5185\u5BB9\uFF08Ctrl/Cmd+V\uFF09";
+    this.pasteArea.onpaste = (event) => {
+      event.preventDefault();
+      void this.applyFromClipboardData(event.clipboardData);
+    };
+    this.hint = document.createElement("span");
+    this.hint.className = "hint";
+    this.hint.textContent = "\u7B49\u5F85\u5185\u5BB9\u5BFC\u5165";
+    this.frame = document.createElement("iframe");
+    this.frame.sandbox.add("allow-same-origin", "allow-scripts");
+    this.frame.onload = () => this.onFrameLoad();
+    this.rootRef.append(style, toolbar, this.pasteArea, this.hint, this.frame);
+  }
+  connectedCallback() {
+    this.renderSnapshot();
+  }
+  setSnapshot(rawHtml) {
+    this.styleProfile = null;
+    this.htmlSnapshot = buildHtmlSnapshot(rawHtml);
+    this.renderSnapshot();
+    this.hint.textContent = "\u5DF2\u52A0\u8F7D HTML \u5FEB\u7167";
+    this.emitChange();
+  }
+  clear() {
+    this.styleProfile = null;
+    this.htmlSnapshot = buildHtmlSnapshot("<p><br/></p>");
+    this.renderSnapshot();
+    this.hint.textContent = "\u6587\u6863\u5DF2\u6E05\u7A7A";
+    this.emitChange();
+  }
+  async onUpload() {
+    const file = this.fileInput.files?.[0];
+    if (!file) return;
+    try {
+      const [snapshot, profile] = await Promise.all([
+        parseDocxToHtmlSnapshot(file),
+        parseDocxStyleProfile(file)
+      ]);
+      this.styleProfile = profile;
+      this.htmlSnapshot = snapshot;
+      this.renderSnapshot();
+      this.hint.textContent = `\u5DF2\u52A0\u8F7D Word \u6587\u4EF6: ${profile.sourceFileName}`;
+      this.emitChange();
+    } catch (error) {
+      this.emitError(error instanceof Error ? error.message : "Word \u89E3\u6790\u5931\u8D25");
+    } finally {
+      this.fileInput.value = "";
+    }
+  }
+  async readClipboard() {
+    if (!navigator.clipboard?.read) {
+      this.emitError("\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 clipboard.read");
+      return;
+    }
+    try {
+      const items = await navigator.clipboard.read();
+      const payload = await extractFromClipboardItems(items);
+      this.applyPayload(payload.html, payload.text);
+    } catch (error) {
+      this.emitError(error instanceof Error ? error.message : "\u8BFB\u53D6\u526A\u8D34\u677F\u5931\u8D25");
+    }
+  }
+  async applyFromClipboardData(data) {
+    if (!data) return;
+    const payload = await extractFromClipboardDataTransfer(data);
+    this.applyPayload(payload.html, payload.text);
+  }
+  applyPayload(html, text) {
+    this.styleProfile = null;
+    if (html.trim()) {
+      this.htmlSnapshot = buildHtmlSnapshot(html);
+    } else if (text.trim()) {
+      this.htmlSnapshot = buildHtmlSnapshot(`<p>${text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")}</p>`);
+    } else {
+      this.hint.textContent = "\u672A\u68C0\u6D4B\u5230\u53EF\u5BFC\u5165\u5185\u5BB9";
+      return;
+    }
+    this.renderSnapshot();
+    this.hint.textContent = "\u5DF2\u5BFC\u5165\u526A\u8D34\u677F\u5185\u5BB9";
+    this.emitChange();
+  }
+  onFrameLoad() {
+    const doc = this.frame.contentDocument;
+    if (!doc) return;
+    applyWordRenderModel({
+      doc,
+      styleProfile: this.styleProfile,
+      showFormattingMarks: false
+    });
+    this.syncHeight();
+    window.setTimeout(() => this.syncHeight(), 120);
+  }
+  syncHeight() {
+    const doc = this.frame.contentDocument;
+    if (!doc) return;
+    const measured = Math.max(760, doc.body.scrollHeight, doc.documentElement.scrollHeight);
+    const next = measured + 24;
+    if (Math.abs(next - this.frameHeight) < 2) return;
+    this.frameHeight = next;
+    this.frame.style.height = `${next}px`;
+  }
+  renderSnapshot() {
+    this.frame.srcdoc = this.htmlSnapshot;
+  }
+  emitChange() {
+    this.dispatchEvent(new CustomEvent("docsjs-change", { detail: { htmlSnapshot: this.htmlSnapshot } }));
+  }
+  emitError(message) {
+    this.dispatchEvent(new CustomEvent("docsjs-error", { detail: { message } }));
+    this.hint.textContent = `\u9519\u8BEF: ${message}`;
+  }
+};
+function defineDocsWordElement() {
+  if (!customElements.get("docs-word-editor")) {
+    customElements.define("docs-word-editor", DocsWordElement);
+  }
+}
+// src/react/WordFidelityEditorReact.tsx
+var import_react = __toESM(require("react"), 1);
+defineDocsWordElement();
+function WordFidelityEditorReact({ onChange, onError }) {
+  const ref2 = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    const node = ref2.current;
+    if (!node) return;
+    const onChangeEvent = (event) => {
+      const detail = event.detail;
+      onChange?.(detail);
+    };
+    const onErrorEvent = (event) => {
+      const detail = event.detail;
+      onError?.(detail);
+    };
+    node.addEventListener("docsjs-change", onChangeEvent);
+    node.addEventListener("docsjs-error", onErrorEvent);
+    return () => {
+      node.removeEventListener("docsjs-change", onChangeEvent);
+      node.removeEventListener("docsjs-error", onErrorEvent);
+    };
+  }, [onChange, onError]);
+  return import_react.default.createElement("docs-word-editor", { ref: ref2 });
+}
+// src/vue/WordFidelityEditorVue.ts
+var import_vue = require("vue");
+defineDocsWordElement();
+var WordFidelityEditorVue = (0, import_vue.defineComponent)({
+  name: "WordFidelityEditorVue",
+  emits: ["change", "error"],
+  setup(_, { emit }) {
+    const elRef = (0, import_vue.ref)(null);
+    const onChange = (event) => {
+      emit("change", event.detail);
+    };
+    const onError = (event) => {
+      emit("error", event.detail);
+    };
+    (0, import_vue.onMounted)(() => {
+      elRef.value?.addEventListener("docsjs-change", onChange);
+      elRef.value?.addEventListener("docsjs-error", onError);
+    });
+    (0, import_vue.onBeforeUnmount)(() => {
+      elRef.value?.removeEventListener("docsjs-change", onChange);
+      elRef.value?.removeEventListener("docsjs-error", onError);
+    });
+    return () => (0, import_vue.h)("docs-word-editor", { ref: elRef });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocsWordElement,
+  WordFidelityEditorReact,
+  WordFidelityEditorVue,
+  defineDocsWordElement
+});
+//# sourceMappingURL=index.cjs.map