@harbour-enterprises/superdoc 0.25.0-next.6 → 0.25.0-next.7

package/dist/super-editor/chunks/{editor-D1Q0suDz.js → editor-CEZNgaJQ.js}

@@ -17604,10 +17604,27 @@ function getStructuredContentBlockTags(state) {
   const result = findChildren$5(state.doc, (node) => node.type.name === "structuredContentBlock");
   return result;
 }
+function getStructuredContentTablesById(id, state) {
+  if (!id || !state) return [];
+  const blocks = getStructuredContentTagsById(id, state).filter(
+    ({ node }) => node.type.name === "structuredContentBlock"
+  );
+  if (!blocks.length) return [];
+  const { pos: blockPos, node: blockNode } = blocks[0];
+  const tablesInBlock = [];
+  blockNode.descendants((child, relPos) => {
+    if (child.type.name === "table") {
+      const absPos = blockPos + 1 + relPos;
+      tablesInBlock.push({ node: child, pos: absPos });
+    }
+  });
+  return tablesInBlock;
+}
 const structuredContentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   getStructuredContentBlockTags,
   getStructuredContentInlineTags,
+  getStructuredContentTablesById,
   getStructuredContentTags,
   getStructuredContentTagsById
 }, Symbol.toStringTag, { value: "Module" }));
@@ -17804,6 +17821,36 @@ const StructuredContentCommands = Extension.create({
           tr.replaceWith(posFrom, posTo, content);
         }
         return true;
+      },
+      /**
+       * Append multiple rows to the end of a table inside a structured content block.
+       * Each inner array represents the cell values for one new row.
+       * @category Command
+       * @param {StructuredContentTableAppendRowsOptions} options - Append configuration
+       * @example
+       * editor.commands.appendRowsToStructuredContentTable({
+       *   id: 'block-123',
+       *   tableIndex: 0,
+       *   rows: [['A', 'B'], ['C', 'D']],
+       *   copyRowStyle: true,
+       * });
+       */
+      appendRowsToStructuredContentTable: ({ id, tableIndex = 0, rows = [], copyRowStyle = false }) => ({ state, commands: commands2, dispatch }) => {
+        const normalized = normalizeRowsInput(rows);
+        if (!normalized.length) return true;
+        const tables = getStructuredContentTablesById(id, state);
+        if (!tables.length || tableIndex < 0 || tableIndex >= tables.length) return true;
+        const { node: tableNode, pos: tablePos } = tables[tableIndex];
+        if (dispatch) {
+          return commands2.appendRowsWithContent({ tablePos, tableNode, valueRows: normalized, copyRowStyle });
+        }
+        return commands2.appendRowsWithContent({
+          tablePos,
+          tableNode,
+          valueRows: normalized,
+          copyRowStyle,
+          dispatch: false
+        });
       }
     };
   },
@@ -17813,6 +17860,15 @@ const StructuredContentCommands = Extension.create({
     };
   }
 });
+const normalizeRowsInput = (rowsOrValues) => {
+  if (!Array.isArray(rowsOrValues) || !rowsOrValues.length) {
+    return [];
+  }
+  if (Array.isArray(rowsOrValues[0])) {
+    return rowsOrValues;
+  }
+  return [rowsOrValues];
+};
 class DocumentSectionView {
   constructor(node, getPos, decorations, editor) {
     __privateAdd(this, _DocumentSectionView_instances);
@@ -23565,6 +23621,107 @@ function cellWrapping($pos) {
   }
   return null;
 }
+function resolveTable(tr, tablePos, tableNode) {
+  if (tableNode && tableNode.type && tableNode.type.name === "table") {
+    return tableNode;
+  }
+  if (typeof tablePos === "number") {
+    const current = tr.doc.nodeAt(tablePos);
+    if (current && current.type.name === "table") {
+      return current;
+    }
+  }
+  return null;
+}
+function pickTemplateRowForAppend(tableNode, schema) {
+  const RowType = schema.nodes.tableRow;
+  const rows = [];
+  tableNode.descendants((child) => {
+    if (child.type === RowType) rows.push(child);
+  });
+  if (!rows.length) return null;
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const r2 = rows[i];
+    const hasBodyCell = r2.content?.content?.some((c) => c.type.name === "tableCell");
+    if (hasBodyCell) return r2;
+  }
+  return rows[rows.length - 1];
+}
+function extractRowTemplateFormatting(cellNode, schema) {
+  const ParagraphType = schema.nodes.paragraph;
+  let blockType = ParagraphType;
+  let blockAttrs = null;
+  let textMarks = [];
+  const blocks = cellNode?.content?.content || [];
+  for (const block of blocks) {
+    const isParagraphish = block.type === ParagraphType || block.type.name === "heading";
+    if (isParagraphish) {
+      blockType = block.type || ParagraphType;
+      blockAttrs = block.attrs || null;
+    }
+    let foundText = null;
+    block.descendants?.((n) => {
+      if (!foundText && n.isText) foundText = n;
+    });
+    if (foundText) {
+      textMarks = foundText.marks ? Array.from(foundText.marks) : [];
+      break;
+    }
+  }
+  if (!blockType || !blockType.validContent) blockType = ParagraphType;
+  return { blockType, blockAttrs, textMarks };
+}
+function buildFormattedCellBlock(schema, value, { blockType, blockAttrs, textMarks }, copyRowStyle = false) {
+  const text = typeof value === "string" ? value : value == null ? "" : String(value);
+  const marks = copyRowStyle ? textMarks || [] : [];
+  const textNode = schema.text(text, marks);
+  const type = blockType || schema.nodes.paragraph;
+  return type.createAndFill(blockAttrs || null, textNode);
+}
+function buildRowFromTemplateRow({ schema, tableNode, templateRow, values, copyRowStyle = false }) {
+  const RowType = schema.nodes.tableRow;
+  const CellType = schema.nodes.tableCell;
+  const HeaderType = schema.nodes.tableHeader;
+  const map2 = TableMap.get(tableNode);
+  const totalColumns = map2.width;
+  const byColumns = Array.isArray(values) && values.length === totalColumns;
+  const newCells = [];
+  let columnCursor = 0;
+  templateRow.content.content.forEach((cellNode, cellIndex) => {
+    const isHeaderCell = cellNode.type === HeaderType;
+    const targetCellType = isHeaderCell ? CellType : cellNode.type;
+    const attrs = { ...cellNode.attrs };
+    const formatting = extractRowTemplateFormatting(cellNode, schema);
+    let cellValue = "";
+    if (byColumns) {
+      const span = Math.max(1, attrs.colspan || 1);
+      cellValue = values[columnCursor] ?? "";
+      columnCursor += span;
+    } else {
+      cellValue = Array.isArray(values) ? values[cellIndex] ?? "" : "";
+    }
+    const content = buildFormattedCellBlock(schema, cellValue, formatting, copyRowStyle);
+    const newCell = targetCellType.createAndFill(attrs, content);
+    if (newCell) newCells.push(newCell);
+  });
+  return RowType.createAndFill(null, newCells);
+}
+function insertRowsAtTableEnd({ tr, tablePos, tableNode, rows }) {
+  if (!rows || !rows.length) return;
+  const RowTypeName = "tableRow";
+  let lastRowRelPos = 0;
+  let lastRowNode = null;
+  tableNode.descendants((child, relPos) => {
+    if (child.type.name === RowTypeName) {
+      lastRowRelPos = relPos;
+      lastRowNode = child;
+    }
+  });
+  if (!lastRowNode) return;
+  const lastRowAbsEnd = tablePos + 1 + lastRowRelPos + lastRowNode.nodeSize;
+  const frag = Fragment.fromArray(rows);
+  tr.insert(lastRowAbsEnd, frag);
+}
 const Table = Node$1.create({
   name: "table",
   content: "tableRow+",
@@ -23724,6 +23881,47 @@ const Table = Node$1.create({
   },
   addCommands() {
     return {
+      /**
+       * Append multiple rows to the end of a table in a single transaction.
+       * @category Command
+       * @param {appendRowsWithContentOptions} options - Append configuration
+       * @example
+       * editor.commands.appendRowsWithContent({ tablePos, valueRows: [['A','B'], ['C','D']], copyRowStyle: true })
+       */
+      appendRowsWithContent: ({ tablePos, tableNode, valueRows = [], copyRowStyle = false }) => ({ editor, chain }) => {
+        if (typeof tablePos !== "number" && !tableNode || !Array.isArray(valueRows) || !valueRows.length) {
+          return false;
+        }
+        return chain().command(({ tr, dispatch }) => {
+          const workingTable = resolveTable(tr, tablePos, tableNode);
+          if (!workingTable) return false;
+          const templateRow = pickTemplateRowForAppend(workingTable, editor.schema);
+          if (!templateRow) return false;
+          const newRows = valueRows.map(
+            (vals) => buildRowFromTemplateRow({
+              schema: editor.schema,
+              tableNode: workingTable,
+              templateRow,
+              values: vals,
+              copyRowStyle
+            })
+          ).filter(Boolean);
+          if (!newRows.length) return false;
+          let resolvedTablePos = tablePos;
+          if (typeof resolvedTablePos !== "number" && workingTable) {
+            const tables = editor.getNodesOfType("table");
+            const match = workingTable ? tables.find((t) => t.node.eq(workingTable)) : tables[0];
+            resolvedTablePos = match?.pos ?? null;
+          }
+          if (typeof resolvedTablePos !== "number") {
+            return false;
+          }
+          if (dispatch) {
+            insertRowsAtTableEnd({ tr, tablePos, tableNode: workingTable, rows: newRows });
+          }
+          return true;
+        }).run();
+      },
       /**
        * Insert a new table into the document
        * @category Command

package/dist/super-editor/chunks/{toolbar-DjuLzygc.js → toolbar-C6e42Zol.js}

@@ -1,6 +1,6 @@
 import { computed, createElementBlock, openBlock, createElementVNode, createCommentVNode, normalizeClass, normalizeStyle, ref, withKeys, unref, withModifiers, createBlock, toDisplayString, withDirectives, vModelText, nextTick, getCurrentInstance, createVNode, readonly, watch, onMounted, onBeforeUnmount, reactive, onBeforeMount, inject, onActivated, onDeactivated, createTextVNode, Fragment, Comment, defineComponent, provide, h, Teleport, toRef, renderSlot, isVNode, shallowRef, watchEffect, mergeProps, Transition, vShow, cloneVNode, Text, renderList, withCtx } from "vue";
 import { p as process$1 } from "./converter-DOkexB95.js";
-import { _ as _export_sfc, u as useHighContrastMode, g as global$1 } from "./editor-D1Q0suDz.js";
+import { _ as _export_sfc, u as useHighContrastMode, g as global$1 } from "./editor-CEZNgaJQ.js";
 const sanitizeNumber = (value, defaultNumber) => {
   let sanitized = value.replace(/[^0-9.]/g, "");
   sanitized = parseFloat(sanitized);

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

@@ -1,4 +1,4 @@
-import { E } from "./chunks/editor-D1Q0suDz.js";
+import { E } from "./chunks/editor-CEZNgaJQ.js";
 import "./chunks/converter-DOkexB95.js";
 import "./chunks/docx-zipper-Ci5JbfjE.js";
 export {

package/dist/super-editor/super-editor/src/extensions/structured-content/structured-content-commands.d.ts

@@ -17,6 +17,13 @@
  * @property {Object} [json] - Replace content with ProseMirror JSON (overrides html)
  * @property {Object} [attrs] - Update attributes only (preserves content)
  */
+/**
+ * @typedef {Object} StructuredContentTableAppendRowsOptions
+ * @property {string} id - Structured content block identifier
+ * @property {number} [tableIndex=0] - Index of the table inside the block
+ * @property {Array<string[]>|Array<string>} rows - Cell values to append
+ * @property {boolean} [copyRowStyle=false] - Clone the last row's styling when true
+ */
 export const StructuredContentCommands: Extension;
 export type StructuredContentInlineInsert = {
     /**
@@ -64,4 +71,22 @@ export type StructuredContentUpdate = {
      */
     attrs?: any;
 };
+export type StructuredContentTableAppendRowsOptions = {
+    /**
+     * - Structured content block identifier
+     */
+    id: string;
+    /**
+     * - Index of the table inside the block
+     */
+    tableIndex?: number;
+    /**
+     * - Cell values to append
+     */
+    rows: Array<string[]> | Array<string>;
+    /**
+     * - Clone the last row's styling when true
+     */
+    copyRowStyle?: boolean;
+};
 import { Extension } from '@core/index';

package/dist/super-editor/super-editor/src/extensions/structured-content/structuredContentHelpers/getStructuredContentTablesById.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Find all tables inside a structured content block identified by id.
+ * @param {string} id - Structured content block id
+ * @param {import('prosemirror-state').EditorState} state - Editor state
+ * @returns {Array<{ node: import('prosemirror-model').Node, pos: number }>} tables with absolute positions
+ */
+export function getStructuredContentTablesById(id: string, state: import("prosemirror-state").EditorState): Array<{
+    node: import("prosemirror-model").Node;
+    pos: number;
+}>;

package/dist/super-editor/super-editor/src/extensions/structured-content/structuredContentHelpers/index.d.ts

@@ -2,3 +2,4 @@ export * from "./getStructuredContentTags";
 export * from "./getStructuredContentInlineTags";
 export * from "./getStructuredContentBlockTags";
 export * from "./getStructuredContentTagsById";
+export * from "./getStructuredContentTablesById";

package/dist/super-editor/super-editor/src/extensions/table/table.d.ts

@@ -388,6 +388,90 @@ export type TableGrid = {
      */
     colWidths?: ColWidth[];
 };
+/**
+ * Row template formatting
+ */
+export type RowTemplateFormatting = {
+    /**
+     * - Node type used when building cell content
+     */
+    blockType: import("prosemirror-model").NodeType;
+    /**
+     * - Attributes to apply to the created block node
+     */
+    blockAttrs: any | null;
+    /**
+     * - Marks copied from the template text node
+     */
+    textMarks: Array<import("prosemirror-model").Mark>;
+};
+/**
+ * Build row from template row parameters
+ */
+export type BuildRowFromTemplateRowParams = {
+    /**
+     * - Editor schema
+     */
+    schema: import("prosemirror-model").Schema;
+    /**
+     * - Table node used for column map lookup
+     */
+    tableNode: import("prosemirror-model").Node;
+    /**
+     * - Row providing structure and formatting
+     */
+    templateRow: import("prosemirror-model").Node;
+    /**
+     * - Values to populate each table cell
+     */
+    values: any[];
+    /**
+     * - Clone template marks and block attrs when true
+     */
+    copyRowStyle?: boolean;
+};
+/**
+ * Append rows to the end of a table in a single transaction.
+ */
+export type appendRowsWithContentOptions = {
+    /**
+     * - Absolute position of the target table; required when `tableNode` is not provided
+     */
+    tablePos?: number;
+    /**
+     * - Table node reference; required when `tablePos` is not provided
+     */
+    tableNode?: import("prosemirror-model").Node;
+    /**
+     * - Cell values for each appended row
+     */
+    valueRows: string[][];
+    /**
+     * - Clone template styling when true
+     */
+    copyRowStyle?: boolean;
+};
+/**
+ * Insert rows at table end parameters
+ */
+export type InsertRowsAtTableEndParams = {
+    /**
+     * - Transaction to mutate
+     */
+    tr: import("prosemirror-state").Transaction;
+    /**
+     * - Absolute position of the target table
+     */
+    tablePos: number;
+    /**
+     * - Table node receiving new rows
+     */
+    tableNode: import("prosemirror-model").Node;
+    /**
+     * - Row nodes to append
+     */
+    rows: import("prosemirror-model").Node[];
+};
 /**
  * Table configuration options
  */

package/dist/super-editor/super-editor/src/extensions/table/tableHelpers/appendRows.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Row template formatting
+ * @typedef {Object} RowTemplateFormatting
+ * @property {import('prosemirror-model').NodeType} blockType - Node type used when building cell content
+ * @property {Object|null} blockAttrs - Attributes to apply to the created block node
+ * @property {Array<import('prosemirror-model').Mark>} textMarks - Marks copied from the template text node
+ */
+/**
+ * Build row from template row parameters
+ * @typedef {Object} BuildRowFromTemplateRowParams
+ * @property {import('prosemirror-model').Schema} schema - Editor schema
+ * @property {import('prosemirror-model').Node} tableNode - Table node used for column map lookup
+ * @property {import('prosemirror-model').Node} templateRow - Row providing structure and formatting
+ * @property {Array} values - Values to populate each table cell
+ * @property {boolean} [copyRowStyle=false] - Clone template marks and block attrs when true
+ */
+/**
+ * Insert rows at table end parameters
+ * @typedef {Object} InsertRowsAtTableEndParams
+ * @property {import('prosemirror-state').Transaction} tr - Transaction to mutate
+ * @property {number} tablePos - Absolute position of the target table
+ * @property {import('prosemirror-model').Node} tableNode - Table node receiving new rows
+ * @property {import('prosemirror-model').Node[]} rows - Row nodes to append
+ */
+/**
+ * Resolve the table node that should receive appended rows.
+ * Prefers an explicit table node, falling back to a position lookup.
+ * @private
+ * @param {import('prosemirror-state').Transaction} tr - Current transaction
+ * @param {number} [tablePos] - Absolute position of the table in the document
+ * @param {import('prosemirror-model').Node} [tableNode] - Explicit table node reference
+ * @returns {import('prosemirror-model').Node|null} Table node to append rows to, or null if not found
+ */
+export function resolveTable(tr: import("prosemirror-state").Transaction, tablePos?: number, tableNode?: import("prosemirror-model").Node): import("prosemirror-model").Node | null;
+/**
+ * Select the template row used to derive structure and attributes for appended rows.
+ * Prefers the last body row (containing table cells) and falls back to the last row in the table.
+ * @private
+ * @param {import('prosemirror-model').Node} tableNode - Table node to inspect
+ * @param {import('prosemirror-model').Schema} schema - Editor schema
+ * @returns {import('prosemirror-model').Node|null} Template row node or null if none exist
+ */
+export function pickTemplateRowForAppend(tableNode: import("prosemirror-model").Node, schema: import("prosemirror-model").Schema): import("prosemirror-model").Node | null;
+/**
+ * Extract block type, attributes, and text marks from a template cell.
+ * Used to reproduce formatting when constructing new row content.
+ * @private
+ * @param {import('prosemirror-model').Node} cellNode - Template cell node
+ * @param {import('prosemirror-model').Schema} schema - Editor schema
+ * @returns {RowTemplateFormatting} Formatting info
+ */
+export function extractRowTemplateFormatting(cellNode: import("prosemirror-model").Node, schema: import("prosemirror-model").Schema): RowTemplateFormatting;
+/**
+ * Create a block node for a new cell, optionally applying marks from the template row.
+ * @private
+ * @param {import('prosemirror-model').Schema} schema - Editor schema
+ * @param {string|any} value - Cell text value
+ * @param {RowTemplateFormatting} formatting - Template formatting info
+ * @param {boolean} [copyRowStyle=false] - Whether to copy marks from the template row
+ * @returns {import('prosemirror-model').Node} Block node ready to insert into the cell
+ */
+export function buildFormattedCellBlock(schema: import("prosemirror-model").Schema, value: string | any, { blockType, blockAttrs, textMarks }: RowTemplateFormatting, copyRowStyle?: boolean): import("prosemirror-model").Node;
+/**
+ * Construct a new table row by cloning structure from a template row and filling in values.
+ * Handles colspan-based value mapping and optional style copying.
+ * @private
+ * @param {BuildRowFromTemplateRowParams} params - Build parameters
+ * @returns {import('prosemirror-model').Node|null} Newly created table row node
+ */
+export function buildRowFromTemplateRow({ schema, tableNode, templateRow, values, copyRowStyle }: BuildRowFromTemplateRowParams): import("prosemirror-model").Node | null;
+/**
+ * Append one or more rows to the end of a table in a single transaction.
+ * @private
+ * @param {InsertRowsAtTableEndParams} params - Insert parameters
+ */
+export function insertRowsAtTableEnd({ tr, tablePos, tableNode, rows }: InsertRowsAtTableEndParams): void;
+/**
+ * Row template formatting
+ */
+export type RowTemplateFormatting = {
+    /**
+     * - Node type used when building cell content
+     */
+    blockType: import("prosemirror-model").NodeType;
+    /**
+     * - Attributes to apply to the created block node
+     */
+    blockAttrs: any | null;
+    /**
+     * - Marks copied from the template text node
+     */
+    textMarks: Array<import("prosemirror-model").Mark>;
+};
+/**
+ * Build row from template row parameters
+ */
+export type BuildRowFromTemplateRowParams = {
+    /**
+     * - Editor schema
+     */
+    schema: import("prosemirror-model").Schema;
+    /**
+     * - Table node used for column map lookup
+     */
+    tableNode: import("prosemirror-model").Node;
+    /**
+     * - Row providing structure and formatting
+     */
+    templateRow: import("prosemirror-model").Node;
+    /**
+     * - Values to populate each table cell
+     */
+    values: any[];
+    /**
+     * - Clone template marks and block attrs when true
+     */
+    copyRowStyle?: boolean;
+};
+/**
+ * Insert rows at table end parameters
+ */
+export type InsertRowsAtTableEndParams = {
+    /**
+     * - Transaction to mutate
+     */
+    tr: import("prosemirror-state").Transaction;
+    /**
+     * - Absolute position of the target table
+     */
+    tablePos: number;
+    /**
+     * - Table node receiving new rows
+     */
+    tableNode: import("prosemirror-model").Node;
+    /**
+     * - Row nodes to append
+     */
+    rows: import("prosemirror-model").Node[];
+};

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

@@ -11,10 +11,10 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _SuperToolbar_instances, initToolbarGroups_fn, _interceptedCommands, makeToolbarItems_fn, initDefaultFonts_fn, updateHighlightColors_fn, deactivateAll_fn, updateToolbarHistory_fn, enrichTrackedChanges_fn, runCommandWithArgumentOnly_fn;
 import { aA as getDefaultExportFromCjs, V as v4, T as TextSelection$1, v as getMarkRange, aD as vClickOutside, H as findParentNode, aE as getActiveFormatting, av as isInTable, aF as readFromClipboard, aG as handleClipboardPaste, aH as getFileObject, aI as runPropertyTranslators, aJ as translator, aK as translator$1, aL as translator$2, aM as translator$3, aN as translator$4, aO as translator$5, aP as translator$6, aQ as translator$7, aR as translator$8, aS as translator$9, aT as translator$a, aU as translator$b, aV as translator$c, aW as translator$d, aX as translator$e, aY as commentRangeEndTranslator, aZ as commentRangeStartTranslator, a_ as translator$f, a$ as translator$g, b0 as translator$h, b1 as translator$i, b2 as translator$j, b3 as translator$k, b4 as translator$l, b5 as translator$m, b6 as translator$n, b7 as translator$o, b8 as translator$p, b9 as translator$q, ba as translator$r, bb as translator$s, bc as translator$t, bd as translator$u, be as translator$v, bf as translator$w, bg as translator$x, bh as translator$y, bi as translator$z, bj as translator$A, bk as translator$B, bl as translator$C, bm as translator$D, bn as translator$E, bo as translator$F, bp as translator$G, bq as translator$H, br as translator$I, bs as translator$J, bt as translator$K, bu as translator$L, bv as translator$M, bw as translator$N, bx as translator$O, by as translator$P, bz as translator$Q, bA as translator$R, bB as translator$S, bC as translator$T, bD as translator$U, bE as translator$V, bF as translator$W, bG as translator$X, bH as translator$Y, bI as translator$Z, bJ as translator$_, bK as translator$$, bL as translator$10, bM as translator$11, bN as translator$12, bO as translator$13, bP as translator$14, bQ as translator$15, bR as translator$16, bS as translator$17, bT as translator$18, bU as translator$19, bV as translator$1a, bW as translator$1b, bX as translator$1c, bY as translator$1d, bZ as translator$1e, b_ as translator$1f, b$ as translator$1g, c0 as translator$1h, P as PluginKey, a as Plugin } from "./chunks/converter-DOkexB95.js";
 import { c1, a5, i, a2 } from "./chunks/converter-DOkexB95.js";
-import { _ as _export_sfc, u as useHighContrastMode, a as getQuickFormatList, b as generateLinkedStyleString, c as getFileOpener, d as checkAndProcessImage, r as replaceSelectionWithImagePlaceholder, e as uploadAndInsertImage, f as collectTrackedChanges, i as isTrackedChangeActionAllowed, y as yUndoPluginKey, h as undoDepth, j as redoDepth, k as collectTrackedChangesForContext, s as shouldBypassContextMenu, S as SlashMenuPluginKey, E as Editor, l as getStarterExtensions, P as Placeholder, m as getRichTextExtensions, D as DecorationSet, n as Decoration, M as Mark, o as Extension, A as Attribute, N as Node } from "./chunks/editor-D1Q0suDz.js";
-import { t, C, v, T, p, w, q } from "./chunks/editor-D1Q0suDz.js";
+import { _ as _export_sfc, u as useHighContrastMode, a as getQuickFormatList, b as generateLinkedStyleString, c as getFileOpener, d as checkAndProcessImage, r as replaceSelectionWithImagePlaceholder, e as uploadAndInsertImage, f as collectTrackedChanges, i as isTrackedChangeActionAllowed, y as yUndoPluginKey, h as undoDepth, j as redoDepth, k as collectTrackedChangesForContext, s as shouldBypassContextMenu, S as SlashMenuPluginKey, E as Editor, l as getStarterExtensions, P as Placeholder, m as getRichTextExtensions, D as DecorationSet, n as Decoration, M as Mark, o as Extension, A as Attribute, N as Node } from "./chunks/editor-CEZNgaJQ.js";
+import { t, C, v, T, p, w, q } from "./chunks/editor-CEZNgaJQ.js";
 import { ref, onMounted, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, createElementVNode, withModifiers, toDisplayString, createCommentVNode, normalizeStyle, computed, watch, withDirectives, withKeys, vModelText, createTextVNode, createVNode, h, createApp, markRaw, nextTick, onBeforeUnmount, reactive, onUnmounted, renderSlot, shallowRef, createBlock, withCtx, resolveDynamicComponent, normalizeProps, guardReactiveProps } from "vue";
-import { t as toolbarIcons, s as sanitizeNumber, T as Toolbar, p as plusIconSvg, a as trashIconSvg, b as borderNoneIconSvg, c as arrowsToDotIconSvg, d as arrowsLeftRightIconSvg, w as wrenchIconSvg, m as magicWandIcon, e as checkIconSvg$1, x as xMarkIconSvg, l as linkIconSvg, f as tableIconSvg, g as scissorsIconSvg, h as copyIconSvg, i as pasteIconSvg, u as useMessage, N as NSkeleton } from "./chunks/toolbar-DjuLzygc.js";
+import { t as toolbarIcons, s as sanitizeNumber, T as Toolbar, p as plusIconSvg, a as trashIconSvg, b as borderNoneIconSvg, c as arrowsToDotIconSvg, d as arrowsLeftRightIconSvg, w as wrenchIconSvg, m as magicWandIcon, e as checkIconSvg$1, x as xMarkIconSvg, l as linkIconSvg, f as tableIconSvg, g as scissorsIconSvg, h as copyIconSvg, i as pasteIconSvg, u as useMessage, N as NSkeleton } from "./chunks/toolbar-C6e42Zol.js";
 import AIWriter from "./ai-writer.es.js";
 import { D } from "./chunks/docx-zipper-Ci5JbfjE.js";
 import { createZip } from "./file-zipper.es.js";

package/dist/super-editor/toolbar.es.js

@@ -1,6 +1,6 @@
 import "vue";
-import { T } from "./chunks/toolbar-DjuLzygc.js";
-import "./chunks/editor-D1Q0suDz.js";
+import { T } from "./chunks/toolbar-C6e42Zol.js";
+import "./chunks/editor-CEZNgaJQ.js";
 export {
   T as default
 };

package/dist/super-editor.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const superEditor_es = require("./chunks/super-editor.es-GExnUB7l.cjs");
+const superEditor_es = require("./chunks/super-editor.es-B2cypcnX.cjs");
 require("./chunks/vue-DKMj1I9B.cjs");
 exports.AIWriter = superEditor_es.AIWriter;
 exports.AnnotatorHelpers = superEditor_es.AnnotatorHelpers;

package/dist/super-editor.es.js

@@ -1,4 +1,4 @@
-import { A, a, _, C, D, E, b, S, c, d, e, f, g, T, h, i, j, k, l, m, n, o, p, r, q } from "./chunks/super-editor.es-XXbEUVCc.es.js";
+import { A, a, _, C, D, E, b, S, c, d, e, f, g, T, h, i, j, k, l, m, n, o, p, r, q } from "./chunks/super-editor.es-CHq5MqBc.es.js";
 import "./chunks/vue-ZWZLQtoU.es.js";
 export {
   A as AIWriter,

package/dist/superdoc.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const superEditor_es = require("./chunks/super-editor.es-GExnUB7l.cjs");
-const superdoc = require("./chunks/index-7exCeEb1.cjs");
+const superEditor_es = require("./chunks/super-editor.es-B2cypcnX.cjs");
+const superdoc = require("./chunks/index-aoNHRlnl.cjs");
 require("./chunks/vue-DKMj1I9B.cjs");
 const blankDocx = require("./chunks/blank-docx-DfW3Eeh2.cjs");
 exports.AnnotatorHelpers = superEditor_es.AnnotatorHelpers;

package/dist/superdoc.es.js

@@ -1,5 +1,5 @@
-import { a, E, b, S, d, i, j, n, r, p, q } from "./chunks/super-editor.es-XXbEUVCc.es.js";
-import { D, H, P, S as S2, m, l } from "./chunks/index-DDGjYIm1.es.js";
+import { a, E, b, S, d, i, j, n, r, p, q } from "./chunks/super-editor.es-CHq5MqBc.es.js";
+import { D, H, P, S as S2, m, l } from "./chunks/index-DOLVGSYC.es.js";
 import "./chunks/vue-ZWZLQtoU.es.js";
 import { B } from "./chunks/blank-docx-ABm6XYAA.es.js";
 export {