@pixerate/editor 0.44.0 → 0.46.0

package/dist/chunk-TK2XZK6Z.js

@@ -0,0 +1,1465 @@
+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/find-replace/pattern.ts
+var FIND_PARAGRAPH_MARK = "\r";
+var MAX_FIND_PATTERN_LENGTH = 1024;
+var MAX_COUNT = 1e3;
+var MAX_PROGRAM_SIZE = 2e4;
+var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+function createSearchBudget(options = {}) {
+  return {
+    deadline: now() + (options.timeLimitMs ?? 250),
+    steps: options.maxSteps ?? 5e7,
+    exhausted: false
+  };
+}
+var PARA = 13;
+var ANY = (cp) => cp !== PARA;
+var LETTER = /\p{L}/u;
+var PUNCT = /\p{P}/u;
+var WORD = /[\p{L}\p{M}\p{Nd}\p{Pc}]/u;
+var foldCache = /* @__PURE__ */ new Map();
+function foldCodePoint(cp) {
+  if (cp < 128) return cp >= 65 && cp <= 90 ? cp + 32 : cp;
+  const cached = foldCache.get(cp);
+  if (cached !== void 0) return cached;
+  const lower = String.fromCodePoint(cp).toLowerCase();
+  const folded = [...lower].length === 1 ? lower.codePointAt(0) : cp;
+  if (foldCache.size < 4096) foldCache.set(cp, folded);
+  return folded;
+}
+function isWordChar(cp) {
+  if (cp < 0) return false;
+  if (cp < 128) {
+    return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 95;
+  }
+  return WORD.test(String.fromCodePoint(cp));
+}
+var isLetter = (cp) => cp < 128 ? cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 : LETTER.test(String.fromCodePoint(cp));
+function isPunct(cp) {
+  if (cp < 128) {
+    return cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126;
+  }
+  return cp >= 8208 && cp <= 8231 || cp === 161 || cp === 191 || cp === 171 || cp === 187 || PUNCT.test(String.fromCodePoint(cp));
+}
+var isSpace = (cp) => cp === 32 || cp === 9 || cp === 160;
+function cpBefore(hay, pos) {
+  if (pos <= 0) return -1;
+  const low = hay.charCodeAt(pos - 1);
+  if (low >= 56320 && low <= 57343 && pos >= 2) {
+    const high = hay.charCodeAt(pos - 2);
+    if (high >= 55296 && high <= 56319) return hay.codePointAt(pos - 2);
+  }
+  return low;
+}
+var cpAt = (hay, pos) => pos < hay.length ? hay.codePointAt(pos) : -1;
+var PatternError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var charNode = (test) => ({ k: "char", test });
+var exact = (cp) => charNode((c) => c === cp);
+var literalNode = (cp, caseInsensitive) => {
+  if (!caseInsensitive) return exact(cp);
+  const f = foldCodePoint(cp);
+  return charNode((_c, folded) => folded === f);
+};
+var star = (body, lazy) => ({ k: "rep", body, min: 0, max: -1, lazy });
+function findCode(c) {
+  switch (c) {
+    case "p":
+      return exact(PARA);
+    case "t":
+      return exact(9);
+    case "?":
+      return charNode(ANY);
+    case "#":
+      return charNode((cp) => cp >= 48 && cp <= 57);
+    case "$":
+      return charNode((cp) => isLetter(cp));
+    case "^":
+      return exact(94);
+    case "l":
+      return exact(10);
+    case "m":
+      return exact(12);
+    case "n":
+      return exact(14);
+    case "+":
+      return exact(8212);
+    case "=":
+      return exact(8211);
+    case "s":
+      return exact(160);
+    case "~":
+      return exact(8209);
+    case "-":
+      return exact(173);
+    case "w":
+      return { k: "rep", body: charNode((cp) => isSpace(cp)), min: 1, max: -1, lazy: false };
+    case "g":
+      return exact(65532);
+    case "%":
+      return exact(167);
+    case "v":
+      return exact(182);
+    default:
+      return null;
+  }
+}
+function replaceCode(c) {
+  switch (c) {
+    case "p":
+      return FIND_PARAGRAPH_MARK;
+    case "t":
+      return "	";
+    case "^":
+      return "^";
+    case "l":
+      return "\n";
+    case "m":
+      return "\f";
+    case "n":
+      return "";
+    case "+":
+      return "\u2014";
+    case "=":
+      return "\u2013";
+    case "s":
+      return "\xA0";
+    case "~":
+      return "\u2011";
+    case "-":
+      return "\xAD";
+    case "%":
+      return "\xA7";
+    case "v":
+      return "\xB6";
+    default:
+      return null;
+  }
+}
+function codeChar(n) {
+  switch (n) {
+    case 13:
+      return PARA;
+    case 11:
+      return 10;
+    case 12:
+      return 12;
+    case 14:
+      return 14;
+    case 30:
+      return 8209;
+    case 31:
+      return 173;
+  }
+  if (n > 1114111 || n >= 55296 && n <= 57343) return null;
+  if (n < 32 && n !== 9 || n >= 127 && n < 160) return null;
+  return n;
+}
+function numericCode(chars, i) {
+  const unicode = chars[i] === "u";
+  const start = unicode ? i + 1 : i;
+  const max = unicode ? 5 : 4;
+  let digits = "";
+  for (let j = start; j < chars.length && digits.length < max && /[0-9]/.test(chars[j]); j++) digits += chars[j];
+  if (!digits) return null;
+  const cp = codeChar(parseInt(digits, 10));
+  return cp === null ? null : { cp, used: start - i + digits.length };
+}
+var toChars = (s) => Array.from(s);
+var cpOf = (ch) => ch.codePointAt(0);
+function parseSpecial(query, o, caseInsensitive) {
+  const chars = toChars(query);
+  const atoms = [];
+  let spans = false;
+  let i = 0;
+  while (i < chars.length) {
+    const c = chars[i++];
+    if (c === "^" && !o.literal && i < chars.length) {
+      const n = chars[i];
+      const code = findCode(n);
+      if (code) {
+        if (n === "p") spans = true;
+        atoms.push(code);
+        i++;
+        continue;
+      }
+      const num = numericCode(chars, i);
+      if (num) {
+        if (num.cp === PARA) spans = true;
+        atoms.push(literalNode(num.cp, caseInsensitive));
+        i += num.used;
+        continue;
+      }
+    }
+    const cp = cpOf(c);
+    if (o.ignorePunctuation && isPunct(cp) || o.ignoreWhitespace && isSpace(cp)) continue;
+    atoms.push(literalNode(cp, caseInsensitive));
+  }
+  const filler = o.ignorePunctuation && o.ignoreWhitespace ? (cp) => isPunct(cp) || isSpace(cp) : o.ignorePunctuation ? (cp) => isPunct(cp) : o.ignoreWhitespace ? (cp) => isSpace(cp) : null;
+  const items = [];
+  atoms.forEach((atom, index) => {
+    if (index > 0 && filler) items.push(star(charNode(filler), false));
+    items.push(atom);
+  });
+  return { node: { k: "cat", items }, spans };
+}
+function parseCount(body) {
+  const bad = () => new PatternError("invalid_pattern", `{${body}} is not a valid count`);
+  const num = (s) => {
+    const t = s.trim();
+    if (!t) return null;
+    if (!/^[0-9]+$/.test(t)) throw bad();
+    const n = parseInt(t, 10);
+    if (n > MAX_COUNT) throw new PatternError("invalid_pattern", `counts go up to ${MAX_COUNT}`);
+    return n;
+  };
+  const sep = body.search(/[,;]/);
+  if (sep < 0) {
+    const n = num(body);
+    if (n === null) throw bad();
+    return { min: n, max: n };
+  }
+  const a = num(body.slice(0, sep)) ?? 0;
+  const b = num(body.slice(sep + 1));
+  if (b !== null && b < a) throw bad();
+  return { min: a, max: b ?? -1 };
+}
+function parseClass(inner) {
+  let negated = false;
+  if (inner[0] === "!") {
+    negated = true;
+    inner = inner.slice(1);
+  }
+  if (inner.length === 0) throw new PatternError("invalid_pattern", "[ ] needs at least one character");
+  const singles = /* @__PURE__ */ new Set();
+  const ranges = [];
+  let i = 0;
+  while (i < inner.length) {
+    let c = inner[i];
+    if (c === "\\" && i + 1 < inner.length) c = inner[++i];
+    i++;
+    if (inner[i] === "-" && i + 1 < inner.length) {
+      const hi = inner[i + 1];
+      if (cpOf(hi) < cpOf(c)) throw new PatternError("invalid_pattern", `[${c}-${hi}] is not in ascending order`);
+      ranges.push([cpOf(c), cpOf(hi)]);
+      i += 2;
+    } else {
+      singles.add(cpOf(c));
+    }
+  }
+  const inSet = (cp) => singles.has(cp) || ranges.some(([lo, hi]) => cp >= lo && cp <= hi);
+  return negated ? (cp) => cp !== PARA && !inSet(cp) : (cp) => inSet(cp);
+}
+function parseWildcards(query) {
+  const chars = toChars(query);
+  const stack = [{ items: [], group: 0 }];
+  let groups = 0;
+  let spans = false;
+  const top = () => stack[stack.length - 1].items;
+  const quantify = (min, max, what) => {
+    const items = top();
+    const last = items[items.length - 1];
+    if (!last || last.k === "assert" || last.k === "rep") {
+      throw new PatternError("invalid_pattern", `${what} needs something to repeat before it`);
+    }
+    items[items.length - 1] = { k: "rep", body: last, min, max, lazy: false };
+  };
+  let i = 0;
+  while (i < chars.length) {
+    const c = chars[i++];
+    switch (c) {
+      case "?":
+        top().push(charNode(ANY));
+        break;
+      case "*":
+        top().push(star(charNode(ANY), true));
+        break;
+      case "@":
+        quantify(1, -1, "@");
+        break;
+      case "<":
+        top().push({ k: "assert", kind: "wordStart" });
+        break;
+      case ">":
+        top().push({ k: "assert", kind: "wordEnd" });
+        break;
+      case "(":
+        stack.push({ items: [], group: ++groups });
+        break;
+      case ")": {
+        if (stack.length === 1) throw new PatternError("invalid_pattern", "a ) has no opening (");
+        const frame = stack.pop();
+        top().push({ k: "group", index: frame.group, body: { k: "cat", items: frame.items } });
+        break;
+      }
+      case "{": {
+        const end = chars.indexOf("}", i);
+        if (end < 0) throw new PatternError("invalid_pattern", "a { needs a closing }");
+        const { min, max } = parseCount(chars.slice(i, end).join(""));
+        quantify(min, max, `{${chars.slice(i, end).join("")}}`);
+        i = end + 1;
+        break;
+      }
+      case "[": {
+        const end = chars.indexOf("]", i);
+        if (end < 0) throw new PatternError("invalid_pattern", "a [ needs a closing ]");
+        top().push(charNode(parseClass(chars.slice(i, end))));
+        i = end + 1;
+        break;
+      }
+      case "\\": {
+        if (i >= chars.length) {
+          top().push(exact(92));
+        } else if (/[0-9]/.test(chars[i])) {
+          throw new PatternError("invalid_pattern", "back-references (\\1) work in Replace with, not in Find what");
+        } else {
+          top().push(exact(cpOf(chars[i++])));
+        }
+        break;
+      }
+      case "^": {
+        if (i >= chars.length) {
+          top().push(exact(94));
+          break;
+        }
+        const n = chars[i];
+        const code = findCode(n);
+        if (code) {
+          if (n === "p") spans = true;
+          top().push(code);
+          i++;
+          break;
+        }
+        const num = numericCode(chars, i);
+        if (num) {
+          if (num.cp === PARA) spans = true;
+          top().push(exact(num.cp));
+          i += num.used;
+        } else {
+          top().push(exact(94));
+        }
+        break;
+      }
+      default:
+        top().push(exact(cpOf(c)));
+    }
+  }
+  if (stack.length > 1) throw new PatternError("invalid_pattern", "a ( needs a closing )");
+  return { node: { k: "cat", items: stack[0].items }, spans, groups };
+}
+function compileProgram(node) {
+  const prog = [];
+  const push = (inst) => {
+    if (prog.length >= MAX_PROGRAM_SIZE) {
+      throw new PatternError("too_complex", "the pattern is too complex (too many repeats)");
+    }
+    prog.push(inst);
+    return prog.length - 1;
+  };
+  const emit = (n) => {
+    switch (n.k) {
+      case "char":
+        push({ op: 0 /* Char */, test: n.test });
+        return;
+      case "cat":
+        n.items.forEach(emit);
+        return;
+      case "group":
+        push({ op: 3 /* Save */, n: 2 * n.index });
+        emit(n.body);
+        push({ op: 3 /* Save */, n: 2 * n.index + 1 });
+        return;
+      case "assert":
+        push({ op: 4 /* Assert */, kind: n.kind });
+        return;
+      case "rep": {
+        for (let k = 0; k < n.min; k++) emit(n.body);
+        if (n.max < 0) {
+          const split = push({ op: 1 /* Split */, x: 0, y: 0 });
+          emit(n.body);
+          push({ op: 2 /* Jmp */, x: split });
+          const exit2 = prog.length;
+          const inst = prog[split];
+          inst.x = n.lazy ? exit2 : split + 1;
+          inst.y = n.lazy ? split + 1 : exit2;
+          return;
+        }
+        const splits = [];
+        for (let k = n.min; k < n.max; k++) {
+          splits.push(push({ op: 1 /* Split */, x: 0, y: 0 }));
+          emit(n.body);
+        }
+        const exit = prog.length;
+        for (const s of splits) {
+          const inst = prog[s];
+          inst.x = n.lazy ? exit : s + 1;
+          inst.y = n.lazy ? s + 1 : exit;
+        }
+        return;
+      }
+    }
+  };
+  push({ op: 3 /* Save */, n: 0 });
+  emit(node);
+  push({ op: 3 /* Save */, n: 1 });
+  push({ op: 5 /* Match */ });
+  return prog;
+}
+function checkAssert(kind, hay, pos) {
+  const before = isWordChar(cpBefore(hay, pos));
+  const after = isWordChar(cpAt(hay, pos));
+  switch (kind) {
+    case "boundary":
+      return before !== after;
+    case "wordStart":
+      return !before && after;
+    case "wordEnd":
+      return before && !after;
+  }
+}
+function pikeExec(prog, groupCount, caseInsensitive, hay, start, end, budget) {
+  const ncap = 2 * (groupCount + 1);
+  const mark = new Int32Array(prog.length);
+  let gen = 1;
+  let clistPc = [];
+  let clistCaps = [];
+  let nlistPc = [];
+  let nlistCaps = [];
+  const stackPc = [];
+  const stackCaps = [];
+  let matched = null;
+  const initial = new Int32Array(ncap).fill(-1);
+  const add = (listPc, listCaps, pc0, caps0, pos) => {
+    stackPc.push(pc0);
+    stackCaps.push(caps0);
+    while (stackPc.length) {
+      const pc = stackPc.pop();
+      const caps = stackCaps.pop();
+      if (mark[pc] === gen) continue;
+      mark[pc] = gen;
+      const inst = prog[pc];
+      switch (inst.op) {
+        case 2 /* Jmp */:
+          stackPc.push(inst.x);
+          stackCaps.push(caps);
+          break;
+        case 1 /* Split */:
+          stackPc.push(inst.y, inst.x);
+          stackCaps.push(caps, caps);
+          break;
+        case 3 /* Save */: {
+          const next = caps.slice();
+          next[inst.n] = pos;
+          stackPc.push(pc + 1);
+          stackCaps.push(next);
+          break;
+        }
+        case 4 /* Assert */:
+          if (checkAssert(inst.kind, hay, pos)) {
+            stackPc.push(pc + 1);
+            stackCaps.push(caps);
+          }
+          break;
+        default:
+          listPc.push(pc);
+          listCaps.push(caps);
+      }
+    }
+  };
+  let i = start;
+  if (budget.steps <= 0 || now() > budget.deadline) {
+    budget.exhausted = true;
+    return "budget";
+  }
+  let steps = 0;
+  for (; ; ) {
+    if (!matched) add(clistPc, clistCaps, 0, initial, i);
+    const cp = i < end ? hay.codePointAt(i) : -1;
+    const width = cp > 65535 ? 2 : 1;
+    if (clistPc.length === 0) {
+      if (matched || i >= end) break;
+      gen++;
+      i += width;
+      continue;
+    }
+    const folded = cp >= 0 && caseInsensitive ? foldCodePoint(cp) : cp;
+    gen++;
+    nlistPc = [];
+    nlistCaps = [];
+    for (let t = 0; t < clistPc.length; t++) {
+      if (++steps >= 4096) {
+        budget.steps -= steps;
+        steps = 0;
+        if (budget.steps <= 0 || now() > budget.deadline) {
+          budget.exhausted = true;
+          return "budget";
+        }
+      }
+      const inst = prog[clistPc[t]];
+      if (inst.op === 0 /* Char */) {
+        if (cp >= 0 && inst.test(cp, folded)) add(nlistPc, nlistCaps, clistPc[t] + 1, clistCaps[t], i + width);
+      } else if (inst.op === 5 /* Match */) {
+        matched = clistCaps[t];
+        break;
+      }
+    }
+    clistPc = nlistPc;
+    clistCaps = nlistCaps;
+    if (i >= end) break;
+    i += width;
+  }
+  budget.steps -= steps;
+  if (!matched) return null;
+  const groups = [];
+  for (let g = 0; g <= groupCount; g++) {
+    const a = matched[2 * g];
+    const b = matched[2 * g + 1];
+    groups.push(a >= 0 && b >= 0 ? hay.slice(a, b) : void 0);
+  }
+  return { start: matched[0], end: matched[1], groups };
+}
+var WORD_CLASS = "[\\p{L}\\p{M}\\p{Nd}\\p{Pc}]";
+var REGEX_BOUNDARY = `(?:(?<=${WORD_CLASS})(?!${WORD_CLASS})|(?<!${WORD_CLASS})(?=${WORD_CLASS}))`;
+function hasNestedRepeat(source) {
+  const quantifierAt = (i) => {
+    const c = source[i];
+    if (c === "*" || c === "+") return { repeats: true, many: true };
+    if (c === "{") {
+      const m = /^\{(\d*)(,?)(\d*)\}/.exec(source.slice(i));
+      if (m) {
+        const max = m[2] ? m[3] ? Number(m[3]) : Infinity : Number(m[1]);
+        return { repeats: max > 1, many: max > 1 };
+      }
+    }
+    return { repeats: false, many: false };
+  };
+  const stack = [];
+  let inClass = false;
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") {
+      inClass = true;
+    } else if (c === "(") {
+      stack.push(false);
+    } else if (c === ")") {
+      const inner = stack.pop() ?? false;
+      const q = quantifierAt(i + 1);
+      if (inner && q.many) return true;
+      if (stack.length && (inner || q.repeats)) stack[stack.length - 1] = true;
+    } else if (stack.length && quantifierAt(i).repeats) {
+      stack[stack.length - 1] = true;
+    }
+  }
+  return false;
+}
+function compileRegex(query, o) {
+  if (hasNestedRepeat(query)) {
+    throw new PatternError(
+      "too_complex",
+      "a repeated group containing a repeat, like (a+)+, can take exponential time; rewrite it without nesting"
+    );
+  }
+  let source = query;
+  if (o.wholeWord || o.matchPrefix && o.matchSuffix) source = `${REGEX_BOUNDARY}(?:${query})${REGEX_BOUNDARY}`;
+  else if (o.matchPrefix) source = `${REGEX_BOUNDARY}(?:${query})`;
+  else if (o.matchSuffix) source = `(?:${query})${REGEX_BOUNDARY}`;
+  let re;
+  try {
+    re = new RegExp(source, o.matchCase ? "gu" : "giu");
+  } catch (error) {
+    throw new PatternError("invalid_pattern", `bad pattern: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let slicedFor = null;
+  return {
+    mode: "regex",
+    spansParagraphs: false,
+    caseInsensitive: !o.matchCase,
+    groupCount: 0,
+    exec(hay, start, end, budget) {
+      if (now() > budget.deadline) {
+        budget.exhausted = true;
+        return "budget";
+      }
+      let text = hay;
+      if (end < hay.length) {
+        if (!slicedFor || slicedFor.hay !== hay || slicedFor.end !== end) {
+          slicedFor = { hay, end, text: hay.slice(0, end) };
+        }
+        text = slicedFor.text;
+      }
+      re.lastIndex = start;
+      const m = re.exec(text);
+      if (!m) return null;
+      return { start: m.index, end: m.index + m[0].length, groups: Array.from(m) };
+    }
+  };
+}
+function compileFindPattern(query, options = {}) {
+  try {
+    if (Array.from(query).length > MAX_FIND_PATTERN_LENGTH) {
+      throw new PatternError("too_long", `the Find what text is longer than ${MAX_FIND_PATTERN_LENGTH} characters`);
+    }
+    if (options.regex) return { ok: true, pattern: compileRegex(query, options) };
+    const wildcards = !!options.wildcards && !options.literal;
+    const caseInsensitive = !options.matchCase && !wildcards;
+    let node;
+    let spans;
+    let groups = 0;
+    if (wildcards) {
+      ({ node, spans, groups } = parseWildcards(query));
+    } else {
+      ({ node, spans } = parseSpecial(query, options, caseInsensitive));
+      const before = options.wholeWord || options.matchPrefix;
+      const after = options.wholeWord || options.matchSuffix;
+      if (before || after) {
+        const items = [];
+        if (before) items.push({ k: "assert", kind: "boundary" });
+        items.push(node);
+        if (after) items.push({ k: "assert", kind: "boundary" });
+        node = { k: "cat", items };
+      }
+    }
+    const prog = compileProgram(node);
+    return {
+      ok: true,
+      pattern: {
+        mode: wildcards ? "wildcards" : "special",
+        spansParagraphs: spans,
+        caseInsensitive,
+        groupCount: groups,
+        exec: (hay, start, end, budget) => pikeExec(prog, groups, caseInsensitive, hay, start, end, budget)
+      }
+    };
+  } catch (error) {
+    if (error instanceof PatternError) return { ok: false, error: { code: error.code, message: error.message } };
+    return { ok: false, error: { code: "invalid_pattern", message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function findAllMatches(pattern, hay, options = {}) {
+  const budget = options.budget ?? createSearchBudget();
+  const maxMatches = options.maxMatches ?? 1e4;
+  const cuts = [...options.cuts ?? [], hay.length].sort((a, b) => a - b);
+  const matches = [];
+  let from = 0;
+  for (const cut of cuts) {
+    if (cut <= from) continue;
+    let pos = from;
+    from = cut;
+    for (; ; ) {
+      const m = pattern.exec(hay, pos, cut, budget);
+      if (m === "budget") return { matches, truncated: true };
+      if (!m) break;
+      const empty = m.end === m.start;
+      const next = empty ? m.end + (cpAt(hay, m.end) > 65535 ? 2 : 1) : m.end;
+      if (next > cut) break;
+      pos = next;
+      if (empty) continue;
+      matches.push(m);
+      if (matches.length >= maxMatches) return { matches, truncated: true };
+    }
+  }
+  return { matches, truncated: false };
+}
+function parseReplacement(replacement, options = {}) {
+  if (options.literal || options.regex) return replacement ? [{ type: "text", text: replacement }] : [];
+  const chars = toChars(replacement);
+  const out = [];
+  let cur = "";
+  const flush = () => {
+    if (cur) out.push({ type: "text", text: cur });
+    cur = "";
+  };
+  let i = 0;
+  while (i < chars.length) {
+    const c = chars[i++];
+    if (c === "\\" && options.wildcards && i < chars.length) {
+      const d = chars[i];
+      if (/[1-9]/.test(d)) {
+        flush();
+        out.push({ type: "group", index: Number(d) });
+      } else {
+        cur += d;
+      }
+      i++;
+      continue;
+    }
+    if (c === "^" && i < chars.length) {
+      const n = chars[i];
+      if (n === "&" || n === "c") {
+        flush();
+        out.push(n === "&" ? { type: "found" } : { type: "clipboard" });
+        i++;
+        continue;
+      }
+      const code = replaceCode(n);
+      if (code !== null) {
+        cur += code;
+        i++;
+        continue;
+      }
+      const num = numericCode(chars, i);
+      if (num) {
+        cur += String.fromCodePoint(num.cp);
+        i += num.used;
+        continue;
+      }
+    }
+    cur += c;
+  }
+  flush();
+  return out;
+}
+function expandReplacement(pieces, match, clipboardText = "") {
+  let out = "";
+  for (const piece of pieces) {
+    switch (piece.type) {
+      case "text":
+        out += piece.text;
+        break;
+      case "found":
+        out += match.groups[0] ?? "";
+        break;
+      case "group":
+        out += match.groups[piece.index] ?? "";
+        break;
+      case "clipboard":
+        out += clipboardText.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
+        break;
+    }
+  }
+  return out;
+}
+
+// src/extensions/find-replace/search.ts
+var DELETION_MARK = "deletion";
+var DROPPED_REPLACEMENT_MARKS = /* @__PURE__ */ new Set([DELETION_MARK, "formatChange"]);
+var OBJECT_CHAR = "\uFFFC";
+function searchDocument(doc, query, options = {}, searchOptions = {}) {
+  if (!query) return { matches: [], truncated: false, error: null };
+  const compiled = compileFindPattern(query, options);
+  if (!compiled.ok) return { matches: [], truncated: false, error: compiled.error };
+  const pattern = compiled.pattern;
+  const pieces = parseReplacement(searchOptions.replacement ?? "", options);
+  const budget = createSearchBudget({ timeLimitMs: searchOptions.timeLimitMs });
+  const maxMatches = searchOptions.maxMatches ?? 1e4;
+  const blocks = [];
+  doc.descendants((node, pos, parent, index) => {
+    if (!node.isTextblock) return true;
+    blocks.push({ node, pos, parent, index });
+    return false;
+  });
+  const chunks = [];
+  blocks.forEach((block, i) => {
+    const prev = blocks[i - 1];
+    const joins = pattern.spansParagraphs && prev && prev.parent === block.parent && prev.index + 1 === block.index;
+    if (joins) chunks[chunks.length - 1].push(block);
+    else chunks.push([block]);
+  });
+  const matches = [];
+  let truncated = false;
+  for (const chunk of chunks) {
+    let hay = "";
+    const posOf = [];
+    const endOf = [];
+    const cuts = [];
+    chunk.forEach((block, k) => {
+      const contentStart = block.pos + 1;
+      block.node.forEach((child, offset) => {
+        const at = contentStart + offset;
+        if (child.marks.some((m) => m.type.name === DELETION_MARK)) {
+          if (cuts[cuts.length - 1] !== hay.length) cuts.push(hay.length);
+          return;
+        }
+        if (child.isText) {
+          const text = child.text ?? "";
+          for (let j = 0; j < text.length; j++) {
+            posOf.push(at + j);
+            endOf.push(at + j + 1);
+          }
+          hay += text;
+        } else {
+          posOf.push(at);
+          endOf.push(at + child.nodeSize);
+          hay += child.type.name === "hardBreak" ? "\n" : OBJECT_CHAR;
+        }
+      });
+      const next = chunk[k + 1];
+      if (next) {
+        posOf.push(contentStart + block.node.content.size);
+        endOf.push(next.pos + 1);
+        hay += FIND_PARAGRAPH_MARK;
+      }
+    });
+    if (!hay) continue;
+    const result = findAllMatches(pattern, hay, {
+      cuts,
+      budget,
+      maxMatches: maxMatches - matches.length
+    });
+    for (const m of result.matches) {
+      matches.push({
+        from: posOf[m.start],
+        to: endOf[m.end - 1],
+        text: m.groups[0] ?? hay.slice(m.start, m.end),
+        replacement: expandReplacement(pieces, m, searchOptions.clipboardText ?? "")
+      });
+    }
+    if (result.truncated) {
+      truncated = true;
+      break;
+    }
+  }
+  return { matches, truncated, error: null };
+}
+function replacementMarks(doc, from, to) {
+  const $from = doc.resolve(from);
+  const node = from < to ? $from.nodeAfter : null;
+  const marks = node ? node.marks : $from.marks();
+  return marks.filter((m) => !DROPPED_REPLACEMENT_MARKS.has(m.type.name));
+}
+function inlineContent(schema, text, marks) {
+  const nodes = [];
+  const hardBreak = schema.nodes.hardBreak;
+  const parts = hardBreak ? text.split("\n") : [text];
+  parts.forEach((part, i) => {
+    if (i > 0) nodes.push(hardBreak.create(null, null, marks));
+    if (part) nodes.push(schema.text(part, marks));
+  });
+  return nodes;
+}
+function applyReplacements(tr, matches) {
+  const ends = new Array(matches.length);
+  const schema = tr.doc.type.schema;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const { from, to, replacement } = matches[i];
+    const marks = replacementMarks(tr.doc, from, to);
+    const parts = replacement.split(/[\r\u2029]/);
+    const stepsBefore = tr.steps.length;
+    const first = inlineContent(schema, parts[0], marks);
+    if (first.length) tr.replaceWith(from, to, first);
+    else if (to > from) tr.delete(from, to);
+    let pos = tr.mapping.slice(stepsBefore).map(to, 1);
+    for (let k = 1; k < parts.length; k++) {
+      tr.split(pos);
+      pos += 2;
+      const content = inlineContent(schema, parts[k], marks);
+      if (content.length) {
+        tr.insert(pos, content);
+        pos += content.reduce((size, node) => size + node.nodeSize, 0);
+      }
+    }
+    const map = tr.mapping.slice(stepsBefore);
+    for (let j = i + 1; j < matches.length; j++) ends[j] = map.map(ends[j], 1);
+    ends[i] = pos;
+  }
+  return ends;
+}
+
+// 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,
+  FIND_PARAGRAPH_MARK,
+  MAX_FIND_PATTERN_LENGTH,
+  createSearchBudget,
+  foldCodePoint,
+  compileFindPattern,
+  findAllMatches,
+  parseReplacement,
+  expandReplacement,
+  searchDocument,
+  applyReplacements,
+  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-TK2XZK6Z.js.map