@yinyoudexing/xml2word 0.1.0 → 0.1.2

package/dist/htmlToWordBodyXml-LY6DZSTW.js

@@ -0,0 +1,877 @@
+// src/lib/htmlToWordBodyXml.ts
+import { parseDocument } from "htmlparser2";
+function escapeXmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function shouldPreserveSpace(text) {
+  if (!text) return false;
+  return /^\s/.test(text) || /\s$/.test(text) || /\s{2,}/.test(text);
+}
+function shouldKeepWhitespaceOnlyRun(text) {
+  if (!text) return false;
+  if (/\r|\n/.test(text)) return false;
+  if (text.includes("\xA0")) return true;
+  return /\s{2,}/.test(text);
+}
+function parseStyleAttribute(style) {
+  if (!style) return {};
+  const normalized = style.replace(/\r/g, "\n");
+  const parts = normalized.split(";");
+  const entries = [];
+  for (const part of parts) {
+    const idx = part.indexOf(":");
+    if (idx <= 0) continue;
+    const key = part.slice(0, idx).trim().toLowerCase();
+    const val = part.slice(idx + 1).trim();
+    if (!key || !val) continue;
+    entries.push([key, val]);
+  }
+  return Object.fromEntries(entries);
+}
+function parseRgbToHex(value) {
+  const m = value.trim().toLowerCase().match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/);
+  if (!m) return void 0;
+  const nums = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (nums.some((n) => Number.isNaN(n) || n < 0 || n > 255)) return void 0;
+  return nums.map((n) => n.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function parseCssColorToHex(value) {
+  if (!value) return void 0;
+  const v = value.trim();
+  const hex = v.match(/^#([0-9a-fA-F]{6})$/)?.[1];
+  if (hex) return hex.toUpperCase();
+  return parseRgbToHex(v);
+}
+function parseFontSizeToHalfPoints(value) {
+  if (!value) return void 0;
+  const v = value.trim().toLowerCase();
+  const pt = v.match(/^(\d+(?:\.\d+)?)pt$/);
+  if (pt) return Math.max(1, Math.round(Number(pt[1]) * 2));
+  const px = v.match(/^(\d+(?:\.\d+)?)px$/);
+  if (px) {
+    const ptValue = Number(px[1]) * 72 / 96;
+    return Math.max(1, Math.round(ptValue * 2));
+  }
+  return void 0;
+}
+function normalizeFontFamily(value) {
+  if (!value) return void 0;
+  const first = value.split(",")[0]?.trim();
+  if (!first) return void 0;
+  return first.replace(/^["']|["']$/g, "");
+}
+function mergeTextStyle(base, patch) {
+  return {
+    bold: patch.bold ?? base.bold,
+    italic: patch.italic ?? base.italic,
+    underline: patch.underline ?? base.underline,
+    colorHex: patch.colorHex ?? base.colorHex,
+    fontFamily: patch.fontFamily ?? base.fontFamily,
+    fontSizeHalfPoints: patch.fontSizeHalfPoints ?? base.fontSizeHalfPoints
+  };
+}
+function styleFromElement(node) {
+  const tag = node.name?.toLowerCase();
+  const styleAttr = node.attribs?.style;
+  const css = parseStyleAttribute(styleAttr);
+  const boldFromCss = (() => {
+    const v = css["font-weight"]?.trim().toLowerCase();
+    if (!v) return void 0;
+    if (v === "bold" || v === "bolder") return true;
+    const n = Number(v);
+    if (!Number.isNaN(n)) return n >= 600;
+    return void 0;
+  })();
+  const italicFromCss = (() => {
+    const v = css["font-style"]?.trim().toLowerCase();
+    if (!v) return void 0;
+    if (v === "italic" || v === "oblique") return true;
+    return void 0;
+  })();
+  const underlineFromCss = (() => {
+    const v = css["text-decoration"]?.trim().toLowerCase();
+    if (!v) return void 0;
+    return v.includes("underline");
+  })();
+  const tagBold = tag === "b" || tag === "strong" ? true : void 0;
+  const tagItalic = tag === "i" || tag === "em" ? true : void 0;
+  const tagUnderline = tag === "u" ? true : void 0;
+  return {
+    bold: tagBold ?? boldFromCss,
+    italic: tagItalic ?? italicFromCss,
+    underline: tagUnderline ?? underlineFromCss,
+    colorHex: parseCssColorToHex(css.color),
+    fontFamily: normalizeFontFamily(css["font-family"]),
+    fontSizeHalfPoints: parseFontSizeToHalfPoints(css["font-size"])
+  };
+}
+function getTextContent(node) {
+  if (node.type === "text") return node.data ?? "";
+  let out = "";
+  const children = node.children ?? [];
+  for (const c of children) out += getTextContent(c);
+  return out;
+}
+var IMAGE_RELATIONSHIP_ID_OFFSET = 7;
+function decodeBase64ToUint8Array(base64) {
+  const BufferCtor = globalThis.Buffer;
+  if (BufferCtor) {
+    return new Uint8Array(BufferCtor.from(base64, "base64"));
+  }
+  const atobFn = globalThis.atob;
+  if (!atobFn) {
+    throw new Error("Base64 decode is not available in this environment.");
+  }
+  const bin = atobFn(base64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function parseImageDataUrl(src) {
+  const m = src.match(/^data:(image\/png|image\/jpeg);base64,([\s\S]+)$/i);
+  if (!m) return void 0;
+  const contentType = m[1].toLowerCase();
+  const base64 = m[2].replace(/\s+/g, "");
+  const data = decodeBase64ToUint8Array(base64);
+  const extension = contentType === "image/png" ? "png" : "jpeg";
+  return { contentType, data, extension };
+}
+function parseCssLengthToPx(value) {
+  if (!value) return void 0;
+  const v = value.trim().toLowerCase();
+  const px = v.match(/^(\d+(?:\.\d+)?)px$/);
+  if (px) return Math.max(1, Math.round(Number(px[1])));
+  return void 0;
+}
+function readUInt32BE(bytes, offset) {
+  if (offset < 0 || offset + 4 > bytes.length) return void 0;
+  return ((bytes[offset] ?? 0) << 24 | (bytes[offset + 1] ?? 0) << 16 | (bytes[offset + 2] ?? 0) << 8 | (bytes[offset + 3] ?? 0)) >>> 0;
+}
+function parsePngDimensions(data) {
+  if (data.length < 24) return void 0;
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  for (let i = 0; i < signature.length; i++) {
+    if ((data[i] ?? 0) !== signature[i]) return void 0;
+  }
+  const widthPx = readUInt32BE(data, 16);
+  const heightPx = readUInt32BE(data, 20);
+  if (!widthPx || !heightPx) return void 0;
+  return { widthPx, heightPx };
+}
+function parseJpegDimensions(data) {
+  if (data.length < 4) return void 0;
+  if (data[0] !== 255 || data[1] !== 216) return void 0;
+  let offset = 2;
+  while (offset + 4 <= data.length) {
+    if (data[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    while (offset < data.length && data[offset] === 255) offset++;
+    if (offset >= data.length) return void 0;
+    const marker = data[offset];
+    offset++;
+    const isStandalone = marker === 217 || marker === 218;
+    if (isStandalone) break;
+    if (offset + 2 > data.length) return void 0;
+    const length = data[offset] << 8 | data[offset + 1];
+    if (length < 2 || offset + length > data.length) return void 0;
+    const isSof = marker === 192 || marker === 193 || marker === 194 || marker === 195 || marker === 197 || marker === 198 || marker === 199 || marker === 201 || marker === 202 || marker === 203 || marker === 205 || marker === 206 || marker === 207;
+    if (isSof) {
+      if (offset + 7 > data.length) return void 0;
+      const heightPx = data[offset + 3] << 8 | data[offset + 4];
+      const widthPx = data[offset + 5] << 8 | data[offset + 6];
+      if (!widthPx || !heightPx) return void 0;
+      return { widthPx, heightPx };
+    }
+    offset += length;
+  }
+  return void 0;
+}
+function parseIntrinsicImageSizePx(contentType, data) {
+  if (contentType === "image/png") return parsePngDimensions(data);
+  if (contentType === "image/jpeg") return parseJpegDimensions(data);
+  return void 0;
+}
+function applyMaxBoxPx(size, maxBox) {
+  const w = Math.max(1, Math.round(size.widthPx));
+  const h = Math.max(1, Math.round(size.heightPx));
+  const scale = Math.min(1, maxBox.maxWidthPx / w, maxBox.maxHeightPx / h);
+  return { widthPx: Math.max(1, Math.round(w * scale)), heightPx: Math.max(1, Math.round(h * scale)) };
+}
+function computeImageSizePx(node, intrinsic) {
+  const wAttr = node.attribs?.width ? Number(node.attribs.width) : void 0;
+  const hAttr = node.attribs?.height ? Number(node.attribs.height) : void 0;
+  const css = parseStyleAttribute(node.attribs?.style);
+  const wCss = parseCssLengthToPx(css.width);
+  const hCss = parseCssLengthToPx(css.height);
+  const widthAttrPx = Number.isFinite(wAttr) && wAttr ? Math.max(1, Math.round(wAttr)) : void 0;
+  const heightAttrPx = Number.isFinite(hAttr) && hAttr ? Math.max(1, Math.round(hAttr)) : void 0;
+  const ratio = intrinsic && intrinsic.widthPx > 0 && intrinsic.heightPx > 0 ? intrinsic.heightPx / intrinsic.widthPx : widthAttrPx && heightAttrPx ? heightAttrPx / widthAttrPx : 0.5;
+  const widthPx = typeof wCss === "number" ? wCss : typeof widthAttrPx === "number" ? widthAttrPx : intrinsic?.widthPx ?? 300;
+  const heightPx = typeof hCss === "number" ? hCss : typeof heightAttrPx === "number" ? heightAttrPx : intrinsic?.heightPx ?? 150;
+  const finalSize = typeof wCss === "number" && typeof hCss !== "number" ? { widthPx, heightPx: Math.max(1, Math.round(widthPx * ratio)) } : typeof hCss === "number" && typeof wCss !== "number" ? { widthPx: Math.max(1, Math.round(heightPx / ratio)), heightPx } : typeof widthAttrPx === "number" && typeof heightAttrPx !== "number" && intrinsic ? { widthPx, heightPx: Math.max(1, Math.round(widthPx * ratio)) } : typeof heightAttrPx === "number" && typeof widthAttrPx !== "number" && intrinsic ? { widthPx: Math.max(1, Math.round(heightPx / ratio)), heightPx } : { widthPx, heightPx };
+  return applyMaxBoxPx(finalSize, { maxWidthPx: 624, maxHeightPx: 864 });
+}
+function collectInlineRuns(node, inherited, out, result) {
+  if (node.type === "text") {
+    const text = node.data ?? "";
+    if (text) out.push({ kind: "text", text, style: inherited });
+    return;
+  }
+  if (node.type === "tag") {
+    const tag = node.name?.toLowerCase();
+    if (tag === "br") {
+      out.push({ kind: "br" });
+      return;
+    }
+    if (tag === "img") {
+      const src = node.attribs?.src;
+      if (!src) return;
+      const parsed = parseImageDataUrl(src);
+      if (!parsed) return;
+      const intrinsic = parseIntrinsicImageSizePx(parsed.contentType, parsed.data);
+      const { widthPx, heightPx } = computeImageSizePx(node, intrinsic);
+      const id = result.images.length + 1;
+      const relationshipId = `rId${id + IMAGE_RELATIONSHIP_ID_OFFSET}`;
+      const target = `media/image${id}.${parsed.extension}`;
+      result.images.push({
+        relationshipId,
+        target,
+        data: parsed.data,
+        contentType: parsed.contentType,
+        widthPx,
+        heightPx
+      });
+      out.push({ kind: "image", image: { relationshipId, widthPx, heightPx } });
+      return;
+    }
+    if (tag === "canvas") {
+      const dataUrl = node.attribs?.["data-image"] ?? node.attribs?.["data-src"];
+      if (!dataUrl) return;
+      const parsed = parseImageDataUrl(dataUrl);
+      if (!parsed) return;
+      const bufferW = node.attribs?.width ? Number(node.attribs.width) : void 0;
+      const bufferH = node.attribs?.height ? Number(node.attribs.height) : void 0;
+      const intrinsic = Number.isFinite(bufferW) && bufferW && Number.isFinite(bufferH) && bufferH ? { widthPx: Math.max(1, Math.round(bufferW)), heightPx: Math.max(1, Math.round(bufferH)) } : parseIntrinsicImageSizePx(parsed.contentType, parsed.data);
+      const { widthPx, heightPx } = computeImageSizePx(node, intrinsic);
+      const id = result.images.length + 1;
+      const relationshipId = `rId${id + IMAGE_RELATIONSHIP_ID_OFFSET}`;
+      const target = `media/image${id}.${parsed.extension}`;
+      result.images.push({
+        relationshipId,
+        target,
+        data: parsed.data,
+        contentType: parsed.contentType,
+        widthPx,
+        heightPx
+      });
+      out.push({ kind: "image", image: { relationshipId, widthPx, heightPx } });
+      return;
+    }
+    const next = mergeTextStyle(inherited, styleFromElement(node));
+    const children2 = node.children ?? [];
+    for (const c of children2) collectInlineRuns(c, next, out, result);
+    return;
+  }
+  const children = node.children ?? [];
+  for (const c of children) collectInlineRuns(c, inherited, out, result);
+}
+function buildRunXml(style, text) {
+  const rPrParts = [];
+  if (style.bold) rPrParts.push("<w:b/>");
+  if (style.italic) rPrParts.push("<w:i/>");
+  if (style.underline) rPrParts.push('<w:u w:val="single"/>');
+  if (style.colorHex) rPrParts.push(`<w:color w:val="${style.colorHex}"/>`);
+  if (style.fontFamily) {
+    const ff = escapeXmlText(style.fontFamily);
+    rPrParts.push(`<w:rFonts w:ascii="${ff}" w:hAnsi="${ff}" w:eastAsia="${ff}"/>`);
+  }
+  if (typeof style.fontSizeHalfPoints === "number") {
+    const sz = style.fontSizeHalfPoints;
+    rPrParts.push(`<w:sz w:val="${sz}"/><w:szCs w:val="${sz}"/>`);
+  }
+  const rPrXml = rPrParts.length ? `<w:rPr>${rPrParts.join("")}</w:rPr>` : "";
+  const escaped = escapeXmlText(text);
+  const preserve = shouldPreserveSpace(text) ? ' xml:space="preserve"' : "";
+  return `<w:r>${rPrXml}<w:t${preserve}>${escaped}</w:t></w:r>`;
+}
+function pxToEmu(px) {
+  return Math.max(1, Math.round(px * 9525));
+}
+function buildImageRunXml(image) {
+  const cx = pxToEmu(image.widthPx);
+  const cy = pxToEmu(image.heightPx);
+  const docPrId = image.relationshipId.replace(/^rId/, "");
+  const name = `Picture ${docPrId}`;
+  return `<w:r><w:drawing xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${docPrId}" name="${escapeXmlText(name)}"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${escapeXmlText(name)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${image.relationshipId}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+}
+function hasClass(node, className) {
+  const cls = node.attribs?.class;
+  if (!cls) return false;
+  return cls.split(/\s+/).includes(className);
+}
+function isSkippableSubtree(node) {
+  if (node.type !== "tag") return false;
+  const tag = node.name?.toLowerCase();
+  if (tag === "button") return true;
+  if (tag === "canvas") {
+    const dataUrl = node.attribs?.["data-image"] ?? node.attribs?.["data-src"];
+    if (!dataUrl) return true;
+  }
+  if (tag === "img" && hasClass(node, "ProseMirror-separator")) return true;
+  if (node.attribs?.id === "pages") return true;
+  if (hasClass(node, "ProseMirror-widget")) return true;
+  return false;
+}
+function parseCssLengthToTwips(value, baseFontHalfPoints) {
+  if (!value) return void 0;
+  const v = value.trim().toLowerCase();
+  if (!v) return void 0;
+  const pt = v.match(/^(-?\d+(?:\.\d+)?)pt$/);
+  if (pt) return Math.round(Number(pt[1]) * 20);
+  const px = v.match(/^(-?\d+(?:\.\d+)?)px$/);
+  if (px) return Math.round(Number(px[1]) * 72 * 20 / 96);
+  const em = v.match(/^(-?\d+(?:\.\d+)?)em$/);
+  if (em) {
+    const basePt = baseFontHalfPoints / 2;
+    return Math.round(Number(em[1]) * basePt * 20);
+  }
+  const num = v.match(/^(-?\d+(?:\.\d+)?)$/);
+  if (num) return Math.round(Number(num[1]));
+  return void 0;
+}
+function inferFirstFontSizeHalfPoints(node) {
+  const stack = [node];
+  while (stack.length) {
+    const cur = stack.pop();
+    if (cur.type === "tag") {
+      const css = parseStyleAttribute(cur.attribs?.style);
+      const sz = parseFontSizeToHalfPoints(css["font-size"]);
+      if (typeof sz === "number") return sz;
+    }
+    const children = cur.children ?? [];
+    for (let i = children.length - 1; i >= 0; i--) {
+      stack.push(children[i]);
+    }
+  }
+  return void 0;
+}
+function buildParagraphPrXml(node, baseFontHalfPoints, extraInd, pStyleId) {
+  const css = parseStyleAttribute(node.attribs?.style);
+  const parts = [];
+  if (pStyleId) parts.push(`<w:pStyle w:val="${escapeXmlText(pStyleId)}"/>`);
+  const align = css["text-align"]?.trim().toLowerCase();
+  const jcVal = align === "center" ? "center" : align === "right" ? "right" : align === "justify" ? "both" : void 0;
+  if (jcVal) parts.push(`<w:jc w:val="${jcVal}"/>`);
+  const left = (() => {
+    const marginLeft = parseCssLengthToTwips(css["margin-left"], baseFontHalfPoints);
+    const paddingLeft = parseCssLengthToTwips(css["padding-left"], baseFontHalfPoints);
+    const sum = (marginLeft ?? 0) + (paddingLeft ?? 0);
+    if (!sum) return void 0;
+    return Math.max(0, sum);
+  })();
+  const firstLine = (() => {
+    const textIndent = parseCssLengthToTwips(css["text-indent"], baseFontHalfPoints);
+    if (typeof textIndent !== "number" || !textIndent) return void 0;
+    return Math.max(0, textIndent);
+  })();
+  const indAttrs = [];
+  const leftTwips = extraInd?.leftTwips ?? left;
+  if (typeof leftTwips === "number") indAttrs.push(`w:left="${leftTwips}"`);
+  const hangingTwips = extraInd?.hangingTwips;
+  if (typeof hangingTwips === "number") indAttrs.push(`w:hanging="${hangingTwips}"`);
+  if (typeof firstLine === "number") indAttrs.push(`w:firstLine="${firstLine}"`);
+  if (indAttrs.length) parts.push(`<w:ind ${indAttrs.join(" ")}/>`);
+  const before = parseCssLengthToTwips(css["margin-top"], baseFontHalfPoints);
+  const after = parseCssLengthToTwips(css["margin-bottom"], baseFontHalfPoints);
+  const lineHeight = (() => {
+    const lh = css["line-height"]?.trim().toLowerCase();
+    if (!lh || lh === "normal") return void 0;
+    const unitless = lh.match(/^(\d+(?:\.\d+)?)$/);
+    if (unitless) {
+      const multiplier = Number(unitless[1]);
+      if (!Number.isFinite(multiplier) || multiplier <= 0) return void 0;
+      const basePt = baseFontHalfPoints / 2;
+      return Math.round(basePt * multiplier * 20);
+    }
+    const twips = parseCssLengthToTwips(lh, baseFontHalfPoints);
+    if (typeof twips !== "number") return void 0;
+    return Math.max(1, twips);
+  })();
+  if (typeof before === "number" || typeof after === "number" || typeof lineHeight === "number") {
+    const attrs = [];
+    if (typeof before === "number") attrs.push(`w:before="${Math.max(0, before)}"`);
+    if (typeof after === "number") attrs.push(`w:after="${Math.max(0, after)}"`);
+    if (typeof lineHeight === "number") {
+      attrs.push(`w:line="${lineHeight}"`, 'w:lineRule="exact"');
+    }
+    parts.push(`<w:spacing ${attrs.join(" ")}/>`);
+  }
+  if (!parts.length) return "";
+  return `<w:pPr>${parts.join("")}</w:pPr>`;
+}
+function buildParagraphXmlFromContainer(node, baseStyle, extraInd, pStyleId, result) {
+  const baseFontHalfPoints = baseStyle.fontSizeHalfPoints ?? inferFirstFontSizeHalfPoints(node) ?? 28;
+  const pPrXml = buildParagraphPrXml(node, baseFontHalfPoints, extraInd, pStyleId);
+  const runs = [];
+  const res = result ?? {
+    bodyXml: "",
+    images: []
+  };
+  for (const c of node.children ?? []) collectInlineRuns(c, baseStyle, runs, res);
+  const rXml = [];
+  for (const token of runs) {
+    if (token.kind === "br") {
+      rXml.push("<w:r><w:br/></w:r>");
+      continue;
+    }
+    if (token.kind === "image") {
+      rXml.push(buildImageRunXml(token.image));
+      continue;
+    }
+    const text = token.text;
+    if (!text) continue;
+    if (!text.trim() && !shouldKeepWhitespaceOnlyRun(text)) continue;
+    rXml.push(buildRunXml(token.style, text));
+  }
+  if (!rXml.length) return "";
+  return `<w:p>${pPrXml}${rXml.join("")}</w:p>`;
+}
+var PAGE_BREAK_XML = '<w:p><w:r><w:br w:type="page"/></w:r></w:p>';
+function isExplicitPageBreak(node) {
+  if (node.type !== "tag") return false;
+  const tag = node.name?.toLowerCase();
+  const css = parseStyleAttribute(node.attribs?.style);
+  const cls = node.attribs?.class ?? "";
+  const classList = cls ? cls.split(/\s+/) : [];
+  if (tag === "hr" && classList.includes("page-break")) return true;
+  if (classList.includes("page-break")) return true;
+  if (node.attribs?.["data-page-break"] === "true") return true;
+  const after = css["page-break-after"]?.toLowerCase() ?? css["break-after"]?.toLowerCase();
+  const before = css["page-break-before"]?.toLowerCase() ?? css["break-before"]?.toLowerCase();
+  if (after?.includes("always") || before?.includes("always")) return true;
+  return false;
+}
+function buildListBlocks(listNode, ordered, level, result) {
+  const liNodes = (listNode.children ?? []).filter(
+    (c) => c.type === "tag" && c.name?.toLowerCase() === "li"
+  );
+  if (!liNodes.length) return [];
+  const out = [];
+  const numId = ordered ? 2 : 1;
+  const ilvl = Math.max(0, Math.min(8, Math.floor(level)));
+  const leftTwips = 720 * (ilvl + 1);
+  const hangingTwips = 360;
+  for (const li of liNodes) {
+    const nestedLists = [];
+    const baseStyle = {};
+    const runs = [];
+    for (const c of li.children ?? []) {
+      if (c.type === "tag") {
+        const tag = c.name?.toLowerCase();
+        if (tag === "ul" || tag === "ol") {
+          nestedLists.push(c);
+          continue;
+        }
+      }
+      collectInlineRuns(c, baseStyle, runs, result);
+    }
+    const rXml = [];
+    for (const token of runs) {
+      if (token.kind === "br") {
+        rXml.push("<w:r><w:br/></w:r>");
+        continue;
+      }
+      if (token.kind === "image") {
+        rXml.push(buildImageRunXml(token.image));
+        continue;
+      }
+      const text = token.text;
+      if (!text) continue;
+      if (!text.trim() && !shouldKeepWhitespaceOnlyRun(text)) continue;
+      rXml.push(buildRunXml(token.style, text));
+    }
+    if (rXml.length) {
+      const baseFontHalfPoints = inferFirstFontSizeHalfPoints(li) ?? 28;
+      const pPrXml = buildParagraphPrXml(
+        li,
+        baseFontHalfPoints,
+        { leftTwips, hangingTwips },
+        void 0
+      );
+      const numPrXml = `<w:numPr><w:ilvl w:val="${ilvl}"/><w:numId w:val="${numId}"/></w:numPr>`;
+      const mergedPPrXml = pPrXml ? pPrXml.replace("<w:pPr>", `<w:pPr>${numPrXml}`) : `<w:pPr>${numPrXml}<w:ind w:left="${leftTwips}" w:hanging="${hangingTwips}"/></w:pPr>`;
+      out.push(`<w:p>${mergedPPrXml}${rXml.join("")}</w:p>`);
+    }
+    for (const nested of nestedLists) {
+      const nestedOrdered = nested.name?.toLowerCase() === "ol";
+      out.push(...buildListBlocks(nested, nestedOrdered, ilvl + 1, result));
+    }
+  }
+  return out;
+}
+function parseCellWidthTwips(node) {
+  const css = parseStyleAttribute(node.attribs?.style);
+  const width = parseCssLengthToTwips(css.width, 28);
+  if (typeof width !== "number" || width <= 0) return void 0;
+  return width;
+}
+function estimateTextWidthTwips(text, baseFontHalfPoints) {
+  const basePt = baseFontHalfPoints / 2;
+  const cjkRegex = /[\u3400-\u4dbf\u4e00-\u9fff\u3000-\u303f\uff00-\uffef]/;
+  let cjk = 0;
+  let latin = 0;
+  let spaces = 0;
+  for (const ch of text) {
+    if (ch === " " || ch === "	") {
+      spaces++;
+      continue;
+    }
+    if (cjkRegex.test(ch)) {
+      cjk++;
+      continue;
+    }
+    latin++;
+  }
+  const cjkTwips = Math.round(basePt * 20);
+  const latinTwips = Math.round(basePt * 11);
+  const spaceTwips = Math.round(basePt * 6);
+  return cjk * cjkTwips + latin * latinTwips + spaces * spaceTwips;
+}
+function parseBorderShorthand(value, baseFontHalfPoints) {
+  if (!value) return void 0;
+  const raw = value.trim().toLowerCase();
+  if (!raw) return void 0;
+  if (raw === "none" || raw === "0") return { val: "nil", sz: 0 };
+  const tokens = raw.split(/\s+/).filter(Boolean);
+  if (!tokens.length) return void 0;
+  const css = Object.fromEntries(tokens.map((t, i) => [`${i}`, t]));
+  const widthToken = Object.values(css).find((t) => /^(?:\d+(?:\.\d+)?)(?:px|pt)?$/.test(t));
+  const styleToken = Object.values(css).find(
+    (t) => ["none", "solid", "dashed", "dotted", "double", "hidden"].includes(t)
+  );
+  const colorToken = Object.values(css).find((t) => t.startsWith("#") || t.startsWith("rgb("));
+  const widthTwips = parseCssLengthToTwips(widthToken, baseFontHalfPoints);
+  const sz = (() => {
+    if (typeof widthTwips !== "number") return 4;
+    if (widthTwips <= 0) return 0;
+    return Math.max(2, Math.round(widthTwips * 0.4));
+  })();
+  const val = (() => {
+    if (!styleToken) return "single";
+    if (styleToken === "none" || styleToken === "hidden") return "nil";
+    if (styleToken === "solid") return "single";
+    if (styleToken === "dashed") return "dashed";
+    if (styleToken === "dotted") return "dotted";
+    if (styleToken === "double") return "double";
+    return "single";
+  })();
+  const colorHex = parseCssColorToHex(colorToken);
+  return { val, sz, colorHex };
+}
+function buildBorderTag(tag, border, fallbackColorHex) {
+  const b = border ?? { val: "single", sz: 4, colorHex: fallbackColorHex };
+  const color = (b.colorHex ?? fallbackColorHex).toUpperCase();
+  return `<w:${tag} w:val="${b.val}" w:sz="${b.sz}" w:space="0" w:color="${color}"/>`;
+}
+function injectTableCellParagraphSpacing(pXml) {
+  if (!pXml.includes("<w:p")) return pXml;
+  if (!pXml.includes("<w:p>")) return pXml;
+  const spacingXml = '<w:spacing w:before="0" w:after="0" w:line="360" w:lineRule="auto"/><w:wordWrap w:val="1"/>';
+  if (pXml.includes("<w:pPr>")) {
+    if (pXml.includes("<w:spacing ")) return pXml;
+    return pXml.replace("<w:pPr>", `<w:pPr>${spacingXml}`);
+  }
+  return pXml.replace("<w:p>", `<w:p><w:pPr>${spacingXml}</w:pPr>`);
+}
+function buildTableCellBlocksXml(cell, baseStyle, result) {
+  const children = cell.children ?? [];
+  const hasBlocks = children.some((c) => {
+    if (c.type !== "tag") return false;
+    const tag = c.name?.toLowerCase();
+    return tag === "p" || tag === "ul" || tag === "ol" || tag === "img" || tag === "canvas" || /^h[1-6]$/.test(tag ?? "");
+  });
+  const out = [];
+  if (!hasBlocks) {
+    const p = buildParagraphXmlFromContainer(cell, baseStyle, void 0, void 0, result);
+    if (p) out.push(p);
+    return out.length ? out.map(injectTableCellParagraphSpacing).join("") : "<w:p/>";
+  }
+  for (const c of children) {
+    if (c.type === "tag") {
+      const tag = c.name?.toLowerCase();
+      if (tag === "p") {
+        const p = buildParagraphXmlFromContainer(c, baseStyle, void 0, void 0, result);
+        if (p) out.push(p);
+        continue;
+      }
+      if (tag && /^h[1-6]$/.test(tag)) {
+        const level = Number(tag.slice(1));
+        const p = buildParagraphXmlFromContainer(c, baseStyle, void 0, `Heading${level}`, result);
+        if (p) out.push(p);
+        continue;
+      }
+      if (tag === "ul" || tag === "ol") {
+        out.push(...buildListBlocks(c, tag === "ol", 0, result));
+        continue;
+      }
+      if (tag === "img" || tag === "canvas") {
+        const p = buildParagraphXmlFromSingleInlineNode(c, baseStyle, result);
+        if (p) out.push(p);
+        continue;
+      }
+    }
+  }
+  if (!out.length) return "<w:p/>";
+  return out.map(injectTableCellParagraphSpacing).join("");
+}
+function buildTableXml(tableNode, result) {
+  const rows = [];
+  const stack = [...tableNode.children ?? []];
+  while (stack.length) {
+    const n = stack.shift();
+    if (n.type === "tag" && n.name?.toLowerCase() === "tr") rows.push(n);
+    if (n.children?.length) stack.unshift(...n.children);
+  }
+  const rowCells = rows.map(
+    (tr) => (tr.children ?? []).filter((c) => c.type === "tag" && (c.name === "td" || c.name === "th"))
+  );
+  const colCount = Math.max(0, ...rowCells.map((cells) => cells.length));
+  const maxTableWidthTwips = 9360;
+  const estimatedColWidths = new Array(colCount).fill(0).map((_, i) => {
+    let explicit;
+    let estimated = 0;
+    for (const cells of rowCells) {
+      const cell = cells[i];
+      if (!cell) continue;
+      const w = parseCellWidthTwips(cell);
+      if (typeof w === "number") explicit = explicit ?? w;
+      const text = getTextContent(cell).replace(/\s+/g, " ").trim();
+      if (!text) continue;
+      const baseFontHalfPoints = inferFirstFontSizeHalfPoints(cell) ?? 28;
+      const wTwips = estimateTextWidthTwips(text, baseFontHalfPoints) + 240;
+      estimated = Math.max(estimated, wTwips);
+    }
+    const base = typeof explicit === "number" ? explicit : estimated || Math.round(maxTableWidthTwips / Math.max(1, colCount));
+    return Math.max(720, Math.min(6e3, Math.round(base)));
+  });
+  const normalizedColWidths = (() => {
+    const sum = estimatedColWidths.reduce((a, b) => a + b, 0);
+    if (!sum) return estimatedColWidths;
+    if (sum <= maxTableWidthTwips) return estimatedColWidths;
+    const scaled = estimatedColWidths.map(
+      (w) => Math.max(720, Math.floor(w * maxTableWidthTwips / sum))
+    );
+    const scaledSum = scaled.reduce((a, b) => a + b, 0);
+    const diff = maxTableWidthTwips - scaledSum;
+    if (diff !== 0 && scaled.length) scaled[scaled.length - 1] = Math.max(720, scaled[scaled.length - 1] + diff);
+    return scaled;
+  })();
+  const tblGrid = `<w:tblGrid>${normalizedColWidths.map((w) => `<w:gridCol w:w="${w}"/>`).join("")}</w:tblGrid>`;
+  const rowXml = [];
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const tr = rows[rowIdx];
+    const cells = rowCells[rowIdx] ?? [];
+    const cellXml = [];
+    for (let i = 0; i < cells.length; i++) {
+      const cell = cells[i];
+      const isHeader = cell.name === "th";
+      const baseStyle = isHeader ? { bold: true } : {};
+      const paragraphs = buildTableCellBlocksXml(cell, baseStyle, result);
+      const css = parseStyleAttribute(cell.attribs?.style);
+      const widthTwips = parseCellWidthTwips(cell) ?? normalizedColWidths[i];
+      const tcW = typeof widthTwips === "number" ? `<w:tcW w:w="${widthTwips}" w:type="dxa"/>` : `<w:tcW w:w="0" w:type="auto"/>`;
+      const vAlign = (() => {
+        const v = css["vertical-align"]?.trim().toLowerCase();
+        if (!v) return "";
+        if (v === "middle" || v === "center") return '<w:vAlign w:val="center"/>';
+        if (v === "bottom") return '<w:vAlign w:val="bottom"/>';
+        if (v === "top") return '<w:vAlign w:val="top"/>';
+        return "";
+      })();
+      const shd = (() => {
+        const hex = parseCssColorToHex(css["background-color"]);
+        if (!hex) return "";
+        return `<w:shd w:val="clear" w:color="auto" w:fill="${hex}"/>`;
+      })();
+      const noWrap = (() => {
+        const ws = css["white-space"]?.trim().toLowerCase();
+        if (ws?.includes("nowrap")) return "<w:noWrap/>";
+        return "";
+      })();
+      const cellBorder = (() => {
+        const bAll = parseBorderShorthand(css.border, 28);
+        const bTop = parseBorderShorthand(css["border-top"] ?? css.border, 28);
+        const bLeft = parseBorderShorthand(css["border-left"] ?? css.border, 28);
+        const bBottom = parseBorderShorthand(css["border-bottom"] ?? css.border, 28);
+        const bRight = parseBorderShorthand(css["border-right"] ?? css.border, 28);
+        const any = bAll || css.border || css["border-top"] || css["border-left"] || css["border-bottom"] || css["border-right"];
+        if (!any) return "";
+        const fallback = bAll?.colorHex ?? "D9D9D9";
+        return `<w:tcBorders>${buildBorderTag("top", bTop, fallback)}${buildBorderTag(
+          "left",
+          bLeft,
+          fallback
+        )}${buildBorderTag("bottom", bBottom, fallback)}${buildBorderTag(
+          "right",
+          bRight,
+          fallback
+        )}</w:tcBorders>`;
+      })();
+      cellXml.push(`<w:tc><w:tcPr>${tcW}${vAlign}${shd}${noWrap}${cellBorder}</w:tcPr>${paragraphs}</w:tc>`);
+    }
+    if (cellXml.length) rowXml.push(`<w:tr>${cellXml.join("")}</w:tr>`);
+  }
+  const tblCss = parseStyleAttribute(tableNode.attribs?.style);
+  const tblAlign = (() => {
+    const ml = tblCss["margin-left"]?.trim().toLowerCase();
+    const mr = tblCss["margin-right"]?.trim().toLowerCase();
+    const m = tblCss.margin?.trim().toLowerCase();
+    if (ml === "auto" && mr === "auto" || (m?.includes("auto") ?? false)) return '<w:tblJc w:val="center"/>';
+    const ta = tblCss["text-align"]?.trim().toLowerCase();
+    if (ta === "center") return '<w:tblJc w:val="center"/>';
+    if (ta === "right") return '<w:tblJc w:val="right"/>';
+    return "";
+  })();
+  const tblBorder = (() => {
+    const border = parseBorderShorthand(tblCss.border, 28);
+    if (tblCss.border) {
+      const fallback2 = border?.colorHex ?? "D9D9D9";
+      return `<w:tblBorders>${buildBorderTag("top", border, fallback2)}${buildBorderTag(
+        "left",
+        border,
+        fallback2
+      )}${buildBorderTag("bottom", border, fallback2)}${buildBorderTag(
+        "right",
+        border,
+        fallback2
+      )}${buildBorderTag("insideH", border, fallback2)}${buildBorderTag(
+        "insideV",
+        border,
+        fallback2
+      )}</w:tblBorders>`;
+    }
+    const fallback = "D9D9D9";
+    return `<w:tblBorders>${buildBorderTag("top", void 0, fallback)}${buildBorderTag(
+      "left",
+      void 0,
+      fallback
+    )}${buildBorderTag("bottom", void 0, fallback)}${buildBorderTag(
+      "right",
+      void 0,
+      fallback
+    )}${buildBorderTag("insideH", void 0, fallback)}${buildBorderTag("insideV", void 0, fallback)}</w:tblBorders>`;
+  })();
+  const tblW = `<w:tblW w:w="${normalizedColWidths.reduce((a, b) => a + b, 0)}" w:type="dxa"/>`;
+  const tblPr = `<w:tblPr>${tblW}<w:tblLayout w:type="fixed"/>${tblAlign}${tblBorder}</w:tblPr>`;
+  return `<w:tbl>${tblPr}${tblGrid}${rowXml.join("")}</w:tbl>`;
+}
+function buildParagraphXmlFromSingleInlineNode(node, baseStyle, result) {
+  const wrapper = {
+    type: "tag",
+    name: "p",
+    attribs: { style: "text-align: center;" },
+    children: [node]
+  };
+  return buildParagraphXmlFromContainer(wrapper, baseStyle, void 0, void 0, result);
+}
+function collectBodyBlocks(node, out, result) {
+  if (isSkippableSubtree(node)) return;
+  if (node.type === "tag") {
+    const tag = node.name?.toLowerCase();
+    if (isExplicitPageBreak(node)) {
+      out.push(PAGE_BREAK_XML);
+      return;
+    }
+    if (tag === "p") {
+      const pXml = buildParagraphXmlFromContainer(node, {}, void 0, void 0, result);
+      if (pXml) out.push(pXml);
+      return;
+    }
+    if (tag === "img" || tag === "canvas") {
+      const pXml = buildParagraphXmlFromSingleInlineNode(node, {}, result);
+      if (pXml) out.push(pXml);
+      return;
+    }
+    if (tag && /^h[1-6]$/.test(tag)) {
+      const level = Number(tag.slice(1));
+      const hXml = buildParagraphXmlFromContainer(node, {}, void 0, `Heading${level}`, result);
+      if (hXml) out.push(hXml);
+      return;
+    }
+    if (tag === "table") {
+      const tblXml = buildTableXml(node, result);
+      if (tblXml) out.push(tblXml);
+      return;
+    }
+    if (tag === "ul" || tag === "ol") {
+      out.push(...buildListBlocks(node, tag === "ol", 0, result));
+      return;
+    }
+  }
+  for (const c of node.children ?? []) collectBodyBlocks(c, out, result);
+}
+function textToWordBodyXml(text) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (!normalized.trim()) {
+    throw new Error("Text is empty.");
+  }
+  const lines = normalized.split("\n");
+  const out = [];
+  for (const line of lines) {
+    if (!line) {
+      out.push("<w:p/>");
+      continue;
+    }
+    out.push(`<w:p>${buildRunXml({}, line)}</w:p>`);
+  }
+  return out.join("");
+}
+function htmlToWordBody(html) {
+  const normalized = html.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const doc = parseDocument(normalized, {
+    lowerCaseAttributeNames: true,
+    lowerCaseTags: true,
+    recognizeSelfClosing: true
+  });
+  const result = { bodyXml: "", images: [] };
+  const out = [];
+  collectBodyBlocks(doc, out, result);
+  result.bodyXml = out.join("");
+  return result;
+}
+function htmlToWordBodyXml(html) {
+  const { bodyXml } = htmlToWordBody(html);
+  if (!bodyXml) {
+    const text = getTextContent(
+      parseDocument(html, {
+        lowerCaseAttributeNames: true,
+        lowerCaseTags: true,
+        recognizeSelfClosing: true
+      })
+    );
+    return textToWordBodyXml(text);
+  }
+  return bodyXml;
+}
+function htmlToWordBodyWithAssets(html) {
+  const result = htmlToWordBody(html);
+  if (!result.bodyXml) {
+    const text = getTextContent(
+      parseDocument(html, {
+        lowerCaseAttributeNames: true,
+        lowerCaseTags: true,
+        recognizeSelfClosing: true
+      })
+    );
+    return { bodyXml: textToWordBodyXml(text), images: [] };
+  }
+  return result;
+}
+export {
+  htmlToWordBodyWithAssets,
+  htmlToWordBodyXml,
+  textToWordBodyXml
+};
+//# sourceMappingURL=htmlToWordBodyXml-LY6DZSTW.js.map