@windoc/core 0.3.23 → 0.3.25

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.3.23";
+var version = "0.3.25";
 
 // src/dataset/enum/Common.ts
 var MaxHeightRatio = /* @__PURE__ */ ((MaxHeightRatio2) => {
@@ -106,21 +106,6 @@ function debounce(func, delay) {
     }, delay);
   };
 }
-function deepCloneOmitKeys(obj, omitKeys) {
-  if (!obj || typeof obj !== "object") {
-    return obj;
-  }
-  let newObj = {};
-  if (Array.isArray(obj)) {
-    newObj = obj.map((item) => deepCloneOmitKeys(item, omitKeys));
-  } else {
-    Object.keys(obj).forEach((key) => {
-      if (omitKeys.includes(key)) return;
-      newObj[key] = deepCloneOmitKeys(obj[key], omitKeys);
-    });
-  }
-  return newObj;
-}
 function deepClone(obj) {
   if (typeof structuredClone === "function") {
     return structuredClone(obj);
@@ -192,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);
 }
@@ -3817,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
@@ -4944,9 +4936,7 @@ function mergeSplitTableRowsForZip(trList) {
   for (let t = trList.length - 1; t >= 0; t--) {
     const splitTr = trList[t];
     if (!splitTr.splitParentId) continue;
-    const parentTrIdx = trList.findIndex(
-      (tr) => tr.id === splitTr.splitParentId
-    );
+    const parentTrIdx = trList.findIndex((tr) => tr.id === splitTr.splitParentId);
     if (!~parentTrIdx) continue;
     const parentTr = trList[parentTrIdx];
     parentTr.height += splitTr.height;
@@ -5992,10 +5982,184 @@ ${ulListStyleText || `${listIndex + 1}.`}${buildText(
   return buildText(zipElementList(elementList));
 }
 function getSlimCloneElementList(elementList) {
-  return deepCloneOmitKeys(elementList, [
-    "metrics",
-    "style"
-  ]);
+  const snapshotElementList = [];
+  let preSourceElement = null;
+  let preSnapshotElement = null;
+  for (let i = 0; i < elementList.length; i++) {
+    const element = elementList[i];
+    if (preSourceElement && preSnapshotElement && isHistoryTextSnapshotMergeable(preSourceElement, element)) {
+      preSnapshotElement.value += element.value;
+      preSourceElement = element;
+      continue;
+    }
+    const snapshotElement = cloneHistorySnapshotElement(element);
+    snapshotElementList.push(snapshotElement);
+    preSourceElement = element;
+    preSnapshotElement = snapshotElement;
+  }
+  return snapshotElementList;
+}
+var HISTORY_SNAPSHOT_OMIT_ATTR = /* @__PURE__ */ new Set([
+  "metrics",
+  "style",
+  "rowList",
+  "positionList",
+  "x",
+  "y",
+  "trIndex",
+  "tdIndex",
+  "isLastRowTd",
+  "isLastColTd",
+  "isLastTd",
+  "rowIndex",
+  "colIndex",
+  "mainHeight",
+  "realHeight",
+  "realMinHeight",
+  "splitBoundaryTop",
+  "splitBoundaryBottom",
+  "actualSize"
+]);
+function cloneHistorySnapshotValue(payload) {
+  if (!payload || typeof payload !== "object") {
+    return payload;
+  }
+  if (Array.isArray(payload)) {
+    return payload.map((item) => cloneHistorySnapshotValue(item));
+  }
+  const snapshot = {};
+  for (const key of Object.keys(payload)) {
+    if (HISTORY_SNAPSHOT_OMIT_ATTR.has(String(key))) continue;
+    snapshot[String(key)] = cloneHistorySnapshotValue(
+      payload[key]
+    );
+  }
+  return snapshot;
+}
+function cloneHistorySnapshotTd(td) {
+  const snapshot = {};
+  for (const key of Object.keys(td)) {
+    if (HISTORY_SNAPSHOT_OMIT_ATTR.has(String(key))) continue;
+    const value = td[key];
+    if (key === "value") {
+      snapshot.value = getSlimCloneElementList(value);
+      continue;
+    }
+    snapshot[String(key)] = cloneHistorySnapshotValue(value);
+  }
+  return snapshot;
+}
+function cloneHistorySnapshotTr(tr) {
+  const snapshot = {};
+  for (const key of Object.keys(tr)) {
+    if (HISTORY_SNAPSHOT_OMIT_ATTR.has(String(key))) continue;
+    const value = tr[key];
+    if (key === "tdList") {
+      snapshot.tdList = value.map((td) => cloneHistorySnapshotTd(td));
+      continue;
+    }
+    snapshot[String(key)] = cloneHistorySnapshotValue(value);
+  }
+  return snapshot;
+}
+function cloneHistorySnapshotElement(element) {
+  const snapshot = {};
+  for (const key of Object.keys(element)) {
+    if (HISTORY_SNAPSHOT_OMIT_ATTR.has(String(key))) continue;
+    const value = element[key];
+    if (key === "trList" && Array.isArray(value)) {
+      snapshot.trList = value.map((tr) => cloneHistorySnapshotTr(tr));
+      continue;
+    }
+    if (key === "valueList" && Array.isArray(value)) {
+      snapshot.valueList = getSlimCloneElementList(value);
+      continue;
+    }
+    if (key === "control" && value && typeof value === "object") {
+      snapshot.control = cloneHistorySnapshotControl(
+        value
+      );
+      continue;
+    }
+    snapshot[String(key)] = cloneHistorySnapshotValue(value);
+  }
+  return snapshot;
+}
+function cloneHistorySnapshotControl(control) {
+  const snapshot = {};
+  for (const key of Object.keys(control)) {
+    const value = control[key];
+    if (key === "value" && Array.isArray(value)) {
+      snapshot.value = getSlimCloneElementList(value);
+      continue;
+    }
+    snapshot[String(key)] = cloneHistorySnapshotValue(value);
+  }
+  return snapshot;
+}
+function isHistoryTextSnapshotElement(element) {
+  return !element.type || TEXTLIKE_ELEMENT_TYPE.includes(element.type);
+}
+function isHistoryTextSnapshotMergeable(source, target) {
+  if (!isHistoryTextSnapshotElement(source) || !isHistoryTextSnapshotElement(target)) {
+    return false;
+  }
+  return isSameHistoryElementExceptValue(source, target);
+}
+function isSameHistoryElementExceptValue(source, target) {
+  const sourceKeys = Object.keys(source).filter(
+    (key) => !HISTORY_SNAPSHOT_OMIT_ATTR.has(key)
+  );
+  const targetKeys = Object.keys(target).filter(
+    (key) => !HISTORY_SNAPSHOT_OMIT_ATTR.has(key)
+  );
+  if (sourceKeys.length !== targetKeys.length) return false;
+  for (let s = 0; s < sourceKeys.length; s++) {
+    const key = sourceKeys[s];
+    if (key === "value") continue;
+    if (key === "groupIds" && Array.isArray(source[key]) && Array.isArray(target[key]) && isArrayEqual(source[key], target[key])) {
+      continue;
+    }
+    if (source[key] !== target[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function inflateElementList(elementList) {
+  let i = 0;
+  while (i < elementList.length) {
+    const element = elementList[i];
+    if (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++) {
+          inflateElementList(tr.tdList[d].value);
+        }
+      }
+    }
+    if (element.valueList?.length) {
+      inflateElementList(element.valueList);
+    }
+    if (element.control?.value?.length) {
+      inflateElementList(element.control.value);
+    }
+    if (isHistoryTextSnapshotElement(element) && element.value?.length > 1) {
+      const textList = splitText(element.value);
+      elementList.splice(
+        i,
+        1,
+        ...textList.map((value) => ({
+          ...element,
+          value
+        }))
+      );
+      i += textList.length;
+      continue;
+    }
+    i++;
+  }
+  return elementList;
 }
 function getIsBlockElement(element) {
   return !!element?.type && (BLOCK_ELEMENT_TYPE.includes(element.type) || element.imgDisplay === "inline" /* INLINE */);
@@ -7668,7 +7832,8 @@ function backspace(evt, host) {
   } else {
     rangeManager.setRange(curIndex, curIndex);
     draw.render({
-      curIndex
+      curIndex,
+      dirtyStartIndex: curIndex + 1
     });
   }
 }
@@ -7810,7 +7975,8 @@ function del(evt, host) {
   } else {
     rangeManager.setRange(curIndex, curIndex);
     draw.render({
-      curIndex
+      curIndex,
+      dirtyStartIndex: curIndex + 1
     });
   }
 }
@@ -8652,10 +8818,12 @@ function input(data2, host) {
   if (~curIndex) {
     rangeManager.setRange(curIndex, curIndex);
     const isWordBoundary = !isComposing && /[\s\p{P}]/u.test(data2);
+    const dirtyStartIndex = startIndex + 1;
     draw.render({
       curIndex,
       isSubmitHistory: !isComposing,
-      isInputHistory: !isComposing && !isWordBoundary
+      isInputHistory: !isComposing && !isWordBoundary,
+      dirtyStartIndex
     });
   }
   if (isComposing && ~curIndex) {
@@ -9339,7 +9507,7 @@ var HistoryManager = class {
       const pop = this.undoStack.pop();
       this.redoStack.push(pop);
       if (this.undoStack.length) {
-        this.undoStack[this.undoStack.length - 1]();
+        this.undoStack[this.undoStack.length - 1].restore();
       }
     }
   }
@@ -9347,11 +9515,11 @@ var HistoryManager = class {
     if (this.redoStack.length) {
       const pop = this.redoStack.pop();
       this.undoStack.push(pop);
-      pop();
+      pop.restore();
     }
   }
-  execute(fn) {
-    this.undoStack.push(fn);
+  execute(entry) {
+    this.undoStack.push(this._normalizeEntry(entry));
     if (this.redoStack.length) {
       this.redoStack = [];
     }
@@ -9359,11 +9527,12 @@ var HistoryManager = class {
       this.undoStack.shift();
     }
   }
-  replaceLatest(fn) {
+  replaceLatest(entry) {
+    const normalizedEntry = this._normalizeEntry(entry);
     if (this.undoStack.length > 0) {
-      this.undoStack[this.undoStack.length - 1] = fn;
+      this.undoStack[this.undoStack.length - 1] = normalizedEntry;
     } else {
-      this.execute(fn);
+      this.execute(normalizedEntry);
     }
     if (this.redoStack.length) {
       this.redoStack = [];
@@ -9394,6 +9563,14 @@ var HistoryManager = class {
   popUndo() {
     return this.undoStack.pop();
   }
+  _normalizeEntry(entry) {
+    if (typeof entry === "function") {
+      return {
+        restore: entry
+      };
+    }
+    return entry;
+  }
 };
 
 // src/core/position/Position.ts
@@ -11601,6 +11778,7 @@ var ScrollObserver = class {
       const { intersectionPageNo, visiblePageNoList } = this.getPageVisibleInfo();
       this.draw.setIntersectionPageNo(intersectionPageNo);
       this.draw.setVisiblePageNoList(visiblePageNoList);
+      this.draw.renderVisiblePages(visiblePageNoList);
     }, 150);
     this.draw = draw;
     this.options = draw.getOptions();
@@ -20408,6 +20586,9 @@ var Area = class {
   getAreaInfo() {
     return this.areaInfoMap;
   }
+  clear() {
+    this.areaInfoMap.clear();
+  }
   getActiveAreaId() {
     if (!this.areaInfoMap.size) return null;
     const { startIndex } = this.range.getRange();
@@ -20799,6 +20980,7 @@ var Draw = class {
     this.container = this._wrapContainer(rootContainer);
     this.pageList = [];
     this.ctxList = [];
+    this.pageRenderVersionList = [];
     this.pageNo = 0;
     this.renderCount = 0;
     this.pagePixelRatio = null;
@@ -20811,6 +20993,7 @@ var Draw = class {
     this._formatContainer();
     this.pageContainer = this._createPageContainer();
     this._createPage(0);
+    this.measureCtx = this._createMeasureContext();
     this.i18n = new I18n(options.locale);
     this.historyManager = new HistoryManager(this);
     this.position = new Position(this);
@@ -20875,6 +21058,8 @@ var Draw = class {
     this.pageRowList = [];
     this.painterStyle = null;
     this.painterOptions = null;
+    this.elementFontCache = /* @__PURE__ */ new WeakMap();
+    this.elementRowMarginCache = /* @__PURE__ */ new WeakMap();
     this.visiblePageNoList = [];
     this.intersectionPageNo = 0;
     this.lazyRenderIntersectionObserver = null;
@@ -21041,7 +21226,9 @@ var Draw = class {
   getContextInnerWidth() {
     const positionContext = this.position.getPositionContext();
     if (positionContext.isTable) {
-      const td = this.resolveTableCellContext(this.getOriginalElementList())?.td;
+      const td = this.resolveTableCellContext(
+        this.getOriginalElementList()
+      )?.td;
       if (!td) return this.getColumnWidth() / this.options.scale;
       const tdPadding = this.getTdPadding();
       return td.width - tdPadding[1] - tdPadding[3];
@@ -21094,6 +21281,7 @@ var Draw = class {
     return this.visiblePageNoList;
   }
   setVisiblePageNoList(payload) {
+    if (isArrayEqual(this.visiblePageNoList, payload)) return;
     this.visiblePageNoList = payload;
     if (this.listener.visiblePageNoListChange) {
       this.listener.visiblePageNoListChange(this.visiblePageNoList);
@@ -21106,6 +21294,7 @@ var Draw = class {
     return this.intersectionPageNo;
   }
   setIntersectionPageNo(payload) {
+    if (this.intersectionPageNo === payload) return;
     this.intersectionPageNo = payload;
     if (this.listener.intersectionPageNoChange) {
       this.listener.intersectionPageNoChange(this.intersectionPageNo);
@@ -21133,7 +21322,9 @@ var Draw = class {
       candidateIndexes.push(context.index);
     }
     if (context.tableId) {
-      const tableIndex = sourceElementList.findIndex((el) => el.id === context.tableId);
+      const tableIndex = sourceElementList.findIndex(
+        (el) => el.id === context.tableId
+      );
       if (~tableIndex && !candidateIndexes.includes(tableIndex)) {
         candidateIndexes.push(tableIndex);
       }
@@ -21242,9 +21433,7 @@ var Draw = class {
     return this.header.getElementList();
   }
   getTableElementList(sourceElementList) {
-    const splitCellSelectionContext = this.getSplitCellSelectionContext(
-      sourceElementList
-    );
+    const splitCellSelectionContext = this.getSplitCellSelectionContext(sourceElementList);
     if (splitCellSelectionContext) {
       return splitCellSelectionContext.value;
     }
@@ -21368,10 +21557,7 @@ var Draw = class {
       positionContext.trId = continuationTr.id;
       positionContext.tableId = tableId;
       this.position.setPositionContext(positionContext);
-      this.range.setRange(
-        continuationCursorIndex,
-        continuationCursorIndex
-      );
+      this.range.setRange(continuationCursorIndex, continuationCursorIndex);
       this.pendingTableCursorIndex = continuationCursorIndex;
       return true;
     }
@@ -21431,7 +21617,10 @@ var Draw = class {
     });
     const splitCellSelection = this.range.getSplitCellSelection();
     if (splitCellSelection) {
-      const curIndex2 = this.replaceSplitCellSelection(payload, splitCellSelection);
+      const curIndex2 = this.replaceSplitCellSelection(
+        payload,
+        splitCellSelection
+      );
       if (~curIndex2) {
         this.range.setRange(curIndex2, curIndex2);
         this.render({
@@ -21561,12 +21750,7 @@ var Draw = class {
       trId: rootCellContext.tr.id,
       tdId: rootTd.id
     });
-    this.spliceElementList(
-      rootTd.value,
-      1,
-      rootTd.value.length - 1,
-      payload
-    );
+    this.spliceElementList(rootTd.value, 1, rootTd.value.length - 1, payload);
     rootTd.rowList = void 0;
     rootTd.positionList = void 0;
     rootTd.mainHeight = void 0;
@@ -21986,6 +22170,15 @@ var Draw = class {
     this._initPageContext(ctx);
     this.pageList.push(canvas);
     this.ctxList.push(ctx);
+    this.pageRenderVersionList.push(0);
+  }
+  _createMeasureContext() {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    ctx.letterSpacing = "0px";
+    ctx.wordSpacing = "0px";
+    ctx.direction = "ltr";
+    return ctx;
   }
   _initPageContext(ctx) {
     const dpr = this.getPagePixelRatio();
@@ -21998,8 +22191,22 @@ var Draw = class {
     const { defaultSize, defaultFont } = this.options;
     const font = el.font || defaultFont;
     const size = el.actualSize || el.size || defaultSize;
+    const cache = this.elementFontCache.get(el);
+    if (cache && cache.scale === scale && cache.font === font && cache.size === size && cache.actualSize === el.actualSize && cache.bold === el.bold && cache.italic === el.italic) {
+      return cache.style;
+    }
     const sizePx = size * (96 / 72) * scale;
-    return `${el.italic ? "italic " : ""}${el.bold ? "bold " : ""}${sizePx}px ${font}`;
+    const style = `${el.italic ? "italic " : ""}${el.bold ? "bold " : ""}${sizePx}px ${font}`;
+    this.elementFontCache.set(el, {
+      scale,
+      font,
+      size,
+      actualSize: el.actualSize,
+      bold: el.bold,
+      italic: el.italic,
+      style
+    });
+    return style;
   }
   getElementSize(el) {
     return el.actualSize || el.size || this.options.defaultSize;
@@ -22012,13 +22219,25 @@ var Draw = class {
       scale
     } = this.options;
     const fontSize = el.size || defaultSize;
+    const rowMarginValue = el.rowMargin ?? defaultRowMargin;
+    const cache = this.elementRowMarginCache.get(el);
+    if (cache && cache.scale === scale && cache.size === fontSize && cache.rowMargin === rowMarginValue) {
+      return cache.value;
+    }
     let ratio = 1;
     if (fontSize < 12) {
       ratio = fontSize / 12;
     } else if (fontSize > 30) {
       ratio = 1 + (fontSize - 30) / 30;
     }
-    return defaultBasicRowMarginHeight * ratio * (el.rowMargin ?? defaultRowMargin) * scale;
+    const value = defaultBasicRowMarginHeight * ratio * rowMarginValue * scale;
+    this.elementRowMarginCache.set(el, {
+      scale,
+      size: fontSize,
+      rowMargin: rowMarginValue,
+      value
+    });
+    return value;
   }
   createListStateSeed(initialListState) {
     const listLevelIndex = /* @__PURE__ */ new Map();
@@ -22097,7 +22316,12 @@ var Draw = class {
       pageHeight = 0,
       mainOuterHeight = 0,
       surroundElementList = [],
-      initialListState
+      initialListState,
+      hasListElement = true,
+      fromIndex = 0,
+      initialY = startY,
+      initialPageNo = 0,
+      initialRowIndex = 0
     } = payload;
     const {
       defaultSize,
@@ -22106,27 +22330,62 @@ var Draw = class {
       defaultTabWidth
     } = this.options;
     const defaultBasicRowMarginHeight = this.getDefaultBasicRowMarginHeight();
-    const canvas = document.createElement("canvas");
-    const ctx = canvas.getContext("2d");
-    const listStyleMap = this.listParticle.computeListStyle(ctx, elementList);
+    const ctx = this.measureCtx;
+    ctx.save();
+    ctx.font = "10px sans-serif";
+    ctx.textAlign = "start";
+    ctx.textBaseline = "alphabetic";
+    const listStyleMap = hasListElement ? this.listParticle.computeListStyle(ctx, elementList) : /* @__PURE__ */ new Map();
+    const wordMeasureCache = /* @__PURE__ */ new Map();
+    const getWordMeasure = (curIndex, elementFont) => {
+      const cache = wordMeasureCache.get(curIndex);
+      if (cache) return cache;
+      let endIndex = curIndex;
+      while (endIndex < elementList.length) {
+        const measureElement = elementList[endIndex];
+        if (measureElement.type && measureElement.type !== "text" /* TEXT */ || !this.LETTER_REG.test(measureElement.value)) {
+          break;
+        }
+        if (this.getElementFont(measureElement) !== elementFont) {
+          const fallbackWord = this.textParticle.measureWord(
+            ctx,
+            elementList,
+            curIndex
+          );
+          wordMeasureCache.set(curIndex, fallbackWord);
+          return fallbackWord;
+        }
+        endIndex++;
+      }
+      const endElement = elementList[endIndex] || null;
+      let suffixWidth = 0;
+      for (let i = endIndex - 1; i >= curIndex; i--) {
+        suffixWidth += this.textParticle.measureText(ctx, elementList[i]).width;
+        wordMeasureCache.set(i, {
+          width: suffixWidth,
+          endElement
+        });
+      }
+      return wordMeasureCache.get(curIndex);
+    };
     const rowList = [];
-    if (elementList.length) {
+    if (elementList.length && fromIndex < elementList.length) {
       rowList.push({
         width: 0,
         height: 0,
         ascent: 0,
         elementList: [],
-        startIndex: 0,
-        rowIndex: 0,
-        rowFlex: elementList?.[0]?.rowFlex || elementList?.[1]?.rowFlex
+        startIndex: fromIndex,
+        rowIndex: initialRowIndex,
+        rowFlex: elementList?.[fromIndex]?.rowFlex || elementList?.[fromIndex + 1]?.rowFlex
       });
     }
     let x = startX;
-    let y = startY;
-    let pageNo = 0;
+    let y = initialY;
+    let pageNo = initialPageNo;
     const listState = this.createListStateSeed(initialListState);
     let controlRealWidth = 0;
-    for (let i = 0; i < elementList.length; i++) {
+    for (let i = fromIndex; i < elementList.length; i++) {
       const curRow = rowList[rowList.length - 1];
       const element = elementList[i];
       const rowMargin = this.getElementRowMargin(element);
@@ -22172,9 +22431,7 @@ var Draw = class {
       } else if (element.type === "table" /* TABLE */) {
         let activeSplitRange;
         let mergedSplitFallback;
-        const logicalSplitCursor = this.getCollapsedSplitTableCursorContext(
-          element
-        );
+        const logicalSplitCursor = this.getCollapsedSplitTableCursorContext(element);
         if (element.pagingId) {
           let tableIndex = i + 1;
           let combineCount = 0;
@@ -22779,16 +23036,14 @@ var Draw = class {
           element.actualSize = Math.ceil(size * 0.6);
         }
         metrics.height = (element.actualSize || size) * scale;
-        ctx.font = this.getElementFont(element);
+        const elementFont = this.getElementFont(element);
+        ctx.font = elementFont;
         const fontMetrics = this.textParticle.measureText(ctx, element);
         metrics.width = fontMetrics.width * scale;
         if (element.letterSpacing) {
           metrics.width += element.letterSpacing * scale;
         }
-        const basisMetrics = this.textParticle.measureBasisWord(
-          ctx,
-          element.font
-        );
+        const basisMetrics = this.textParticle.measureBasisWord(ctx, elementFont);
         metrics.boundingBoxAscent = basisMetrics.fontBoundingBoxAscent * scale;
         metrics.boundingBoxDescent = basisMetrics.fontBoundingBoxDescent * scale;
         if (element.type === "superscript" /* SUPERSCRIPT */) {
@@ -22825,11 +23080,7 @@ var Draw = class {
         if ((!preElement?.type || preElement?.type === "text" /* TEXT */) && (!element.type || element.type === "text" /* TEXT */)) {
           const word = `${preElement?.value || ""}${element.value}`;
           if (this.WORD_LIKE_REG.test(word)) {
-            const { width, endElement } = this.textParticle.measureWord(
-              ctx,
-              elementList,
-              i
-            );
+            const { width, endElement } = getWordMeasure(i, ctx.font);
             const wordWidth = width * scale;
             if (endElement && wordWidth <= availableWidth) {
               curRowWidth += wordWidth;
@@ -22962,6 +23213,7 @@ var Draw = class {
         x += metrics.width;
       }
     }
+    ctx.restore();
     return rowList;
   }
   _applyRowSpacing() {
@@ -23554,30 +23806,11 @@ var Draw = class {
     if (this.isGraffitiMode()) {
       this.graffiti.render(ctx, pageNo);
     }
+    this.pageRenderVersionList[pageNo] = this.renderCount;
   }
   _disconnectLazyRender() {
     this.lazyRenderIntersectionObserver?.disconnect();
-  }
-  _lazyRender() {
-    const positionList = this.position.getOriginalMainPositionList();
-    const elementList = this.getOriginalMainElementList();
-    this._disconnectLazyRender();
-    this.lazyRenderIntersectionObserver = new IntersectionObserver((entries) => {
-      entries.forEach((entry) => {
-        if (entry.isIntersecting) {
-          const index = Number(entry.target.dataset.index);
-          this._drawPage({
-            elementList,
-            positionList,
-            rowList: this.pageRowList[index],
-            pageNo: index
-          });
-        }
-      });
-    });
-    this.pageList.forEach((el) => {
-      this.lazyRenderIntersectionObserver.observe(el);
-    });
+    this.lazyRenderIntersectionObserver = null;
   }
   _immediateRender() {
     const positionList = this.position.getOriginalMainPositionList();
@@ -23591,6 +23824,100 @@ var Draw = class {
       });
     }
   }
+  _collectMainRenderMeta() {
+    const surroundElementList = [];
+    let hasAreaElement = false;
+    let hasListElement = false;
+    let hasStructuralElement = false;
+    for (let i = 0; i < this.elementList.length; i++) {
+      const element = this.elementList[i];
+      if (!hasAreaElement && element.areaId) {
+        hasAreaElement = true;
+      }
+      if (!hasListElement && element.listId) {
+        hasListElement = true;
+      }
+      if (!hasStructuralElement && (element.type === "table" /* TABLE */ || element.type === "block" /* BLOCK */ || element.type === "pageBreak" /* PAGE_BREAK */ || element.type === "columnBreak" /* COLUMN_BREAK */ || element.type === "image" /* IMAGE */ || element.type === "latex" /* LATEX */ || element.type === "separator" /* SEPARATOR */)) {
+        hasStructuralElement = true;
+      }
+      if (element.imgDisplay === "surround" /* SURROUND */) {
+        surroundElementList.push(element);
+      }
+    }
+    return {
+      hasAreaElement,
+      hasListElement,
+      hasStructuralElement,
+      surroundElementList
+    };
+  }
+  _getIncrementalRestartState(dirtyStartIndex, rowList, pageRowList, startY) {
+    if (!rowList.length || !pageRowList.length) return null;
+    const searchIndex = Math.max(dirtyStartIndex - 1, 0);
+    let restartRowIndex = -1;
+    for (let i = 0; i < rowList.length; i++) {
+      if (rowList[i].startIndex <= searchIndex) {
+        restartRowIndex = i;
+      } else {
+        break;
+      }
+    }
+    if (restartRowIndex < 0) return null;
+    if (restartRowIndex > 0 && this.elementList[rowList[restartRowIndex].startIndex]?.value === ZERO && !this.elementList[rowList[restartRowIndex].startIndex]?.listWrap) {
+      restartRowIndex -= 1;
+    }
+    const restartRow = rowList[restartRowIndex];
+    const fromIndex = Math.min(restartRow.startIndex, this.elementList.length);
+    let initialPageNo = 0;
+    let initialY = startY;
+    let absoluteRowIndex = 0;
+    let isFound = false;
+    for (let pageNo = 0; pageNo < pageRowList.length; pageNo++) {
+      const rows = pageRowList[pageNo];
+      let y = startY;
+      for (let rowNo = 0; rowNo < rows.length; rowNo++) {
+        if (absoluteRowIndex === restartRowIndex) {
+          initialPageNo = pageNo;
+          initialY = y;
+          isFound = true;
+          break;
+        }
+        const row = rows[rowNo];
+        y += (row.offsetY || 0) + (row.spaceAbove || 0) + row.height + (row.spaceBelow || 0);
+        absoluteRowIndex++;
+      }
+      if (isFound) break;
+    }
+    if (!isFound) return null;
+    return {
+      fromIndex,
+      initialY,
+      initialPageNo,
+      initialRowIndex: restartRow.rowIndex,
+      initialListState: this.getListStateBeforeIndex(this.elementList, fromIndex),
+      prefixRows: rowList.slice(0, restartRowIndex)
+    };
+  }
+  renderVisiblePages(pageNoList) {
+    const positionList = this.position.getOriginalMainPositionList();
+    const elementList = this.getOriginalMainElementList();
+    const targetPageNoList = pageNoList ?? this.visiblePageNoList;
+    if (!targetPageNoList?.length) return;
+    const renderedPageNoSet = /* @__PURE__ */ new Set();
+    for (let i = 0; i < targetPageNoList.length; i++) {
+      const pageNo = targetPageNoList[i];
+      if (renderedPageNoSet.has(pageNo) || pageNo < 0 || pageNo >= this.pageRowList.length || this.pageRenderVersionList[pageNo] === this.renderCount) {
+        continue;
+      }
+      renderedPageNoSet.add(pageNo);
+      this._drawPage({
+        elementList,
+        positionList,
+        rowList: this.pageRowList[pageNo],
+        pageNo
+      });
+    }
+  }
   render(payload) {
     this.renderCount++;
     const { header, footer } = this.options;
@@ -23602,15 +23929,19 @@ var Draw = class {
       isLazy = true,
       isInit = false,
       isSourceHistory = false,
-      isFirstRender = false
+      isFirstRender = false,
+      dirtyStartIndex
     } = payload || {};
     let { curIndex } = payload || {};
     this.pendingTableCursorIndex = void 0;
     const innerWidth = this.getInnerWidth();
     const columnWidth = this.getColumnWidth();
     const isPagingMode = this.getIsPagingMode();
+    const columnCount = this.getColumnCount();
     const oldPageSize = this.pageRowList.length;
     if (isCompute) {
+      const oldRowList = this.rowList;
+      const oldPageRowList = this.pageRowList;
       this.position.setFloatPositionList([]);
       if (isPagingMode) {
         if (!header.disabled) {
@@ -23626,8 +23957,13 @@ var Draw = class {
       const mainOuterHeight = this.getMainOuterHeight();
       const startX = margins[3];
       const startY = margins[0] + extraHeight;
-      const surroundElementList = pickSurroundElementList(this.elementList);
-      this.rowList = this.computeRowList({
+      const {
+        hasAreaElement,
+        hasListElement,
+        hasStructuralElement,
+        surroundElementList
+      } = this._collectMainRenderMeta();
+      const rowListPayload = {
         startX,
         startY,
         pageHeight,
@@ -23635,12 +23971,41 @@ var Draw = class {
         isPagingMode,
         innerWidth: columnWidth,
         surroundElementList,
+        hasListElement,
         elementList: this.elementList
-      });
+      };
+      const canUseIncrementalMainRows = dirtyStartIndex !== void 0 && dirtyStartIndex >= 0 && !isInit && !isSourceHistory && isPagingMode && columnCount === 1 && !hasAreaElement && !hasStructuralElement && surroundElementList.length === 0 && oldRowList.length > 0 && oldPageRowList.length > 0;
+      if (canUseIncrementalMainRows) {
+        const restartState = this._getIncrementalRestartState(
+          dirtyStartIndex,
+          oldRowList,
+          oldPageRowList,
+          startY
+        );
+        if (restartState) {
+          const suffixRows = this.computeRowList({
+            ...rowListPayload,
+            fromIndex: restartState.fromIndex,
+            initialY: restartState.initialY,
+            initialPageNo: restartState.initialPageNo,
+            initialRowIndex: restartState.initialRowIndex,
+            initialListState: restartState.initialListState
+          });
+          this.rowList = restartState.prefixRows.concat(suffixRows);
+        } else {
+          this.rowList = this.computeRowList(rowListPayload);
+        }
+      } else {
+        this.rowList = this.computeRowList(rowListPayload);
+      }
       this._applyRowSpacing();
       this.pageRowList = this._computePageList();
       this.position.computePositionList();
-      this.area.compute();
+      if (hasAreaElement) {
+        this.area.compute();
+      } else {
+        this.area.clear();
+      }
       if (!this.isPrintMode()) {
         const searchKeyword = this.search.getSearchKeyword();
         if (searchKeyword) {
@@ -23664,10 +24029,26 @@ var Draw = class {
     if (prePageCount > curPageCount) {
       const deleteCount = prePageCount - curPageCount;
       this.ctxList.splice(curPageCount, deleteCount);
+      this.pageRenderVersionList.splice(curPageCount, deleteCount);
       this.pageList.splice(curPageCount, deleteCount).forEach((page) => page.remove());
     }
     if (isLazy && isPagingMode) {
-      this._lazyRender();
+      let visiblePageNoList = this.visiblePageNoList.filter(
+        (pageNo) => pageNo >= 0 && pageNo < curPageCount
+      );
+      let intersectionPageNo = Math.min(
+        this.intersectionPageNo,
+        Math.max(curPageCount - 1, 0)
+      );
+      if (!visiblePageNoList.length || oldPageSize !== curPageCount || intersectionPageNo >= curPageCount) {
+        const visibleInfo = this.scrollObserver.getPageVisibleInfo();
+        intersectionPageNo = visibleInfo.intersectionPageNo;
+        visiblePageNoList = visibleInfo.visiblePageNoList;
+        this.setIntersectionPageNo(intersectionPageNo);
+        this.setVisiblePageNoList(visiblePageNoList);
+      }
+      const renderPageNoList = visiblePageNoList.length ? visiblePageNoList : [intersectionPageNo];
+      this.renderVisiblePages(renderPageNoList);
     } else {
       this._immediateRender();
     }
@@ -23716,7 +24097,9 @@ var Draw = class {
     const positionContext = this.position.getPositionContext();
     const positionList = this.position.getPositionList();
     if (positionContext.isTable) {
-      const tablePositionList = this.resolveTableCellContext(this.getOriginalElementList())?.td.positionList;
+      const tablePositionList = this.resolveTableCellContext(
+        this.getOriginalElementList()
+      )?.td.positionList;
       if (curIndex === void 0 && tablePositionList) {
         curIndex = tablePositionList.length - 1;
       }
@@ -23743,36 +24126,51 @@ var Draw = class {
     return curIndex;
   }
   submitHistory(curIndex, isInput = false) {
-    const positionContext = this.position.getPositionContext();
-    const oldElementList = getSlimCloneElementList(this.elementList);
-    const oldHeaderElementList = getSlimCloneElementList(
-      this.header.getElementList()
-    );
-    const oldFooterElementList = getSlimCloneElementList(
-      this.footer.getElementList()
-    );
-    const oldRange = deepClone(this.range.getRange());
-    const pageNo = this.pageNo;
-    const oldPositionContext = deepClone(positionContext);
-    const zone = this.zone.getZone();
-    const fn = () => {
-      this.zone.setZone(zone);
-      this.setPageNo(pageNo);
-      this.position.setPositionContext(deepClone(oldPositionContext));
-      this.header.setElementList(deepClone(oldHeaderElementList));
-      this.footer.setElementList(deepClone(oldFooterElementList));
-      this.elementList = deepClone(oldElementList);
-      this.range.replaceRange(deepClone(oldRange));
-      this.render({
-        curIndex,
-        isSubmitHistory: false,
-        isSourceHistory: true
-      });
+    const snapshot = {
+      elementList: getSlimCloneElementList(this.elementList),
+      headerElementList: getSlimCloneElementList(this.header.getElementList()),
+      footerElementList: getSlimCloneElementList(this.footer.getElementList()),
+      range: deepClone(this.range.getRange()),
+      pageNo: this.pageNo,
+      positionContext: deepClone(this.position.getPositionContext()),
+      zone: this.zone.getZone()
+    };
+    const entry = {
+      restore: () => {
+        const {
+          elementList,
+          headerElementList,
+          footerElementList,
+          range,
+          pageNo,
+          positionContext,
+          zone
+        } = snapshot;
+        const restoredHeaderElementList = inflateElementList(
+          deepClone(headerElementList)
+        );
+        const restoredFooterElementList = inflateElementList(
+          deepClone(footerElementList)
+        );
+        const restoredMainElementList = inflateElementList(deepClone(elementList));
+        this.zone.setZone(zone);
+        this.setPageNo(pageNo);
+        this.position.setPositionContext(deepClone(positionContext));
+        this.header.setElementList(restoredHeaderElementList);
+        this.footer.setElementList(restoredFooterElementList);
+        this.elementList = restoredMainElementList;
+        this.range.replaceRange(deepClone(range));
+        this.render({
+          curIndex,
+          isSubmitHistory: false,
+          isSourceHistory: true
+        });
+      }
     };
     if (isInput && this.historyManager.isInputGroupable()) {
-      this.historyManager.replaceLatest(fn);
+      this.historyManager.replaceLatest(entry);
     } else {
-      this.historyManager.execute(fn);
+      this.historyManager.execute(entry);
     }
     if (isInput) {
       this.historyManager.recordInputTime();
@@ -23867,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);
@@ -23947,50 +24347,3189 @@ 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 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");
+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 footerChildren = editorOptions.footer.disabled ? [] : await serializeElementList(data2.footer || [], editorOptions, context);
+  const pageNumberParagraph = createPageNumberParagraph(
+    editorOptions.pageNumber
+  );
+  if (pageNumberParagraph) {
+    footerChildren.push(pageNumberParagraph);
+  }
+  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: [
+      {
+        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({})]
+      }
+    ]
+  });
+}
+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);
+  }
+  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;
+        }
+      }
+    }
+    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
+    );
+  }
+  if (current) {
+    flushParagraph();
+  }
+  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
+      })
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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;
+  }
+  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;
+    }
+    const text = normalizeText(getInlineElementText(element)).replace(
+      /\n/g,
+      " "
+    );
+    if (text) {
+      children.push(createTextRun(text, element, defaultSize, defaultFont));
+    }
+  }
+  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 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");
@@ -25159,6 +28698,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();