@yinyoudexing/xml2word 0.1.0

package/dist/index.cjs

@@ -0,0 +1,653 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/lib/normalizeDocumentXml.ts
+function hasWordDocumentRoot(xml) {
+  return /<w:document[\s>]/.test(xml);
+}
+function ensureXmlDeclaration(xml) {
+  if (/^\s*<\?xml\b/.test(xml)) return xml;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${xml}`;
+}
+function wrapBodyXml(bodyXml) {
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+>
+  <w:body>
+${bodyXml}
+    <w:sectPr>
+      <w:pgSz w:w="12240" w:h="15840"/>
+      <w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="708" w:footer="708" w:gutter="0"/>
+      <w:cols w:space="708"/>
+      <w:docGrid w:linePitch="360"/>
+    </w:sectPr>
+  </w:body>
+</w:document>
+`;
+  return xml;
+}
+function ensureWordNamespace(xml) {
+  const hasWNamespace = /xmlns:w\s*=\s*["']http:\/\/schemas\.openxmlformats\.org\/wordprocessingml\/2006\/main["']/.test(
+    xml
+  );
+  if (hasWNamespace) return xml;
+  return xml.replace(
+    /<w:document\b/,
+    `<w:document xmlns:w="${WORD_MAIN_NS}"`
+  );
+}
+function normalizeDocumentXml(xml, inputKind) {
+  const trimmed = xml.trim();
+  if (!trimmed) {
+    throw new Error("XML is empty.");
+  }
+  if (inputKind === "document") {
+    const withDecl = ensureXmlDeclaration(trimmed);
+    const withNs = ensureWordNamespace(withDecl);
+    if (!hasWordDocumentRoot(withNs)) {
+      throw new Error('inputKind="document" requires a <w:document> root.');
+    }
+    return withNs;
+  }
+  if (inputKind === "body") {
+    return wrapBodyXml(trimmed);
+  }
+  if (hasWordDocumentRoot(trimmed)) {
+    const withDecl = ensureXmlDeclaration(trimmed);
+    return ensureWordNamespace(withDecl);
+  }
+  return wrapBodyXml(trimmed);
+}
+var WORD_MAIN_NS;
+var init_normalizeDocumentXml = __esm({
+  "src/lib/normalizeDocumentXml.ts"() {
+    "use strict";
+    WORD_MAIN_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  }
+});
+
+// src/lib/validateXml.ts
+function validateXmlIfNeeded(xml, validateXml) {
+  if (!validateXml) return;
+  const result = import_fast_xml_parser.XMLValidator.validate(xml);
+  if (result === true) return;
+  const err = result.err;
+  const msg = err?.msg ?? "Invalid XML.";
+  const line = err?.line;
+  const col = err?.col;
+  const location = typeof line === "number" && typeof col === "number" ? ` (line ${line}, col ${col})` : "";
+  throw new Error(`${msg}${location}`);
+}
+var import_fast_xml_parser;
+var init_validateXml = __esm({
+  "src/lib/validateXml.ts"() {
+    "use strict";
+    import_fast_xml_parser = require("fast-xml-parser");
+  }
+});
+
+// src/lib/createDocxZip.ts
+var createDocxZip_exports = {};
+__export(createDocxZip_exports, {
+  createDocxZipUint8Array: () => createDocxZipUint8Array
+});
+async function createDocxZipUint8Array(xml, options = {}) {
+  const documentXml = normalizeDocumentXml(xml, options.inputKind ?? "auto");
+  validateXmlIfNeeded(documentXml, options.validateXml ?? true);
+  const zip = new import_jszip.default();
+  zip.file("[Content_Types].xml", CONTENT_TYPES_XML);
+  const relsFolder = zip.folder("_rels");
+  relsFolder?.file(".rels", ROOT_RELS_XML);
+  const wordFolder = zip.folder("word");
+  wordFolder?.file("document.xml", documentXml);
+  return zip.generateAsync({ type: "uint8array" });
+}
+var import_jszip, CONTENT_TYPES_XML, ROOT_RELS_XML;
+var init_createDocxZip = __esm({
+  "src/lib/createDocxZip.ts"() {
+    "use strict";
+    import_jszip = __toESM(require("jszip"), 1);
+    init_normalizeDocumentXml();
+    init_validateXml();
+    CONTENT_TYPES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+</Types>
+`;
+    ROOT_RELS_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1"
+    Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+    Target="word/document.xml"/>
+</Relationships>
+`;
+  }
+});
+
+// src/lib/htmlToWordBodyXml.ts
+var htmlToWordBodyXml_exports = {};
+__export(htmlToWordBodyXml_exports, {
+  htmlToWordBodyXml: () => htmlToWordBodyXml,
+  textToWordBodyXml: () => textToWordBodyXml
+});
+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 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;
+}
+function collectInlineRuns(node, inherited, out) {
+  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;
+    }
+    const next = mergeTextStyle(inherited, styleFromElement(node));
+    const children2 = node.children ?? [];
+    for (const c of children2) collectInlineRuns(c, next, out);
+    return;
+  }
+  const children = node.children ?? [];
+  for (const c of children) collectInlineRuns(c, inherited, out);
+}
+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 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" || tag === "canvas") 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) {
+  const css = parseStyleAttribute(node.attribs?.style);
+  const parts = [];
+  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) {
+  const baseFontHalfPoints = baseStyle.fontSizeHalfPoints ?? inferFirstFontSizeHalfPoints(node) ?? 28;
+  const pPrXml = buildParagraphPrXml(node, baseFontHalfPoints, extraInd);
+  const runs = [];
+  for (const c of node.children ?? []) collectInlineRuns(c, baseStyle, runs);
+  const rXml = [];
+  for (const token of runs) {
+    if (token.kind === "br") {
+      rXml.push("<w:r><w:br/></w:r>");
+      continue;
+    }
+    const text = token.text;
+    if (!text) continue;
+    if (!text.trim()) continue;
+    rXml.push(buildRunXml(token.style, text));
+  }
+  if (!rXml.length) return "";
+  return `<w:p>${pPrXml}${rXml.join("")}</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 buildHeadingBaseStyle(level) {
+  const size = level === 1 ? 44 : level === 2 ? 32 : level === 3 ? 28 : level === 4 ? 24 : 22;
+  return { bold: true, fontSizeHalfPoints: size };
+}
+function buildListBlocks(listNode, ordered) {
+  const items = [];
+  const stack = [...listNode.children ?? []];
+  while (stack.length) {
+    const n = stack.shift();
+    if (n.type === "tag" && n.name?.toLowerCase() === "li") items.push(n);
+  }
+  const out = [];
+  for (let i = 0; i < items.length; i++) {
+    const prefix = ordered ? `${i + 1}. ` : "\u2022 ";
+    const li = items[i];
+    const baseStyle = {};
+    const runs = [];
+    runs.push({ kind: "text", text: prefix, style: baseStyle });
+    for (const c of li.children ?? []) collectInlineRuns(c, baseStyle, runs);
+    const rXml = [];
+    for (const token of runs) {
+      if (token.kind === "br") {
+        rXml.push("<w:r><w:br/></w:r>");
+        continue;
+      }
+      const text = token.text;
+      if (!text) continue;
+      if (!text.trim()) continue;
+      rXml.push(buildRunXml(token.style, text));
+    }
+    if (!rXml.length) continue;
+    const pPrXml = buildParagraphPrXml(li, inferFirstFontSizeHalfPoints(li) ?? 28, {
+      leftTwips: 720,
+      hangingTwips: 360
+    });
+    out.push(`<w:p>${pPrXml}${rXml.join("")}</w:p>`);
+  }
+  return out;
+}
+function buildTableXml(tableNode) {
+  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 rowXml = [];
+  for (const tr of rows) {
+    const cells = (tr.children ?? []).filter(
+      (c) => c.type === "tag" && (c.name === "td" || c.name === "th")
+    );
+    const cellXml = [];
+    for (const cell of cells) {
+      const isHeader = cell.name === "th";
+      const baseStyle = isHeader ? { bold: true } : {};
+      const pXml = buildParagraphXmlFromContainer(cell, baseStyle);
+      const paragraphs = pXml ? pXml : "<w:p/>";
+      cellXml.push(
+        `<w:tc><w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>${paragraphs}</w:tc>`
+      );
+    }
+    if (cellXml.length) rowXml.push(`<w:tr>${cellXml.join("")}</w:tr>`);
+  }
+  const tblPr = `<w:tblPr><w:tblW w:w="0" w:type="auto"/><w:tblBorders><w:top w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/><w:left w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/><w:bottom w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/><w:right w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/><w:insideH w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/><w:insideV w:val="single" w:sz="4" w:space="0" w:color="D9D9D9"/></w:tblBorders></w:tblPr>`;
+  const tblGrid = `<w:tblGrid/>`;
+  return `<w:tbl>${tblPr}${tblGrid}${rowXml.join("")}</w:tbl>`;
+}
+function collectBodyBlocks(node, out) {
+  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, {});
+      if (pXml) out.push(pXml);
+      return;
+    }
+    if (tag && /^h[1-6]$/.test(tag)) {
+      const level = Number(tag.slice(1));
+      const hXml = buildParagraphXmlFromContainer(node, buildHeadingBaseStyle(level));
+      if (hXml) out.push(hXml);
+      return;
+    }
+    if (tag === "table") {
+      const tblXml = buildTableXml(node);
+      if (tblXml) out.push(tblXml);
+      return;
+    }
+    if (tag === "ul" || tag === "ol") {
+      out.push(...buildListBlocks(node, tag === "ol"));
+      return;
+    }
+  }
+  for (const c of node.children ?? []) collectBodyBlocks(c, out);
+}
+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 htmlToWordBodyXml(html) {
+  const normalized = html.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const doc = (0, import_htmlparser2.parseDocument)(normalized, {
+    lowerCaseAttributeNames: true,
+    lowerCaseTags: true,
+    recognizeSelfClosing: true
+  });
+  const out = [];
+  collectBodyBlocks(doc, out);
+  if (!out.length) {
+    const text = getTextContent(doc);
+    return textToWordBodyXml(text);
+  }
+  return out.join("");
+}
+var import_htmlparser2, PAGE_BREAK_XML;
+var init_htmlToWordBodyXml = __esm({
+  "src/lib/htmlToWordBodyXml.ts"() {
+    "use strict";
+    import_htmlparser2 = require("htmlparser2");
+    PAGE_BREAK_XML = '<w:p><w:r><w:br w:type="page"/></w:r></w:p>';
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  htmlToDocxBlob: () => htmlToDocxBlob,
+  htmlToDocxBuffer: () => htmlToDocxBuffer,
+  htmlToDocxUint8Array: () => htmlToDocxUint8Array,
+  xmlToDocxBlob: () => xmlToDocxBlob,
+  xmlToDocxBuffer: () => xmlToDocxBuffer,
+  xmlToDocxUint8Array: () => xmlToDocxUint8Array
+});
+module.exports = __toCommonJS(index_exports);
+function looksLikeHtml(input) {
+  const s = input.trim();
+  if (!s) return false;
+  if (!s.includes("<") || !s.includes(">")) return false;
+  return /<\/?[a-zA-Z][\s\S]*?>/.test(s);
+}
+async function xmlToDocxUint8Array(xml, options = {}) {
+  const { createDocxZipUint8Array: createDocxZipUint8Array2 } = await Promise.resolve().then(() => (init_createDocxZip(), createDocxZip_exports));
+  return createDocxZipUint8Array2(xml, options);
+}
+async function xmlToDocxBlob(xml, options = {}) {
+  const docx = await xmlToDocxUint8Array(xml, options);
+  const bytes = new Uint8Array(docx);
+  return new Blob([bytes], {
+    type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  });
+}
+async function xmlToDocxBuffer(xml, options = {}) {
+  const docx = await xmlToDocxUint8Array(xml, options);
+  const BufferCtor = globalThis.Buffer;
+  if (!BufferCtor) {
+    throw new Error("Buffer is not available. Use xmlToDocxUint8Array or xmlToDocxBlob instead.");
+  }
+  return BufferCtor.from(docx);
+}
+async function htmlToDocxUint8Array(html, options = {}) {
+  const { htmlToWordBodyXml: htmlToWordBodyXml2, textToWordBodyXml: textToWordBodyXml2 } = await Promise.resolve().then(() => (init_htmlToWordBodyXml(), htmlToWordBodyXml_exports));
+  const format = options.inputFormat ?? "auto";
+  const bodyXml = format === "html" ? htmlToWordBodyXml2(html) : format === "text" ? textToWordBodyXml2(html) : looksLikeHtml(html) ? htmlToWordBodyXml2(html) : textToWordBodyXml2(html);
+  return xmlToDocxUint8Array(bodyXml, {
+    inputKind: "body",
+    validateXml: options.validateXml
+  });
+}
+async function htmlToDocxBlob(html, options = {}) {
+  const docx = await htmlToDocxUint8Array(html, options);
+  const bytes = new Uint8Array(docx);
+  return new Blob([bytes], {
+    type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  });
+}
+async function htmlToDocxBuffer(html, options = {}) {
+  const docx = await htmlToDocxUint8Array(html, options);
+  const BufferCtor = globalThis.Buffer;
+  if (!BufferCtor) {
+    throw new Error("Buffer is not available. Use htmlToDocxUint8Array or htmlToDocxBlob instead.");
+  }
+  return BufferCtor.from(docx);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  htmlToDocxBlob,
+  htmlToDocxBuffer,
+  htmlToDocxUint8Array,
+  xmlToDocxBlob,
+  xmlToDocxBuffer,
+  xmlToDocxUint8Array
+});
+//# sourceMappingURL=index.cjs.map