@pixerate/editor 0.44.0 → 0.45.0

package/dist/chunk-5H2OPMXZ.js

@@ -1,586 +0,0 @@
-import {
-  isTrackChangesEnabled
-} from "./chunk-SWE3NPOU.js";
-
-// src/extensions/table/nesting.ts
-import { Fragment, Slice } from "@tiptap/pm/model";
-import { Plugin, PluginKey, Selection } from "@tiptap/pm/state";
-import {
-  CellSelection,
-  __pastedCells,
-  handlePaste as handleTablePaste
-} from "@tiptap/pm/tables";
-var ALLOW_NESTED_TABLES_META = "allowNestedTables";
-var tableNestingPluginKey = new PluginKey("tableNesting");
-var roleOf = (node) => node.type.spec.tableRole;
-var isTableNode = (node) => roleOf(node) === "table";
-function outermostTableDepth($pos) {
-  for (let d = 1; d <= $pos.depth; d++) if (isTableNode($pos.node(d))) return d;
-  return -1;
-}
-function isInTableCell($pos) {
-  for (let d = $pos.depth; d > 0; d--) {
-    const role = roleOf($pos.node(d));
-    if (role === "cell" || role === "header_cell") return true;
-  }
-  return false;
-}
-function sliceContainsTable(content) {
-  const fragment = content instanceof Slice ? content.content : content;
-  let found = false;
-  fragment.descendants((node) => {
-    if (found) return false;
-    if (isTableNode(node)) found = true;
-    return !found;
-  });
-  return found;
-}
-function insertSliceAfterTable(tr, from, to, slice) {
-  const $from = tr.doc.resolve(from);
-  const depth = outermostTableDepth($from);
-  if (depth < 0) return null;
-  const tableStart = $from.before(depth);
-  const tableEnd = $from.after(depth);
-  if (to > from && to < tableEnd) {
-    if (tr.selection instanceof CellSelection && tr.selection.from === from && tr.selection.to === to) {
-      tr.deleteSelection();
-    } else {
-      tr.delete(from, to);
-    }
-  }
-  const table = tr.doc.nodeAt(tableStart);
-  if (!table) return null;
-  const after = tableStart + table.nodeSize;
-  const before = tr.doc.content.size;
-  tr.replace(after, after, new Slice(slice.content, 0, 0));
-  return after + (tr.doc.content.size - before);
-}
-function handleTablePasteWithoutNesting(view, event, slice) {
-  const { state } = view;
-  const { selection } = state;
-  if (outermostTableDepth(selection.$from) < 0) return false;
-  if (selection instanceof CellSelection || __pastedCells(slice)) {
-    if (handleTablePaste(view, event, slice)) return true;
-  }
-  if (!sliceContainsTable(slice)) return false;
-  const tr = state.tr;
-  const end = insertSliceAfterTable(tr, selection.from, selection.to, slice);
-  if (end === null) return false;
-  tr.setSelection(Selection.near(tr.doc.resolve(end), -1));
-  view.dispatch(tr.scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
-  return true;
-}
-function changedRanges(transactions, skip2) {
-  let ranges = [];
-  for (const tr of transactions) {
-    const skipped = skip2(tr);
-    for (const step of tr.steps) {
-      const map = step.getMap();
-      ranges = ranges.map(([from, to]) => [map.map(from, 1), map.map(to, -1)]).filter(([from, to]) => to > from);
-      if (skipped) continue;
-      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-        if (newEnd > newStart) ranges.push([newStart, newEnd]);
-      });
-    }
-  }
-  return ranges;
-}
-function findNestedTables(doc, ranges) {
-  const found = /* @__PURE__ */ new Set();
-  for (const [from, to] of ranges) {
-    doc.nodesBetween(from, to, (node, pos) => {
-      if (!isTableNode(node) || pos < from) return true;
-      if (isInTableCell(doc.resolve(pos))) {
-        found.add(pos);
-        return false;
-      }
-      return true;
-    });
-  }
-  const sorted = [...found].sort((a, b) => a - b);
-  const outer = [];
-  for (const pos of sorted) {
-    const last = outer[outer.length - 1];
-    if (last === void 0 || pos >= last + doc.nodeAt(last).nodeSize) outer.push(pos);
-  }
-  return outer;
-}
-function unnestTables(tr, ranges) {
-  let changed = false;
-  for (let round = 0; round < 32 && ranges.length; round++) {
-    const nested = findNestedTables(tr.doc, ranges);
-    if (!nested.length) break;
-    const groups = /* @__PURE__ */ new Map();
-    for (const pos of nested) {
-      const $pos = tr.doc.resolve(pos);
-      const outer = $pos.before(outermostTableDepth($pos));
-      groups.set(outer, [...groups.get(outer) ?? [], pos]);
-    }
-    const next = [];
-    for (const outer of [...groups.keys()].sort((a, b) => b - a)) {
-      const positions = groups.get(outer);
-      const nodes = positions.map((pos) => tr.doc.nodeAt(pos));
-      for (let i = positions.length - 1; i >= 0; i--) {
-        const pos = positions[i];
-        const node = nodes[i];
-        const $pos = tr.doc.resolve(pos);
-        const parent = $pos.parent;
-        const filler = parent.childCount === 1 ? parent.type.contentMatch.defaultType?.createAndFill() : null;
-        if (filler) tr.replaceWith(pos, pos + node.nodeSize, filler);
-        else tr.delete(pos, pos + node.nodeSize);
-      }
-      const table = tr.doc.nodeAt(outer);
-      const after = outer + table.nodeSize;
-      const fragment = Fragment.fromArray(nodes);
-      tr.insert(after, fragment);
-      next.push([after, after + fragment.size]);
-      changed = true;
-    }
-    ranges = next;
-  }
-  return changed;
-}
-function replacesDocument(tr) {
-  return tr.steps.some((step, i) => {
-    const { from, to } = step;
-    return from === 0 && to !== void 0 && to >= tr.docs[i].content.size;
-  });
-}
-var skip = (tr) => !tr.docChanged || tr.getMeta(ALLOW_NESTED_TABLES_META) === true || // Undo/redo and remote collaborative changes restore what was there.
-!!tr.getMeta("history$") || !!tr.getMeta("y-sync$") || // Other plugins' housekeeping, e.g. Track Changes putting a deleted
-// (nested) table back so the deletion can be reviewed.
-!!tr.getMeta("appendedTransaction") || replacesDocument(tr);
-function createTableNestingPlugin() {
-  return new Plugin({
-    key: tableNestingPluginKey,
-    props: {
-      handlePaste: (view, event, slice) => handleTablePasteWithoutNesting(view, event, slice)
-    },
-    appendTransaction(transactions, _oldState, newState) {
-      if (transactions.every(skip)) return null;
-      const ranges = changedRanges(transactions, skip);
-      if (!ranges.length) return null;
-      const tr = newState.tr;
-      if (!unnestTables(tr, ranges)) return null;
-      return tr;
-    }
-  });
-}
-
-// src/extensions/table/extension.ts
-import { getHTMLFromFragment } from "@tiptap/core";
-import { Fragment as Fragment2 } from "@tiptap/pm/model";
-import * as _Table from "@tiptap/extension-table";
-import * as _TableRow from "@tiptap/extension-table-row";
-import * as _TableHeader from "@tiptap/extension-table-header";
-import * as _TableCell from "@tiptap/extension-table-cell";
-var resolveExt = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
-var BaseTable = resolveExt(_Table, "Table");
-var BaseTableRow = resolveExt(_TableRow, "TableRow");
-var BaseTableHeader = resolveExt(_TableHeader, "TableHeader");
-var BaseTableCell = resolveExt(_TableCell, "TableCell");
-var ALIGNMENTS = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
-function normalizeTableCellAlignment(value) {
-  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
-  return ALIGNMENTS.has(v) ? v : null;
-}
-var COLOR_REGEX = /^(?:#[0-9a-f]{3,8}|(?:rgb|rgba|hsl|hsla)\(\s*[-0-9.%\s,/deg]+\)|[a-z]{3,20})$/i;
-function normalizeTableCellColor(value) {
-  const v = typeof value === "string" ? value.trim() : "";
-  if (!v || v.length > 64 || !COLOR_REGEX.test(v)) return null;
-  if (/^(?:inherit|initial|unset|revert|transparent)$/i.test(v)) return null;
-  return v;
-}
-var cellAttributes = () => ({
-  align: {
-    default: null,
-    parseHTML: (element) => normalizeTableCellAlignment(element.style?.textAlign || element.getAttribute("align")),
-    renderHTML: (attrs) => {
-      const align = normalizeTableCellAlignment(attrs.align);
-      return align ? { style: `text-align: ${align}` } : {};
-    }
-  },
-  backgroundColor: {
-    default: null,
-    parseHTML: (element) => normalizeTableCellColor(
-      element.getAttribute("data-background-color") || element.style?.backgroundColor || element.getAttribute("bgcolor")
-    ),
-    renderHTML: (attrs) => {
-      const color = normalizeTableCellColor(attrs.backgroundColor);
-      return color ? { style: `background-color: ${color}`, "data-background-color": color } : {};
-    }
-  }
-});
-var children = (node) => {
-  const list = [];
-  node.forEach((child) => list.push(child));
-  return list;
-};
-var hasSpan = (cell) => (cell.attrs.colspan ?? 1) > 1 || (cell.attrs.rowspan ?? 1) > 1;
-function isGfmTable(node) {
-  const rows = children(node);
-  if (rows.length === 0) return false;
-  const width = rows[0].childCount;
-  return rows.every(
-    (row, r) => row.childCount === width && children(row).every(
-      (cell) => (r === 0 ? cell.type.name === "tableHeader" : cell.type.name === "tableCell") && !hasSpan(cell) && cell.childCount === 1 && cell.firstChild.type.name === "paragraph"
-    )
-  );
-}
-var DELIMITERS = { left: ":---", center: ":---:", right: "---:" };
-function serializeTableMarkdown(state, node) {
-  if (!isGfmTable(node)) {
-    const html = getHTMLFromFragment(Fragment2.from(node), node.type.schema);
-    state.write(html.replace(/\n{2,}/g, "\n"));
-    state.closeBlock(node);
-    return;
-  }
-  const previous = state.inTable;
-  state.inTable = true;
-  children(node).forEach((row, r) => {
-    if (r) state.ensureNewLine();
-    state.write("| ");
-    children(row).forEach((cell, c) => {
-      if (c) state.write(" | ");
-      const paragraph = cell.firstChild;
-      const start = state.out.length;
-      if (paragraph.childCount) state.renderInline(paragraph);
-      const text = state.out.slice(start);
-      state.out = state.out.slice(0, start) + text.replace(/\n/g, " ").replace(/\|/g, "\\|");
-    });
-    state.write(" |");
-    if (r === 0) {
-      const delimiter = children(row).map((cell) => DELIMITERS[cell.attrs.align] ?? "---");
-      state.ensureNewLine();
-      state.write(`| ${delimiter.join(" | ")} |`);
-    }
-  });
-  state.inTable = previous;
-  state.closeBlock(node);
-}
-var DEFAULT_TABLE_OPTIONS = {
-  resizable: true,
-  handleWidth: 5,
-  cellMinWidth: 25,
-  lastColumnResizable: true,
-  allowTableNodeSelection: true,
-  HTMLAttributes: { class: "pixerate-table" },
-  cellHTMLAttributes: {},
-  headerHTMLAttributes: {},
-  rowHTMLAttributes: {}
-};
-var Table = BaseTable.extend({
-  addStorage() {
-    return { markdown: { serialize: serializeTableMarkdown } };
-  },
-  addProseMirrorPlugins() {
-    return [...this.parent?.() ?? [], createTableNestingPlugin()];
-  }
-});
-var TableRow = BaseTableRow;
-var TableCell = BaseTableCell.extend({
-  addAttributes() {
-    return { ...this.parent?.(), ...cellAttributes() };
-  }
-});
-var TableHeader = BaseTableHeader.extend({
-  addAttributes() {
-    return { ...this.parent?.(), ...cellAttributes() };
-  }
-});
-function createTableExtensions(options = {}) {
-  const o = { ...DEFAULT_TABLE_OPTIONS, ...options };
-  return [
-    Table.configure({
-      resizable: o.resizable,
-      handleWidth: o.handleWidth,
-      cellMinWidth: o.cellMinWidth,
-      lastColumnResizable: o.lastColumnResizable,
-      allowTableNodeSelection: o.allowTableNodeSelection,
-      HTMLAttributes: o.HTMLAttributes
-    }),
-    TableRow.configure({ HTMLAttributes: o.rowHTMLAttributes }),
-    TableHeader.configure({ HTMLAttributes: o.headerHTMLAttributes }),
-    TableCell.configure({ HTMLAttributes: o.cellHTMLAttributes })
-  ];
-}
-
-// src/extensions/table/actions.ts
-import { CellSelection as CellSelection2, isInTable, selectedRect } from "@tiptap/pm/tables";
-var TABLE_ACTIONS = [
-  { action: "insertTable", label: "Insert Table", description: "Inserts a table (rows, cols, withHeaderRow) at the cursor.", keywords: ["table", "grid", "new"] },
-  { action: "addRowBefore", label: "Insert Row Above", description: "Adds a row above the current row.", keywords: ["row", "add", "above"] },
-  { action: "addRowAfter", label: "Insert Row Below", description: "Adds a row below the current row.", keywords: ["row", "add", "below"] },
-  { action: "deleteRow", label: "Delete Row", description: "Deletes the selected rows.", keywords: ["row", "remove"] },
-  { action: "addColumnBefore", label: "Insert Column Left", description: "Adds a column left of the current column.", keywords: ["column", "add", "left", "before"] },
-  { action: "addColumnAfter", label: "Insert Column Right", description: "Adds a column right of the current column.", keywords: ["column", "add", "right", "after"] },
-  { action: "deleteColumn", label: "Delete Column", description: "Deletes the selected columns.", keywords: ["column", "remove"] },
-  { action: "deleteTable", label: "Delete Table", description: "Deletes the table around the cursor.", keywords: ["table", "remove"] },
-  { action: "mergeCells", label: "Merge Cells", description: "Merges the selected cells into one.", keywords: ["combine", "join", "span"] },
-  { action: "splitCell", label: "Split Cell", description: "Splits a merged cell back into single cells.", keywords: ["unmerge", "span"] },
-  { action: "toggleHeaderRow", label: "Toggle Header Row", description: "Turns the first row into header cells, or back.", keywords: ["header", "row", "th"] },
-  { action: "toggleHeaderColumn", label: "Toggle Header Column", description: "Turns the first column into header cells, or back.", keywords: ["header", "column", "th"] },
-  { action: "toggleHeaderCell", label: "Toggle Header Cell", description: "Turns the selected cells into header cells, or back.", keywords: ["header", "cell", "th"] },
-  { action: "goToNextCell", label: "Next Cell", description: "Moves the cursor to the next cell.", keywords: ["tab", "navigate"] },
-  { action: "goToPreviousCell", label: "Previous Cell", description: "Moves the cursor to the previous cell.", keywords: ["shift tab", "navigate"] },
-  { action: "setCellAlignment", label: "Align Cells\u2026", description: "Sets the horizontal alignment (align: left | center | right | justify | null) of the selected cells.", keywords: ["align", "left", "center", "right"] },
-  { action: "setCellBackground", label: "Cell Background\u2026", description: "Sets the background color (color: CSS color or null) of the selected cells.", keywords: ["shading", "fill", "color"] }
-];
-var DEFAULT_TABLE_TOOLBAR = [
-  { id: "addRowBefore", action: "addRowBefore", label: "+ Row \u2191", title: "Insert row above", group: "rows" },
-  { id: "addRowAfter", action: "addRowAfter", label: "+ Row \u2193", title: "Insert row below", group: "rows" },
-  { id: "deleteRow", action: "deleteRow", label: "\u2212 Row", title: "Delete row", group: "rows" },
-  { id: "addColumnBefore", action: "addColumnBefore", label: "+ Col \u2190", title: "Insert column left", group: "columns" },
-  { id: "addColumnAfter", action: "addColumnAfter", label: "+ Col \u2192", title: "Insert column right", group: "columns" },
-  { id: "deleteColumn", action: "deleteColumn", label: "\u2212 Col", title: "Delete column", group: "columns" },
-  { id: "mergeCells", action: "mergeCells", label: "Merge", title: "Merge cells", group: "cells" },
-  { id: "splitCell", action: "splitCell", label: "Split", title: "Split cell", group: "cells" },
-  { id: "toggleHeaderRow", action: "toggleHeaderRow", label: "Header row", title: "Toggle header row", group: "headers", active: (s) => s.headerRow },
-  { id: "toggleHeaderColumn", action: "toggleHeaderColumn", label: "Header col", title: "Toggle header column", group: "headers", active: (s) => s.headerColumn },
-  { id: "toggleHeaderCell", action: "toggleHeaderCell", label: "Header cell", title: "Toggle header cell", group: "headers", active: (s) => s.headerCell },
-  { id: "alignLeft", action: "setCellAlignment", params: { align: "left" }, label: "Left", title: "Align cell left", group: "align", active: (s) => s.cellAlignment === "left" },
-  { id: "alignCenter", action: "setCellAlignment", params: { align: "center" }, label: "Center", title: "Align cell center", group: "align", active: (s) => s.cellAlignment === "center" },
-  { id: "alignRight", action: "setCellAlignment", params: { align: "right" }, label: "Right", title: "Align cell right", group: "align", active: (s) => s.cellAlignment === "right" },
-  { id: "deleteTable", action: "deleteTable", label: "Delete table", title: "Delete table", group: "table" }
-];
-var MAX_TABLE_ROWS = 100;
-var MAX_TABLE_COLUMNS = 50;
-var live = (editor) => !!editor && !editor.isDestroyed;
-function isTableEnabled(editor) {
-  return live(editor) && !!editor.schema.nodes.table && !!editor.schema.nodes.tableRow;
-}
-function isSelectionInTable(state) {
-  if (!state.schema.nodes.table) return false;
-  return state.selection instanceof CellSelection2 || isInTable(state);
-}
-function shouldShowTableBubbleMenu({ editor, state }) {
-  return editor.isEditable && isSelectionInTable(state);
-}
-var isInt = (value, min, max) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
-var can = (editor, run) => {
-  try {
-    return !!run(editor.can().chain()).run();
-  } catch {
-    return false;
-  }
-};
-function getTableActionState(editor, action, params = {}) {
-  if (!live(editor)) return "The editor is not available.";
-  if (!isTableEnabled(editor)) return "Tables are not enabled in this editor.";
-  if (!editor.isEditable) return "The editor is read-only.";
-  const state = editor.state;
-  const inTable = isSelectionInTable(state);
-  if (action === "insertTable") {
-    if (inTable) return "Tables cannot be nested: move the cursor out of the table first.";
-    if (params.rows !== void 0 && !isInt(params.rows, 1, MAX_TABLE_ROWS)) {
-      return `Rows must be a whole number from 1 to ${MAX_TABLE_ROWS}.`;
-    }
-    if (params.cols !== void 0 && !isInt(params.cols, 1, MAX_TABLE_COLUMNS)) {
-      return `Columns must be a whole number from 1 to ${MAX_TABLE_COLUMNS}.`;
-    }
-    return can(editor, (c) => c.insertTable({ rows: 1, cols: 1 })) ? true : "A table cannot be inserted here.";
-  }
-  if (!inTable) return "Place the cursor in a table first.";
-  switch (action) {
-    case "mergeCells":
-    case "splitCell": {
-      if (isTrackChangesEnabled(editor)) {
-        return `${action === "mergeCells" ? "Merging" : "Splitting"} cells cannot be tracked: turn off Track Changes first.`;
-      }
-      if (action === "mergeCells") {
-        return can(editor, (c) => c.mergeCells()) ? true : "Select two or more adjacent cells to merge.";
-      }
-      return can(editor, (c) => c.splitCell()) ? true : "Only a merged cell can be split.";
-    }
-    case "deleteRow":
-    case "deleteColumn": {
-      const rect = selectedRect(state);
-      const all = action === "deleteRow" ? rect.top === 0 && rect.bottom === rect.map.height : rect.left === 0 && rect.right === rect.map.width;
-      const what = action === "deleteRow" ? "rows" : "columns";
-      if (all || !can(editor, (c) => c[action]())) return `These are all the ${what}: delete the table instead.`;
-      return true;
-    }
-    case "goToNextCell":
-      return can(editor, (c) => c.goToNextCell()) ? true : "This is the last cell.";
-    case "goToPreviousCell":
-      return can(editor, (c) => c.goToPreviousCell()) ? true : "This is the first cell.";
-    case "setCellAlignment":
-      if (params.align !== void 0 && params.align !== null && !normalizeTableCellAlignment(params.align)) {
-        return 'Alignment must be "left", "center", "right", "justify" or null.';
-      }
-      if (!editor.schema.nodes.tableCell?.spec.attrs?.align) return "Cell alignment is not supported by this schema.";
-      return true;
-    case "setCellBackground":
-      if (params.color !== void 0 && params.color !== null && !normalizeTableCellColor(params.color)) {
-        return "Color must be a CSS color such as #fde68a, rgb(\u2026) or a color name, or null.";
-      }
-      if (!editor.schema.nodes.tableCell?.spec.attrs?.backgroundColor) return "Cell backgrounds are not supported by this schema.";
-      return true;
-    default:
-      return can(editor, (c) => c[action]()) ? true : "This table action is not available here.";
-  }
-}
-function runTableAction(editor, action, params = {}, options = {}) {
-  if (getTableActionState(editor, action, params) !== true) return false;
-  const ed = editor;
-  let chain = ed.chain();
-  if (options.focus) chain = chain.focus();
-  switch (action) {
-    case "insertTable":
-      chain = chain.insertTable({
-        rows: params.rows ?? 3,
-        cols: params.cols ?? 3,
-        withHeaderRow: params.withHeaderRow ?? true
-      });
-      break;
-    case "setCellAlignment":
-      chain = chain.setCellAttribute("align", normalizeTableCellAlignment(params.align));
-      break;
-    case "setCellBackground":
-      chain = chain.setCellAttribute("backgroundColor", normalizeTableCellColor(params.color));
-      break;
-    default:
-      chain = chain[action]();
-  }
-  return !!chain.run();
-}
-var NO_ACTIONS = Object.fromEntries(
-  TABLE_ACTIONS.map(({ action }) => [action, { enabled: false, reason: "The editor is not available." }])
-);
-var EMPTY_TABLE_STATE = Object.freeze({
-  enabled: false,
-  inTable: false,
-  cellSelection: false,
-  rows: 0,
-  columns: 0,
-  row: -1,
-  column: -1,
-  headerRow: false,
-  headerColumn: false,
-  headerCell: false,
-  cellAlignment: null,
-  cellBackground: null,
-  actions: NO_ACTIONS
-});
-function getTableState(editor) {
-  if (!live(editor)) return EMPTY_TABLE_STATE;
-  const actions = Object.fromEntries(
-    TABLE_ACTIONS.map(({ action }) => {
-      const result = getTableActionState(editor, action);
-      return [action, result === true ? { enabled: true } : { enabled: false, reason: result }];
-    })
-  );
-  const state = editor.state;
-  const base = { ...EMPTY_TABLE_STATE, enabled: isTableEnabled(editor), actions };
-  if (!base.enabled || !isSelectionInTable(state)) return base;
-  try {
-    const rect = selectedRect(state);
-    const { map, table } = rect;
-    const cellAt = (row, col) => table.nodeAt(map.map[row * map.width + col]);
-    const allHeaders = (positions) => positions.length > 0 && positions.every((pos) => table.nodeAt(pos)?.type.name === "tableHeader");
-    const firstRow = map.cellsInRect({ left: 0, right: map.width, top: 0, bottom: 1 });
-    const firstColumn = map.cellsInRect({ left: 0, right: 1, top: 0, bottom: map.height });
-    const cell = cellAt(rect.top, rect.left);
-    return {
-      ...base,
-      inTable: true,
-      cellSelection: state.selection instanceof CellSelection2,
-      rows: map.height,
-      columns: map.width,
-      row: rect.top,
-      column: rect.left,
-      headerRow: allHeaders(firstRow),
-      headerColumn: allHeaders(firstColumn),
-      headerCell: cell?.type.name === "tableHeader",
-      cellAlignment: normalizeTableCellAlignment(cell?.attrs.align),
-      cellBackground: normalizeTableCellColor(cell?.attrs.backgroundColor)
-    };
-  } catch {
-    return { ...base, inTable: true };
-  }
-}
-var stateKey = (state) => JSON.stringify(state);
-function createTableStore(editor) {
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = getTableState(editor);
-  let key = stateKey(snapshot);
-  const update = () => {
-    const next = getTableState(editor);
-    const nextKey = stateKey(next);
-    if (nextKey === key) return;
-    snapshot = next;
-    key = nextKey;
-    listeners.forEach((listener) => listener());
-  };
-  const detach = () => {
-    editor?.off("transaction", update);
-    editor?.off("update", update);
-    editor?.off("focus", update);
-    editor?.off("destroy", update);
-  };
-  return {
-    getSnapshot: () => {
-      if (!listeners.size) {
-        const next = getTableState(editor);
-        const nextKey = stateKey(next);
-        if (nextKey !== key) {
-          snapshot = next;
-          key = nextKey;
-        }
-      }
-      return snapshot;
-    },
-    subscribe(listener) {
-      if (!listeners.size && editor) {
-        update();
-        editor.on("transaction", update);
-        editor.on("update", update);
-        editor.on("focus", update);
-        editor.on("destroy", update);
-      }
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-        if (!listeners.size) detach();
-      };
-    },
-    destroy() {
-      detach();
-      listeners.clear();
-    }
-  };
-}
-
-export {
-  ALLOW_NESTED_TABLES_META,
-  tableNestingPluginKey,
-  outermostTableDepth,
-  isInTableCell,
-  sliceContainsTable,
-  insertSliceAfterTable,
-  handleTablePasteWithoutNesting,
-  unnestTables,
-  createTableNestingPlugin,
-  normalizeTableCellAlignment,
-  normalizeTableCellColor,
-  isGfmTable,
-  DEFAULT_TABLE_OPTIONS,
-  Table,
-  TableRow,
-  TableCell,
-  TableHeader,
-  createTableExtensions,
-  TABLE_ACTIONS,
-  DEFAULT_TABLE_TOOLBAR,
-  MAX_TABLE_ROWS,
-  MAX_TABLE_COLUMNS,
-  isTableEnabled,
-  isSelectionInTable,
-  shouldShowTableBubbleMenu,
-  getTableActionState,
-  runTableAction,
-  EMPTY_TABLE_STATE,
-  getTableState,
-  createTableStore
-};
-//# sourceMappingURL=chunk-5H2OPMXZ.js.map