superdoc 1.0.0-beta.10 → 1.0.0-beta.12

package/dist/chunks/{super-editor.es-Bf7zv4k5.cjs → super-editor.es-CBMp55sv.cjs}

@@ -35605,7 +35605,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.10") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.12") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -52312,7 +52312,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.0-beta.10";
+const summaryVersion = "1.0.0-beta.12";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -53091,7 +53091,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      Promise.resolve().then(() => require("./index-CC6Vsniy-D24AMjnI.cjs")),
+      Promise.resolve().then(() => require("./index-Cha-6AFg-28WIXlKN.cjs")),
       Promise.resolve().then(() => require("./index-DRCvimau-H4Ck3S9a.cjs")),
       Promise.resolve().then(() => require("./index-C_x_N6Uh-Db3CUJMX.cjs")),
       Promise.resolve().then(() => require("./index-D_sWOSiG-BtDZzJ6I.cjs")),
@@ -53296,7 +53296,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.10");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.12");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -57397,28 +57397,42 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
   const indentSource = attrs.indent ?? paragraphProps.indent ?? hydrated?.indent;
   const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? attrs.textIndent);
   const unwrapTabStops = (tabStops) => {
-    if (!Array.isArray(tabStops)) return void 0;
+    if (!Array.isArray(tabStops)) {
+      return void 0;
+    }
     const unwrapped = [];
     for (const entry of tabStops) {
-      if (entry && typeof entry === "object" && "tab" in entry) {
-        const tab = entry.tab;
-        if (tab && typeof tab === "object") {
-          const tabObj = tab;
-          const val = typeof tabObj.tabType === "string" ? tabObj.tabType : typeof tabObj.val === "string" ? tabObj.val : void 0;
-          const pos = pickNumber(tabObj.originalPos ?? tabObj.pos);
-          if (val && pos != null) {
-            const normalized = { val, pos };
-            const leader = tabObj.leader;
-            if (typeof leader === "string") normalized.leader = leader;
-            const originalPos = pickNumber(tabObj.originalPos);
-            if (originalPos != null) normalized.originalPos = originalPos;
-            unwrapped.push(normalized);
-            continue;
-          }
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      if ("tab" in entry) {
+        const entryRecord2 = entry;
+        const tab = entryRecord2.tab;
+        if (!tab || typeof tab !== "object") {
+          continue;
         }
+        const tabObj = tab;
+        const val = typeof tabObj.tabType === "string" ? tabObj.tabType : typeof tabObj.val === "string" ? tabObj.val : void 0;
+        const pos = pickNumber(tabObj.originalPos ?? tabObj.pos);
+        if (!val || pos == null) {
+          continue;
+        }
+        const normalized = { val, pos };
+        const leader = tabObj.leader;
+        if (typeof leader === "string" && leader.length > 0) {
+          normalized.leader = leader;
+        }
+        const originalPos = pickNumber(tabObj.originalPos);
+        if (originalPos != null && Number.isFinite(originalPos)) {
+          normalized.originalPos = originalPos;
+        }
+        unwrapped.push(normalized);
+        continue;
       }
-      if (entry && typeof entry === "object") {
-        unwrapped.push(entry);
+      const entryRecord = entry;
+      const hasValidStructure = ("val" in entryRecord || "tabType" in entryRecord) && ("pos" in entryRecord || "originalPos" in entryRecord);
+      if (hasValidStructure) {
+        unwrapped.push(entryRecord);
       }
     }
     return unwrapped.length > 0 ? unwrapped : void 0;
@@ -65253,7 +65267,7 @@ const resolveTableCellBorders = (tableBorders, rowIndex, colIndex, totalRows, to
   };
 };
 const renderTableCell = (deps) => {
-  const { doc: doc2, x: x2, y: y2, rowHeight, cellMeasure, cell, borders, useDefaultBorder, renderLine, context, applySdtDataset } = deps;
+  const { doc: doc2, x: x2, y: y2, rowHeight, cellMeasure, cell, borders, renderLine, context, applySdtDataset } = deps;
   const cellEl = doc2.createElement("div");
   cellEl.style.position = "absolute";
   cellEl.style.left = `${x2}px`;
@@ -65263,8 +65277,6 @@ const renderTableCell = (deps) => {
   cellEl.style.boxSizing = "border-box";
   if (borders) {
     applyCellBorders(cellEl, borders);
-  } else if (useDefaultBorder) {
-    cellEl.style.border = "1px solid rgba(0,0,0,0.6)";
   }
   if (cell?.attrs?.background) {
     cellEl.style.backgroundColor = cell.attrs.background;
@@ -65306,25 +65318,55 @@ const renderTableRow = (deps) => {
     row,
     totalRows,
     tableBorders,
+    columnWidths,
+    allRowHeights,
     context,
     renderLine,
     applySdtDataset
   } = deps;
-  let x2 = 0;
+  const calculateXPosition = (gridColumnStart) => {
+    let x2 = 0;
+    for (let i = 0; i < gridColumnStart && i < columnWidths.length; i++) {
+      x2 += columnWidths[i];
+    }
+    return x2;
+  };
+  const calculateRowspanHeight = (startRowIndex, rowSpan) => {
+    let totalHeight = 0;
+    for (let i = 0; i < rowSpan && startRowIndex + i < allRowHeights.length; i++) {
+      totalHeight += allRowHeights[startRowIndex + i];
+    }
+    return totalHeight;
+  };
   for (let cellIndex = 0; cellIndex < rowMeasure.cells.length; cellIndex += 1) {
     const cellMeasure = rowMeasure.cells[cellIndex];
     const cell = row?.cells?.[cellIndex];
-    const hasExplicitBorders = Boolean(cell?.attrs?.borders);
-    const resolvedBorders = hasExplicitBorders ? cell?.attrs?.borders : tableBorders ? resolveTableCellBorders(tableBorders, rowIndex, cellIndex, totalRows, rowMeasure.cells.length) : void 0;
+    const x2 = cellMeasure.gridColumnStart != null ? calculateXPosition(cellMeasure.gridColumnStart) : cellIndex === 0 ? 0 : calculateXPosition(cellIndex);
+    const cellBordersAttr = cell?.attrs?.borders;
+    const hasBordersAttribute = cellBordersAttr !== void 0;
+    const hasExplicitBorders = hasBordersAttribute && cellBordersAttr && (cellBordersAttr.top !== void 0 || cellBordersAttr.right !== void 0 || cellBordersAttr.bottom !== void 0 || cellBordersAttr.left !== void 0);
+    const gridColIndex = cellMeasure.gridColumnStart ?? cellIndex;
+    const totalCols = columnWidths.length;
+    let resolvedBorders;
+    if (hasExplicitBorders) {
+      resolvedBorders = cellBordersAttr;
+    } else if (hasBordersAttribute) {
+      resolvedBorders = void 0;
+    } else if (tableBorders) {
+      resolvedBorders = resolveTableCellBorders(tableBorders, rowIndex, gridColIndex, totalRows, totalCols);
+    } else {
+      resolvedBorders = void 0;
+    }
+    const rowSpan = cellMeasure.rowSpan ?? 1;
+    const cellHeight = rowSpan > 1 ? calculateRowspanHeight(rowIndex, rowSpan) : rowMeasure.height;
     const { cellElement, contentElement } = renderTableCell({
       doc: doc2,
       x: x2,
       y: y2,
-      rowHeight: rowMeasure.height,
+      rowHeight: cellHeight,
       cellMeasure,
       cell,
       borders: resolvedBorders,
-      useDefaultBorder: !hasExplicitBorders && !tableBorders,
       renderLine,
       context,
       applySdtDataset
@@ -65333,7 +65375,6 @@ const renderTableRow = (deps) => {
     if (contentElement) {
       container.appendChild(contentElement);
     }
-    x2 += cellMeasure.width;
   }
 };
 const renderTableFragment = (deps) => {
@@ -65375,6 +65416,45 @@ const renderTableFragment = (deps) => {
   applySdtDataset(container, block.attrs?.sdt);
   container.classList.add("superdoc-table-fragment");
   if (fragment.metadata?.columnBoundaries) {
+    const columnCount = measure.columnWidths.length;
+    const rowCount = block.rows.length;
+    const boundarySegments = [];
+    for (let i = 0; i < columnCount; i++) {
+      boundarySegments.push([]);
+    }
+    let rowY = 0;
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+      const rowMeasure = measure.rows[rowIndex];
+      if (!rowMeasure) continue;
+      const boundariesInRow = /* @__PURE__ */ new Set();
+      for (const cellMeasure of rowMeasure.cells) {
+        const startCol = cellMeasure.gridColumnStart ?? 0;
+        const colSpan = cellMeasure.colSpan ?? 1;
+        const endCol = startCol + colSpan;
+        if (startCol > 0) {
+          boundariesInRow.add(startCol);
+        }
+        if (endCol < columnCount) {
+          boundariesInRow.add(endCol);
+        }
+      }
+      for (const boundaryCol of boundariesInRow) {
+        const segments = boundarySegments[boundaryCol];
+        const lastSegment = segments[segments.length - 1];
+        if (lastSegment && lastSegment.toRow === rowIndex) {
+          lastSegment.toRow = rowIndex + 1;
+          lastSegment.height += rowMeasure.height;
+        } else {
+          segments.push({
+            fromRow: rowIndex,
+            toRow: rowIndex + 1,
+            y: rowY,
+            height: rowMeasure.height
+          });
+        }
+      }
+      rowY += rowMeasure.height;
+    }
     const metadata = {
       columns: fragment.metadata.columnBoundaries.map((boundary) => ({
         i: boundary.index,
@@ -65382,7 +65462,18 @@ const renderTableFragment = (deps) => {
         w: boundary.width,
         min: boundary.minWidth,
         r: boundary.resizable ? 1 : 0
-      }))
+      })),
+      // Add segments for each column boundary (segments where resize handle should appear)
+      segments: boundarySegments.map(
+        (segs, colIndex) => segs.map((seg) => ({
+          c: colIndex,
+          // column index
+          y: seg.y,
+          // y position
+          h: seg.height
+          // height of segment
+        }))
+      )
     };
     container.setAttribute("data-table-boundaries", JSON.stringify(metadata));
   }
@@ -65393,6 +65484,7 @@ const renderTableFragment = (deps) => {
   if (borderCollapse === "separate" && block.attrs?.cellSpacing) {
     container.style.borderSpacing = `${block.attrs.cellSpacing}px`;
   }
+  const allRowHeights = measure.rows.map((r2) => r2.height);
   let y2 = 0;
   for (let r2 = fragment.fromRow; r2 < fragment.toRow; r2 += 1) {
     const rowMeasure = measure.rows[r2];
@@ -65406,6 +65498,8 @@ const renderTableFragment = (deps) => {
       row: block.rows[r2],
       totalRows: block.rows.length,
       tableBorders,
+      columnWidths: measure.columnWidths,
+      allRowHeights,
       context,
       renderLine,
       applySdtDataset
@@ -68047,21 +68141,9 @@ async function measureParagraphBlock(block, maxWidth) {
 }
 async function measureTableBlock(block, constraints) {
   const maxWidth = typeof constraints === "number" ? constraints : constraints.maxWidth;
-  const columnCount = Math.max(1, Math.max(...block.rows.map((r2) => r2.cells.length)));
   let columnWidths;
   if (block.columnWidths && block.columnWidths.length > 0) {
     columnWidths = [...block.columnWidths];
-    if (columnWidths.length < columnCount) {
-      const usedWidth = columnWidths.reduce((a, b2) => a + b2, 0);
-      const remainingWidth = Math.max(0, maxWidth - usedWidth);
-      const missingCount = columnCount - columnWidths.length;
-      const defaultWidth = missingCount > 0 ? Math.max(1, Math.floor(remainingWidth / missingCount)) : 0;
-      for (let i = columnWidths.length; i < columnCount; i++) {
-        columnWidths.push(defaultWidth);
-      }
-    } else if (columnWidths.length > columnCount) {
-      columnWidths = columnWidths.slice(0, columnCount);
-    }
     const totalWidth2 = columnWidths.reduce((a, b2) => a + b2, 0);
     const hasExplicitWidth = block.attrs?.tableWidth != null;
     if (!hasExplicitWidth && totalWidth2 > maxWidth) {
@@ -68069,22 +68151,56 @@ async function measureTableBlock(block, constraints) {
       columnWidths = columnWidths.map((w2) => Math.max(1, Math.floor(w2 * scale)));
     }
   } else {
-    const columnWidth = Math.max(1, Math.floor(maxWidth / columnCount));
-    columnWidths = Array.from({ length: columnCount }, () => columnWidth);
+    const maxCellCount = Math.max(1, Math.max(...block.rows.map((r2) => r2.cells.length)));
+    const columnWidth = Math.max(1, Math.floor(maxWidth / maxCellCount));
+    columnWidths = Array.from({ length: maxCellCount }, () => columnWidth);
   }
+  const gridColumnCount = columnWidths.length;
+  const calculateCellWidth = (startCol, colspan) => {
+    let width = 0;
+    for (let i = 0; i < colspan && startCol + i < columnWidths.length; i++) {
+      width += columnWidths[startCol + i];
+    }
+    return Math.max(1, width);
+  };
+  const rowspanTracker = new Array(gridColumnCount).fill(0);
   const rows = [];
-  for (const row of block.rows) {
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+    const row = block.rows[rowIndex];
     const cellMeasures = [];
-    for (let col = 0; col < columnCount; col++) {
-      const cell = row.cells[col];
-      const cellWidth = columnWidths[col] || columnWidths[0] || Math.floor(maxWidth / columnCount);
-      if (!cell) {
-        cellMeasures.push({ paragraph: { kind: "paragraph", lines: [], totalHeight: 0 }, width: cellWidth, height: 0 });
-        continue;
+    let gridColIndex = 0;
+    for (const cell of row.cells) {
+      const colspan = cell.colSpan ?? 1;
+      const rowspan = cell.rowSpan ?? 1;
+      while (gridColIndex < gridColumnCount && rowspanTracker[gridColIndex] > 0) {
+        rowspanTracker[gridColIndex]--;
+        gridColIndex++;
+      }
+      if (gridColIndex >= gridColumnCount) {
+        break;
+      }
+      const cellWidth = calculateCellWidth(gridColIndex, colspan);
+      if (rowspan > 1) {
+        for (let c2 = 0; c2 < colspan && gridColIndex + c2 < gridColumnCount; c2++) {
+          rowspanTracker[gridColIndex + c2] = rowspan - 1;
+        }
       }
       const paraMeasure = await measureParagraphBlock(cell.paragraph, cellWidth);
       const height = paraMeasure.totalHeight;
-      cellMeasures.push({ paragraph: paraMeasure, width: cellWidth, height });
+      cellMeasures.push({
+        paragraph: paraMeasure,
+        width: cellWidth,
+        height,
+        gridColumnStart: gridColIndex,
+        colSpan: colspan,
+        rowSpan: rowspan
+      });
+      gridColIndex += colspan;
+    }
+    for (let col = gridColIndex; col < gridColumnCount; col++) {
+      if (rowspanTracker[col] > 0) {
+        rowspanTracker[col]--;
+      }
     }
     const rowHeight = Math.max(0, ...cellMeasures.map((c2) => c2.height));
     rows.push({ cells: cellMeasures, height: rowHeight });
@@ -101275,7 +101391,7 @@ async function createZip(blobs, fileNames) {
   blobs.forEach((blob, index2) => {
     zip.file(fileNames[index2], blob);
   });
-  const zipBlob = await zip.generateAsync({ type: "blob" });
+  const zipBlob = await zip.generateAsync({ type: "blob", compression: "DEFLATE" });
   return zipBlob;
 }
 var __defProp = Object.defineProperty;
@@ -106131,13 +106247,31 @@ const _sfc_main$2 = {
       });
       return boundaries;
     });
-    function getHandleStyle(boundary) {
+    function getBoundarySegments(boundary) {
+      if (boundary.type === "right-edge") {
+        return [{ y: 0, h: null }];
+      }
+      const segmentsData = tableMetadata.value?.segments;
+      if (!segmentsData || !Array.isArray(segmentsData)) {
+        return [{ y: 0, h: null }];
+      }
+      const boundaryColIndex = boundary.index + 1;
+      const colSegments = segmentsData[boundaryColIndex];
+      if (!colSegments || colSegments.length === 0) {
+        return [];
+      }
+      return colSegments.map((seg) => ({
+        y: seg.y,
+        h: seg.h
+      }));
+    }
+    function getSegmentHandleStyle(boundary, segment) {
       return {
         position: "absolute",
         left: `${boundary.x}px`,
-        top: "0",
+        top: segment.y != null ? `${segment.y}px` : "0",
         width: "9px",
-        height: "100%",
+        height: segment.h != null ? `${segment.h}px` : "100%",
         transform: "translateX(-4px)",
         cursor: "col-resize",
         pointerEvents: "auto"
@@ -106192,7 +106326,8 @@ const _sfc_main$2 = {
           });
           return;
         }
-        tableMetadata.value = { columns: validatedColumns };
+        const segments = Array.isArray(parsed.segments) ? parsed.segments : void 0;
+        tableMetadata.value = { columns: validatedColumns, segments };
       } catch (error) {
         tableMetadata.value = null;
         emit("resize-error", {
@@ -106354,7 +106489,7 @@ const _sfc_main$2 = {
         updateCellColwidths(tr, tableNode, tablePos, affectedColumns, newWidths);
         dispatch(tr);
         const blockId = props.tableElement?.getAttribute("data-sd-block-id");
-        if (blockId) {
+        if (blockId && blockId.trim()) {
           measureCache.invalidate([blockId]);
         }
         emit("resize-success", { columnIndex, newWidths });
@@ -106457,18 +106592,24 @@ const _sfc_main$2 = {
         onMousedown: _cache[0] || (_cache[0] = vue.withModifiers(() => {
         }, ["stop"]))
       }, [
-        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(resizableBoundaries.value, (boundary, index2) => {
-          return vue.openBlock(), vue.createElementBlock("div", {
-            key: `handle-${boundary.type}-${boundary.index}`,
-            class: vue.normalizeClass(["resize-handle", {
-              "resize-handle--active": dragState.value && dragState.value.boundaryIndex === index2,
-              "resize-handle--edge": boundary.type === "right-edge"
-            }]),
-            "data-boundary-index": index2,
-            "data-boundary-type": boundary.type,
-            style: vue.normalizeStyle(getHandleStyle(boundary)),
-            onMousedown: ($event) => onHandleMouseDown($event, index2)
-          }, null, 46, _hoisted_1$2);
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(resizableBoundaries.value, (boundary, boundaryIndex) => {
+          return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+            key: `boundary-${boundaryIndex}`
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getBoundarySegments(boundary), (segment, segmentIndex) => {
+              return vue.openBlock(), vue.createElementBlock("div", {
+                key: `handle-${boundary.type}-${boundary.index}-${segmentIndex}`,
+                class: vue.normalizeClass(["resize-handle", {
+                  "resize-handle--active": dragState.value && dragState.value.boundaryIndex === boundaryIndex,
+                  "resize-handle--edge": boundary.type === "right-edge"
+                }]),
+                "data-boundary-index": boundaryIndex,
+                "data-boundary-type": boundary.type,
+                style: vue.normalizeStyle(getSegmentHandleStyle(boundary, segment)),
+                onMousedown: ($event) => onHandleMouseDown($event, boundaryIndex)
+              }, null, 46, _hoisted_1$2);
+            }), 128))
+          ], 64);
         }), 128)),
         dragState.value ? (vue.openBlock(), vue.createElementBlock("div", {
           key: 0,
@@ -106479,7 +106620,7 @@ const _sfc_main$2 = {
     };
   }
 };
-const TableResizeOverlay = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-acc51d8d"]]);
+const TableResizeOverlay = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-d4258885"]]);
 function adjustPaginationBreaks(editorElem, editor) {
   if (!editorElem.value || !editor?.value?.options?.scale || isHeadless(editor)) return;
   const zoom = editor.value.options.scale;

package/dist/style.css

@@ -2263,18 +2263,18 @@ https://github.com/ProseMirror/prosemirror-tables/blob/master/demo/index.html
   min-height: 40px;
 }
 
-.superdoc-table-resize-overlay[data-v-acc51d8d] {
+.superdoc-table-resize-overlay[data-v-d4258885] {
   position: absolute;
   pointer-events: none;
   user-select: none;
 }
-.resize-handle[data-v-acc51d8d] {
+.resize-handle[data-v-d4258885] {
   position: absolute;
   cursor: col-resize;
   user-select: none;
   z-index: 15;
 }
-.resize-handle[data-v-acc51d8d]::before {
+.resize-handle[data-v-d4258885]::before {
   content: '';
   position: absolute;
   left: 50%;
@@ -2287,17 +2287,17 @@ https://github.com/ProseMirror/prosemirror-tables/blob/master/demo/index.html
     background-color 0.2s ease,
     width 0.2s ease;
 }
-.resize-handle[data-v-acc51d8d]:hover::before {
+.resize-handle[data-v-d4258885]:hover::before {
   background-color: #4a90e2;
   width: 3px;
   transform: translateX(-1.5px);
 }
-.resize-handle--active[data-v-acc51d8d]::before {
+.resize-handle--active[data-v-d4258885]::before {
   background-color: #4a90e2;
   width: 2px;
   transform: translateX(-1px);
 }
-.resize-guideline[data-v-acc51d8d] {
+.resize-guideline[data-v-d4258885] {
   position: absolute;
   background-color: #4a90e2;
   pointer-events: none;

package/dist/super-editor/ai-writer.es.js

@@ -1,6 +1,6 @@
 import { ref, onMounted, onUnmounted, computed, createElementBlock, openBlock, withModifiers, createElementVNode, withDirectives, unref, vModelText, createCommentVNode, nextTick } from "vue";
-import { T as TextSelection } from "./chunks/converter-xQmDrmCk.js";
-import { _ as _export_sfc } from "./chunks/editor-C0RiU_sq.js";
+import { T as TextSelection } from "./chunks/converter-B4P0mjU2.js";
+import { _ as _export_sfc } from "./chunks/editor-CoLzF_z4.js";
 const DEFAULT_API_ENDPOINT = "https://sd-dev-express-gateway-i6xtm.ondigitalocean.app/insights";
 const SYSTEM_PROMPT = "You are an expert copywriter and you are immersed in a document editor. You are to provide document related text responses based on the user prompts. Only write what is asked for. Do not provide explanations. Try to keep placeholders as short as possible. Do not output your prompt. Your instructions are: ";
 async function baseInsightsFetch(payload, options = {}) {

package/dist/super-editor/chunks/{converter-xQmDrmCk.js → converter-B4P0mjU2.js}

@@ -35869,7 +35869,7 @@ const _SuperConverter = class _SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.0.0-beta.10") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.0.0-beta.12") {
     return _SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**

package/dist/super-editor/chunks/{docx-zipper-BKkVPA0E.js → docx-zipper-D5Do5rOh.js}

@@ -1,4 +1,4 @@
-import { p as process$1, aI as commonjsGlobal, B as Buffer, aJ as getDefaultExportFromCjs, aK as getContentTypesFromXml, aL as xmljs } from "./converter-xQmDrmCk.js";
+import { p as process$1, aI as commonjsGlobal, B as Buffer, aJ as getDefaultExportFromCjs, aK as getContentTypesFromXml, aL as xmljs } from "./converter-B4P0mjU2.js";
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }