@primeui/texteditor-core 0.0.1-alpha.1

package/dist/chunk-6YDCG63C.mjs

@@ -0,0 +1,833 @@
+import { createBlockCommands, wrapInBlockquoteNormalized, wrapInListNormalized } from './chunk-VWGQMUPD.mjs';
+import { DEFAULT_HIGHLIGHT_COLOR } from './chunk-TB7ZSSR2.mjs';
+import { getMarkAttrs } from './chunk-72T5I4O4.mjs';
+import { preserveSelection } from './chunk-RQ2HHNI6.mjs';
+import { docToHtml } from './chunk-6ZN5XRH2.mjs';
+import { parseDimension } from './chunk-F7BJWPT6.mjs';
+import { sanitizeImageUrl, sanitizeTextAttr, sanitizeUrl } from './chunk-MNKMKFLQ.mjs';
+import { setBlockType, toggleMark } from 'prosemirror-commands';
+import { TableMap, CellSelection, toggleHeaderCell, splitCell, mergeCells, toggleHeaderColumn, deleteColumn, addColumnAfter, addColumnBefore, toggleHeaderRow, deleteTable, deleteRow, addRowAfter, addRowBefore } from 'prosemirror-tables';
+import { TextSelection } from 'prosemirror-state';
+import { liftListItem } from 'prosemirror-schema-list';
+import { redo, undo } from 'prosemirror-history';
+
+function toggleMarkCommand(view, markType) {
+  toggleMark(markType)(view.state, view.dispatch);
+  view.focus();
+}
+function applyStyleToRange(tr, markType, attr, value, from, to) {
+  const ranges = [];
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isText) return;
+    const existingMark = markType.isInSet(node.marks);
+    const existingAttrs = existingMark ? { ...existingMark.attrs } : {};
+    const mergedAttrs = { ...existingAttrs, [attr]: value || null };
+    ranges.push({ from: Math.max(pos, from), to: Math.min(pos + node.nodeSize, to), attrs: mergedAttrs });
+  });
+  tr.removeMark(from, to, markType);
+  for (const range of ranges) {
+    if (Object.values(range.attrs).some((v) => v != null)) {
+      tr.addMark(range.from, range.to, markType.create(range.attrs));
+    }
+  }
+  if (ranges.length === 0 && value) {
+    tr.addMark(from, to, markType.create({ [attr]: value }));
+  }
+}
+function applyTextStyle(view, schema, attr, value) {
+  const markType = schema.marks.textStyle;
+  const { selection } = view.state;
+  const { empty } = selection;
+  if (empty) {
+    const currentAttrs = getMarkAttrs(view.state, markType) || {};
+    const newAttrs = { ...currentAttrs, [attr]: value || null };
+    const hasValue = Object.values(newAttrs).some((v) => v != null);
+    const tr2 = hasValue ? view.state.tr.addStoredMark(markType.create(newAttrs)) : view.state.tr.removeStoredMark(markType);
+    view.dispatch(tr2);
+    view.focus();
+    return;
+  }
+  const tr = view.state.tr;
+  if (selection instanceof CellSelection) {
+    selection.forEachCell((cell, pos) => {
+      applyStyleToRange(tr, markType, attr, value, pos + 1, pos + cell.nodeSize - 1);
+    });
+  } else {
+    applyStyleToRange(tr, markType, attr, value, selection.from, selection.to);
+  }
+  view.dispatch(tr);
+  view.focus();
+}
+function isHighlightActive(view, schema) {
+  const attrs = getMarkAttrs(view.state, schema.marks.textStyle);
+  return !!attrs?.backgroundColor;
+}
+function createFormattingCommands(view, schema, options) {
+  const highlightColor = options?.highlightColor || DEFAULT_HIGHLIGHT_COLOR;
+  return {
+    bold: () => toggleMarkCommand(view, schema.marks.bold),
+    italic: () => toggleMarkCommand(view, schema.marks.italic),
+    underline: () => toggleMarkCommand(view, schema.marks.underline),
+    strikethrough: () => toggleMarkCommand(view, schema.marks.strikethrough),
+    subscript: () => toggleMarkCommand(view, schema.marks.subscript),
+    superscript: () => toggleMarkCommand(view, schema.marks.superscript),
+    code: () => toggleMarkCommand(view, schema.marks.code),
+    fontFamily: (family) => applyTextStyle(view, schema, "fontFamily", family),
+    fontSize: (size) => applyTextStyle(view, schema, "fontSize", size),
+    foregroundColor: (color) => applyTextStyle(view, schema, "color", color),
+    backgroundColor: (color) => applyTextStyle(view, schema, "backgroundColor", color),
+    highlight: () => applyTextStyle(view, schema, "backgroundColor", isHighlightActive(view, schema) ? null : highlightColor)
+  };
+}
+function currentListItemType(view, schema) {
+  const { $from } = view.state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type === schema.nodes.list_item) return schema.nodes.list_item;
+    if (node.type === schema.nodes.check_list_item) return schema.nodes.check_list_item;
+  }
+  return null;
+}
+function findList(view, schema) {
+  const { $from } = view.state.selection;
+  const listTypes = [schema.nodes.bullet_list, schema.nodes.ordered_list, schema.nodes.check_list];
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (listTypes.includes(node.type)) {
+      return { pos: $from.before(depth), node, depth };
+    }
+  }
+  const { from, to } = view.state.selection;
+  let found = null;
+  view.state.doc.nodesBetween(from, to, (node, pos) => {
+    if (found) return false;
+    if (listTypes.includes(node.type)) {
+      const $pos = view.state.doc.resolve(pos);
+      found = { pos, node, depth: $pos.depth };
+      return false;
+    }
+    return void 0;
+  });
+  return found;
+}
+function convertNode(node, targetListType, targetItemType, schema) {
+  const listTypes = [schema.nodes.bullet_list, schema.nodes.ordered_list, schema.nodes.check_list];
+  const itemTypes = [schema.nodes.list_item, schema.nodes.check_list_item];
+  if (listTypes.includes(node.type)) {
+    const children = [];
+    node.content.forEach((child) => children.push(convertNode(child, targetListType, targetItemType, schema)));
+    return targetListType.create(null, children);
+  }
+  if (itemTypes.includes(node.type)) {
+    const inner = [];
+    node.content.forEach((child) => inner.push(convertNode(child, targetListType, targetItemType, schema)));
+    const attrs = targetItemType === schema.nodes.check_list_item ? { checked: false } : null;
+    return targetItemType.create(attrs, inner, node.marks);
+  }
+  return node;
+}
+function convertItems(content, targetListType, targetItemType, schema) {
+  const items = [];
+  content.forEach((child) => items.push(convertNode(child, targetListType, targetItemType, schema)));
+  return items;
+}
+function findAllLists(view, schema) {
+  const { from, to } = view.state.selection;
+  const listTypes = [schema.nodes.bullet_list, schema.nodes.ordered_list, schema.nodes.check_list];
+  const results = [];
+  view.state.doc.nodesBetween(from, to, (node, pos) => {
+    if (listTypes.includes(node.type)) {
+      const $pos = view.state.doc.resolve(pos);
+      results.push({ pos, node, depth: $pos.depth });
+      return false;
+    }
+    return void 0;
+  });
+  return results;
+}
+function toggleList(view, schema, targetListType, targetItemType) {
+  const existing = findList(view, schema);
+  if (existing && existing.node.type === targetListType) {
+    const itemType = currentListItemType(view, schema) || targetItemType;
+    liftListItem(itemType)(view.state, view.dispatch);
+    view.focus();
+    return;
+  }
+  if (existing) {
+    const allLists = findAllLists(view, schema);
+    if (allLists.length > 0) {
+      const tr = view.state.tr;
+      const { anchor, head } = view.state.selection;
+      for (let i = allLists.length - 1; i >= 0; i--) {
+        const list = allLists[i];
+        const newList = targetListType.create(null, convertItems(list.node.content, targetListType, targetItemType, schema));
+        tr.replaceWith(list.pos, list.pos + list.node.nodeSize, newList);
+      }
+      try {
+        tr.setSelection(TextSelection.between(tr.doc.resolve(anchor), tr.doc.resolve(head)));
+      } catch {
+      }
+      view.dispatch(tr.scrollIntoView());
+      view.focus();
+      return;
+    }
+  }
+  wrapInListNormalized(view, schema, targetListType);
+  view.focus();
+}
+function createListCommands(view, schema) {
+  return {
+    bulletList: () => toggleList(view, schema, schema.nodes.bullet_list, schema.nodes.list_item),
+    orderedList: () => toggleList(view, schema, schema.nodes.ordered_list, schema.nodes.list_item),
+    checkList: () => toggleList(view, schema, schema.nodes.check_list, schema.nodes.check_list_item)
+  };
+}
+function findTable(view) {
+  const { $from } = view.state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    if ($from.node(depth).type.name === "table") {
+      return { node: $from.node(depth), start: $from.before(depth) + 1 };
+    }
+  }
+  return null;
+}
+function selectColumn(view, colIndex) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  if (colIndex >= map.width) return;
+  const firstCellPos = table.start + map.map[colIndex];
+  const lastCellPos = table.start + map.map[(map.height - 1) * map.width + colIndex];
+  const $first = view.state.doc.resolve(firstCellPos);
+  const $last = view.state.doc.resolve(lastCellPos);
+  view.dispatch(view.state.tr.setSelection(CellSelection.create(view.state.doc, $first.pos, $last.pos)));
+}
+function selectRow(view, rowIndex) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  if (rowIndex >= map.height) return;
+  const firstCellPos = table.start + map.map[rowIndex * map.width];
+  const lastCellPos = table.start + map.map[rowIndex * map.width + (map.width - 1)];
+  const $first = view.state.doc.resolve(firstCellPos);
+  const $last = view.state.doc.resolve(lastCellPos);
+  view.dispatch(view.state.tr.setSelection(CellSelection.create(view.state.doc, $first.pos, $last.pos)));
+}
+function moveColumn(view, colIndex, direction) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const targetCol = colIndex + direction;
+  if (targetCol < 0 || targetCol >= map.width) return;
+  const tr = view.state.tr;
+  for (let row = map.height - 1; row >= 0; row--) {
+    const fromCellPos = table.start + map.map[row * map.width + colIndex];
+    const toCellPos = table.start + map.map[row * map.width + targetCol];
+    const fromCell = view.state.doc.nodeAt(fromCellPos);
+    const toCell = view.state.doc.nodeAt(toCellPos);
+    if (!fromCell || !toCell) return;
+    if ((fromCell.attrs.colspan ?? 1) > 1 || (toCell.attrs.colspan ?? 1) > 1 || (fromCell.attrs.rowspan ?? 1) > 1 || (toCell.attrs.rowspan ?? 1) > 1) return;
+    const [firstPos, firstCell, secondPos, secondCell] = fromCellPos < toCellPos ? [fromCellPos, fromCell, toCellPos, toCell] : [toCellPos, toCell, fromCellPos, fromCell];
+    tr.replaceWith(tr.mapping.map(secondPos), tr.mapping.map(secondPos + secondCell.nodeSize), firstCell.copy(firstCell.content));
+    tr.replaceWith(tr.mapping.map(firstPos), tr.mapping.map(firstPos + firstCell.nodeSize), secondCell.copy(secondCell.content));
+  }
+  if (tr.docChanged) {
+    view.dispatch(tr);
+    view.focus();
+  }
+}
+function moveRow(view, rowIndex, direction) {
+  const table = findTable(view);
+  if (!table) return;
+  const targetRow = rowIndex + direction;
+  if (targetRow < 0 || targetRow >= table.node.childCount) return;
+  const fromRow = table.node.child(rowIndex);
+  const toRow = table.node.child(targetRow);
+  if (fromRow.childCount !== toRow.childCount) return;
+  for (let col = 0; col < fromRow.childCount; col++) {
+    const a = fromRow.child(col);
+    const b = toRow.child(col);
+    if ((a.attrs.rowspan ?? 1) > 1 || (b.attrs.rowspan ?? 1) > 1 || (a.attrs.colspan ?? 1) > 1 || (b.attrs.colspan ?? 1) > 1) return;
+  }
+  let fromRowPos = table.start;
+  for (let i = 0; i < rowIndex; i++) {
+    fromRowPos += table.node.child(i).nodeSize;
+  }
+  let toRowPos = table.start;
+  for (let i = 0; i < targetRow; i++) {
+    toRowPos += table.node.child(i).nodeSize;
+  }
+  const tr = view.state.tr;
+  const [firstPos, firstRow, secondPos, secondRow] = fromRowPos < toRowPos ? [fromRowPos, fromRow, toRowPos, toRow] : [toRowPos, toRow, fromRowPos, fromRow];
+  tr.replaceWith(secondPos, secondPos + secondRow.nodeSize, firstRow.copy(firstRow.content));
+  tr.replaceWith(firstPos, firstPos + firstRow.nodeSize, secondRow.copy(secondRow.content));
+  if (tr.docChanged) {
+    view.dispatch(tr);
+    view.focus();
+  }
+}
+function alignCell(tr, cellPos, doc, alignment) {
+  const cell = doc.nodeAt(cellPos);
+  if (!cell) return;
+  cell.forEach((child, offset) => {
+    if (child.type.name === "paragraph" || child.type.name === "heading") {
+      const pos = cellPos + 1 + offset;
+      tr.setNodeMarkup(tr.mapping.map(pos), null, { ...child.attrs, textAlign: alignment === "left" ? null : alignment });
+    }
+  });
+}
+function alignColumn(view, colIndex, alignment) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const tr = view.state.tr;
+  for (let row = 0; row < map.height; row++) {
+    const cellPos = table.start + map.map[row * map.width + colIndex];
+    alignCell(tr, cellPos, view.state.doc, alignment);
+  }
+  if (tr.docChanged) {
+    view.dispatch(tr);
+    view.focus();
+  }
+}
+function alignRow(view, rowIndex, alignment) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const tr = view.state.tr;
+  for (let col = 0; col < map.width; col++) {
+    const cellPos = table.start + map.map[rowIndex * map.width + col];
+    alignCell(tr, cellPos, view.state.doc, alignment);
+  }
+  if (tr.docChanged) {
+    view.dispatch(tr);
+    view.focus();
+  }
+}
+function alignCurrentCell(view, alignment) {
+  const { $from } = view.state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type.name === "table_cell" || node.type.name === "table_header") {
+      const cellPos = $from.before(depth);
+      const tr = view.state.tr;
+      alignCell(tr, cellPos, view.state.doc, alignment);
+      if (tr.docChanged) {
+        view.dispatch(tr);
+        view.focus();
+      }
+      return;
+    }
+  }
+}
+function setCellBackgroundColor(tr, cellPos, color) {
+  const cell = tr.doc.nodeAt(tr.mapping.map(cellPos));
+  if (!cell) return;
+  tr.setNodeMarkup(tr.mapping.map(cellPos), null, { ...cell.attrs, backgroundColor: color });
+}
+function setCellForegroundColor(view, cellPos, color) {
+  const cell = view.state.doc.nodeAt(cellPos);
+  if (!cell) return;
+  const from = cellPos + 1;
+  const to = cellPos + cell.nodeSize - 1;
+  const textStyleType = view.state.schema.marks.textStyle;
+  if (!textStyleType) return;
+  const tr = view.state.tr;
+  if (color) {
+    tr.addMark(from, to, textStyleType.create({ color }));
+  } else {
+    tr.removeMark(from, to, textStyleType);
+  }
+  view.dispatch(tr);
+}
+function colorColumn(view, colIndex, color, property) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  if (property === "backgroundColor") {
+    const tr = view.state.tr;
+    for (let row = 0; row < map.height; row++) {
+      setCellBackgroundColor(tr, table.start + map.map[row * map.width + colIndex], color || null);
+    }
+    if (tr.docChanged) view.dispatch(tr);
+  } else {
+    for (let row = 0; row < map.height; row++) {
+      setCellForegroundColor(view, table.start + map.map[row * map.width + colIndex], color);
+    }
+  }
+  view.focus();
+}
+function colorRow(view, rowIndex, color, property) {
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  if (property === "backgroundColor") {
+    const tr = view.state.tr;
+    for (let col = 0; col < map.width; col++) {
+      setCellBackgroundColor(tr, table.start + map.map[rowIndex * map.width + col], color || null);
+    }
+    if (tr.docChanged) view.dispatch(tr);
+  } else {
+    for (let col = 0; col < map.width; col++) {
+      setCellForegroundColor(view, table.start + map.map[rowIndex * map.width + col], color);
+    }
+  }
+  view.focus();
+}
+function colorCurrentCell(view, color, property) {
+  const { $from } = view.state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type.name === "table_cell" || node.type.name === "table_header") {
+      const cellPos = $from.before(depth);
+      if (property === "backgroundColor") {
+        const tr = view.state.tr;
+        setCellBackgroundColor(tr, cellPos, color || null);
+        if (tr.docChanged) view.dispatch(tr);
+      } else {
+        setCellForegroundColor(view, cellPos, color);
+      }
+      view.focus();
+      return;
+    }
+  }
+}
+function duplicateColumn(view, colIndex) {
+  const source = findTable(view);
+  if (!source) return;
+  const sourceMap = TableMap.get(source.node);
+  for (let row = 0; row < sourceMap.height; row++) {
+    const cell = view.state.doc.nodeAt(source.start + sourceMap.map[row * sourceMap.width + colIndex]);
+    if (cell && ((cell.attrs.colspan ?? 1) > 1 || (cell.attrs.rowspan ?? 1) > 1)) return;
+  }
+  addColumnAfter(view.state, view.dispatch);
+  const table = findTable(view);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const tr = view.state.tr;
+  for (let row = 0; row < map.height; row++) {
+    const sourceCellPos = table.start + map.map[row * map.width + colIndex];
+    const targetCellPos = table.start + map.map[row * map.width + colIndex + 1];
+    const sourceCell = view.state.doc.nodeAt(sourceCellPos);
+    const targetCell = view.state.doc.nodeAt(targetCellPos);
+    if (!sourceCell || !targetCell) continue;
+    tr.replaceWith(tr.mapping.map(targetCellPos + 1), tr.mapping.map(targetCellPos + targetCell.nodeSize - 1), sourceCell.content);
+  }
+  if (tr.docChanged) {
+    view.dispatch(tr);
+  }
+  view.focus();
+}
+function duplicateRow(view, rowIndex) {
+  const table = findTable(view);
+  if (!table) return;
+  const row = table.node.child(rowIndex);
+  let rowEndPos = table.start;
+  for (let i = 0; i <= rowIndex; i++) {
+    rowEndPos += table.node.child(i).nodeSize;
+  }
+  const tr = view.state.tr.insert(rowEndPos, row.copy(row.content));
+  view.dispatch(tr);
+  view.focus();
+}
+
+// src/commands/tables.ts
+function insertTable(view, schema, rows = 3, cols = 3, defaultCellWidth) {
+  const cells = [];
+  const cellAttrs = defaultCellWidth ? { colwidth: [defaultCellWidth] } : null;
+  for (let i = 0; i < cols; i++) {
+    cells.push(schema.nodes.table_cell.create(cellAttrs, schema.nodes.paragraph.create()));
+  }
+  const tableRows = [];
+  for (let i = 0; i < rows; i++) {
+    const rowCells = cells.map((cell) => cell.copy(cell.content));
+    tableRows.push(schema.nodes.table_row.create(null, rowCells));
+  }
+  const table = schema.nodes.table.create(null, tableRows);
+  const $from = view.state.selection.$from;
+  const parent = $from.node($from.depth);
+  const tr = view.state.tr;
+  let tablePos;
+  if (parent.isTextblock && parent.content.size === 0) {
+    tablePos = $from.before($from.depth);
+    tr.replaceWith(tablePos, tablePos + parent.nodeSize, table);
+  } else {
+    tablePos = $from.after(1);
+    tr.insert(tablePos, table);
+  }
+  const cellParagraphPos = tablePos + 3;
+  const selection = TextSelection.findFrom(tr.doc.resolve(cellParagraphPos), 1, true);
+  if (selection) tr.setSelection(selection);
+  view.dispatch(tr.scrollIntoView());
+  view.focus();
+}
+function createTableColumnCommands(view, schema, _colIndex, onDismiss) {
+  const run = (cmd) => {
+    cmd(view.state, view.dispatch);
+    view.focus();
+    onDismiss();
+  };
+  return {
+    insertBefore: () => run(addColumnBefore),
+    insertAfter: () => run(addColumnAfter),
+    delete: () => run(deleteColumn),
+    moveLeft: () => {
+      moveColumn(view, _colIndex, -1);
+      selectColumn(view, _colIndex - 1);
+      onDismiss();
+    },
+    moveRight: () => {
+      moveColumn(view, _colIndex, 1);
+      selectColumn(view, _colIndex + 1);
+      onDismiss();
+    },
+    duplicate: () => {
+      duplicateColumn(view, _colIndex);
+      onDismiss();
+    },
+    align: (value) => {
+      alignColumn(view, _colIndex, value);
+      onDismiss();
+    },
+    toggleHeader: () => run(toggleHeaderColumn),
+    foregroundColor: (color) => {
+      colorColumn(view, _colIndex, color, "color");
+      onDismiss();
+    },
+    backgroundColor: (color) => {
+      colorColumn(view, _colIndex, color, "backgroundColor");
+      onDismiss();
+    }
+  };
+}
+function createTableRowCommands(view, schema, _rowIndex, onDismiss) {
+  const run = (cmd) => {
+    cmd(view.state, view.dispatch);
+    view.focus();
+    onDismiss();
+  };
+  return {
+    insertBefore: () => run(addRowBefore),
+    insertAfter: () => run(addRowAfter),
+    delete: () => run(deleteRow),
+    moveUp: () => {
+      moveRow(view, _rowIndex, -1);
+      selectRow(view, _rowIndex - 1);
+      onDismiss();
+    },
+    moveDown: () => {
+      moveRow(view, _rowIndex, 1);
+      selectRow(view, _rowIndex + 1);
+      onDismiss();
+    },
+    duplicate: () => {
+      duplicateRow(view, _rowIndex);
+      onDismiss();
+    },
+    deleteTable: () => run(deleteTable),
+    align: (value) => {
+      alignRow(view, _rowIndex, value);
+      onDismiss();
+    },
+    toggleHeader: () => run(toggleHeaderRow),
+    foregroundColor: (color) => {
+      colorRow(view, _rowIndex, color, "color");
+      onDismiss();
+    },
+    backgroundColor: (color) => {
+      colorRow(view, _rowIndex, color, "backgroundColor");
+      onDismiss();
+    }
+  };
+}
+function createTableCellCommands(view, schema, onDismiss) {
+  return {
+    clearContents: () => {
+      const { $from } = view.state.selection;
+      for (let depth = $from.depth; depth > 0; depth--) {
+        if ($from.node(depth).type === schema.nodes.table_cell || $from.node(depth).type === schema.nodes.table_header) {
+          const cellStart = $from.start(depth);
+          const cellEnd = $from.end(depth);
+          const tr = view.state.tr.replaceWith(cellStart, cellEnd, schema.nodes.paragraph.create());
+          view.dispatch(tr);
+          break;
+        }
+      }
+      view.focus();
+      onDismiss();
+    },
+    align: (value) => {
+      alignCurrentCell(view, value);
+      onDismiss();
+    },
+    mergeCells: () => {
+      mergeCells(view.state, view.dispatch);
+      view.focus();
+      onDismiss();
+    },
+    splitCell: () => {
+      splitCell(view.state, view.dispatch);
+      view.focus();
+      onDismiss();
+    },
+    toggleHeader: () => {
+      toggleHeaderCell(view.state, view.dispatch);
+      view.focus();
+      onDismiss();
+    },
+    foregroundColor: (color) => {
+      colorCurrentCell(view, color, "color");
+      onDismiss();
+    },
+    backgroundColor: (color) => {
+      colorCurrentCell(view, color, "backgroundColor");
+      onDismiss();
+    }
+  };
+}
+
+// src/commands/markRange.ts
+function findMarkRange(doc, pos, markType) {
+  const $pos = doc.resolve(pos);
+  const parent = $pos.parent;
+  const parentStart = $pos.start();
+  const markAt = (i) => i >= 0 && i < parent.childCount ? markType.isInSet(parent.child(i).marks) || null : null;
+  let index = $pos.index();
+  let anchor = markAt(index);
+  if (!anchor && markAt(index - 1)) {
+    index -= 1;
+    anchor = markAt(index);
+  }
+  if (!anchor) return null;
+  const sameMark = (i) => {
+    const m = markAt(i);
+    return !!m && m.eq(anchor);
+  };
+  let start = index;
+  let end = index;
+  while (start > 0 && sameMark(start - 1)) start--;
+  while (end < parent.childCount - 1 && sameMark(end + 1)) end++;
+  let from = parentStart;
+  for (let i = 0; i < start; i++) from += parent.child(i).nodeSize;
+  let to = from;
+  for (let i = start; i <= end; i++) to += parent.child(i).nodeSize;
+  return { from, to };
+}
+
+// src/commands/content.ts
+function createContentCommands(view, schema) {
+  const getLinkRange = () => {
+    const { from, to, empty } = view.state.selection;
+    if (!empty) return { from, to };
+    return findMarkRange(view.state.doc, from, schema.marks.link) ?? { from, to };
+  };
+  return {
+    insertLink: (url, text) => {
+      const href = sanitizeUrl(url);
+      if (href == null) return;
+      const { from, to, empty } = view.state.selection;
+      const linkMark = schema.marks.link.create({ href });
+      if (empty && text) {
+        const textNode = schema.text(text, [linkMark]);
+        view.dispatch(view.state.tr.replaceSelectionWith(textNode, false));
+      } else if (empty) {
+        const displayText = href;
+        const textNode = schema.text(displayText, [linkMark]);
+        view.dispatch(view.state.tr.replaceSelectionWith(textNode, false));
+      } else {
+        view.dispatch(view.state.tr.addMark(from, to, linkMark));
+      }
+      view.focus();
+    },
+    updateLink: (url) => {
+      const href = sanitizeUrl(url);
+      if (href == null) return;
+      const { from, to } = getLinkRange();
+      const tr = view.state.tr;
+      tr.removeMark(from, to, schema.marks.link);
+      tr.addMark(from, to, schema.marks.link.create({ href }));
+      view.dispatch(tr);
+      view.focus();
+    },
+    removeLink: () => {
+      const { from, to } = getLinkRange();
+      view.dispatch(view.state.tr.removeMark(from, to, schema.marks.link));
+      view.focus();
+    },
+    openLink: () => {
+      const { $from } = view.state.selection;
+      const linkMark = schema.marks.link.isInSet($from.marks()) ?? schema.marks.link.isInSet(view.state.doc.resolve(Math.max(0, $from.pos - 1)).marks());
+      const href = linkMark?.attrs.href ? sanitizeUrl(linkMark.attrs.href) : null;
+      if (href) window.open(href, "_blank", "noopener,noreferrer");
+    },
+    insertImage: (src, attrs) => {
+      const safeSrc = sanitizeImageUrl(src);
+      if (safeSrc == null) return;
+      const imageNode = schema.nodes.image.create({
+        src: safeSrc,
+        alt: sanitizeTextAttr(attrs?.alt) || null,
+        width: parseDimension(attrs?.width == null ? null : String(attrs.width)),
+        height: parseDimension(attrs?.height == null ? null : String(attrs.height))
+      });
+      view.dispatch(view.state.tr.replaceSelectionWith(imageNode));
+      view.focus();
+    }
+  };
+}
+function createEditorCommands(view, schema, callbacks) {
+  const insertUploadPlaceholder = (placeholderType, onInsert) => {
+    let exists = false;
+    view.state.doc.descendants((node) => {
+      if (node.type === placeholderType) exists = true;
+    });
+    if (exists) return;
+    view.dispatch(view.state.tr.replaceSelectionWith(placeholderType.create()).scrollIntoView());
+    onInsert?.();
+  };
+  return {
+    clearFormatting: () => {
+      const { from, to, empty } = view.state.selection;
+      if (empty) return;
+      const tr = view.state.tr;
+      for (const markType of Object.values(schema.marks)) {
+        tr.removeMark(from, to, markType);
+      }
+      view.state.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.isTextblock && node.type !== schema.nodes.paragraph && node.type !== schema.nodes.code_block) {
+          tr.setNodeMarkup(pos, schema.nodes.paragraph);
+        }
+      });
+      view.dispatch(tr);
+      view.focus();
+    },
+    print: () => {
+      const content = docToHtml(view.state.doc, schema);
+      const iframe = document.createElement("iframe");
+      iframe.setAttribute("sandbox", "allow-modals allow-same-origin");
+      iframe.style.position = "fixed";
+      iframe.style.inset = "0";
+      iframe.style.width = "0";
+      iframe.style.height = "0";
+      iframe.style.border = "none";
+      document.body.appendChild(iframe);
+      const doc = iframe.contentDocument;
+      if (doc) {
+        doc.open();
+        doc.write(
+          `<!DOCTYPE html><html><head><style>body { font-family: system-ui, sans-serif; padding: 2rem; line-height: 1.6; } img { max-width: 100%; } table { border-collapse: collapse; width: 100%; } td, th { border: 1px solid #ccc; padding: 0.5rem; }</style></head><body>${content}</body></html>`
+        );
+        doc.close();
+        iframe.contentWindow?.focus();
+        iframe.contentWindow?.print();
+      }
+      setTimeout(() => iframe.remove(), 1e3);
+    },
+    uploadImages: () => insertUploadPlaceholder(schema.nodes.image_upload_placeholder, callbacks?.onUploadImages),
+    uploadDocuments: () => insertUploadPlaceholder(schema.nodes.document_upload_placeholder, callbacks?.onUploadDocuments),
+    undo: () => {
+      undo(view.state, view.dispatch);
+      view.focus();
+    },
+    redo: () => {
+      redo(view.state, view.dispatch);
+      view.focus();
+    }
+  };
+}
+
+// src/commands/index.ts
+function createCommands(view, schema, callbacks, options) {
+  const formatting = createFormattingCommands(view, schema, { highlightColor: options?.highlightColor });
+  const blocks = createBlockCommands(view, schema);
+  const lists = createListCommands(view, schema);
+  const content = createContentCommands(view, schema);
+  const editorCmds = createEditorCommands(view, schema, callbacks);
+  return {
+    // Formatting marks
+    bold: formatting.bold,
+    italic: formatting.italic,
+    underline: formatting.underline,
+    strikethrough: formatting.strikethrough,
+    subscript: formatting.subscript,
+    superscript: formatting.superscript,
+    code: formatting.code,
+    highlight: formatting.highlight,
+    clearFormatting: editorCmds.clearFormatting,
+    // Block types
+    heading: blocks.heading,
+    paragraph: blocks.paragraph,
+    codeBlock: blocks.codeBlock,
+    blockquote: blocks.blockquote,
+    insertHorizontalRule: blocks.insertHorizontalRule,
+    textAlign: blocks.textAlign,
+    // Formatting styles
+    fontFamily: formatting.fontFamily,
+    fontSize: formatting.fontSize,
+    foregroundColor: formatting.foregroundColor,
+    backgroundColor: formatting.backgroundColor,
+    // Lists
+    bulletList: lists.bulletList,
+    orderedList: lists.orderedList,
+    checkList: lists.checkList,
+    // Content
+    insertLink: content.insertLink,
+    updateLink: content.updateLink,
+    removeLink: content.removeLink,
+    openLink: content.openLink,
+    insertImage: content.insertImage,
+    // Table
+    table: (rows, cols) => insertTable(view, schema, rows || 3, cols || 3, options?.defaultCellWidth),
+    // Features
+    print: editorCmds.print,
+    uploadImages: editorCmds.uploadImages,
+    uploadDocuments: editorCmds.uploadDocuments,
+    // History
+    undo: editorCmds.undo,
+    redo: editorCmds.redo,
+    // Selection highlight
+    preserveSelection: () => preserveSelection(view),
+    // Turn into (non-toggle: always sets the type)
+    turnInto: {
+      text: () => {
+        setBlockType(schema.nodes.paragraph)(view.state, view.dispatch);
+        view.focus();
+      },
+      heading1: () => {
+        setBlockType(schema.nodes.heading, { level: 1 })(view.state, view.dispatch);
+        view.focus();
+      },
+      heading2: () => {
+        setBlockType(schema.nodes.heading, { level: 2 })(view.state, view.dispatch);
+        view.focus();
+      },
+      heading3: () => {
+        setBlockType(schema.nodes.heading, { level: 3 })(view.state, view.dispatch);
+        view.focus();
+      },
+      bulletList: () => {
+        wrapInListNormalized(view, schema, schema.nodes.bullet_list);
+        view.focus();
+      },
+      orderedList: () => {
+        wrapInListNormalized(view, schema, schema.nodes.ordered_list);
+        view.focus();
+      },
+      checkList: () => {
+        wrapInListNormalized(view, schema, schema.nodes.check_list);
+        view.focus();
+      },
+      blockquote: () => {
+        wrapInBlockquoteNormalized(view, schema);
+        view.focus();
+      },
+      codeBlock: () => {
+        setBlockType(schema.nodes.code_block)(view.state, view.dispatch);
+        view.focus();
+      }
+    }
+  };
+}
+
+export { createCommands, createTableCellCommands, createTableColumnCommands, createTableRowCommands, selectColumn, selectRow };
+//# sourceMappingURL=chunk-6YDCG63C.mjs.map
+//# sourceMappingURL=chunk-6YDCG63C.mjs.map