@windoc/core 0.3.24 → 0.3.26

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.3.24";
+var version = "0.3.26";
 
 // src/dataset/enum/Common.ts
 var MaxHeightRatio = /* @__PURE__ */ ((MaxHeightRatio2) => {
@@ -177,6 +177,13 @@ function downloadFile(href, fileName) {
   a.download = fileName;
   a.click();
 }
+function downloadBlob(blob, fileName) {
+  const href = URL.createObjectURL(blob);
+  downloadFile(href, fileName);
+  window.setTimeout(() => {
+    URL.revokeObjectURL(href);
+  }, 0);
+}
 function threeClick(dom, fn) {
   nClickEvent(3, dom, fn);
 }
@@ -3802,23 +3809,23 @@ var ListStyle = /* @__PURE__ */ ((ListStyle3) => {
   ListStyle3["CHECKBOX"] = "checkbox" /* CHECKBOX */;
   return ListStyle3;
 })(ListStyle || {});
-var OlPreset = /* @__PURE__ */ ((OlPreset2) => {
-  OlPreset2["DEFAULT"] = "olDefault";
-  OlPreset2["PARENTHESIS"] = "olParen";
-  OlPreset2["OUTLINE"] = "olOutline";
-  OlPreset2["UPPER_ALPHA"] = "olUpperA";
-  OlPreset2["ROMAN"] = "olRoman";
-  OlPreset2["ZERO_PAD"] = "olZeroPad";
-  return OlPreset2;
+var OlPreset = /* @__PURE__ */ ((OlPreset3) => {
+  OlPreset3["DEFAULT"] = "olDefault";
+  OlPreset3["PARENTHESIS"] = "olParen";
+  OlPreset3["OUTLINE"] = "olOutline";
+  OlPreset3["UPPER_ALPHA"] = "olUpperA";
+  OlPreset3["ROMAN"] = "olRoman";
+  OlPreset3["ZERO_PAD"] = "olZeroPad";
+  return OlPreset3;
 })(OlPreset || {});
-var UlPreset = /* @__PURE__ */ ((UlPreset2) => {
-  UlPreset2["DEFAULT"] = "ulDefault";
-  UlPreset2["DIAMOND"] = "ulDiamond";
-  UlPreset2["HOLLOW_SQ"] = "ulHollowSq";
-  UlPreset2["ARROW"] = "ulArrow";
-  UlPreset2["STAR"] = "ulStar";
-  UlPreset2["CHECK_ARROW"] = "ulCheckArr";
-  return UlPreset2;
+var UlPreset = /* @__PURE__ */ ((UlPreset3) => {
+  UlPreset3["DEFAULT"] = "ulDefault";
+  UlPreset3["DIAMOND"] = "ulDiamond";
+  UlPreset3["HOLLOW_SQ"] = "ulHollowSq";
+  UlPreset3["ARROW"] = "ulArrow";
+  UlPreset3["STAR"] = "ulStar";
+  UlPreset3["CHECK_ARROW"] = "ulCheckArr";
+  return UlPreset3;
 })(UlPreset || {});
 
 // src/dataset/constant/List.ts
@@ -24258,6 +24265,8 @@ var Command = class {
     this.executeSearchNavigateNext = adapt.searchNavigateNext.bind(adapt);
     this.executeReplace = adapt.replace.bind(adapt);
     this.executePrint = adapt.print.bind(adapt);
+    this.executeExportDocx = adapt.exportDocx.bind(adapt);
+    this.executeExportPdf = adapt.exportPdf.bind(adapt);
     this.executeReplaceImageElement = adapt.replaceImageElement.bind(adapt);
     this.executeSaveAsImageElement = adapt.saveAsImageElement.bind(adapt);
     this.executeSetImageCrop = adapt.setImageCrop.bind(adapt);
@@ -24338,172 +24347,3344 @@ var Command = class {
   }
 };
 
-// src/utils/print.ts
-function convertPxToPaperSize(width, height) {
-  if (width === 1125 && height === 1593) {
-    return {
-      size: "a3",
-      width: "297mm",
-      height: "420mm"
-    };
-  }
-  if (width === 794 && height === 1123) {
-    return {
-      size: "a4",
-      width: "210mm",
-      height: "297mm"
-    };
-  }
-  if (width === 565 && height === 796) {
-    return {
-      size: "a5",
-      width: "148mm",
-      height: "210mm"
-    };
-  }
+// src/utils/docx.ts
+import {
+  AlignmentType,
+  BorderStyle,
+  ColumnBreak,
+  Document as Document2,
+  ExternalHyperlink,
+  Footer as Footer2,
+  Header as Header2,
+  HeadingLevel,
+  ImageRun,
+  LevelFormat,
+  LineRuleType,
+  Packer,
+  PageBreak,
+  PageNumber as PageNumber2,
+  PageOrientation,
+  Paragraph,
+  ShadingType,
+  Table,
+  TableCell,
+  TableLayoutType,
+  TableRow,
+  TextRun,
+  UnderlineType,
+  VerticalAlign as DocxVerticalAlign,
+  WidthType
+} from "docx";
+var DEFAULT_DOCX_FILE_NAME = "document.docx";
+var DEFAULT_IMAGE_WIDTH = 320;
+var DEFAULT_IMAGE_HEIGHT = 180;
+var DEFAULT_LINE_HEIGHT = 1.15;
+var DOCX_FOOTER_TEXT_COLOR = "#000000";
+var docxBulletCharMap = {
+  ["disc" /* DISC */]: "\u2022",
+  ["circle" /* CIRCLE */]: "\u25E6",
+  ["square" /* SQUARE */]: "\u25A0",
+  ["checkbox" /* CHECKBOX */]: "\u2611"
+};
+var titleHeadingMap = {
+  ["first" /* FIRST */]: HeadingLevel.HEADING_1,
+  ["second" /* SECOND */]: HeadingLevel.HEADING_2,
+  ["third" /* THIRD */]: HeadingLevel.HEADING_3,
+  ["fourth" /* FOURTH */]: HeadingLevel.HEADING_4,
+  ["fifth" /* FIFTH */]: HeadingLevel.HEADING_5,
+  ["sixth" /* SIXTH */]: HeadingLevel.HEADING_6
+};
+var orderedStyleFormatMap = {
+  ["decimal" /* DECIMAL */]: LevelFormat.DECIMAL,
+  ["lowerAlpha" /* LOWER_ALPHA */]: LevelFormat.LOWER_LETTER,
+  ["upperAlpha" /* UPPER_ALPHA */]: LevelFormat.UPPER_LETTER,
+  ["lowerRoman" /* LOWER_ROMAN */]: LevelFormat.LOWER_ROMAN,
+  ["upperRoman" /* UPPER_ROMAN */]: LevelFormat.UPPER_ROMAN,
+  ["decimalParen" /* DECIMAL_PAREN */]: LevelFormat.DECIMAL,
+  decimalZero: LevelFormat.DECIMAL_ZERO,
+  lowerAlphaParen: LevelFormat.LOWER_LETTER,
+  lowerRomanParen: LevelFormat.LOWER_ROMAN,
+  outline: LevelFormat.DECIMAL
+};
+async function exportEditorDataToDocx(payload, options = {}) {
+  const fileName = normalizeDocxFileName(options.fileName);
+  const file = await createDocxDocument(payload);
+  const blob = await Packer.toBlob(file);
   return {
-    size: "",
-    width: `${width}px`,
-    height: `${height}px`
+    blob,
+    fileName
   };
 }
-function printImageBase64(base64List, options) {
-  const { width, height, direction = "vertical" /* VERTICAL */ } = options;
-  const iframe = document.createElement("iframe");
-  iframe.style.visibility = "hidden";
-  iframe.style.position = "absolute";
-  iframe.style.left = "0";
-  iframe.style.top = "0";
-  iframe.style.width = "0";
-  iframe.style.height = "0";
-  iframe.style.border = "none";
-  document.body.append(iframe);
-  const contentWindow = iframe.contentWindow;
-  const doc = contentWindow.document;
-  doc.open();
-  const container = document.createElement("div");
-  const paperSize = convertPxToPaperSize(width, height);
-  base64List.forEach((base64) => {
-    const image = document.createElement("img");
-    image.style.width = direction === "horizontal" /* HORIZONTAL */ ? paperSize.height : paperSize.width;
-    image.style.height = direction === "horizontal" /* HORIZONTAL */ ? paperSize.width : paperSize.height;
-    image.src = base64;
-    container.append(image);
-  });
-  const style = document.createElement("style");
-  const stylesheet = `
-  * {
-    margin: 0;
-    padding: 0;
+async function createDocxDocument(payload) {
+  const { data: data2, options } = payload;
+  const editorOptions = options;
+  const context = createSerializeContext();
+  const headerChildren = editorOptions.header.disabled ? [] : await serializeElementList(data2.header || [], editorOptions, context);
+  const docxFooterElementList = forceDocxFooterTextColor(data2.footer || []);
+  const footerChildren = editorOptions.footer.disabled ? [] : await serializeElementList(
+    docxFooterElementList,
+    editorOptions,
+    context
+  );
+  const pageNumberParagraph = createPageNumberParagraph(
+    {
+      ...editorOptions.pageNumber,
+      color: DOCX_FOOTER_TEXT_COLOR
+    }
+  );
+  if (pageNumberParagraph) {
+    footerChildren.push(pageNumberParagraph);
   }
-  @page {
-    margin: 0;
-    size: ${paperSize.size} ${direction === "horizontal" /* HORIZONTAL */ ? `landscape` : `portrait`};
-  }`;
-  style.append(document.createTextNode(stylesheet));
-  setTimeout(() => {
-    doc.write(`${style.outerHTML}${container.innerHTML}`);
-    contentWindow.print();
-    doc.close();
-    window.addEventListener(
-      "mouseover",
-      () => {
-        iframe?.remove();
-      },
+  const sectionChildren = await serializeElementList(
+    data2.main,
+    editorOptions,
+    context
+  );
+  const { width, height, paperDirection } = editorOptions;
+  const pageWidth = paperDirection === "horizontal" /* HORIZONTAL */ ? height : width;
+  const pageHeight = paperDirection === "horizontal" /* HORIZONTAL */ ? width : height;
+  return new Document2({
+    features: {
+      updateFields: true
+    },
+    numbering: {
+      config: createNumberingConfig()
+    },
+    sections: [
       {
-        once: true
+        properties: {
+          page: {
+            size: {
+              width: pxToTwips(pageWidth),
+              height: pxToTwips(pageHeight),
+              orientation: paperDirection === "horizontal" /* HORIZONTAL */ ? PageOrientation.LANDSCAPE : PageOrientation.PORTRAIT
+            },
+            margin: {
+              top: pxToTwips(editorOptions.margins[0]),
+              right: pxToTwips(editorOptions.margins[1]),
+              bottom: pxToTwips(editorOptions.margins[2]),
+              left: pxToTwips(editorOptions.margins[3]),
+              header: pxToTwips(editorOptions.header.top),
+              footer: pxToTwips(editorOptions.footer.bottom)
+            },
+            pageNumbers: !editorOptions.pageNumber.disabled && editorOptions.pageNumber.fromPageNo === 0 ? {
+              start: editorOptions.pageNumber.startPageNo
+            } : void 0
+          }
+        },
+        headers: headerChildren.length > 0 ? {
+          default: new Header2({
+            children: headerChildren
+          })
+        } : void 0,
+        footers: footerChildren.length > 0 ? {
+          default: new Footer2({
+            children: footerChildren
+          })
+        } : void 0,
+        children: sectionChildren.length ? sectionChildren : [new Paragraph({})]
       }
-    );
+    ]
   });
 }
-
-// src/core/command/CommandAdapt.ts
-var CommandAdapt = class {
-  constructor(draw) {
-    this.draw = draw;
-    this.range = draw.getRange();
-    this.position = draw.getPosition();
-    this.historyManager = draw.getHistoryManager();
-    this.canvasEvent = draw.getCanvasEvent();
-    this.options = draw.getOptions();
-    this.control = draw.getControl();
-    this.workerManager = draw.getWorkerManager();
-    this.searchManager = draw.getSearch();
-    this.i18n = draw.getI18n();
-    this.zone = draw.getZone();
-    this.tableOperate = draw.getTableOperate();
+async function serializeElementList(elementList, options, context) {
+  const blocks = [];
+  let inlineBuffer = [];
+  const flushInlineBuffer = async () => {
+    if (!inlineBuffer.length) return;
+    blocks.push(
+      ...await serializeInlineElements(inlineBuffer, options, context)
+    );
+    inlineBuffer = [];
+  };
+  for (let i = 0; i < elementList.length; i++) {
+    const element = elementList[i];
+    if (element.type === "area" /* AREA */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(
+        ...await serializeElementList(element.valueList, options, context)
+      );
+      continue;
+    }
+    if (element.type === "title" /* TITLE */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(
+        ...await serializeInlineElements(element.valueList, options, context, {
+          heading: titleHeadingMap[element.level || "first" /* FIRST */]
+        })
+      );
+      continue;
+    }
+    if (element.type === "list" /* LIST */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(...await serializeListElement(element, options, context));
+      continue;
+    }
+    if (element.type === "table" /* TABLE */ && element.trList?.length) {
+      await flushInlineBuffer();
+      blocks.push(await serializeTableElement(element, options, context));
+      continue;
+    }
+    if (element.type === "pageBreak" /* PAGE_BREAK */) {
+      await flushInlineBuffer();
+      blocks.push(
+        new Paragraph({
+          children: [new PageBreak()]
+        })
+      );
+      continue;
+    }
+    if (element.type === "separator" /* SEPARATOR */) {
+      await flushInlineBuffer();
+      blocks.push(
+        new Paragraph({
+          thematicBreak: true
+        })
+      );
+      continue;
+    }
+    if (element.type === "image" /* IMAGE */ && element.imgDisplay && element.imgDisplay !== "inline") {
+      await flushInlineBuffer();
+      blocks.push(...await serializeInlineElements([element], options));
+      continue;
+    }
+    if (element.type === "block" /* BLOCK */) {
+      await flushInlineBuffer();
+      const blockText = getBlockFallbackText(element);
+      if (blockText) {
+        blocks.push(
+          ...await serializeInlineElements(
+            [{ value: blockText }],
+            options,
+            context
+          )
+        );
+      }
+      continue;
+    }
+    inlineBuffer.push(element);
   }
-  getStyleSelectionElementList(options = {}) {
-    const selection = this.range.getSelectionElementList();
-    if (!selection?.length) return null;
-    const { textLikeOnly = false } = options;
-    const result = [];
-    const collect = (elementList) => {
-      for (let i = 0; i < elementList.length; i++) {
-        const element = elementList[i];
-        if (element.type === "table" /* TABLE */ && element.trList?.length) {
-          for (let t = 0; t < element.trList.length; t++) {
-            const tr = element.trList[t];
-            for (let d = 0; d < tr.tdList.length; d++) {
-              collect(tr.tdList[d].value);
-            }
-          }
-          continue;
+  await flushInlineBuffer();
+  return blocks;
+}
+async function serializeInlineElements(elementList, options, _context, overrides = {}) {
+  const paragraphs = [];
+  let current = null;
+  const getParagraphContext = (element) => ({
+    heading: overrides.heading,
+    numbering: overrides.numbering,
+    alignment: overrides.alignment !== void 0 ? overrides.alignment : mapRowFlexToAlignment(element?.rowFlex),
+    rowMargin: overrides.rowMargin !== void 0 ? overrides.rowMargin : element?.rowMargin
+  });
+  const flushParagraph = (context) => {
+    if (!current) {
+      if (!context) return;
+      paragraphs.push(createParagraph([], context, options.defaultRowMargin));
+      return;
+    }
+    paragraphs.push(
+      createParagraph(
+        current.children,
+        current.context,
+        options.defaultRowMargin
+      )
+    );
+    current = null;
+  };
+  const ensureParagraph = (element) => {
+    if (!current) {
+      current = {
+        children: [],
+        context: getParagraphContext(element)
+      };
+    }
+    return current;
+  };
+  const appendText = (element, text, childFactory, preserveTrailingBreak = false) => {
+    const normalized = normalizeText(text);
+    const parts = normalized.split("\n");
+    let lastSeparatorFlushedContent = false;
+    for (let i = 0; i < parts.length; i++) {
+      const segment = parts[i];
+      if (segment) {
+        ensureParagraph(element).children.push(childFactory(segment));
+      }
+      if (i < parts.length - 1) {
+        if (!current) {
+          paragraphs.push(
+            createParagraph(
+              [],
+              getParagraphContext(element),
+              options.defaultRowMargin
+            )
+          );
+          lastSeparatorFlushedContent = false;
+        } else {
+          flushParagraph();
+          lastSeparatorFlushedContent = true;
         }
-        result.push(element);
       }
-    };
-    collect(selection);
-    if (!textLikeOnly) {
-      return result;
     }
-    return result.filter(
-      (element) => isTextLikeElement(element) || element.type === "label" /* LABEL */
+    if (preserveTrailingBreak && normalized.endsWith("\n") && lastSeparatorFlushedContent) {
+      paragraphs.push(
+        createParagraph(
+          [],
+          getParagraphContext(element),
+          options.defaultRowMargin
+        )
+      );
+    }
+  };
+  for (let i = 0; i < elementList.length; i++) {
+    const element = elementList[i];
+    if (element.type === "hyperlink" /* HYPERLINK */ && element.valueList?.length) {
+      const hyperlink = await createHyperlinkChild(element, options);
+      if (hyperlink) {
+        ensureParagraph(element).children.push(hyperlink);
+      }
+      continue;
+    }
+    if (element.type === "image" /* IMAGE */) {
+      const imageChild = await createImageChild(element);
+      if (!imageChild) {
+        appendText(
+          element,
+          "[Image unavailable]",
+          (segment) => createTextRun(
+            segment,
+            element,
+            options.defaultSize,
+            options.defaultFont
+          ),
+          i === elementList.length - 1
+        );
+        continue;
+      }
+      ensureParagraph(element).children.push(imageChild);
+      continue;
+    }
+    if (element.type === "columnBreak" /* COLUMN_BREAK */) {
+      ensureParagraph(element).children.push(new ColumnBreak());
+      continue;
+    }
+    if (element.type === "tab" /* TAB */) {
+      appendText(
+        element,
+        "	",
+        (segment) => createTextRun(
+          segment,
+          element,
+          options.defaultSize,
+          options.defaultFont
+        ),
+        i === elementList.length - 1
+      );
+      continue;
+    }
+    const textValue = getInlineElementText(element);
+    if (!textValue) {
+      continue;
+    }
+    appendText(
+      element,
+      textValue,
+      (segment) => createTextRun(
+        segment,
+        element,
+        options.defaultSize,
+        options.defaultFont
+      ),
+      i === elementList.length - 1
     );
   }
-  mode(payload) {
-    this.draw.setMode(payload);
+  if (current) {
+    flushParagraph();
   }
-  async cut() {
-    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
-    if (isDisabled) return;
-    await this.canvasEvent.cut();
+  return paragraphs.length ? paragraphs : [createParagraph([], overrides, options.defaultRowMargin)];
+}
+async function serializeListElement(element, options, context) {
+  const zipList = zipElementList(element.valueList || []);
+  const listItemMap = splitListElement(zipList);
+  const paragraphs = [];
+  const listInstance = createListInstance(context);
+  for (const listItemElements of listItemMap.values()) {
+    const numbering = getListNumbering(
+      getListItemNumberingElement(listItemElements, element),
+      listInstance
+    );
+    paragraphs.push(
+      ...await serializeInlineElements(listItemElements, options, context, {
+        numbering
+      })
+    );
   }
-  async copy(payload) {
-    await this.canvasEvent.copy(payload);
+  return paragraphs;
+}
+async function serializeTableElement(element, options, context) {
+  const rows = [];
+  const trList = element.trList || [];
+  const tableContext = createTableSerializeContext(element);
+  for (let i = 0; i < trList.length; i++) {
+    rows.push(
+      await serializeTableRow(trList[i], options, context, tableContext)
+    );
   }
-  paste(payload) {
-    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
-    if (isDisabled) return;
-    pasteByApi(this.canvasEvent, payload);
+  const tableWidth = getTableWidthFromColgroup(element.colgroup);
+  return new Table({
+    rows,
+    width: tableWidth ? {
+      size: pxToTwips(tableWidth),
+      type: WidthType.DXA
+    } : {
+      size: 100,
+      type: WidthType.PERCENTAGE
+    },
+    columnWidths: element.colgroup?.map((col) => pxToTwips(col.width)),
+    layout: TableLayoutType.FIXED,
+    borders: createTableBorders(element)
+  });
+}
+async function serializeTableRow(tr, options, context, tableContext) {
+  const children = [];
+  for (let i = 0; i < tr.tdList.length; i++) {
+    children.push(
+      await serializeTableCell(tr.tdList[i], options, context, tableContext)
+    );
   }
-  selectAll() {
-    this.canvasEvent.selectAll();
+  return new TableRow({
+    children
+  });
+}
+async function serializeTableCell(td, options, context, tableContext) {
+  const children = await serializeElementList(td.value, options, context);
+  const shadingFill = td.backgroundColor ? normalizeHexColor(td.backgroundColor) : void 0;
+  const cellWidth = tableContext.cellLayoutMap.get(td)?.width || td.width;
+  return new TableCell({
+    children: children.length ? children : [new Paragraph({})],
+    columnSpan: td.colspan > 1 ? td.colspan : void 0,
+    rowSpan: td.rowspan > 1 ? td.rowspan : void 0,
+    verticalAlign: mapCellVerticalAlign(td.verticalAlign),
+    width: cellWidth ? {
+      size: pxToTwips(cellWidth),
+      type: WidthType.DXA
+    } : void 0,
+    shading: shadingFill ? {
+      fill: shadingFill,
+      type: ShadingType.CLEAR
+    } : void 0,
+    margins: mapPaddingToTableMargins(td.padding),
+    borders: createTableCellBorders(
+      td,
+      tableContext.borderColor,
+      tableContext.borderWidth
+    )
+  });
+}
+function createParagraph(children, context, defaultRowMargin) {
+  return new Paragraph({
+    children,
+    heading: context.heading,
+    numbering: context.numbering,
+    alignment: context.alignment,
+    spacing: {
+      line: Math.round(
+        240 * (context.rowMargin || defaultRowMargin || DEFAULT_LINE_HEIGHT)
+      ),
+      lineRule: LineRuleType.AUTO
+    }
+  });
+}
+function createTextRun(text, element, defaultSize, defaultFont) {
+  const color = element.color ? normalizeHexColor(element.color, "000000") : void 0;
+  const highlightFill = element.highlight ? normalizeHexColor(element.highlight) : void 0;
+  return new TextRun({
+    text,
+    bold: !!element.bold,
+    italics: !!element.italic,
+    strike: !!element.strikeout,
+    subScript: element.type === "subscript" /* SUBSCRIPT */,
+    superScript: element.type === "superscript" /* SUPERSCRIPT */,
+    color,
+    shading: highlightFill ? {
+      fill: highlightFill,
+      type: ShadingType.CLEAR
+    } : void 0,
+    underline: element.underline ? {
+      type: mapUnderlineType(element.textDecoration?.style)
+    } : void 0,
+    font: element.font || defaultFont,
+    size: Math.round((element.size || defaultSize) * 2)
+  });
+}
+async function createHyperlinkChild(element, options) {
+  if (!element.url) {
+    const fallbackText = getTextFromElementList(element.valueList || []);
+    return fallbackText ? createTextRun(
+      fallbackText,
+      element.valueList?.[0] || element,
+      options.defaultSize,
+      options.defaultFont
+    ) : null;
+  }
+  const children = await createHyperlinkRuns(
+    element.valueList || [],
+    options.defaultSize,
+    options.defaultFont
+  );
+  if (!children.length) {
+    return null;
   }
-  backspace() {
-    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
-    if (isDisabled) return;
-    const elementList = this.draw.getElementList();
-    const { startIndex, endIndex } = this.range.getRange();
-    const isCollapsed = startIndex === endIndex;
-    if (isCollapsed && elementList[startIndex].value === ZERO && startIndex === 0) {
-      return;
+  return new ExternalHyperlink({
+    link: element.url,
+    children
+  });
+}
+async function createHyperlinkRuns(valueList, defaultSize, defaultFont) {
+  const children = [];
+  for (let i = 0; i < valueList.length; i++) {
+    const element = valueList[i];
+    if (element.type === "tab" /* TAB */) {
+      children.push(createTextRun("	", element, defaultSize, defaultFont));
+      continue;
     }
-    if (!isCollapsed) {
-      this.draw.spliceElementList(
-        elementList,
-        startIndex + 1,
-        endIndex - startIndex
-      );
-    } else {
-      this.draw.spliceElementList(elementList, startIndex, 1);
+    const text = normalizeText(getInlineElementText(element)).replace(
+      /\n/g,
+      " "
+    );
+    if (text) {
+      children.push(createTextRun(text, element, defaultSize, defaultFont));
     }
-    const curIndex = isCollapsed ? startIndex - 1 : startIndex;
-    this.range.setRange(curIndex, curIndex);
-    this.draw.render({ curIndex });
   }
-  setRange(startIndex, endIndex, tableId, startTdIndex, endTdIndex, startTrIndex, endTrIndex) {
-    if (startIndex < 0 || endIndex < 0 || endIndex < startIndex) return;
+  return children;
+}
+async function createImageChild(element) {
+  try {
+    const image = await loadImagePayload(element.value);
+    const width = Math.max(1, Math.round(element.width || DEFAULT_IMAGE_WIDTH));
+    const height = Math.max(
+      1,
+      Math.round(element.height || DEFAULT_IMAGE_HEIGHT)
+    );
+    if (image.type === "svg" && image.fallbackPng) {
+      return new ImageRun({
+        type: "svg",
+        data: image.data,
+        fallback: {
+          type: "png",
+          data: image.fallbackPng
+        },
+        transformation: {
+          width,
+          height
+        }
+      });
+    }
+    return new ImageRun({
+      type: image.type,
+      data: image.data,
+      transformation: {
+        width,
+        height
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+async function loadImagePayload(src) {
+  const source = src.trim();
+  if (source.startsWith("data:")) {
+    return getImagePayloadFromDataUrl(source);
+  }
+  const response = await fetch(source);
+  if (!response.ok) {
+    throw new Error(`Image request failed: ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  const data2 = await response.arrayBuffer();
+  return normalizeImagePayload(data2, contentType);
+}
+async function getImagePayloadFromDataUrl(src) {
+  const [, meta = "", encoded = ""] = src.match(/^data:([^,]*),(.*)$/) || [];
+  const mime = meta.split(";")[0] || "";
+  const isBase64 = meta.includes(";base64");
+  const text = isBase64 ? atob(encoded) : decodeURIComponent(encoded);
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) {
+    bytes[i] = text.charCodeAt(i);
+  }
+  return normalizeImagePayload(bytes.buffer, mime);
+}
+async function normalizeImagePayload(data2, mime) {
+  const type = getRegularImageType(mime);
+  if (type) {
+    return {
+      type,
+      data: data2
+    };
+  }
+  if (mime.includes("svg")) {
+    return {
+      type: "svg",
+      data: data2,
+      fallbackPng: await rasterizeSvgToPng(data2)
+    };
+  }
+  const fallbackPng = await rasterizeImageToPng(data2, mime);
+  return {
+    type: "png",
+    data: fallbackPng
+  };
+}
+async function rasterizeSvgToPng(data2) {
+  return rasterizeImageToPng(data2, "image/svg+xml");
+}
+async function rasterizeImageToPng(data2, mime) {
+  const blob = new Blob([data2], {
+    type: mime || "image/png"
+  });
+  const url = URL.createObjectURL(blob);
+  try {
+    const image = await loadHtmlImage(url);
+    const canvas = document.createElement("canvas");
+    canvas.width = image.naturalWidth || DEFAULT_IMAGE_WIDTH;
+    canvas.height = image.naturalHeight || DEFAULT_IMAGE_HEIGHT;
+    const context = canvas.getContext("2d");
+    if (!context) {
+      throw new Error("Canvas context is unavailable");
+    }
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    const pngBlob = await new Promise((resolve, reject) => {
+      canvas.toBlob((output) => {
+        if (output) {
+          resolve(output);
+        } else {
+          reject(new Error("Failed to create PNG blob"));
+        }
+      }, "image/png");
+    });
+    return await pngBlob.arrayBuffer();
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function loadHtmlImage(src) {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error("Failed to load image"));
+    image.src = src;
+  });
+}
+function createPageNumberParagraph(pageNumber) {
+  if (pageNumber.disabled || pageNumber.fromPageNo > 0) {
+    return null;
+  }
+  const children = [];
+  const format = pageNumber.format || FORMAT_PLACEHOLDER.PAGE_NO;
+  const tokens = format.split(/(\{pageNo\}|\{pageCount\})/);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    const runChildren = token === FORMAT_PLACEHOLDER.PAGE_NO ? [PageNumber2.CURRENT] : token === FORMAT_PLACEHOLDER.PAGE_COUNT ? [PageNumber2.TOTAL_PAGES] : void 0;
+    children.push(
+      new TextRun({
+        text: runChildren ? void 0 : token,
+        children: runChildren,
+        color: normalizeHexColor(pageNumber.color || "#000000", "000000"),
+        font: pageNumber.font,
+        size: Math.round((pageNumber.size || 12) * 2)
+      })
+    );
+  }
+  return new Paragraph({
+    children,
+    alignment: mapRowFlexToAlignment(pageNumber.rowFlex)
+  });
+}
+function forceDocxFooterTextColor(elementList) {
+  const footerElementList = deepClone(elementList);
+  forceColorValue(footerElementList);
+  return footerElementList;
+}
+function forceColorValue(value) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      forceColorValue(value[i]);
+    }
+    return;
+  }
+  const record = value;
+  if ("color" in record) {
+    record.color = DOCX_FOOTER_TEXT_COLOR;
+  }
+  const keys = Object.keys(record);
+  for (let i = 0; i < keys.length; i++) {
+    forceColorValue(record[keys[i]]);
+  }
+}
+function createNumberingConfig() {
+  const config = [
+    createOrderedReference("windoc-ol-decimal", Array(9).fill("decimal" /* DECIMAL */)),
+    createOrderedReference(
+      "windoc-ol-lower-alpha",
+      Array(9).fill("lowerAlpha" /* LOWER_ALPHA */)
+    ),
+    createOrderedReference(
+      "windoc-ol-upper-alpha",
+      Array(9).fill("upperAlpha" /* UPPER_ALPHA */)
+    ),
+    createOrderedReference(
+      "windoc-ol-lower-roman",
+      Array(9).fill("lowerRoman" /* LOWER_ROMAN */)
+    ),
+    createOrderedReference(
+      "windoc-ol-upper-roman",
+      Array(9).fill("upperRoman" /* UPPER_ROMAN */)
+    ),
+    createOrderedReference(
+      "windoc-ol-decimal-paren",
+      Array(9).fill("decimalParen" /* DECIMAL_PAREN */)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olDefault" /* DEFAULT */}`,
+      createCycleList(olPresetCycles["olDefault" /* DEFAULT */], 9)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olParen" /* PARENTHESIS */}`,
+      createCycleList(olPresetCycles["olParen" /* PARENTHESIS */], 9)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olOutline" /* OUTLINE */}`,
+      createCycleList(olPresetCycles["olOutline" /* OUTLINE */], 9)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olUpperA" /* UPPER_ALPHA */}`,
+      createCycleList(olPresetCycles["olUpperA" /* UPPER_ALPHA */], 9)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olRoman" /* ROMAN */}`,
+      createCycleList(olPresetCycles["olRoman" /* ROMAN */], 9)
+    ),
+    createOrderedReference(
+      `windoc-ol-${"olZeroPad" /* ZERO_PAD */}`,
+      createCycleList(olPresetCycles["olZeroPad" /* ZERO_PAD */], 9)
+    ),
+    createBulletReference(
+      "windoc-ul-disc",
+      Array(9).fill(docxBulletCharMap["disc" /* DISC */])
+    ),
+    createBulletReference(
+      "windoc-ul-circle",
+      Array(9).fill(docxBulletCharMap["circle" /* CIRCLE */])
+    ),
+    createBulletReference(
+      "windoc-ul-square",
+      Array(9).fill(docxBulletCharMap["square" /* SQUARE */])
+    ),
+    createBulletReference(
+      "windoc-ul-checkbox",
+      Array(9).fill(docxBulletCharMap["checkbox" /* CHECKBOX */])
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulDefault" /* DEFAULT */}`,
+      createCycleList(ulPresetCycles["ulDefault" /* DEFAULT */], 9)
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulDiamond" /* DIAMOND */}`,
+      createCycleList(ulPresetCycles["ulDiamond" /* DIAMOND */], 9)
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulHollowSq" /* HOLLOW_SQ */}`,
+      createCycleList(ulPresetCycles["ulHollowSq" /* HOLLOW_SQ */], 9)
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulArrow" /* ARROW */}`,
+      createCycleList(ulPresetCycles["ulArrow" /* ARROW */], 9)
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulStar" /* STAR */}`,
+      createCycleList(ulPresetCycles["ulStar" /* STAR */], 9)
+    ),
+    createBulletReference(
+      `windoc-ul-${"ulCheckArr" /* CHECK_ARROW */}`,
+      createCycleList(ulPresetCycles["ulCheckArr" /* CHECK_ARROW */], 9)
+    )
+  ];
+  return config;
+}
+function createOrderedReference(reference, styles) {
+  return {
+    reference,
+    levels: styles.map((style, level) => ({
+      level,
+      format: orderedStyleFormatMap[style] || LevelFormat.DECIMAL,
+      text: getOrderedLevelText(style, level),
+      alignment: AlignmentType.START,
+      style: {
+        paragraph: {
+          indent: {
+            left: 720 * (level + 1),
+            hanging: 360
+          }
+        }
+      }
+    }))
+  };
+}
+function createBulletReference(reference, bullets) {
+  return {
+    reference,
+    levels: bullets.map((bullet, level) => ({
+      level,
+      format: LevelFormat.BULLET,
+      text: bullet,
+      alignment: AlignmentType.START,
+      style: {
+        paragraph: {
+          indent: {
+            left: 720 * (level + 1),
+            hanging: 360
+          }
+        }
+      }
+    }))
+  };
+}
+function getOrderedLevelText(style, level) {
+  const placeholder = `%${level + 1}`;
+  if (style === "outline") {
+    return Array.from({ length: level + 1 }, (_, index) => `%${index + 1}`).join(
+      "."
+    ) + ".";
+  }
+  if (style.endsWith("Paren") || style === "decimalParen" /* DECIMAL_PAREN */) {
+    return `${placeholder})`;
+  }
+  return `${placeholder}.`;
+}
+function createCycleList(source = [], size) {
+  const result = [];
+  for (let i = 0; i < size; i++) {
+    result.push(source[i % source.length]);
+  }
+  return result;
+}
+function getListNumbering(element, instance) {
+  const level = Math.max(0, Math.min(element.listLevel || 0, 8));
+  if (element.listType === "ul" /* UL */) {
+    const reference2 = element.listPreset ? `windoc-ul-${element.listPreset}` : `windoc-ul-${element.listStyle || "disc" /* DISC */}`;
+    return {
+      reference: reference2,
+      level,
+      instance
+    };
+  }
+  const reference = element.listPreset ? `windoc-ol-${element.listPreset}` : getOrderedReferenceFromStyle(element.listStyle);
+  return {
+    reference,
+    level,
+    instance
+  };
+}
+function getOrderedReferenceFromStyle(style) {
+  switch (style) {
+    case "lowerAlpha" /* LOWER_ALPHA */:
+      return "windoc-ol-lower-alpha";
+    case "upperAlpha" /* UPPER_ALPHA */:
+      return "windoc-ol-upper-alpha";
+    case "lowerRoman" /* LOWER_ROMAN */:
+      return "windoc-ol-lower-roman";
+    case "upperRoman" /* UPPER_ROMAN */:
+      return "windoc-ol-upper-roman";
+    case "decimalParen" /* DECIMAL_PAREN */:
+      return "windoc-ol-decimal-paren";
+    default:
+      return "windoc-ol-decimal";
+  }
+}
+function createTableBorders(element) {
+  const outerBorder = createBorder(
+    element.borderColor,
+    BorderStyle.SINGLE,
+    element.borderExternalWidth || element.borderWidth
+  );
+  const innerBorder = createBorder(
+    element.borderColor,
+    BorderStyle.SINGLE,
+    element.borderWidth
+  );
+  switch (element.borderType) {
+    case "empty" /* EMPTY */:
+      return {
+        top: noneBorder(),
+        bottom: noneBorder(),
+        left: noneBorder(),
+        right: noneBorder(),
+        insideHorizontal: noneBorder(),
+        insideVertical: noneBorder()
+      };
+    case "external" /* EXTERNAL */:
+      return {
+        top: outerBorder,
+        bottom: outerBorder,
+        left: outerBorder,
+        right: outerBorder,
+        insideHorizontal: noneBorder(),
+        insideVertical: noneBorder()
+      };
+    case "internal" /* INTERNAL */:
+      return {
+        top: noneBorder(),
+        bottom: noneBorder(),
+        left: noneBorder(),
+        right: noneBorder(),
+        insideHorizontal: innerBorder,
+        insideVertical: innerBorder
+      };
+    case "dash" /* DASH */:
+      return {
+        top: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderExternalWidth || element.borderWidth
+        ),
+        bottom: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderExternalWidth || element.borderWidth
+        ),
+        left: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderExternalWidth || element.borderWidth
+        ),
+        right: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderExternalWidth || element.borderWidth
+        ),
+        insideHorizontal: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderWidth
+        ),
+        insideVertical: createBorder(
+          element.borderColor,
+          BorderStyle.DASHED,
+          element.borderWidth
+        )
+      };
+    default:
+      return {
+        top: outerBorder,
+        bottom: outerBorder,
+        left: outerBorder,
+        right: outerBorder,
+        insideHorizontal: innerBorder,
+        insideVertical: innerBorder
+      };
+  }
+}
+function createTableCellBorders(td, inheritedColor, inheritedWidth) {
+  if (!td.borderTypes?.length && !td.borderColor) {
+    return void 0;
+  }
+  const color = td.borderColor || inheritedColor;
+  const createCellBorder = () => createBorder(color, BorderStyle.SINGLE, inheritedWidth);
+  if (td.borderColor && !td.borderTypes?.length) {
+    return {
+      top: createCellBorder(),
+      right: createCellBorder(),
+      bottom: createCellBorder(),
+      left: createCellBorder()
+    };
+  }
+  const top = td.borderTypes?.includes("top" /* TOP */) ? createCellBorder() : noneBorder();
+  const right2 = td.borderTypes?.includes("right" /* RIGHT */) ? createCellBorder() : noneBorder();
+  const bottom = td.borderTypes?.includes("bottom" /* BOTTOM */) ? createCellBorder() : noneBorder();
+  const left2 = td.borderTypes?.includes("left" /* LEFT */) ? createCellBorder() : noneBorder();
+  return {
+    top,
+    right: right2,
+    bottom,
+    left: left2
+  };
+}
+function createBorder(color = "#000000", style = BorderStyle.SINGLE, width = 1) {
+  return {
+    style,
+    color: normalizeHexColor(color, "000000") || "000000",
+    size: pxBorderToDocxSize(width)
+  };
+}
+function noneBorder() {
+  return {
+    style: BorderStyle.NONE,
+    size: 0,
+    color: "FFFFFF"
+  };
+}
+function mapPaddingToTableMargins(padding) {
+  if (!padding) return void 0;
+  return {
+    top: pxToTwips(padding[0]),
+    right: pxToTwips(padding[1]),
+    bottom: pxToTwips(padding[2]),
+    left: pxToTwips(padding[3]),
+    marginUnitType: WidthType.DXA
+  };
+}
+function mapCellVerticalAlign(verticalAlign) {
+  switch (verticalAlign) {
+    case VerticalAlign.CENTER:
+      return DocxVerticalAlign.CENTER;
+    case "bottom" /* BOTTOM */:
+      return DocxVerticalAlign.BOTTOM;
+    default:
+      return DocxVerticalAlign.TOP;
+  }
+}
+function mapRowFlexToAlignment(rowFlex) {
+  switch (rowFlex) {
+    case "center" /* CENTER */:
+      return AlignmentType.CENTER;
+    case "right" /* RIGHT */:
+      return AlignmentType.RIGHT;
+    case "alignment" /* ALIGNMENT */:
+    case "justify" /* JUSTIFY */:
+      return AlignmentType.JUSTIFIED;
+    default:
+      return AlignmentType.LEFT;
+  }
+}
+function mapUnderlineType(style) {
+  switch (style) {
+    case "double" /* DOUBLE */:
+      return UnderlineType.DOUBLE;
+    case "dashed" /* DASHED */:
+      return UnderlineType.DASH;
+    case "dotted" /* DOTTED */:
+      return UnderlineType.DOTTED;
+    case "wavy" /* WAVY */:
+      return UnderlineType.WAVE;
+    default:
+      return UnderlineType.SINGLE;
+  }
+}
+function getInlineElementText(element) {
+  switch (element.type) {
+    case "control" /* CONTROL */:
+      return getControlText(element.control);
+    case "date" /* DATE */:
+      return element.valueList?.length ? getTextFromElementList(element.valueList) : element.value;
+    case "checkbox" /* CHECKBOX */:
+      return element.checkbox?.value ? "\u2611" : "\u2610";
+    case "radio" /* RADIO */:
+      return element.radio?.value ? "\u25C9" : "\u25CB";
+    case "label" /* LABEL */:
+    case "latex" /* LATEX */:
+    case "subscript" /* SUBSCRIPT */:
+    case "superscript" /* SUPERSCRIPT */:
+      return element.value;
+    default:
+      return element.value;
+  }
+}
+function getControlText(control) {
+  if (!control) return "";
+  if (control.type === "text" /* TEXT */ || control.type === "date" /* DATE */ || control.type === "number" /* NUMBER */) {
+    const value = control.value?.length ? getTextFromElementList(control.value) : "";
+    const content = value || control.placeholder || "";
+    return `${control.preText || ""}${content}${control.postText || ""}`;
+  }
+  if (control.type === "select" /* SELECT */) {
+    const labels = getSelectedControlLabels(control.code, control.valueSets);
+    const content = labels.length ? labels.join(control.multiSelectDelimiter || ", ") : control.placeholder || "";
+    return `${control.preText || ""}${content}${control.postText || ""}`;
+  }
+  if (control.type === "checkbox" /* CHECKBOX */ || control.type === "radio" /* RADIO */) {
+    const isRadio = control.type === "radio" /* RADIO */;
+    return (control.valueSets || []).map((valueSet) => {
+      const checked = control.code?.split(",").includes(valueSet.code) || false;
+      return `${checked ? isRadio ? "\u25C9" : "\u2611" : isRadio ? "\u25CB" : "\u2610"} ${valueSet.value}`;
+    }).join("  ");
+  }
+  return "";
+}
+function getSelectedControlLabels(code, valueSets) {
+  if (!code || !valueSets?.length) return [];
+  return code.split(",").map(
+    (selectCode) => valueSets.find((valueSet) => valueSet.code === selectCode)?.value
+  ).filter((value) => !!value);
+}
+function getBlockFallbackText(element) {
+  if (element.block?.iframeBlock?.src) {
+    return element.block.iframeBlock.src;
+  }
+  if (element.block?.videoBlock?.src) {
+    return element.block.videoBlock.src;
+  }
+  return "";
+}
+function normalizeText(text = "") {
+  return text.replace(new RegExp(ZERO, "g"), "").replace(/\r\n/g, "\n");
+}
+function createSerializeContext() {
+  return {
+    nextListInstance: 1
+  };
+}
+function getListItemNumberingElement(listItemElements, fallback) {
+  return listItemElements.find(
+    (listItem) => listItem.listId || listItem.listLevel !== void 0 || !!listItem.listPreset || !!listItem.listStyle || !!listItem.listType
+  ) || fallback;
+}
+function createListInstance(context) {
+  return context.nextListInstance++;
+}
+function createTableSerializeContext(element) {
+  return {
+    cellLayoutMap: computeTableCellLayout(
+      element.trList || [],
+      element.colgroup || []
+    ),
+    borderColor: element.borderColor,
+    borderWidth: element.borderWidth,
+    borderExternalWidth: element.borderExternalWidth
+  };
+}
+function computeTableCellLayout(trList, colgroup) {
+  const cellLayoutMap = /* @__PURE__ */ new WeakMap();
+  if (!trList.length || !colgroup.length) {
+    return cellLayoutMap;
+  }
+  const occupiedUntilRow = Array(colgroup.length).fill(0);
+  for (let rowIndex = 0; rowIndex < trList.length; rowIndex++) {
+    const tr = trList[rowIndex];
+    let colIndex = 0;
+    for (let tdIndex = 0; tdIndex < tr.tdList.length; tdIndex++) {
+      while (colIndex < colgroup.length && occupiedUntilRow[colIndex] > rowIndex) {
+        colIndex += 1;
+      }
+      const td = tr.tdList[tdIndex];
+      let width = 0;
+      for (let currentCol = colIndex; currentCol < colIndex + td.colspan && currentCol < colgroup.length; currentCol++) {
+        width += colgroup[currentCol].width;
+        occupiedUntilRow[currentCol] = Math.max(
+          occupiedUntilRow[currentCol],
+          rowIndex + td.rowspan
+        );
+      }
+      cellLayoutMap.set(td, { width });
+      colIndex += td.colspan;
+    }
+  }
+  return cellLayoutMap;
+}
+function getTableWidthFromColgroup(colgroup) {
+  if (!colgroup?.length) {
+    return void 0;
+  }
+  return colgroup.reduce((sum, col) => sum + col.width, 0);
+}
+function normalizeHexColor(color, fallback) {
+  const normalized = normalizeHexLiteral(color) || normalizeRgbColor(color) || normalizeBrowserColor(color);
+  if (normalized) {
+    return normalized;
+  }
+  return fallback ? normalizeHexLiteral(fallback) || void 0 : void 0;
+}
+function normalizeHexLiteral(color) {
+  const value = color.trim().replace(/^#/, "");
+  if (/^[\da-f]{3}$/i.test(value)) {
+    return value.split("").map((part) => `${part}${part}`).join("").toUpperCase();
+  }
+  if (/^[\da-f]{4}$/i.test(value)) {
+    return value.slice(0, 3).split("").map((part) => `${part}${part}`).join("").toUpperCase();
+  }
+  if (/^[\da-f]{6}$/i.test(value)) {
+    return value.toUpperCase();
+  }
+  if (/^[\da-f]{8}$/i.test(value)) {
+    return value.slice(0, 6).toUpperCase();
+  }
+  return void 0;
+}
+function normalizeRgbColor(color) {
+  const match = color.trim().match(/^rgba?\((.+)\)$/i);
+  if (!match) {
+    return void 0;
+  }
+  const parts = match[1].replace(/\s*\/\s*/g, ",").split(/\s*,\s*|\s+/).filter(Boolean);
+  if (parts.length < 3) {
+    return void 0;
+  }
+  const red = parseRgbChannel(parts[0]);
+  const green = parseRgbChannel(parts[1]);
+  const blue = parseRgbChannel(parts[2]);
+  if (red === null || green === null || blue === null) {
+    return void 0;
+  }
+  const alpha = parts[3] !== void 0 ? parseAlphaChannel(parts[3]) : 1;
+  if (alpha === null || alpha <= 0) {
+    return void 0;
+  }
+  const flattened = alpha >= 1 ? [red, green, blue] : [
+    flattenChannel(red, alpha),
+    flattenChannel(green, alpha),
+    flattenChannel(blue, alpha)
+  ];
+  return flattened.map(toHexChannel).join("");
+}
+function normalizeBrowserColor(color) {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return void 0;
+  }
+  context.fillStyle = "#000000";
+  context.fillStyle = color;
+  const normalized = context.fillStyle;
+  if (typeof normalized !== "string") {
+    return void 0;
+  }
+  return normalizeHexLiteral(normalized) || normalizeRgbColor(normalized);
+}
+function parseRgbChannel(value) {
+  if (value.endsWith("%")) {
+    const percent = Number(value.slice(0, -1));
+    if (!Number.isFinite(percent)) {
+      return null;
+    }
+    return clampColorChannel(Math.round(percent / 100 * 255));
+  }
+  const channel = Number(value);
+  if (!Number.isFinite(channel)) {
+    return null;
+  }
+  return clampColorChannel(Math.round(channel));
+}
+function parseAlphaChannel(value) {
+  if (value.endsWith("%")) {
+    const percent = Number(value.slice(0, -1));
+    if (!Number.isFinite(percent)) {
+      return null;
+    }
+    return Math.min(Math.max(percent / 100, 0), 1);
+  }
+  const alpha = Number(value);
+  if (!Number.isFinite(alpha)) {
+    return null;
+  }
+  return Math.min(Math.max(alpha, 0), 1);
+}
+function clampColorChannel(value) {
+  return Math.min(Math.max(value, 0), 255);
+}
+function flattenChannel(value, alpha) {
+  return clampColorChannel(Math.round(255 * (1 - alpha) + value * alpha));
+}
+function toHexChannel(value) {
+  return value.toString(16).padStart(2, "0").toUpperCase();
+}
+function pxBorderToDocxSize(width) {
+  const safeWidth = Number.isFinite(width) && width > 0 ? width : 1;
+  return Math.max(2, Math.round(safeWidth * 6));
+}
+function getRegularImageType(mime) {
+  if (mime.includes("png")) return "png";
+  if (mime.includes("jpeg") || mime.includes("jpg")) return "jpg";
+  if (mime.includes("gif")) return "gif";
+  if (mime.includes("bmp")) return "bmp";
+  return null;
+}
+function normalizeDocxFileName(fileName) {
+  const trimmed = fileName?.trim();
+  if (!trimmed) {
+    return DEFAULT_DOCX_FILE_NAME;
+  }
+  return trimmed.toLowerCase().endsWith(".docx") ? trimmed : `${trimmed}.docx`;
+}
+function pxToTwips(px) {
+  return Math.round(px * 15);
+}
+
+// src/utils/pdf.ts
+import {
+  PDFDocument,
+  StandardFonts,
+  rgb
+} from "pdf-lib";
+var DEFAULT_PDF_FILE_NAME = "document.pdf";
+var DEFAULT_IMAGE_WIDTH2 = 320;
+var DEFAULT_IMAGE_HEIGHT2 = 180;
+var DEFAULT_LINE_HEIGHT2 = 1.15;
+var PAGE_REGION_GAP = 12;
+var SEPARATOR_HEIGHT = 12;
+var LIST_GAP = 8;
+var FOOTER_MIN_BAR_HEIGHT = 29;
+var PDF_TEXT_FALLBACKS = {
+  "\u2297": "x",
+  "\u2611": "[x]",
+  "\u2612": "[x]",
+  "\u2610": "[]",
+  "\u2713": "v",
+  "\u2714": "v",
+  "\u2717": "x",
+  "\u2715": "x",
+  "\u25E6": "o",
+  "\u25AA": "*",
+  "\u25A0": "*"
+};
+var pdfTextCache = /* @__PURE__ */ new WeakMap();
+var bulletCharMap = {
+  ["disc" /* DISC */]: "\u2022",
+  ["circle" /* CIRCLE */]: "\u25E6",
+  ["square" /* SQUARE */]: "\u25A0",
+  ["checkbox" /* CHECKBOX */]: "\u2611"
+};
+async function exportEditorDataToPdf(payload, options = {}) {
+  const editorOptions = payload.options;
+  const pdfDoc = await PDFDocument.create();
+  const context = await createPdfContext(pdfDoc, editorOptions);
+  const headerBlocks = editorOptions.header.disabled ? [] : await parseElementList(payload.data.header || [], context, editorOptions);
+  const footerBlocks = editorOptions.footer.disabled ? [] : await parseElementList(payload.data.footer || [], context, editorOptions);
+  const mainBlocks = await parseElementList(
+    payload.data.main,
+    context,
+    editorOptions
+  );
+  const headerHeight = measureBlocksHeight(
+    headerBlocks,
+    context.contentWidth,
+    context
+  );
+  const footerHeight = measureBlocksHeight(
+    footerBlocks,
+    context.contentWidth,
+    context
+  );
+  const footerBarHeight = getFooterBarHeight(footerHeight, context);
+  const pageNumberHeight = getPageNumberHeight(editorOptions.pageNumber);
+  const contentTop = Math.max(
+    context.margins[0],
+    context.headerTop + headerHeight + (headerBlocks.length ? context.headerGap : 0)
+  );
+  const contentBottom = Math.max(
+    context.margins[2],
+    context.footerBottom + footerBarHeight,
+    getReservedPageNumberBottom(editorOptions.pageNumber, pageNumberHeight)
+  );
+  const pages = renderMainBlocks(
+    mainBlocks,
+    context,
+    contentTop,
+    contentBottom
+  );
+  renderPageDecorations(
+    pages,
+    context,
+    headerBlocks,
+    footerBlocks,
+    headerHeight,
+    footerHeight,
+    footerBarHeight,
+    editorOptions.pageNumber
+  );
+  const bytes = await pdfDoc.save();
+  return {
+    blob: new Blob([bytes], { type: "application/pdf" }),
+    fileName: normalizePdfFileName(options.fileName)
+  };
+}
+async function createPdfContext(pdfDoc, options) {
+  const [sans, sansBold, sansItalic, sansBoldItalic] = await Promise.all([
+    pdfDoc.embedFont(StandardFonts.Helvetica),
+    pdfDoc.embedFont(StandardFonts.HelveticaBold),
+    pdfDoc.embedFont(StandardFonts.HelveticaOblique),
+    pdfDoc.embedFont(StandardFonts.HelveticaBoldOblique)
+  ]);
+  const [serif, serifBold, serifItalic, serifBoldItalic] = await Promise.all([
+    pdfDoc.embedFont(StandardFonts.TimesRoman),
+    pdfDoc.embedFont(StandardFonts.TimesRomanBold),
+    pdfDoc.embedFont(StandardFonts.TimesRomanItalic),
+    pdfDoc.embedFont(StandardFonts.TimesRomanBoldItalic)
+  ]);
+  const [mono, monoBold, monoItalic, monoBoldItalic] = await Promise.all([
+    pdfDoc.embedFont(StandardFonts.Courier),
+    pdfDoc.embedFont(StandardFonts.CourierBold),
+    pdfDoc.embedFont(StandardFonts.CourierOblique),
+    pdfDoc.embedFont(StandardFonts.CourierBoldOblique)
+  ]);
+  const pageWidth = options.paperDirection === "horizontal" /* HORIZONTAL */ ? pxToPt(options.height) : pxToPt(options.width);
+  const pageHeight = options.paperDirection === "horizontal" /* HORIZONTAL */ ? pxToPt(options.width) : pxToPt(options.height);
+  const margins = options.margins.map(pxToPt);
+  return {
+    pdfDoc,
+    options,
+    fonts: {
+      sans: {
+        regular: sans,
+        bold: sansBold,
+        italic: sansItalic,
+        boldItalic: sansBoldItalic
+      },
+      serif: {
+        regular: serif,
+        bold: serifBold,
+        italic: serifItalic,
+        boldItalic: serifBoldItalic
+      },
+      mono: {
+        regular: mono,
+        bold: monoBold,
+        italic: monoItalic,
+        boldItalic: monoBoldItalic
+      }
+    },
+    pageWidth,
+    pageHeight,
+    margins,
+    contentWidth: pageWidth - margins[1] - margins[3],
+    headerTop: pxToPt(options.header.top),
+    footerBottom: pxToPt(options.footer.bottom),
+    headerGap: PAGE_REGION_GAP,
+    footerGap: PAGE_REGION_GAP,
+    separatorGap: SEPARATOR_HEIGHT,
+    imageCache: /* @__PURE__ */ new Map()
+  };
+}
+async function parseElementList(elementList, context, options) {
+  const blocks = [];
+  let inlineBuffer = [];
+  const flushInlineBuffer = async () => {
+    if (!inlineBuffer.length) return;
+    blocks.push(...await parseInlineElements(inlineBuffer, context, options));
+    inlineBuffer = [];
+  };
+  for (let i = 0; i < elementList.length; i++) {
+    const element = elementList[i];
+    if (element.type === "area" /* AREA */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(
+        ...await parseElementList(element.valueList, context, options)
+      );
+      continue;
+    }
+    if (element.type === "title" /* TITLE */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(
+        ...await parseInlineElements(element.valueList, context, options, {
+          alignment: element.rowFlex,
+          rowMargin: element.rowMargin,
+          listMarker: void 0,
+          titleLevel: element.level || "first" /* FIRST */
+        })
+      );
+      continue;
+    }
+    if (element.type === "list" /* LIST */ && element.valueList?.length) {
+      await flushInlineBuffer();
+      blocks.push(...await parseListBlock(element, context, options));
+      continue;
+    }
+    if (element.type === "table" /* TABLE */ && element.trList?.length) {
+      await flushInlineBuffer();
+      blocks.push(await parseTableBlock(element, context, options));
+      continue;
+    }
+    if (element.type === "pageBreak" /* PAGE_BREAK */) {
+      await flushInlineBuffer();
+      blocks.push({ type: "pageBreak" });
+      continue;
+    }
+    if (element.type === "separator" /* SEPARATOR */) {
+      await flushInlineBuffer();
+      blocks.push({ type: "separator" });
+      continue;
+    }
+    if (element.type === "image" /* IMAGE */ && element.imgDisplay && element.imgDisplay !== "inline") {
+      await flushInlineBuffer();
+      const imageBlock = await createImageBlock(element, context);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
+      continue;
+    }
+    if (element.type === "block" /* BLOCK */) {
+      await flushInlineBuffer();
+      const blockText = getBlockFallbackText2(element);
+      if (blockText) {
+        blocks.push(
+          ...await parseInlineElements(
+            [{ value: blockText }],
+            context,
+            options
+          )
+        );
+      }
+      continue;
+    }
+    inlineBuffer.push(element);
+  }
+  await flushInlineBuffer();
+  return blocks;
+}
+async function parseInlineElements(elementList, context, options, overrides = {}) {
+  const paragraphs = [];
+  let current = null;
+  const getParagraphContext = (element) => ({
+    alignment: overrides.alignment !== void 0 ? overrides.alignment : element?.rowFlex,
+    rowMargin: overrides.rowMargin !== void 0 ? overrides.rowMargin : element?.rowMargin,
+    listMarker: overrides.listMarker
+  });
+  const ensureParagraph = (element) => {
+    if (!current) {
+      current = {
+        runs: [],
+        context: getParagraphContext(element)
+      };
+    }
+    return current;
+  };
+  const flushParagraph = (contextValue) => {
+    if (!current) {
+      if (!contextValue) return;
+      paragraphs.push({
+        type: "paragraph",
+        runs: [],
+        context: contextValue
+      });
+      return;
+    }
+    paragraphs.push({
+      type: "paragraph",
+      runs: current.runs,
+      context: current.context
+    });
+    current = null;
+  };
+  const appendText = (element, text, factory, preserveTrailingBreak = false) => {
+    const normalized = normalizeText2(text);
+    const parts = normalized.split("\n");
+    let lastSeparatorFlushedContent = false;
+    for (let i = 0; i < parts.length; i++) {
+      const segment = parts[i];
+      if (segment) {
+        ensureParagraph(element).runs.push(factory(segment));
+      }
+      if (i < parts.length - 1) {
+        if (!current) {
+          paragraphs.push({
+            type: "paragraph",
+            runs: [],
+            context: getParagraphContext(element)
+          });
+          lastSeparatorFlushedContent = false;
+        } else {
+          flushParagraph();
+          lastSeparatorFlushedContent = true;
+        }
+      }
+    }
+    if (preserveTrailingBreak && normalized.endsWith("\n") && lastSeparatorFlushedContent) {
+      paragraphs.push({
+        type: "paragraph",
+        runs: [],
+        context: getParagraphContext(element)
+      });
+    }
+  };
+  for (let i = 0; i < elementList.length; i++) {
+    const element = elementList[i];
+    if (element.type === "hyperlink" /* HYPERLINK */ && element.valueList?.length) {
+      const children = element.valueList || [];
+      for (let childIndex = 0; childIndex < children.length; childIndex++) {
+        const child = children[childIndex];
+        const text = normalizeText2(getInlineElementText2(child));
+        if (!text) continue;
+        appendText(
+          element,
+          text,
+          (segment) => {
+            const run = createTextRun2(
+              child,
+              options,
+              overrides.titleLevel,
+              segment
+            );
+            run.color = run.color || options.defaultHyperlinkColor;
+            run.underline = true;
+            return run;
+          },
+          i === elementList.length - 1 && childIndex === children.length - 1
+        );
+      }
+      continue;
+    }
+    if (element.type === "image" /* IMAGE */) {
+      const imageRun = await createInlineImageRun(element, context);
+      if (imageRun) {
+        ensureParagraph(element).runs.push(imageRun);
+      }
+      continue;
+    }
+    if (element.type === "columnBreak" /* COLUMN_BREAK */) {
+      flushParagraph(getParagraphContext(element));
+      continue;
+    }
+    if (element.type === "pageBreak" /* PAGE_BREAK */) {
+      flushParagraph();
+      paragraphs.push({ type: "pageBreak" });
+      continue;
+    }
+    if (element.type === "tab" /* TAB */) {
+      ensureParagraph(element).runs.push({
+        type: "tab",
+        width: pxToPt(options.defaultTabWidth)
+      });
+      continue;
+    }
+    if (element.type === "label" /* LABEL */) {
+      const badgeRun = createBadgeRun(element, options, overrides.titleLevel);
+      ensureParagraph(element).runs.push(badgeRun);
+      continue;
+    }
+    const textValue = getInlineElementText2(element);
+    if (!textValue) {
+      continue;
+    }
+    appendText(
+      element,
+      textValue,
+      (segment) => createTextRun2(element, options, overrides.titleLevel, segment),
+      i === elementList.length - 1
+    );
+  }
+  if (current) {
+    flushParagraph();
+  }
+  return paragraphs.length ? paragraphs : [
+    {
+      type: "paragraph",
+      runs: [],
+      context: getParagraphContext()
+    }
+  ];
+}
+async function parseListBlock(element, context, options) {
+  const zipList = zipElementList(element.valueList || []);
+  const listItemMap = splitListElement(zipList);
+  const blocks = [];
+  const orderedCounts = Array(9).fill(0);
+  for (const listItemElements of listItemMap.values()) {
+    const itemElement = getListItemNumberingElement2(listItemElements, element);
+    const marker = getListMarker(itemElement, orderedCounts);
+    blocks.push(
+      ...await parseInlineElements(listItemElements, context, options, {
+        alignment: itemElement.rowFlex,
+        rowMargin: itemElement.rowMargin,
+        listMarker: marker
+      })
+    );
+  }
+  return blocks;
+}
+async function parseTableBlock(element, context, options) {
+  const placements = computeTableCellPlacement(
+    element.trList || [],
+    element.colgroup || []
+  );
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < (element.trList || []).length; rowIndex++) {
+    const tr = element.trList[rowIndex];
+    const cells = [];
+    for (let cellIndex = 0; cellIndex < tr.tdList.length; cellIndex++) {
+      const td = tr.tdList[cellIndex];
+      const placement = placements.get(td);
+      cells.push({
+        colspan: td.colspan,
+        rowspan: td.rowspan,
+        blocks: await parseElementList(td.value, context, options),
+        colIndex: placement?.colIndex || 0,
+        width: placement?.width || td.width || 0,
+        padding: td.padding || options.table.tdPadding,
+        verticalAlign: td.verticalAlign,
+        backgroundColor: td.backgroundColor,
+        borderColor: td.borderColor,
+        borderTypes: td.borderTypes
+      });
+    }
+    rows.push({
+      height: Math.max(tr.height || 0, options.table.defaultTrMinHeight),
+      cells
+    });
+  }
+  return {
+    type: "table",
+    rows,
+    colWidths: (element.colgroup || []).map((col) => col.width),
+    borderType: element.borderType,
+    borderColor: element.borderColor || options.table.defaultBorderColor,
+    borderWidth: element.borderWidth || 1,
+    borderExternalWidth: element.borderExternalWidth
+  };
+}
+async function createImageBlock(element, context) {
+  const image = await loadPdfImage(element.value, context);
+  if (!image) {
+    return null;
+  }
+  return {
+    type: "image",
+    image,
+    width: pxToPt(
+      Math.max(1, Math.round(element.width || DEFAULT_IMAGE_WIDTH2))
+    ),
+    height: pxToPt(
+      Math.max(1, Math.round(element.height || DEFAULT_IMAGE_HEIGHT2))
+    ),
+    alignment: element.rowFlex
+  };
+}
+async function createInlineImageRun(element, context) {
+  const image = await loadPdfImage(element.value, context);
+  if (!image) {
+    return null;
+  }
+  return {
+    type: "image",
+    image,
+    width: pxToPt(
+      Math.max(1, Math.round(element.width || DEFAULT_IMAGE_WIDTH2))
+    ),
+    height: pxToPt(
+      Math.max(1, Math.round(element.height || DEFAULT_IMAGE_HEIGHT2))
+    )
+  };
+}
+function createTextRun2(element, options, titleLevel, text) {
+  const titleSize = getTitleSize(titleLevel, options);
+  const size = element.size || titleSize || options.defaultSize;
+  const isTitle = !!titleLevel;
+  return {
+    type: "text",
+    text,
+    size,
+    font: element.font || options.defaultFont,
+    bold: isTitle ? true : !!element.bold,
+    italic: !!element.italic,
+    underline: !!element.underline,
+    strikeout: !!element.strikeout,
+    color: element.color || (isTitle ? "#000000" : void 0),
+    highlight: element.highlight,
+    superscript: element.type === "superscript" /* SUPERSCRIPT */,
+    subscript: element.type === "subscript" /* SUBSCRIPT */
+  };
+}
+function createBadgeRun(element, options, titleLevel) {
+  const titleSize = getTitleSize(titleLevel, options);
+  return {
+    type: "badge",
+    text: element.value,
+    size: element.size || titleSize || options.defaultSize,
+    font: element.font || options.defaultFont,
+    bold: titleLevel ? true : !!element.bold,
+    italic: !!element.italic,
+    underline: !!element.underline,
+    strikeout: !!element.strikeout,
+    color: element.label?.color || element.color,
+    backgroundColor: element.label?.backgroundColor,
+    borderColor: element.label?.borderColor,
+    padding: element.label?.padding || [2, 4, 2, 4]
+  };
+}
+function renderMainBlocks(blocks, context, contentTop, contentBottom) {
+  const pages = [];
+  const contentEnd = context.pageHeight - contentBottom;
+  const createPage = () => {
+    const page = context.pdfDoc.addPage([
+      context.pageWidth,
+      context.pageHeight
+    ]);
+    const state = {
+      page,
+      cursorY: contentTop,
+      isEmpty: true
+    };
+    pages.push(state);
+    return state;
+  };
+  let currentPage = createPage();
+  const ensureSpace = (height) => {
+    if (currentPage.cursorY + height <= contentEnd || currentPage.isEmpty) {
+      return;
+    }
+    currentPage = createPage();
+  };
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type === "pageBreak") {
+      currentPage = createPage();
+      continue;
+    }
+    if (block.type === "paragraph") {
+      currentPage = renderParagraphAcrossPages(
+        block,
+        currentPage,
+        pages,
+        context,
+        contentTop,
+        contentEnd
+      );
+      continue;
+    }
+    if (block.type === "separator") {
+      ensureSpace(context.separatorGap);
+      renderSeparator(
+        currentPage.page,
+        context,
+        currentPage.cursorY,
+        context.margins[3],
+        context.contentWidth
+      );
+      currentPage.cursorY += context.separatorGap;
+      currentPage.isEmpty = false;
+      continue;
+    }
+    if (block.type === "image") {
+      ensureSpace(block.height);
+      renderImageBlock(currentPage.page, block, context, currentPage.cursorY);
+      currentPage.cursorY += block.height;
+      currentPage.isEmpty = false;
+      continue;
+    }
+    const tableLayout = layoutTable(block, context.contentWidth, context);
+    currentPage = renderTableAcrossPages(
+      block,
+      tableLayout,
+      currentPage,
+      pages,
+      context,
+      contentTop,
+      contentEnd
+    );
+  }
+  return pages;
+}
+function renderParagraphAcrossPages(block, currentPage, pages, context, contentTop, contentEnd) {
+  const layout = layoutParagraph(block, context.contentWidth, context);
+  for (let lineIndex = 0; lineIndex < layout.lines.length; lineIndex++) {
+    const line = layout.lines[lineIndex];
+    if (currentPage.cursorY + line.height > contentEnd && !currentPage.isEmpty) {
+      const page = context.pdfDoc.addPage([
+        context.pageWidth,
+        context.pageHeight
+      ]);
+      currentPage = {
+        page,
+        cursorY: contentTop,
+        isEmpty: true
+      };
+      pages.push(currentPage);
+    }
+    renderParagraphLine(
+      currentPage.page,
+      block,
+      line,
+      lineIndex === 0,
+      layout,
+      context,
+      currentPage.cursorY,
+      context.margins[3],
+      context.contentWidth
+    );
+    currentPage.cursorY += line.height;
+    currentPage.isEmpty = false;
+  }
+  return currentPage;
+}
+function renderTableAcrossPages(block, tableLayout, currentPage, pages, context, contentTop, contentEnd) {
+  const scaledColWidths = scaleColumnWidths(
+    block.colWidths,
+    context.contentWidth
+  );
+  let tableTop = currentPage.cursorY;
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+    const row = block.rows[rowIndex];
+    const rowHeight = tableLayout.rowHeights[rowIndex];
+    const spanHeight = getSpanningRowHeight(
+      block.rows,
+      tableLayout.rowHeights,
+      rowIndex
+    );
+    if (currentPage.cursorY + spanHeight > contentEnd && !currentPage.isEmpty) {
+      const page = context.pdfDoc.addPage([
+        context.pageWidth,
+        context.pageHeight
+      ]);
+      currentPage = {
+        page,
+        cursorY: contentTop,
+        isEmpty: true
+      };
+      pages.push(currentPage);
+      tableTop = currentPage.cursorY;
+    }
+    const rowTop = currentPage.cursorY;
+    for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
+      const cell = row.cells[cellIndex];
+      const cellX = context.margins[3] + getColumnOffset(scaledColWidths, cell.colIndex);
+      const cellWidth = getColumnSpanWidth(
+        scaledColWidths,
+        cell.colIndex,
+        cell.colspan
+      );
+      const cellHeight = getRowSpanHeight(
+        tableLayout.rowHeights,
+        rowIndex,
+        cell.rowspan
+      );
+      renderTableCell(
+        currentPage.page,
+        cell,
+        context,
+        block,
+        cellX,
+        rowTop,
+        cellWidth,
+        cellHeight
+      );
+    }
+    currentPage.cursorY += rowHeight;
+    currentPage.isEmpty = false;
+  }
+  return currentPage;
+}
+function renderPageDecorations(pages, context, headerBlocks, footerBlocks, headerHeight, footerHeight, footerBarHeight, pageNumber) {
+  const totalPages = pages.length;
+  for (let index = 0; index < pages.length; index++) {
+    const pageState = pages[index];
+    if (headerBlocks.length) {
+      renderBlocksInRegion(
+        pageState.page,
+        headerBlocks,
+        context,
+        context.margins[3],
+        context.headerTop,
+        context.contentWidth
+      );
+    }
+    if (footerBarHeight > 0) {
+      if (context.options.footer.backgroundColor) {
+        pageState.page.drawRectangle({
+          x: 0,
+          y: context.footerBottom,
+          width: context.pageWidth,
+          height: footerBarHeight,
+          color: toPdfColor(context.options.footer.backgroundColor, "#FFFFFF")
+        });
+      }
+      if (footerBlocks.length) {
+        const footerTop = context.pageHeight - context.footerBottom - footerBarHeight;
+        const footerContentTop = footerTop + Math.max(0, (footerBarHeight - footerHeight) / 2);
+        renderBlocksInRegion(
+          pageState.page,
+          footerBlocks,
+          context,
+          context.margins[3],
+          footerContentTop,
+          context.contentWidth
+        );
+      }
+    }
+    renderPageNumber(pageState.page, context, pageNumber, index, totalPages);
+  }
+}
+function renderBlocksInRegion(page, blocks, context, x, top, width) {
+  let cursorY = top;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type === "pageBreak") {
+      continue;
+    }
+    if (block.type === "paragraph") {
+      const layout = layoutParagraph(block, width, context);
+      for (let lineIndex = 0; lineIndex < layout.lines.length; lineIndex++) {
+        const line = layout.lines[lineIndex];
+        renderParagraphLine(
+          page,
+          block,
+          line,
+          lineIndex === 0,
+          layout,
+          context,
+          cursorY,
+          x,
+          width
+        );
+        cursorY += line.height;
+      }
+      continue;
+    }
+    if (block.type === "separator") {
+      renderSeparator(page, context, cursorY, x, width);
+      cursorY += context.separatorGap;
+      continue;
+    }
+    if (block.type === "image") {
+      renderImageBlock(page, block, context, cursorY, x, width);
+      cursorY += block.height;
+      continue;
+    }
+    const tableLayout = layoutTable(block, width, context);
+    const scaledColWidths = scaleColumnWidths(block.colWidths, width);
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+      const row = block.rows[rowIndex];
+      const rowTop = cursorY;
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
+        const cell = row.cells[cellIndex];
+        const cellX = x + getColumnOffset(scaledColWidths, cell.colIndex);
+        const cellWidth = getColumnSpanWidth(
+          scaledColWidths,
+          cell.colIndex,
+          cell.colspan
+        );
+        const cellHeight = getRowSpanHeight(
+          tableLayout.rowHeights,
+          rowIndex,
+          cell.rowspan
+        );
+        renderTableCell(
+          page,
+          cell,
+          context,
+          block,
+          cellX,
+          rowTop,
+          cellWidth,
+          cellHeight
+        );
+      }
+      cursorY += tableLayout.rowHeights[rowIndex];
+    }
+  }
+}
+function renderParagraphLine(page, block, line, isFirstLine, layout, context, top, baseX, regionWidth) {
+  const alignment = normalizeAlignment(block.context.alignment);
+  const lineWidth = line.width;
+  const availableWidth = Math.max(
+    1,
+    regionWidth - layout.listIndent - layout.markerWidth
+  );
+  const justifyExtra = alignment === "justify" /* JUSTIFY */ && !isLastParagraphLine(layout, line) ? getJustifyExtra(line, availableWidth) : 0;
+  let offsetX = 0;
+  if (alignment === "center" /* CENTER */) {
+    offsetX = (availableWidth - lineWidth) / 2;
+  } else if (alignment === "right" /* RIGHT */) {
+    offsetX = availableWidth - lineWidth;
+  }
+  const lineStart = baseX + layout.listIndent + layout.markerWidth + Math.max(0, offsetX);
+  if (isFirstLine && block.context.listMarker) {
+    const markerRun = getMarkerRun(block, context);
+    const markerText = block.context.listMarker.text;
+    drawTextRun(
+      page,
+      markerRun,
+      markerText,
+      baseX + layout.listIndent,
+      top,
+      line.height,
+      context
+    );
+  }
+  let cursorX = lineStart;
+  for (let index = 0; index < line.fragments.length; index++) {
+    const fragment = line.fragments[index];
+    if (fragment.kind === "space" && justifyExtra > 0) {
+      cursorX += justifyExtra;
+    }
+    drawLineFragment(page, fragment, cursorX, top, line.height, context);
+    cursorX += fragment.width;
+  }
+}
+function renderSeparator(page, context, top, x, width) {
+  const lineY = toPdfY(context.pageHeight, top + SEPARATOR_HEIGHT / 2);
+  page.drawLine({
+    start: { x, y: lineY },
+    end: { x: x + width, y: lineY },
+    thickness: 1,
+    color: rgb(0.6, 0.6, 0.6)
+  });
+}
+function renderImageBlock(page, block, context, top, baseX = context.margins[3], width = context.contentWidth) {
+  const alignment = normalizeAlignment(block.alignment);
+  let x = baseX;
+  if (alignment === "center" /* CENTER */) {
+    x += Math.max(0, (width - block.width) / 2);
+  } else if (alignment === "right" /* RIGHT */) {
+    x += Math.max(0, width - block.width);
+  }
+  page.drawImage(block.image, {
+    x,
+    y: toPdfY(context.pageHeight, top, block.height),
+    width: block.width,
+    height: block.height
+  });
+}
+function renderTableCell(page, cell, context, table, x, top, width, height) {
+  if (cell.backgroundColor) {
+    page.drawRectangle({
+      x,
+      y: toPdfY(context.pageHeight, top, height),
+      width,
+      height,
+      color: toPdfColor(cell.backgroundColor)
+    });
+  }
+  drawTableCellBorders(page, cell, context, table, x, top, width, height);
+  const padding = getPadding(cell.padding || defaultTableOption.tdPadding).map(
+    pxToPt
+  );
+  const contentWidth = Math.max(1, width - padding[1] - padding[3]);
+  const contentHeight = measureBlocksHeight(cell.blocks, contentWidth, context);
+  let contentTop = top + padding[0];
+  if (cell.verticalAlign === VerticalAlign.CENTER) {
+    contentTop = top + (height - contentHeight) / 2;
+  } else if (cell.verticalAlign === "bottom" /* BOTTOM */) {
+    contentTop = top + height - contentHeight - padding[2];
+  }
+  renderBlocksInRegion(
+    page,
+    cell.blocks,
+    context,
+    x + padding[3],
+    contentTop,
+    contentWidth
+  );
+}
+function renderPageNumber(page, context, pageNumber, pageIndex, totalPages) {
+  if (pageNumber.disabled || pageIndex < pageNumber.fromPageNo || Number.isInteger(pageNumber.maxPageNo) && pageIndex >= pageNumber.maxPageNo) {
+    return;
+  }
+  let text = pageNumber.format || FORMAT_PLACEHOLDER.PAGE_NO;
+  const currentValue = pageIndex + pageNumber.startPageNo - pageNumber.fromPageNo;
+  const totalValue = totalPages - pageNumber.fromPageNo;
+  text = text.replace(
+    new RegExp(FORMAT_PLACEHOLDER.PAGE_NO, "g"),
+    `${currentValue}`
+  );
+  text = text.replace(
+    new RegExp(FORMAT_PLACEHOLDER.PAGE_COUNT, "g"),
+    `${Math.max(0, totalValue)}`
+  );
+  const font = getFont(
+    pageNumber.font || context.options.defaultFont,
+    false,
+    false,
+    context
+  );
+  const size = pageNumber.size || 12;
+  const bottom = pxToPt(pageNumber.bottom || 0);
+  const safeText = sanitizeTextForPdf(text, font);
+  const width = font.widthOfTextAtSize(safeText, size);
+  const descenderHeight = Math.max(
+    0,
+    font.heightAtSize(size) - font.heightAtSize(size, { descender: false })
+  );
+  let x = context.margins[3];
+  const alignment = normalizeAlignment(pageNumber.rowFlex);
+  if (alignment === "center" /* CENTER */) {
+    x = (context.pageWidth - width) / 2;
+  } else if (alignment === "right" /* RIGHT */) {
+    x = context.pageWidth - context.margins[1] - width;
+  }
+  page.drawText(safeText, {
+    x,
+    // Canvas draw uses the alphabetic baseline at `pageHeight - bottom`.
+    // pdf-lib positions text from the text box bottom, so compensate by the
+    // descender height to keep the baseline aligned.
+    y: bottom - descenderHeight,
+    size,
+    font,
+    color: toPdfColor(pageNumber.color, "#000000")
+  });
+}
+function layoutParagraph(block, width, context) {
+  const markerWidth = getMarkerWidth(block, context);
+  const listIndent = block.context.listMarker ? pxToPt(block.context.listMarker.level * INDENT_PER_LEVEL) : 0;
+  const availableWidth = Math.max(1, width - listIndent - markerWidth);
+  const tokens = tokenizeParagraphRuns(block.runs, context);
+  const lines = [];
+  let line = {
+    fragments: [],
+    width: 0,
+    height: getEmptyLineHeight(block, context)
+  };
+  const commitLine = () => {
+    trimTrailingSpaces(line);
+    lines.push(line);
+    line = {
+      fragments: [],
+      width: 0,
+      height: getEmptyLineHeight(block, context)
+    };
+  };
+  for (let i = 0; i < tokens.length; i++) {
+    let token = tokens[i];
+    if (token.kind === "space" && !line.fragments.length) {
+      continue;
+    }
+    if (token.width > availableWidth && token.kind === "text" && token.run.type === "text") {
+      const segments = splitTextToken(token, availableWidth, context);
+      for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+        tokens.splice(i + segmentIndex, 0, segments[segmentIndex]);
+      }
+      continue;
+    }
+    if (line.width + token.width > availableWidth && line.fragments.length) {
+      commitLine();
+      i--;
+      continue;
+    }
+    line.fragments.push(token);
+    line.width += token.width;
+    line.height = Math.max(line.height, token.height);
+  }
+  if (line.fragments.length || !lines.length) {
+    commitLine();
+  }
+  return {
+    lines,
+    height: lines.reduce((sum, current) => sum + current.height, 0),
+    markerWidth,
+    listIndent
+  };
+}
+function tokenizeParagraphRuns(runs, context) {
+  const fragments = [];
+  for (let index = 0; index < runs.length; index++) {
+    const run = runs[index];
+    if (run.type === "tab") {
+      fragments.push({
+        kind: "tab",
+        width: run.width,
+        height: 0,
+        run
+      });
+      continue;
+    }
+    if (run.type === "image") {
+      fragments.push({
+        kind: "image",
+        width: run.width,
+        height: run.height,
+        run
+      });
+      continue;
+    }
+    if (run.type === "badge") {
+      const badgeWidth = measureBadgeWidth(run, context);
+      const badgeHeight = measureBadgeHeight(run);
+      fragments.push({
+        kind: "badge",
+        width: badgeWidth,
+        height: badgeHeight,
+        run
+      });
+      continue;
+    }
+    const parts = run.text.split(/(\s+)/);
+    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
+      const part = parts[partIndex];
+      if (!part) continue;
+      const isWhitespace = /^\s+$/.test(part);
+      fragments.push({
+        kind: isWhitespace ? "space" : "text",
+        width: measureTextWidth(part, run, context),
+        height: getRunHeight(run),
+        run: { ...run, text: part }
+      });
+    }
+  }
+  return fragments;
+}
+function splitTextToken(token, availableWidth, context) {
+  if (token.run.type !== "text") {
+    return [token];
+  }
+  const chars = splitText(token.run.text);
+  const result = [];
+  let current = "";
+  for (let i = 0; i < chars.length; i++) {
+    const next = current + chars[i];
+    const width = measureTextWidth(next, token.run, context);
+    if (width > availableWidth && current) {
+      result.push({
+        kind: "text",
+        width: measureTextWidth(current, token.run, context),
+        height: getRunHeight(token.run),
+        run: { ...token.run, text: current }
+      });
+      current = chars[i];
+    } else {
+      current = next;
+    }
+  }
+  if (current) {
+    result.push({
+      kind: /^\s+$/.test(current) ? "space" : "text",
+      width: measureTextWidth(current, token.run, context),
+      height: getRunHeight(token.run),
+      run: { ...token.run, text: current }
+    });
+  }
+  return result.length ? result : [token];
+}
+function trimTrailingSpaces(line) {
+  while (line.fragments.length && line.fragments[line.fragments.length - 1].kind === "space") {
+    const fragment = line.fragments.pop();
+    line.width -= fragment.width;
+  }
+}
+function layoutTable(table, width, context) {
+  const rowHeights = table.rows.map(
+    (row) => Math.max(
+      pxToPt(row.height),
+      pxToPt(context.options.table.defaultTrMinHeight)
+    )
+  );
+  const scaledColWidths = scaleColumnWidths(table.colWidths, width);
+  for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex++) {
+    const row = table.rows[rowIndex];
+    for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
+      const cell = row.cells[cellIndex];
+      const cellWidth = getColumnSpanWidth(
+        scaledColWidths,
+        cell.colIndex,
+        cell.colspan
+      );
+      const padding = getPadding(
+        cell.padding || defaultTableOption.tdPadding
+      ).map(pxToPt);
+      const contentWidth = Math.max(1, cellWidth - padding[1] - padding[3]);
+      const contentHeight = measureBlocksHeight(cell.blocks, contentWidth, context) + padding[0] + padding[2];
+      const spanHeight = getRowSpanHeight(rowHeights, rowIndex, cell.rowspan);
+      if (contentHeight > spanHeight) {
+        rowHeights[rowIndex + cell.rowspan - 1] += contentHeight - spanHeight;
+      }
+    }
+  }
+  return {
+    rowHeights,
+    totalHeight: rowHeights.reduce((sum, height) => sum + height, 0)
+  };
+}
+function measureBlocksHeight(blocks, width, context) {
+  let height = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (block.type === "pageBreak") {
+      continue;
+    }
+    if (block.type === "paragraph") {
+      height += layoutParagraph(block, width, context).height;
+      continue;
+    }
+    if (block.type === "separator") {
+      height += context.separatorGap;
+      continue;
+    }
+    if (block.type === "image") {
+      height += block.height;
+      continue;
+    }
+    height += layoutTable(block, width, context).totalHeight;
+  }
+  return height;
+}
+function drawLineFragment(page, fragment, x, top, lineHeight, context) {
+  if (fragment.run.type === "tab") {
+    return;
+  }
+  if (fragment.run.type === "image") {
+    const imageTop = top + (lineHeight - fragment.run.height) / 2;
+    page.drawImage(fragment.run.image, {
+      x,
+      y: toPdfY(context.pageHeight, imageTop, fragment.run.height),
+      width: fragment.run.width,
+      height: fragment.run.height
+    });
+    return;
+  }
+  if (fragment.run.type === "badge") {
+    const badgeHeight = measureBadgeHeight(fragment.run);
+    const badgeTop = top + (lineHeight - badgeHeight) / 2;
+    const padding = getPadding(fragment.run.padding || [2, 4, 2, 4]).map(
+      pxToPt
+    );
+    page.drawRectangle({
+      x,
+      y: toPdfY(context.pageHeight, badgeTop, badgeHeight),
+      width: fragment.width,
+      height: badgeHeight,
+      color: toPdfColor(fragment.run.backgroundColor, "#FFFFFF"),
+      borderColor: fragment.run.borderColor ? toPdfColor(fragment.run.borderColor) : void 0,
+      borderWidth: fragment.run.borderColor ? 0.75 : void 0
+    });
+    drawTextRun(
+      page,
+      fragment.run,
+      fragment.run.text,
+      x + padding[3],
+      badgeTop + padding[0],
+      badgeHeight - padding[0] - padding[2],
+      context
+    );
+    return;
+  }
+  if (fragment.run.type !== "text") {
+    return;
+  }
+  drawTextRun(
+    page,
+    fragment.run,
+    fragment.run.text,
+    x,
+    top,
+    lineHeight,
+    context
+  );
+}
+function drawTextRun(page, run, text, x, top, lineHeight, context) {
+  const resolved = resolveTextMetrics(run, context);
+  const safeText = sanitizeTextForPdf(text, resolved.font);
+  let textTop = top + (lineHeight - resolved.size) / 2;
+  if (run.type === "text" && run.superscript) {
+    textTop -= resolved.size * 0.25;
+  }
+  if (run.type === "text" && run.subscript) {
+    textTop += resolved.size * 0.2;
+  }
+  const textY = toPdfY(context.pageHeight, textTop, resolved.size);
+  if ("highlight" in run && run.highlight) {
+    page.drawRectangle({
+      x,
+      y: textY,
+      width: resolved.font.widthOfTextAtSize(safeText, resolved.size),
+      height: resolved.size * 1.05,
+      color: toPdfColor(run.highlight)
+    });
+  }
+  page.drawText(safeText, {
+    x,
+    y: textY,
+    size: resolved.size,
+    font: resolved.font,
+    color: toPdfColor(run.color, "#000000")
+  });
+  const textWidth = resolved.font.widthOfTextAtSize(safeText, resolved.size);
+  if (run.underline) {
+    const underlineY = textY - 1;
+    page.drawLine({
+      start: { x, y: underlineY },
+      end: { x: x + textWidth, y: underlineY },
+      thickness: 0.75,
+      color: toPdfColor(run.color, "#000000")
+    });
+  }
+  if (run.strikeout) {
+    const strikeY = textY + resolved.size * 0.35;
+    page.drawLine({
+      start: { x, y: strikeY },
+      end: { x: x + textWidth, y: strikeY },
+      thickness: 0.75,
+      color: toPdfColor(run.color, "#000000")
+    });
+  }
+}
+function drawTableCellBorders(page, cell, context, table, x, top, width, height) {
+  const tableColor = table.borderColor || context.options.table.defaultBorderColor;
+  const innerWidth = table.borderWidth || 1;
+  const outerWidth = table.borderExternalWidth || innerWidth;
+  const color = cell.borderColor || tableColor;
+  const isEmpty = table.borderType === "empty" /* EMPTY */;
+  const isExternal = table.borderType === "external" /* EXTERNAL */;
+  const isInternal = table.borderType === "internal" /* INTERNAL */;
+  const isDash = table.borderType === "dash" /* DASH */;
+  const dashArray = isDash ? [3, 3] : void 0;
+  const lineColor = toPdfColor(color, "#000000");
+  const bottomY = toPdfY(context.pageHeight, top, height);
+  const topY = toPdfY(context.pageHeight, top);
+  const rightX = x + width;
+  const drawEdge = (startX, startY, endX, endY, thickness) => {
+    page.drawLine({
+      start: { x: startX, y: startY },
+      end: { x: endX, y: endY },
+      thickness,
+      color: lineColor,
+      dashArray
+    });
+  };
+  if (cell.borderTypes?.length) {
+    if (cell.borderTypes.includes("top" /* TOP */)) {
+      drawEdge(x, topY, rightX, topY, innerWidth);
+    }
+    if (cell.borderTypes.includes("right" /* RIGHT */)) {
+      drawEdge(rightX, topY, rightX, bottomY, innerWidth);
+    }
+    if (cell.borderTypes.includes("bottom" /* BOTTOM */)) {
+      drawEdge(x, bottomY, rightX, bottomY, innerWidth);
+    }
+    if (cell.borderTypes.includes("left" /* LEFT */)) {
+      drawEdge(x, topY, x, bottomY, innerWidth);
+    }
+  }
+  if (cell.borderColor && !cell.borderTypes?.length) {
+    drawEdge(x, topY, rightX, topY, innerWidth);
+    drawEdge(rightX, topY, rightX, bottomY, innerWidth);
+    drawEdge(x, bottomY, rightX, bottomY, innerWidth);
+    drawEdge(x, topY, x, bottomY, innerWidth);
+    return;
+  }
+  if (isEmpty) {
+    return;
+  }
+  if (!isInternal) {
+    drawEdge(x, topY, rightX, topY, outerWidth);
+    drawEdge(x, topY, x, bottomY, outerWidth);
+    drawEdge(rightX, topY, rightX, bottomY, outerWidth);
+    drawEdge(x, bottomY, rightX, bottomY, outerWidth);
+    if (isExternal) {
+      return;
+    }
+  }
+  drawEdge(rightX, topY, rightX, bottomY, innerWidth);
+  drawEdge(x, bottomY, rightX, bottomY, innerWidth);
+}
+function getMarkerWidth(block, context) {
+  if (!block.context.listMarker) {
+    return 0;
+  }
+  const markerRun = getMarkerRun(block, context);
+  return measureTextWidth(block.context.listMarker.text, markerRun, context) + pxToPt(LIST_GAP);
+}
+function getMarkerRun(block, context) {
+  const firstTextRun = block.runs.find((run) => run.type === "text" || run.type === "badge") || null;
+  if (!firstTextRun) {
+    return {
+      type: "text",
+      text: "",
+      size: context.options.defaultSize,
+      font: context.options.defaultFont
+    };
+  }
+  if (firstTextRun.type === "badge") {
+    return {
+      type: "text",
+      text: firstTextRun.text,
+      size: firstTextRun.size,
+      font: firstTextRun.font,
+      bold: firstTextRun.bold,
+      italic: firstTextRun.italic,
+      color: firstTextRun.color
+    };
+  }
+  return firstTextRun;
+}
+function getEmptyLineHeight(block, context) {
+  const markerRun = getMarkerRun(block, context);
+  return getRunHeight(
+    markerRun,
+    block.context.rowMargin || context.options.defaultRowMargin
+  );
+}
+function getRunHeight(run, rowMargin = DEFAULT_LINE_HEIGHT2) {
+  return run.size * rowMargin;
+}
+function resolveTextMetrics(run, context) {
+  let size = run.size || context.options.defaultSize;
+  if ("superscript" in run && run.superscript) {
+    size *= 0.65;
+  }
+  if ("subscript" in run && run.subscript) {
+    size *= 0.65;
+  }
+  return {
+    size,
+    font: getFont(
+      run.font || context.options.defaultFont,
+      !!run.bold,
+      !!run.italic,
+      context
+    )
+  };
+}
+function measureTextWidth(text, run, context) {
+  const resolved = resolveTextMetrics(run, context);
+  const safeText = sanitizeTextForPdf(text, resolved.font);
+  return resolved.font.widthOfTextAtSize(safeText, resolved.size);
+}
+function measureBadgeWidth(run, context) {
+  const padding = getPadding(run.padding || [2, 4, 2, 4]).map(pxToPt);
+  return measureTextWidth(run.text, run, context) + padding[1] + padding[3];
+}
+function measureBadgeHeight(run) {
+  const padding = getPadding(run.padding || [2, 4, 2, 4]).map(pxToPt);
+  return run.size + padding[0] + padding[2];
+}
+function getJustifyExtra(line, availableWidth) {
+  const spaceCount = line.fragments.filter(
+    (fragment) => fragment.kind === "space"
+  ).length;
+  if (!spaceCount || line.width >= availableWidth) {
+    return 0;
+  }
+  return (availableWidth - line.width) / spaceCount;
+}
+function isLastParagraphLine(layout, line) {
+  return layout.lines[layout.lines.length - 1] === line;
+}
+function getSpanningRowHeight(rows, rowHeights, rowIndex) {
+  const row = rows[rowIndex];
+  let maxHeight = rowHeights[rowIndex];
+  for (let i = 0; i < row.cells.length; i++) {
+    const cell = row.cells[i];
+    maxHeight = Math.max(
+      maxHeight,
+      getRowSpanHeight(rowHeights, rowIndex, cell.rowspan)
+    );
+  }
+  return maxHeight;
+}
+function getRowSpanHeight(rowHeights, rowIndex, rowSpan) {
+  let height = 0;
+  for (let i = rowIndex; i < rowIndex + rowSpan; i++) {
+    height += rowHeights[i] || 0;
+  }
+  return height;
+}
+function scaleColumnWidths(widths, maxWidth) {
+  const ptWidths = widths.map(pxToPt);
+  const total = ptWidths.reduce((sum, width) => sum + width, 0);
+  if (!total || total <= maxWidth) {
+    return ptWidths;
+  }
+  const ratio = maxWidth / total;
+  return ptWidths.map((width) => width * ratio);
+}
+function getColumnOffset(widths, colIndex) {
+  let offset = 0;
+  for (let i = 0; i < colIndex; i++) {
+    offset += widths[i] || 0;
+  }
+  return offset;
+}
+function getColumnSpanWidth(widths, colIndex, span) {
+  let width = 0;
+  for (let i = colIndex; i < colIndex + span; i++) {
+    width += widths[i] || 0;
+  }
+  return width;
+}
+function computeTableCellPlacement(trList, colgroup) {
+  const placementMap = /* @__PURE__ */ new WeakMap();
+  if (!trList.length || !colgroup.length) {
+    return placementMap;
+  }
+  const occupiedUntilRow = Array(colgroup.length).fill(0);
+  for (let rowIndex = 0; rowIndex < trList.length; rowIndex++) {
+    const tr = trList[rowIndex];
+    let colIndex = 0;
+    for (let tdIndex = 0; tdIndex < tr.tdList.length; tdIndex++) {
+      while (colIndex < colgroup.length && occupiedUntilRow[colIndex] > rowIndex) {
+        colIndex += 1;
+      }
+      const td = tr.tdList[tdIndex];
+      let width = 0;
+      for (let currentCol = colIndex; currentCol < colIndex + td.colspan; currentCol++) {
+        width += colgroup[currentCol]?.width || 0;
+        occupiedUntilRow[currentCol] = Math.max(
+          occupiedUntilRow[currentCol],
+          rowIndex + td.rowspan
+        );
+      }
+      placementMap.set(td, { colIndex, width });
+      colIndex += td.colspan;
+    }
+  }
+  return placementMap;
+}
+async function loadPdfImage(src, context) {
+  if (context.imageCache.has(src)) {
+    return context.imageCache.get(src);
+  }
+  try {
+    const payload = await loadPdfImagePayload(src);
+    const image = payload.type === "jpg" ? await context.pdfDoc.embedJpg(payload.data) : await context.pdfDoc.embedPng(payload.data);
+    context.imageCache.set(src, image);
+    return image;
+  } catch {
+    return null;
+  }
+}
+async function loadPdfImagePayload(src) {
+  const source = src.trim();
+  if (source.startsWith("data:")) {
+    return getPdfImagePayloadFromDataUrl(source);
+  }
+  const response = await fetch(source);
+  if (!response.ok) {
+    throw new Error(`Image request failed: ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  const data2 = await response.arrayBuffer();
+  return normalizePdfImagePayload(data2, contentType);
+}
+async function getPdfImagePayloadFromDataUrl(src) {
+  const [, meta = "", encoded = ""] = src.match(/^data:([^,]*),(.*)$/) || [];
+  const mime = meta.split(";")[0] || "";
+  const isBase64 = meta.includes(";base64");
+  const text = isBase64 ? atob(encoded) : decodeURIComponent(encoded);
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) {
+    bytes[i] = text.charCodeAt(i);
+  }
+  return normalizePdfImagePayload(bytes.buffer, mime);
+}
+async function normalizePdfImagePayload(data2, mime) {
+  const lower = mime.toLowerCase();
+  if (lower.includes("jpeg") || lower.includes("jpg")) {
+    return {
+      type: "jpg",
+      data: data2
+    };
+  }
+  if (lower.includes("png")) {
+    return {
+      type: "png",
+      data: data2
+    };
+  }
+  return {
+    type: "png",
+    data: await rasterizeImageToPng2(data2, mime)
+  };
+}
+async function rasterizeImageToPng2(data2, mime) {
+  const blob = new Blob([data2], {
+    type: mime || "image/png"
+  });
+  const url = URL.createObjectURL(blob);
+  try {
+    const image = await loadHtmlImage2(url);
+    const canvas = document.createElement("canvas");
+    canvas.width = image.naturalWidth || DEFAULT_IMAGE_WIDTH2;
+    canvas.height = image.naturalHeight || DEFAULT_IMAGE_HEIGHT2;
+    const context = canvas.getContext("2d");
+    if (!context) {
+      throw new Error("Canvas context is unavailable");
+    }
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    const pngBlob = await new Promise((resolve, reject) => {
+      canvas.toBlob((output) => {
+        if (output) {
+          resolve(output);
+        } else {
+          reject(new Error("Failed to create PNG blob"));
+        }
+      }, "image/png");
+    });
+    return await pngBlob.arrayBuffer();
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function loadHtmlImage2(src) {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error("Failed to load image"));
+    image.src = src;
+  });
+}
+function getInlineElementText2(element) {
+  switch (element.type) {
+    case "control" /* CONTROL */:
+      return getControlText2(element.control);
+    case "date" /* DATE */:
+      return element.valueList?.length ? getTextFromElementList(element.valueList) : element.value;
+    case "checkbox" /* CHECKBOX */:
+      return element.checkbox?.value ? "\u2611" : "\u2610";
+    case "radio" /* RADIO */:
+      return element.radio?.value ? "\u25C9" : "\u25CB";
+    case "label" /* LABEL */:
+    case "latex" /* LATEX */:
+    case "subscript" /* SUBSCRIPT */:
+    case "superscript" /* SUPERSCRIPT */:
+      return element.value;
+    default:
+      return element.value;
+  }
+}
+function getControlText2(control) {
+  if (!control) return "";
+  if (control.type === "text" /* TEXT */ || control.type === "date" /* DATE */ || control.type === "number" /* NUMBER */) {
+    const value = control.value?.length ? getTextFromElementList(control.value) : "";
+    const content = value || control.placeholder || "";
+    return `${control.preText || ""}${content}${control.postText || ""}`;
+  }
+  if (control.type === "select" /* SELECT */) {
+    const labels = getSelectedControlLabels2(control.code, control.valueSets);
+    const content = labels.length ? labels.join(control.multiSelectDelimiter || ", ") : control.placeholder || "";
+    return `${control.preText || ""}${content}${control.postText || ""}`;
+  }
+  if (control.type === "checkbox" /* CHECKBOX */ || control.type === "radio" /* RADIO */) {
+    const isRadio = control.type === "radio" /* RADIO */;
+    return (control.valueSets || []).map((valueSet) => {
+      const checked = control.code?.split(",").includes(valueSet.code) || false;
+      return `${checked ? isRadio ? "\u25C9" : "\u2611" : isRadio ? "\u25CB" : "\u2610"} ${valueSet.value}`;
+    }).join("  ");
+  }
+  return "";
+}
+function getSelectedControlLabels2(code, valueSets) {
+  if (!code || !valueSets?.length) return [];
+  return code.split(",").map(
+    (selectCode) => valueSets.find((valueSet) => valueSet.code === selectCode)?.value
+  ).filter((value) => !!value);
+}
+function getBlockFallbackText2(element) {
+  if (element.block?.iframeBlock?.src) {
+    return element.block.iframeBlock.src;
+  }
+  if (element.block?.videoBlock?.src) {
+    return element.block.videoBlock.src;
+  }
+  return "";
+}
+function getListItemNumberingElement2(listItemElements, fallback) {
+  return listItemElements.find(
+    (listItem) => listItem.listId || listItem.listLevel !== void 0 || !!listItem.listPreset || !!listItem.listStyle || !!listItem.listType
+  ) || fallback;
+}
+function getListMarker(element, orderedCounts) {
+  const level = Math.max(0, Math.min(element.listLevel || 0, 8));
+  if (element.listType === "ul" /* UL */) {
+    return {
+      text: getUnorderedMarkerText(element, level),
+      level
+    };
+  }
+  while (orderedCounts.length <= level) {
+    orderedCounts.push(0);
+  }
+  orderedCounts[level] += 1;
+  orderedCounts.length = level + 1;
+  const style = element.listPreset ? getOrderedPresetStyle(element.listPreset, level) : getOrderedStyle(element.listStyle);
+  const outlinePrefix = style === "outline" ? orderedCounts.slice(0, level + 1).join(".") : void 0;
+  return {
+    text: formatOlNumber2(orderedCounts[level] - 1, style, outlinePrefix),
+    level
+  };
+}
+function getOrderedPresetStyle(preset, level = 0) {
+  const cycle = preset ? olPresetCycles[preset] : void 0;
+  if (!cycle?.length) {
+    return "decimal";
+  }
+  return cycle[level % cycle.length];
+}
+function getOrderedStyle(style) {
+  switch (style) {
+    case "lowerAlpha" /* LOWER_ALPHA */:
+      return "lowerAlpha";
+    case "upperAlpha" /* UPPER_ALPHA */:
+      return "upperAlpha";
+    case "lowerRoman" /* LOWER_ROMAN */:
+      return "lowerRoman";
+    case "upperRoman" /* UPPER_ROMAN */:
+      return "upperRoman";
+    case "decimalParen" /* DECIMAL_PAREN */:
+      return "decimalParen";
+    default:
+      return "decimal";
+  }
+}
+function getUnorderedMarkerText(element, level) {
+  if (element.listPreset) {
+    const cycle = ulPresetCycles[element.listPreset];
+    if (cycle?.length) {
+      return cycle[level % cycle.length];
+    }
+  }
+  return bulletCharMap[element.listStyle || "disc" /* DISC */] || bulletCharMap["disc" /* DISC */];
+}
+function toAlpha2(n, upper) {
+  let result = "";
+  let num = n + 1;
+  while (num > 0) {
+    num--;
+    result = String.fromCharCode((upper ? 65 : 97) + num % 26) + result;
+    num = Math.floor(num / 26);
+  }
+  return result;
+}
+function toRoman2(n, upper) {
+  const num = n + 1;
+  const vals = [1e3, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+  const syms = [
+    "M",
+    "CM",
+    "D",
+    "CD",
+    "C",
+    "XC",
+    "L",
+    "XL",
+    "X",
+    "IX",
+    "V",
+    "IV",
+    "I"
+  ];
+  let result = "";
+  let remaining = num;
+  for (let i = 0; i < vals.length; i++) {
+    while (remaining >= vals[i]) {
+      result += syms[i];
+      remaining -= vals[i];
+    }
+  }
+  return upper ? result : result.toLowerCase();
+}
+function formatOlNumber2(index, style, outlinePrefix) {
+  switch (style) {
+    case "decimal":
+      return `${index + 1}.`;
+    case "decimalParen":
+      return `${index + 1})`;
+    case "decimalZero":
+      return `${String(index + 1).padStart(2, "0")}.`;
+    case "lowerAlpha":
+      return `${toAlpha2(index, false)}.`;
+    case "lowerAlphaParen":
+      return `${toAlpha2(index, false)})`;
+    case "upperAlpha":
+      return `${toAlpha2(index, true)}.`;
+    case "lowerRoman":
+      return `${toRoman2(index, false)}.`;
+    case "lowerRomanParen":
+      return `${toRoman2(index, false)})`;
+    case "upperRoman":
+      return `${toRoman2(index, true)}.`;
+    case "outline":
+      return outlinePrefix ? `${outlinePrefix}.` : `${index + 1}.`;
+    default:
+      return `${index + 1}.`;
+  }
+}
+function normalizeAlignment(rowFlex) {
+  if (rowFlex === "alignment" /* ALIGNMENT */) {
+    return "justify" /* JUSTIFY */;
+  }
+  return rowFlex || "left" /* LEFT */;
+}
+function getFont(family, bold, italic, context) {
+  const fontSet = context.fonts[resolveFontFamily(family)];
+  if (bold && italic) {
+    return fontSet.boldItalic;
+  }
+  if (bold) {
+    return fontSet.bold;
+  }
+  if (italic) {
+    return fontSet.italic;
+  }
+  return fontSet.regular;
+}
+function resolveFontFamily(font) {
+  const normalized = (font || "").trim().toLowerCase();
+  if (normalized.includes("sans-serif") || normalized.includes("arial") || normalized.includes("helvetica") || normalized.includes("yahei") || normalized.includes("microsoft") || normalized.includes("inter") || normalized.includes("roboto")) {
+    return "sans";
+  }
+  if (normalized.includes("times") || normalized === "serif" || normalized.endsWith(", serif")) {
+    return "serif";
+  }
+  if (normalized.includes("courier") || normalized.includes("mono") || normalized.includes("code")) {
+    return "mono";
+  }
+  return "sans";
+}
+function sanitizeTextForPdf(text, font) {
+  let fontCache = pdfTextCache.get(font);
+  if (!fontCache) {
+    fontCache = /* @__PURE__ */ new Map();
+    pdfTextCache.set(font, fontCache);
+  }
+  if (fontCache.has(text)) {
+    return fontCache.get(text);
+  }
+  let safeText = text;
+  try {
+    font.encodeText(text);
+  } catch {
+    safeText = Array.from(text).map((char) => sanitizePdfChar(char, font)).join("");
+  }
+  fontCache.set(text, safeText);
+  return safeText;
+}
+function sanitizePdfChar(char, font) {
+  try {
+    font.encodeText(char);
+    return char;
+  } catch {
+    const directFallback = PDF_TEXT_FALLBACKS[char];
+    if (directFallback) {
+      return directFallback;
+    }
+    if (/^\s$/u.test(char)) {
+      return " ";
+    }
+    const normalized = char.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^\x20-\x7E]/g, "");
+    if (normalized) {
+      try {
+        font.encodeText(normalized);
+        return normalized;
+      } catch {
+        return "?";
+      }
+    }
+    return "?";
+  }
+}
+function getPadding(padding) {
+  return [padding[0] ?? 0, padding[1] ?? 0, padding[2] ?? 0, padding[3] ?? 0];
+}
+function getTitleSize(titleLevel, options) {
+  if (!titleLevel) {
+    return void 0;
+  }
+  return options.title[titleSizeMapping[titleLevel]];
+}
+function getPageNumberHeight(pageNumber) {
+  if (pageNumber.disabled) {
+    return 0;
+  }
+  return pageNumber.size || 12;
+}
+function getFooterBarHeight(footerHeight, context) {
+  if (context.options.footer.disabled) {
+    return 0;
+  }
+  return Math.max(footerHeight, pxToPt(FOOTER_MIN_BAR_HEIGHT));
+}
+function getReservedPageNumberBottom(pageNumber, pageNumberHeight) {
+  if (pageNumber.disabled) {
+    return 0;
+  }
+  return pxToPt(pageNumber.bottom + 4) + pageNumberHeight;
+}
+function normalizeText2(text = "") {
+  return text.replace(new RegExp(ZERO, "g"), "").replace(/\r\n/g, "\n");
+}
+function normalizePdfFileName(fileName) {
+  const trimmed = fileName?.trim();
+  if (!trimmed) {
+    return DEFAULT_PDF_FILE_NAME;
+  }
+  return trimmed.toLowerCase().endsWith(".pdf") ? trimmed : `${trimmed}.pdf`;
+}
+function pxToPt(px) {
+  return px * (72 / 96);
+}
+function toPdfY(pageHeight, top, height = 0) {
+  return pageHeight - top - height;
+}
+function toPdfColor(color, fallback = "#000000") {
+  const hex = normalizeHexColor2(color || fallback, "000000") || "000000";
+  const red = parseInt(hex.slice(0, 2), 16) / 255;
+  const green = parseInt(hex.slice(2, 4), 16) / 255;
+  const blue = parseInt(hex.slice(4, 6), 16) / 255;
+  return rgb(red, green, blue);
+}
+function normalizeHexColor2(color, fallback) {
+  const normalized = normalizeHexLiteral2(color) || normalizeRgbColor2(color) || normalizeBrowserColor2(color);
+  if (normalized) {
+    return normalized;
+  }
+  return fallback ? normalizeHexLiteral2(fallback) || void 0 : void 0;
+}
+function normalizeHexLiteral2(color) {
+  const value = color.trim().replace(/^#/, "");
+  if (/^[\da-f]{3}$/i.test(value)) {
+    return value.split("").map((part) => `${part}${part}`).join("").toUpperCase();
+  }
+  if (/^[\da-f]{4}$/i.test(value)) {
+    return value.slice(0, 3).split("").map((part) => `${part}${part}`).join("").toUpperCase();
+  }
+  if (/^[\da-f]{6}$/i.test(value)) {
+    return value.toUpperCase();
+  }
+  if (/^[\da-f]{8}$/i.test(value)) {
+    return value.slice(0, 6).toUpperCase();
+  }
+  return void 0;
+}
+function normalizeRgbColor2(color) {
+  const match = color.trim().match(/^rgba?\((.+)\)$/i);
+  if (!match) {
+    return void 0;
+  }
+  const parts = match[1].replace(/\s*\/\s*/g, ",").split(/\s*,\s*|\s+/).filter(Boolean);
+  if (parts.length < 3) {
+    return void 0;
+  }
+  const red = parseRgbChannel2(parts[0]);
+  const green = parseRgbChannel2(parts[1]);
+  const blue = parseRgbChannel2(parts[2]);
+  if (red === null || green === null || blue === null) {
+    return void 0;
+  }
+  const alpha = parts[3] !== void 0 ? parseAlphaChannel2(parts[3]) : 1;
+  if (alpha === null || alpha <= 0) {
+    return void 0;
+  }
+  const flattened = alpha >= 1 ? [red, green, blue] : [
+    flattenChannel2(red, alpha),
+    flattenChannel2(green, alpha),
+    flattenChannel2(blue, alpha)
+  ];
+  return flattened.map(toHexChannel2).join("");
+}
+function normalizeBrowserColor2(color) {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return void 0;
+  }
+  context.fillStyle = "#000000";
+  context.fillStyle = color;
+  const normalized = context.fillStyle;
+  if (typeof normalized !== "string") {
+    return void 0;
+  }
+  return normalizeHexLiteral2(normalized) || normalizeRgbColor2(normalized);
+}
+function parseRgbChannel2(value) {
+  if (value.endsWith("%")) {
+    const percent = Number(value.slice(0, -1));
+    if (!Number.isFinite(percent)) {
+      return null;
+    }
+    return clampColorChannel2(Math.round(percent / 100 * 255));
+  }
+  const channel = Number(value);
+  if (!Number.isFinite(channel)) {
+    return null;
+  }
+  return clampColorChannel2(Math.round(channel));
+}
+function parseAlphaChannel2(value) {
+  if (value.endsWith("%")) {
+    const percent = Number(value.slice(0, -1));
+    if (!Number.isFinite(percent)) {
+      return null;
+    }
+    return Math.min(Math.max(percent / 100, 0), 1);
+  }
+  const alpha = Number(value);
+  if (!Number.isFinite(alpha)) {
+    return null;
+  }
+  return Math.min(Math.max(alpha, 0), 1);
+}
+function clampColorChannel2(value) {
+  return Math.min(Math.max(value, 0), 255);
+}
+function flattenChannel2(value, alpha) {
+  return clampColorChannel2(Math.round(255 * (1 - alpha) + value * alpha));
+}
+function toHexChannel2(value) {
+  return value.toString(16).padStart(2, "0").toUpperCase();
+}
+
+// src/utils/print.ts
+function convertPxToPaperSize(width, height) {
+  if (width === 1125 && height === 1593) {
+    return {
+      size: "a3",
+      width: "297mm",
+      height: "420mm"
+    };
+  }
+  if (width === 794 && height === 1123) {
+    return {
+      size: "a4",
+      width: "210mm",
+      height: "297mm"
+    };
+  }
+  if (width === 565 && height === 796) {
+    return {
+      size: "a5",
+      width: "148mm",
+      height: "210mm"
+    };
+  }
+  return {
+    size: "",
+    width: `${width}px`,
+    height: `${height}px`
+  };
+}
+function printImageBase64(base64List, options) {
+  const { width, height, direction = "vertical" /* VERTICAL */ } = options;
+  const iframe = document.createElement("iframe");
+  iframe.style.visibility = "hidden";
+  iframe.style.position = "absolute";
+  iframe.style.left = "0";
+  iframe.style.top = "0";
+  iframe.style.width = "0";
+  iframe.style.height = "0";
+  iframe.style.border = "none";
+  document.body.append(iframe);
+  const contentWindow = iframe.contentWindow;
+  const doc = contentWindow.document;
+  doc.open();
+  const container = document.createElement("div");
+  const paperSize = convertPxToPaperSize(width, height);
+  base64List.forEach((base64) => {
+    const image = document.createElement("img");
+    image.style.width = direction === "horizontal" /* HORIZONTAL */ ? paperSize.height : paperSize.width;
+    image.style.height = direction === "horizontal" /* HORIZONTAL */ ? paperSize.width : paperSize.height;
+    image.src = base64;
+    container.append(image);
+  });
+  const style = document.createElement("style");
+  const stylesheet = `
+  * {
+    margin: 0;
+    padding: 0;
+  }
+  @page {
+    margin: 0;
+    size: ${paperSize.size} ${direction === "horizontal" /* HORIZONTAL */ ? `landscape` : `portrait`};
+  }`;
+  style.append(document.createTextNode(stylesheet));
+  setTimeout(() => {
+    doc.write(`${style.outerHTML}${container.innerHTML}`);
+    contentWindow.print();
+    doc.close();
+    window.addEventListener(
+      "mouseover",
+      () => {
+        iframe?.remove();
+      },
+      {
+        once: true
+      }
+    );
+  });
+}
+
+// src/core/command/CommandAdapt.ts
+var CommandAdapt = class {
+  constructor(draw) {
+    this.draw = draw;
+    this.range = draw.getRange();
+    this.position = draw.getPosition();
+    this.historyManager = draw.getHistoryManager();
+    this.canvasEvent = draw.getCanvasEvent();
+    this.options = draw.getOptions();
+    this.control = draw.getControl();
+    this.workerManager = draw.getWorkerManager();
+    this.searchManager = draw.getSearch();
+    this.i18n = draw.getI18n();
+    this.zone = draw.getZone();
+    this.tableOperate = draw.getTableOperate();
+  }
+  getStyleSelectionElementList(options = {}) {
+    const selection = this.range.getSelectionElementList();
+    if (!selection?.length) return null;
+    const { textLikeOnly = false } = options;
+    const result = [];
+    const collect = (elementList) => {
+      for (let i = 0; i < elementList.length; i++) {
+        const element = elementList[i];
+        if (element.type === "table" /* TABLE */ && element.trList?.length) {
+          for (let t = 0; t < element.trList.length; t++) {
+            const tr = element.trList[t];
+            for (let d = 0; d < tr.tdList.length; d++) {
+              collect(tr.tdList[d].value);
+            }
+          }
+          continue;
+        }
+        result.push(element);
+      }
+    };
+    collect(selection);
+    if (!textLikeOnly) {
+      return result;
+    }
+    return result.filter(
+      (element) => isTextLikeElement(element) || element.type === "label" /* LABEL */
+    );
+  }
+  mode(payload) {
+    this.draw.setMode(payload);
+  }
+  async cut() {
+    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
+    if (isDisabled) return;
+    await this.canvasEvent.cut();
+  }
+  async copy(payload) {
+    await this.canvasEvent.copy(payload);
+  }
+  paste(payload) {
+    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
+    if (isDisabled) return;
+    pasteByApi(this.canvasEvent, payload);
+  }
+  selectAll() {
+    this.canvasEvent.selectAll();
+  }
+  backspace() {
+    const isDisabled = this.draw.isReadonly() || this.draw.isDisabled();
+    if (isDisabled) return;
+    const elementList = this.draw.getElementList();
+    const { startIndex, endIndex } = this.range.getRange();
+    const isCollapsed = startIndex === endIndex;
+    if (isCollapsed && elementList[startIndex].value === ZERO && startIndex === 0) {
+      return;
+    }
+    if (!isCollapsed) {
+      this.draw.spliceElementList(
+        elementList,
+        startIndex + 1,
+        endIndex - startIndex
+      );
+    } else {
+      this.draw.spliceElementList(elementList, startIndex, 1);
+    }
+    const curIndex = isCollapsed ? startIndex - 1 : startIndex;
+    this.range.setRange(curIndex, curIndex);
+    this.draw.render({ curIndex });
+  }
+  setRange(startIndex, endIndex, tableId, startTdIndex, endTdIndex, startTrIndex, endTrIndex) {
+    if (startIndex < 0 || endIndex < 0 || endIndex < startIndex) return;
     this.range.setRange(
       startIndex,
       endIndex,
@@ -25550,6 +28731,16 @@ var CommandAdapt = class {
       this.draw.setPageScale(scale);
     }
   }
+  async exportDocx(payload = {}) {
+    const result = this.draw.getValue();
+    const { blob, fileName } = await exportEditorDataToDocx(result, payload);
+    downloadBlob(blob, fileName);
+  }
+  async exportPdf(payload = {}) {
+    const result = this.draw.getValue();
+    const { blob, fileName } = await exportEditorDataToPdf(result, payload);
+    downloadBlob(blob, fileName);
+  }
   replaceImageElement(payload) {
     const { startIndex } = this.range.getRange();
     const elementList = this.draw.getElementList();