quoin-editor 0.4.1 → 1.0.0

package/dist/chunk-AEJXZBVR.cjs

@@ -0,0 +1,1378 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2VDK27IFcjs = require('./chunk-2VDK27IF.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkGTTPVJSDcjs = require('./chunk-GTTPVJSD.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPZ4GT5JOcjs = require('./chunk-PZ4GT5JO.cjs');
+
+
+
+
+
+
+
+
+var _chunkND5XJVK2cjs = require('./chunk-ND5XJVK2.cjs');
+
+// src/engine/commands/table-shape.ts
+var CELL = /^cell:(\d+):(\d+)$/;
+var tableShape = (block) => ({
+  rows: _chunkND5XJVK2cjs.countOf.call(void 0, block.attrs.rows),
+  cols: _chunkND5XJVK2cjs.countOf.call(void 0, block.attrs.cols)
+});
+var ALIGNS = ["left", "center", "right"];
+var columnAligns = (block, cols) => Array.from({ length: cols }, (_, col) => {
+  const align = Array.isArray(block.attrs.align) ? block.attrs.align[col] : null;
+  return ALIGNS.includes(align) ? align : null;
+});
+var validWidths = (value, cols) => Array.isArray(value) && value.length === cols && value.every((width) => typeof width === "number" && width > 0) ? value : null;
+var storedWidths = (block, cols) => validWidths(block.attrs.widths, cols);
+function cellOf(region) {
+  const match = CELL.exec(region);
+  return match === null ? null : [Number(match[1]), Number(match[2])];
+}
+function tableBlock(doc, id) {
+  const block = _chunkND5XJVK2cjs.blockById.call(void 0, doc, id);
+  return _optionalChain([block, 'optionalAccess', _2 => _2.type]) === "TABLE" ? block : null;
+}
+var isIndex = (index, length) => Number.isInteger(index) && index >= 0 && index < length;
+function movedOrder(length, from, to) {
+  const order = Array.from({ length }, (_, i) => i).filter((i) => i !== from);
+  order.splice(to, 0, from);
+  return order;
+}
+function rebuiltTable(block, plan) {
+  const regions = {};
+  for (let row = 0; row < plan.rows; row++) {
+    for (let col = 0; col < plan.cols; col++) {
+      const from = plan.source(row, col);
+      regions[_chunkND5XJVK2cjs.cellKey.call(void 0, row, col)] = from === null ? [] : _nullishCoalesce(block.regions[_chunkND5XJVK2cjs.cellKey.call(void 0, ...from)], () => ( []));
+    }
+  }
+  return { ...block, attrs: { ...block.attrs, ...plan.attrs, rows: plan.rows, cols: plan.cols }, regions };
+}
+function followedPos(pos, blockId, plan) {
+  const cell = pos.block === blockId ? cellOf(pos.region) : null;
+  if (cell === null) return pos;
+  const moved = plan.target(cell);
+  return moved === null ? { block: blockId, region: _chunkND5XJVK2cjs.cellKey.call(void 0, ...plan.landing(cell)), offset: 0 } : { ...pos, region: _chunkND5XJVK2cjs.cellKey.call(void 0, ...moved) };
+}
+function followedSelection(selection, blockId, plan) {
+  if (_optionalChain([selection, 'optionalAccess', _3 => _3.kind]) !== "text") return selection;
+  const anchor = followedPos(selection.anchor, blockId, plan);
+  const head = followedPos(selection.head, blockId, plan);
+  return anchor === selection.anchor && head === selection.head ? selection : _chunkPZ4GT5JOcjs.textSelection.call(void 0, anchor, head);
+}
+
+// src/engine/state/cell-selection.ts
+var cellSelectionKey = _chunkPZ4GT5JOcjs.createPluginKey.call(void 0, "cellSelection");
+function rangeOfSelection({ doc, selection }) {
+  if (_optionalChain([selection, 'optionalAccess', _4 => _4.kind]) !== "text") return null;
+  const { anchor, head } = selection;
+  if (anchor.block !== head.block || anchor.region === head.region || tableBlock(doc, anchor.block) === null) return null;
+  const from = cellOf(anchor.region);
+  const to = cellOf(head.region);
+  return from && to ? { block: anchor.block, anchor: from, head: to } : null;
+}
+var sameCell = (a, b) => a[0] === b[0] && a[1] === b[1];
+var sameRange = (a, b) => a === b || a !== null && b !== null && a.block === b.block && sameCell(a.anchor, b.anchor) && sameCell(a.head, b.head);
+var cellSelectionPlugin = {
+  key: cellSelectionKey,
+  init: rangeOfSelection,
+  apply(_tr, value, _old, next) {
+    const range = rangeOfSelection(next);
+    return sameRange(range, value) ? value : range;
+  }
+};
+function cellSelection(state) {
+  const held = state.pluginState.get(cellSelectionKey.name);
+  return held === void 0 ? rangeOfSelection(state) : held;
+}
+var between = (value, a, b) => value >= Math.min(a, b) && value <= Math.max(a, b);
+var rangeHasCell = ({ anchor, head }, [row, col]) => between(row, anchor[0], head[0]) && between(col, anchor[1], head[1]);
+function cellsInRange({ anchor, head }) {
+  const cells = [];
+  for (let row = Math.min(anchor[0], head[0]); row <= Math.max(anchor[0], head[0]); row++) {
+    for (let col = Math.min(anchor[1], head[1]); col <= Math.max(anchor[1], head[1]); col++) cells.push([row, col]);
+  }
+  return cells;
+}
+function selectCells(blockId, anchor, head) {
+  return (state, dispatch) => {
+    const block = tableBlock(state.doc, blockId);
+    const { rows, cols } = block === null ? { rows: 0, cols: 0 } : tableShape(block);
+    const inside = ([row, col]) => isIndex(row, rows) && isIndex(col, cols);
+    if (block === null || !inside(anchor) || !inside(head)) return false;
+    const end2 = _chunkND5XJVK2cjs.cellKey.call(void 0, ...head);
+    const selection = _chunkPZ4GT5JOcjs.textSelection.call(void 0, 
+      { block: blockId, region: _chunkND5XJVK2cjs.cellKey.call(void 0, ...anchor), offset: 0 },
+      { block: blockId, region: end2, offset: _chunkND5XJVK2cjs.inlineLength.call(void 0, _nullishCoalesce(block.regions[end2], () => ( []))) }
+    );
+    _optionalChain([dispatch, 'optionalCall', _5 => _5(new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setSelection(selection))]);
+    return true;
+  };
+}
+
+// src/engine/commands/cell-commands.ts
+function filledCells(doc, range) {
+  const regions = _nullishCoalesce(_optionalChain([_chunkND5XJVK2cjs.blockById.call(void 0, doc, range.block), 'optionalAccess', _6 => _6.regions]), () => ( {}));
+  return cellsInRange(range).flatMap((cell) => {
+    const region = _chunkND5XJVK2cjs.cellKey.call(void 0, ...cell);
+    const length = _chunkND5XJVK2cjs.inlineLength.call(void 0, _nullishCoalesce(regions[region], () => ( [])));
+    return length > 0 ? [{ region, length }] : [];
+  });
+}
+function firstCell({ block, anchor, head }) {
+  return { block, region: _chunkND5XJVK2cjs.cellKey.call(void 0, Math.min(anchor[0], head[0]), Math.min(anchor[1], head[1])), offset: 0 };
+}
+function emptied(state, range) {
+  const tr = new (0, _chunkPZ4GT5JOcjs.Transaction)(state);
+  for (const { region, length } of filledCells(state.doc, range)) {
+    tr.step(_chunkPZ4GT5JOcjs.replaceInlineStep.call(void 0, range.block, region, 0, length, []));
+  }
+  return tr;
+}
+var deleteCellContents = (state, dispatch) => {
+  const range = cellSelection(state);
+  if (range === null) return false;
+  _optionalChain([dispatch, 'optionalCall', _7 => _7(emptied(state, range).setSelection(_chunkPZ4GT5JOcjs.textSelection.call(void 0, firstCell(range))))]);
+  return true;
+};
+function typeOverCells(text) {
+  return (state, dispatch) => {
+    const range = cellSelection(state);
+    if (range === null || text === "") return false;
+    const tr = emptied(state, range);
+    _optionalChain([dispatch, 'optionalCall', _8 => _8(tr.setSelection(_chunkPZ4GT5JOcjs.textSelection.call(void 0, _chunkPZ4GT5JOcjs.insertTextAt.call(void 0, tr, state.schema, firstCell(range), text))))]);
+    return true;
+  };
+}
+function setCellsMark(type, attrs) {
+  return (state, dispatch) => {
+    const range = cellSelection(state);
+    const cells = range === null ? [] : filledCells(state.doc, range);
+    const regions = range === null ? void 0 : _optionalChain([_chunkND5XJVK2cjs.blockById.call(void 0, state.doc, range.block), 'optionalAccess', _9 => _9.regions]);
+    if (range === null || regions === void 0 || cells.length === 0) return false;
+    const carried = cells.every(({ region }) => _chunkPZ4GT5JOcjs.markCoverage.call(void 0, regions[region], type, attrs).every);
+    const mark = carried ? _chunkPZ4GT5JOcjs.toggleMark.call(void 0, type, attrs) : _chunkPZ4GT5JOcjs.setMark.call(void 0, type, attrs);
+    const tr = new (0, _chunkPZ4GT5JOcjs.Transaction)(state);
+    for (const { region, length } of cells) {
+      const start = { block: range.block, region, offset: 0 };
+      const whole = _chunkPZ4GT5JOcjs.textSelection.call(void 0, start, { ...start, offset: length });
+      mark({ ...state, doc: tr.doc, selection: whole, storedMarks: null }, (cell) => {
+        for (const step of cell.steps) tr.step(step);
+      });
+    }
+    if (!tr.docChanged) return false;
+    _optionalChain([dispatch, 'optionalCall', _10 => _10(tr)]);
+    return true;
+  };
+}
+
+// src/extensions/table/TableBlock.tsx
+var _react = require('react');
+
+// src/extensions/table/controls-slot.ts
+var CONTROLS_SLOT = "data-quoin-table-controls";
+var controlsSlot = (controller, blockId) => _nullishCoalesce(_optionalChain([controller, 'access', _11 => _11.blockElement, 'call', _12 => _12(blockId), 'optionalAccess', _13 => _13.querySelector, 'call', _14 => _14(`[${CONTROLS_SLOT}]`)]), () => ( null));
+
+// src/extensions/table/TableCell.tsx
+
+var _jsxruntime = require('react/jsx-runtime');
+var TableCell = _react.memo.call(void 0, function TableCell2({ controller, blockId, row, col, header, align, label }) {
+  const inRange = _chunkGTTPVJSDcjs.useEditorState.call(void 0, 
+    controller,
+    _react.useCallback.call(void 0, 
+      (state) => {
+        const range = cellSelection(state);
+        return _optionalChain([range, 'optionalAccess', _15 => _15.block]) === blockId && rangeHasCell(range, [row, col]);
+      },
+      [blockId, row, col]
+    )
+  );
+  const Cell = header ? "th" : "td";
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    Cell,
+    {
+      scope: header ? "col" : void 0,
+      "data-row": row,
+      "data-col": col,
+      "data-in-range": inRange ? "" : void 0,
+      style: align === null ? void 0 : { textAlign: align },
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkGTTPVJSDcjs.EditableRegion, { block: blockId, region: _chunkND5XJVK2cjs.cellKey.call(void 0, row, col), label, className: "quoin-table-text" })
+    }
+  );
+});
+
+// src/extensions/table/table-ui-store.ts
+
+function createTableUiStore() {
+  let state = { preview: null };
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => state,
+    set(patch) {
+      state = { ...state, ...patch };
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    }
+  };
+}
+var stores = /* @__PURE__ */ new WeakMap();
+function tableUiStore(controller) {
+  let store = stores.get(controller);
+  if (store === void 0) {
+    store = createTableUiStore();
+    stores.set(controller, store);
+  }
+  return store;
+}
+function useWidthPreview(controller, blockId) {
+  const store = tableUiStore(controller);
+  const read = _react.useCallback.call(void 0, () => {
+    const { preview } = store.get();
+    return _optionalChain([preview, 'optionalAccess', _16 => _16.block]) === blockId ? preview.widths : null;
+  }, [store, blockId]);
+  return _react.useSyncExternalStore.call(void 0, store.subscribe, read, read);
+}
+
+// src/extensions/table/use-cell-press.ts
+
+
+// src/engine/commands/table-commands.ts
+function changeTable(blockId, change, plan) {
+  return (state, dispatch) => {
+    const block = tableBlock(state.doc, blockId);
+    const next = block && change(block);
+    if (!next) return false;
+    const tr = new (0, _chunkPZ4GT5JOcjs.Transaction)(state).step(_chunkPZ4GT5JOcjs.replaceBlockStep.call(void 0, next));
+    _optionalChain([dispatch, 'optionalCall', _17 => _17(plan ? tr.setSelection(followedSelection(state.selection, blockId, plan)) : tr)]);
+    return true;
+  };
+}
+function reshape(blockId, plan) {
+  return (state, dispatch) => {
+    const block = tableBlock(state.doc, blockId);
+    const made = block && plan(block, tableShape(block));
+    return made ? changeTable(blockId, (table) => rebuiltTable(table, made), made)(state, dispatch) : false;
+  };
+}
+function spliced(list, index, remove, ...insert) {
+  const copy = [...list];
+  copy.splice(index, remove, ...insert);
+  return copy;
+}
+var reordered = (list, order) => order.map((i) => list[i]);
+var columnAttrs = (align, widths) => widths === null ? { align } : { align, widths };
+var addRow = (blockId, index) => reshape(
+  blockId,
+  (_, { rows, cols }) => isIndex(index, rows + 1) ? {
+    rows: rows + 1,
+    cols,
+    source: (row, col) => row === index ? null : [row < index ? row : row - 1, col],
+    target: ([row, col]) => [row < index ? row : row + 1, col],
+    landing: (cell) => cell
+  } : null
+);
+var removeRow = (blockId, index) => reshape(
+  blockId,
+  (_, { rows, cols }) => isIndex(index, rows) && rows > 1 ? {
+    rows: rows - 1,
+    cols,
+    source: (row, col) => [row < index ? row : row + 1, col],
+    target: ([row, col]) => row === index ? null : [row < index ? row : row - 1, col],
+    landing: ([, col]) => [Math.min(index, rows - 2), col]
+  } : null
+);
+var moveRow = (blockId, from, to) => reshape(blockId, (_, { rows, cols }) => {
+  if (!isIndex(from, rows) || !isIndex(to, rows) || from === to) return null;
+  const order = movedOrder(rows, from, to);
+  return {
+    rows,
+    cols,
+    source: (row, col) => [order[row], col],
+    target: ([row, col]) => [order.indexOf(row), col],
+    landing: (cell) => cell
+  };
+});
+var addColumn = (blockId, index) => reshape(blockId, (block, { rows, cols }) => {
+  if (!isIndex(index, cols + 1)) return null;
+  const widths = storedWidths(block, cols);
+  return {
+    rows,
+    cols: cols + 1,
+    source: (row, col) => col === index ? null : [row, col < index ? col : col - 1],
+    target: ([row, col]) => [row, col < index ? col : col + 1],
+    landing: (cell) => cell,
+    attrs: columnAttrs(
+      spliced(columnAligns(block, cols), index, 0, null),
+      widths && spliced(widths, index, 0, widths[Math.max(index - 1, 0)])
+    )
+  };
+});
+var removeColumn = (blockId, index) => reshape(blockId, (block, { rows, cols }) => {
+  if (!isIndex(index, cols) || cols < 2) return null;
+  const widths = storedWidths(block, cols);
+  return {
+    rows,
+    cols: cols - 1,
+    source: (row, col) => [row, col < index ? col : col + 1],
+    target: ([row, col]) => col === index ? null : [row, col < index ? col : col - 1],
+    landing: ([row]) => [row, Math.min(index, cols - 2)],
+    attrs: columnAttrs(spliced(columnAligns(block, cols), index, 1), widths && spliced(widths, index, 1))
+  };
+});
+var moveColumn = (blockId, from, to) => reshape(blockId, (block, { rows, cols }) => {
+  if (!isIndex(from, cols) || !isIndex(to, cols) || from === to) return null;
+  const order = movedOrder(cols, from, to);
+  const widths = storedWidths(block, cols);
+  return {
+    rows,
+    cols,
+    source: (row, col) => [row, order[col]],
+    target: ([row, col]) => [row, order.indexOf(col)],
+    landing: (cell) => cell,
+    attrs: columnAttrs(reordered(columnAligns(block, cols), order), widths && reordered(widths, order))
+  };
+});
+var toggleHeaderRow = (blockId) => changeTable(blockId, (block) => ({ ...block, attrs: { ...block.attrs, header: block.attrs.header === false } }));
+var withAttrs = (block, attrs) => ({ ...block, attrs: { ...block.attrs, ...attrs } });
+var setColumnAlign = (blockId, col, align) => changeTable(blockId, (block) => {
+  const aligns = columnAligns(block, tableShape(block).cols);
+  if (!isIndex(col, aligns.length) || aligns[col] === align) return null;
+  return withAttrs(block, { align: spliced(aligns, col, 1, align) });
+});
+var DEFAULT_COLUMN_WIDTH = 120;
+var setColumnWidth = (blockId, col, px, drawn) => changeTable(blockId, (block) => {
+  const { cols } = tableShape(block);
+  const width = Math.round(px);
+  if (!isIndex(col, cols) || !(width > 0)) return null;
+  const stored = storedWidths(block, cols);
+  if (_optionalChain([stored, 'optionalAccess', _18 => _18[col]]) === width) return null;
+  const measured = drawn && validWidths(drawn.map(Math.round), cols);
+  const widths = _nullishCoalesce(_nullishCoalesce(stored, () => ( measured)), () => ( Array(cols).fill(DEFAULT_COLUMN_WIDTH)));
+  return withAttrs(block, { widths: spliced(widths, col, 1, width) });
+});
+var isCount = (value) => Number.isInteger(value) && value > 0;
+function emptyCells({ rows, cols }) {
+  const regions = {};
+  for (let row = 0; row < rows; row++) for (let col = 0; col < cols; col++) regions[_chunkND5XJVK2cjs.cellKey.call(void 0, row, col)] = [];
+  return regions;
+}
+function insertTable(rows, cols, options = {}) {
+  return (state, dispatch) => {
+    const { doc, schema } = state;
+    const id = _chunkPZ4GT5JOcjs.headBlockId.call(void 0, state.selection);
+    if (id === null || !isCount(rows) || !isCount(cols)) return false;
+    const index = _chunkND5XJVK2cjs.requireBlockIndex.call(void 0, doc, id);
+    const current = doc.blocks[index];
+    const fills = _chunkPZ4GT5JOcjs.isParagraph.call(void 0, current) && _chunkPZ4GT5JOcjs.regionLength.call(void 0, current, _nullishCoalesce(_chunkPZ4GT5JOcjs.primaryRegion.call(void 0, schema, current), () => ( ""))) === 0;
+    const table = {
+      id: fills ? current.id : (_nullishCoalesce(options.newId, () => ( (0, _chunkND5XJVK2cjs.newId))))(),
+      type: "TABLE",
+      indent: current.indent,
+      attrs: { header: true, align: Array.from({ length: cols }, () => null), rows, cols },
+      regions: emptyCells({ rows, cols })
+    };
+    const tr = new (0, _chunkPZ4GT5JOcjs.Transaction)(state).step(
+      fills ? _chunkPZ4GT5JOcjs.replaceBlockStep.call(void 0, table) : _chunkPZ4GT5JOcjs.insertBlocksStep.call(void 0, _chunkPZ4GT5JOcjs.descendantsEnd.call(void 0, doc, index), [table])
+    );
+    _optionalChain([dispatch, 'optionalCall', _19 => _19(tr.setSelection(_chunkPZ4GT5JOcjs.textSelection.call(void 0, { block: table.id, region: _chunkND5XJVK2cjs.cellKey.call(void 0, 0, 0), offset: 0 })))]);
+    return true;
+  };
+}
+
+// src/extensions/table/table-keys.ts
+function headCell({ doc, selection }) {
+  if (_optionalChain([selection, 'optionalAccess', _20 => _20.kind]) !== "text") return null;
+  const { head } = selection;
+  const block = tableBlock(doc, head.block);
+  const cell = block && cellOf(head.region);
+  return block && cell ? { block, cell, head, shape: tableShape(block) } : null;
+}
+var cellLength = (block, [row, col]) => _chunkND5XJVK2cjs.inlineLength.call(void 0, _nullishCoalesce(block.regions[_chunkND5XJVK2cjs.cellKey.call(void 0, row, col)], () => ( [])));
+var cellPos = (block, cell, atEnd = false) => ({
+  block: block.id,
+  region: _chunkND5XJVK2cjs.cellKey.call(void 0, ...cell),
+  offset: atEnd ? cellLength(block, cell) : 0
+});
+var moveTo = (state, pos) => new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setSelection(_chunkPZ4GT5JOcjs.textSelection.call(void 0, pos));
+var thenCaretIn = (command, blockId, at) => (state, dispatch) => {
+  const caret = _chunkPZ4GT5JOcjs.textSelection.call(void 0, { block: blockId, region: _chunkND5XJVK2cjs.cellKey.call(void 0, ...at), offset: 0 });
+  return command(state, dispatch && ((tr) => dispatch(tr.setSelection(caret))));
+};
+var cellAtIndex = (index, { cols }) => [Math.floor(index / cols), index % cols];
+var indexOfCell = ([row, col], { cols }) => row * cols + col;
+var nextCell = (state, dispatch) => {
+  const caret = headCell(state);
+  if (caret === null) return false;
+  const { block, cell, shape } = caret;
+  const next = indexOfCell(cell, shape) + 1;
+  if (next === shape.rows * shape.cols) {
+    return thenCaretIn(addRow(block.id, shape.rows), block.id, [shape.rows, 0])(state, dispatch);
+  }
+  _optionalChain([dispatch, 'optionalCall', _21 => _21(moveTo(state, cellPos(block, cellAtIndex(next, shape), true)))]);
+  return true;
+};
+var previousCell = (state, dispatch) => {
+  const caret = headCell(state);
+  if (caret === null) return false;
+  const { block, cell, shape } = caret;
+  const previous = indexOfCell(cell, shape) - 1;
+  if (previous >= 0) _optionalChain([dispatch, 'optionalCall', _22 => _22(moveTo(state, cellPos(block, cellAtIndex(previous, shape), true)))]);
+  return true;
+};
+var enterInCell = (state, dispatch) => {
+  const caret = headCell(state);
+  if (caret === null) return false;
+  if (cellSelection(state) !== null) return true;
+  const { block, cell, shape } = caret;
+  const [row, col] = cell;
+  if (row === shape.rows - 1 && cellLength(block, cell) === 0) {
+    return thenCaretIn(addRow(block.id, shape.rows), block.id, [shape.rows, col])(state, dispatch);
+  }
+  return _chunkPZ4GT5JOcjs.insertHardBreak.call(void 0, state, dispatch);
+};
+var stopAtCellEdge = (atEnd) => (state) => {
+  const caret = headCell(state);
+  if (caret === null || !_chunkPZ4GT5JOcjs.isCollapsed.call(void 0, state.selection)) return false;
+  return caret.head.offset === (atEnd ? cellLength(caret.block, caret.cell) : 0);
+};
+var firstThatApplies = (...commands) => (state, dispatch) => commands.some((command) => command(state, dispatch));
+var MARK_KEYS = {
+  "Mod-b": "bold",
+  "Mod-i": "italic",
+  "Mod-u": "underline",
+  "Mod-Shift-s": "strike",
+  "Mod-e": "code",
+  "Mod-Shift-h": "highlight"
+};
+var tableKeymap = {
+  Tab: nextCell,
+  "Shift-Tab": previousCell,
+  Enter: enterInCell,
+  Backspace: firstThatApplies(deleteCellContents, stopAtCellEdge(false)),
+  Delete: firstThatApplies(deleteCellContents, stopAtCellEdge(true)),
+  ...Object.fromEntries(Object.entries(MARK_KEYS).map(([name, mark]) => [name, setCellsMark(mark)]))
+};
+
+// src/extensions/table/use-cell-press.ts
+function cellOf2(element) {
+  const row = element.getAttribute("data-row");
+  const col = element.getAttribute("data-col");
+  return element.matches("td, th") && row !== null && col !== null ? [Number(row), Number(col)] : null;
+}
+function useCellPress(controller, blockId, table, editable) {
+  _react.useEffect.call(void 0, () => {
+    const element = table.current;
+    if (!editable || element === null) return;
+    const onPointerDown = (event) => {
+      const cell = event.button === 0 && event.pointerType !== "touch" ? cellOf2(event.target) : null;
+      const block = cell && _chunkND5XJVK2cjs.blockById.call(void 0, controller.editor.state.doc, blockId);
+      if (!cell || !block) return;
+      event.preventDefault();
+      event.stopPropagation();
+      controller.focus(cellPos(block, cell, true));
+    };
+    element.addEventListener("pointerdown", onPointerDown);
+    return () => element.removeEventListener("pointerdown", onPointerDown);
+  }, [controller, blockId, table, editable]);
+}
+
+// src/extensions/table/use-reveal-cell.ts
+
+function useRevealCell(controller, blockId) {
+  const region = _chunkGTTPVJSDcjs.useEditorState.call(void 0, 
+    controller,
+    _react.useCallback.call(void 0, 
+      (state) => {
+        const caret = headCell(state);
+        return _optionalChain([caret, 'optionalAccess', _23 => _23.block, 'access', _24 => _24.id]) === blockId ? caret.head.region : null;
+      },
+      [blockId]
+    )
+  );
+  _react.useEffect.call(void 0, () => {
+    const host = region === null ? void 0 : controller.registry.get(blockId, region);
+    const root = controller.root;
+    if (!host || !_optionalChain([root, 'optionalAccess', _25 => _25.contains, 'call', _26 => _26(root.ownerDocument.activeElement)])) return;
+    _optionalChain([host, 'access', _27 => _27.closest, 'call', _28 => _28("td, th"), 'optionalAccess', _29 => _29.scrollIntoView, 'call', _30 => _30({ block: "nearest", inline: "nearest" })]);
+  }, [controller, blockId, region]);
+}
+
+// src/extensions/table/use-table-keys.ts
+
+
+// src/extensions/table/vertical-cell-move.ts
+var VERTICAL = { ArrowUp: -1, ArrowDown: 1 };
+function caretAtGoal(controller, blockId, cell, direction) {
+  const region = _chunkND5XJVK2cjs.cellKey.call(void 0, ...cell);
+  const host = controller.registry.get(blockId, region);
+  const { goalX } = controller;
+  const line = host && _chunkGTTPVJSDcjs.lineEdgeRect.call(void 0, host, direction < 0);
+  if (!host || !line || goalX === null) return null;
+  const box = host.getBoundingClientRect();
+  const x = Math.min(Math.max(goalX, box.left), box.right - 1);
+  const point = _chunkGTTPVJSDcjs.caretFromPoint.call(void 0, host.ownerDocument, x, line.top + line.height / 2);
+  const pos = point && _chunkGTTPVJSDcjs.domToPos.call(void 0, controller.registry, point.node, point.offset);
+  return pos && pos.block === blockId && pos.region === region ? pos : null;
+}
+var plainArrow = (event) => event.altKey || event.ctrlKey || event.metaKey ? void 0 : VERTICAL[event.key];
+function caretOnEdgeLine(controller, head, direction) {
+  const host = controller.registry.get(head.block, head.region);
+  const point = _chunkGTTPVJSDcjs.posToDom.call(void 0, controller.registry, head);
+  if (!host || !point || !(direction < 0 ? _chunkGTTPVJSDcjs.isOnFirstLine.call(void 0, host, point) : _chunkGTTPVJSDcjs.isOnLastLine.call(void 0, host, point))) return null;
+  return { left: _nullishCoalesce(_optionalChain([_chunkGTTPVJSDcjs.caretClientRect.call(void 0, point), 'optionalAccess', _31 => _31.left]), () => ( null)) };
+}
+function columnAt(controller, blockId, row, x) {
+  const cells = Array.from(_nullishCoalesce(_optionalChain([controller, 'access', _32 => _32.blockElement, 'call', _33 => _33(blockId), 'optionalAccess', _34 => _34.querySelector, 'call', _35 => _35("table"), 'optionalAccess', _36 => _36.rows, 'access', _37 => _37[row], 'optionalAccess', _38 => _38.cells]), () => ( [])));
+  const index = cells.findIndex((cell) => x < cell.getBoundingClientRect().right);
+  return index === -1 ? Math.max(cells.length - 1, 0) : index;
+}
+function enterTable(controller, blockId, event) {
+  const direction = plainArrow(event);
+  const { state } = controller.editor;
+  const { selection } = state;
+  const block = tableBlock(state.doc, blockId);
+  if (direction === void 0 || event.shiftKey || block === null || _optionalChain([selection, 'optionalAccess', _39 => _39.kind]) !== "text") return false;
+  if (!_chunkPZ4GT5JOcjs.isCollapsed.call(void 0, selection) || _optionalChain([_chunkGTTPVJSDcjs.neighbourBlock.call(void 0, state.doc, selection.head.block, direction), 'optionalAccess', _40 => _40.id]) !== blockId) return false;
+  const caret = caretOnEdgeLine(controller, selection.head, direction);
+  if (caret === null) return false;
+  controller.goalX ??= caret.left;
+  const { rows, cols } = tableShape(block);
+  const row = direction > 0 ? 0 : rows - 1;
+  const { goalX } = controller;
+  const cell = [row, goalX === null ? direction > 0 ? 0 : cols - 1 : columnAt(controller, blockId, row, goalX)];
+  const pos = _nullishCoalesce(caretAtGoal(controller, blockId, cell, direction), () => ( cellPos(block, cell, direction < 0)));
+  controller.dispatch(controller.editor.createTransaction().setSelection(_chunkPZ4GT5JOcjs.textSelection.call(void 0, pos)));
+  return true;
+}
+function moveBetweenRows(controller, blockId, event) {
+  const direction = plainArrow(event);
+  const { state } = controller.editor;
+  const caret = headCell(state);
+  if (direction === void 0 || caret === null || caret.block.id !== blockId || _optionalChain([state, 'access', _41 => _41.selection, 'optionalAccess', _42 => _42.kind]) !== "text") {
+    return false;
+  }
+  const target = [caret.cell[0] + direction, caret.cell[1]];
+  if (target[0] < 0 || target[0] >= caret.shape.rows) return false;
+  const edge = caretOnEdgeLine(controller, caret.head, direction);
+  if (edge === null) return false;
+  controller.goalX ??= edge.left;
+  const pos = _nullishCoalesce(caretAtGoal(controller, blockId, target, direction), () => ( cellPos(caret.block, target, direction < 0)));
+  const selection = event.shiftKey ? _chunkPZ4GT5JOcjs.textSelection.call(void 0, state.selection.anchor, pos) : _chunkPZ4GT5JOcjs.textSelection.call(void 0, pos);
+  controller.dispatch(controller.editor.createTransaction().setSelection(selection));
+  return true;
+}
+
+// src/extensions/table/use-table-keys.ts
+var printable = (event) => [...event.key].length === 1 && !event.ctrlKey && !event.metaKey;
+function typeOver(controller, blockId, event) {
+  if (_optionalChain([cellSelection, 'call', _43 => _43(controller.editor.state), 'optionalAccess', _44 => _44.block]) !== blockId || !printable(event)) return false;
+  return controller.run(typeOverCells(event.key));
+}
+function useTableKeys(controller, blockId, editable) {
+  _react.useEffect.call(void 0, () => {
+    if (!editable) return;
+    const intercept = (event) => {
+      if (_chunkGTTPVJSDcjs.isComposingKey.call(void 0, controller, event)) return false;
+      const handled = typeOver(controller, blockId, event) || moveBetweenRows(controller, blockId, event) || enterTable(controller, blockId, event);
+      if (handled) event.preventDefault();
+      return handled;
+    };
+    return _chunk2VDK27IFcjs.interceptKeys.call(void 0, controller, intercept);
+  }, [controller, blockId, editable]);
+}
+
+// src/extensions/table/TableBlock.tsx
+
+var indexes = (from, to) => Array.from({ length: Math.max(to - from, 0) }, (_, i) => from + i);
+function TableBlock({ block, controller, labels }) {
+  const readOnly = _chunkGTTPVJSDcjs.useReadOnly.call(void 0, controller);
+  const table = _react.useRef.call(void 0, null);
+  const { rows, cols } = tableShape(block);
+  const header = block.attrs.header !== false && rows > 0;
+  const aligns = columnAligns(block, cols);
+  const preview = useWidthPreview(controller, block.id);
+  const widths = _optionalChain([preview, 'optionalAccess', _45 => _45.length]) === cols ? preview : storedWidths(block, cols);
+  useTableKeys(controller, block.id, !readOnly);
+  useCellPress(controller, block.id, table, !readOnly);
+  useRevealCell(controller, block.id);
+  const row = (index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { children: indexes(0, cols).map((col) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    TableCell,
+    {
+      controller,
+      blockId: block.id,
+      row: index,
+      col,
+      header: header && index === 0,
+      align: aligns[col],
+      label: labels.cell(index + 1, col + 1)
+    },
+    col
+  )) }, index);
+  const scroller = readOnly ? { role: "region", "aria-label": labels.table, tabIndex: 0 } : void 0;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { contentEditable: false, className: "quoin-table", "data-readonly": readOnly ? "" : void 0, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: `quoin-table-scroll ${readOnly ? _chunk2VDK27IFcjs.FOCUS_RING : ""}`, ...scroller, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      "table",
+      {
+        ref: table,
+        "aria-label": readOnly ? void 0 : labels.table,
+        style: widths === null ? void 0 : { width: widths.reduce((sum, width) => sum + width, 0), tableLayout: "fixed" },
+        children: [
+          widths !== null && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "colgroup", { children: widths.map((width, col) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "col", { style: { width } }, col)) }),
+          header && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "thead", { children: row(0) }),
+          rows > (header ? 1 : 0) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tbody", { children: indexes(header ? 1 : 0, rows).map(row) })
+        ]
+      }
+    ),
+    !readOnly && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "quoin-table-controls", ...{ [CONTROLS_SLOT]: "" } })
+  ] }) });
+}
+
+// src/extensions/table/TableControls.tsx
+
+var _reactdom = require('react-dom');
+
+// src/extensions/table/menu-cells.ts
+var EMPTY = [];
+function menuCells(block, target, axis) {
+  const { rows, cols } = tableShape(block);
+  const row = Math.min(target.row, rows - 1);
+  const col = Math.min(target.col, cols - 1);
+  return Array.from(
+    { length: axis === "row" ? cols : rows },
+    (_, index) => axis === "row" ? _nullishCoalesce(block.regions[_chunkND5XJVK2cjs.cellKey.call(void 0, row, index)], () => ( EMPTY)) : _nullishCoalesce(block.regions[_chunkND5XJVK2cjs.cellKey.call(void 0, index, col)], () => ( EMPTY))
+  );
+}
+function sameMenuCells(opened, current, target, axis) {
+  const before = menuCells(opened, target, axis);
+  const after = menuCells(current, target, axis);
+  return before.length === after.length && before.every((cell, index) => _chunkND5XJVK2cjs.equalInline.call(void 0, cell, after[index]));
+}
+
+// src/extensions/table/TableHandles.tsx
+
+var _lucidereact = require('lucide-react');
+
+// src/extensions/table/ColumnResizer.tsx
+
+
+var MIN_COLUMN_WIDTH = 48;
+var MAX_COLUMN_WIDTH = 1200;
+var STEP = 10;
+var LARGE_STEP = 50;
+var clampWidth = (px) => Math.min(MAX_COLUMN_WIDTH, Math.max(MIN_COLUMN_WIDTH, Math.round(px)));
+function ColumnResizer(props) {
+  const { controller, labels, blockId, col, drawn, style, resizerRef, onHold, onBack } = props;
+  const drag = _react.useRef.call(void 0, null);
+  const width = Math.round(_nullishCoalesce(drawn[col], () => ( 0)));
+  const store = tableUiStore(controller);
+  const write = (px, widths) => {
+    if (!controller.readOnly) controller.run(setColumnWidth(blockId, col, px, widths));
+  };
+  const onKeyDown = (event) => {
+    if (_chunkGTTPVJSDcjs.isComposingKey.call(void 0, controller, event.nativeEvent)) return;
+    const step = event.shiftKey ? LARGE_STEP : STEP;
+    const tab = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+    if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+      const next = clampWidth(width + (event.key === "ArrowLeft" ? -step : step));
+      if (next !== width) write(next, drawn);
+    } else if (tab && event.shiftKey) onBack();
+    else if (tab || event.key === "Escape") controller.focus();
+    else return;
+    event.preventDefault();
+  };
+  const onPointerDown = (event) => {
+    if (event.button !== 0) return;
+    _optionalChain([event, 'access', _46 => _46.currentTarget, 'access', _47 => _47.setPointerCapture, 'optionalCall', _48 => _48(event.pointerId)]);
+    drag.current = { x: event.clientX, widths: [...drawn], to: null };
+    onHold(true);
+  };
+  const onPointerMove = (event) => {
+    const current = drag.current;
+    if (current === null) return;
+    current.to = clampWidth(current.widths[col] + event.clientX - current.x);
+    const widths = current.widths.map((px, i) => i === col ? _nullishCoalesce(current.to, () => ( px)) : px);
+    store.set({ preview: { block: blockId, widths } });
+  };
+  const stop = () => {
+    const current = drag.current;
+    drag.current = null;
+    store.set({ preview: null });
+    onHold(false);
+    return current;
+  };
+  _react.useEffect.call(void 0, 
+    () => () => {
+      if (drag.current !== null) store.set({ preview: null });
+    },
+    [store]
+  );
+  const end2 = () => {
+    const ended = stop();
+    if (_optionalChain([ended, 'optionalAccess', _49 => _49.to]) != null && ended.to !== Math.round(ended.widths[col])) write(ended.to, ended.widths);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "div",
+    {
+      ref: resizerRef,
+      role: "separator",
+      tabIndex: -1,
+      "aria-orientation": "vertical",
+      "aria-label": labels.resizeColumn(col + 1),
+      "aria-valuenow": width,
+      "aria-valuemin": MIN_COLUMN_WIDTH,
+      "aria-valuemax": MAX_COLUMN_WIDTH,
+      "aria-valuetext": labels.columnWidth(width),
+      className: "quoin-table-resizer",
+      style,
+      ...{ [_chunkGTTPVJSDcjs.NATIVE_INTERACTION]: "" },
+      onKeyDown,
+      onPointerDown,
+      onPointerMove,
+      onPointerUp: end2,
+      onPointerCancel: stop
+    }
+  );
+}
+
+// src/extensions/table/HandleMenu.tsx
+
+
+
+var DESTRUCTIVE = "text-destructive focus:text-destructive";
+function HandleMenu({ controller, axis, label, style, items, open, onOpenChange, buttonRef, children }) {
+  const run = (item3) => {
+    if (controller.run(item3.command)) controller.announce(item3.done);
+  };
+  const item2 = (entry) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _chunk2VDK27IFcjs.DropdownMenuItem,
+    {
+      disabled: entry.disabled,
+      className: entry.destructive ? DESTRUCTIVE : void 0,
+      onSelect: () => run(entry),
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.MenuIcon, { icon: entry.icon }),
+        entry.label
+      ]
+    },
+    entry.id
+  );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _chunk2VDK27IFcjs.DropdownMenu, { open, onOpenChange, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "button",
+      {
+        ref: buttonRef,
+        type: "button",
+        tabIndex: -1,
+        "aria-label": label,
+        "data-axis": axis,
+        className: "quoin-table-handle",
+        style,
+        children: axis === "row" ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.GripVertical, { "aria-hidden": "true" }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.GripHorizontal, { "aria-hidden": "true" })
+      }
+    ) }),
+    open && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      _chunk2VDK27IFcjs.DropdownMenuContent,
+      {
+        align: "start",
+        "aria-label": label,
+        "aria-labelledby": void 0,
+        onCloseAutoFocus: _chunk2VDK27IFcjs.returnFocusToText.call(void 0, controller),
+        ..._chunk2VDK27IFcjs.bubblePart.call(void 0, controller),
+        children: [
+          items.filter((entry) => !entry.destructive).map(item2),
+          children,
+          items.filter((entry) => entry.destructive).map((entry) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.Fragment, { children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.DropdownMenuSeparator, {}),
+            item2(entry)
+          ] }, entry.id))
+        ]
+      }
+    )
+  ] });
+}
+
+// src/extensions/table/table-menu-items.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var item = (id, label, icon, command, done, options = {}) => ({ id, label, icon, command, done, ...options });
+function rowMenuItems(labels, blockId, row, { rows }) {
+  const { rowInserted, rowMoved, rowDeleted } = labels;
+  return [
+    item("above", labels.insertRowAbove, _lucidereact.ArrowUpToLine, addRow(blockId, row), rowInserted),
+    item("below", labels.insertRowBelow, _lucidereact.ArrowDownToLine, addRow(blockId, row + 1), rowInserted),
+    item("up", labels.moveRowUp, _lucidereact.ArrowUp, moveRow(blockId, row, row - 1), rowMoved, { disabled: row === 0 }),
+    item("down", labels.moveRowDown, _lucidereact.ArrowDown, moveRow(blockId, row, row + 1), rowMoved, { disabled: row === rows - 1 }),
+    item("delete", labels.deleteRow, _lucidereact.Trash, removeRow(blockId, row), rowDeleted, { disabled: rows === 1, destructive: true })
+  ];
+}
+function columnMenuItems(labels, blockId, col, { cols }) {
+  const { columnInserted, columnMoved, columnDeleted } = labels;
+  const last = col === cols - 1;
+  return [
+    item("left", labels.insertColumnLeft, _lucidereact.ArrowLeftToLine, addColumn(blockId, col), columnInserted),
+    item("right", labels.insertColumnRight, _lucidereact.ArrowRightToLine, addColumn(blockId, col + 1), columnInserted),
+    item("move-left", labels.moveColumnLeft, _lucidereact.ArrowLeft, moveColumn(blockId, col, col - 1), columnMoved, { disabled: col === 0 }),
+    item("move-right", labels.moveColumnRight, _lucidereact.ArrowRight, moveColumn(blockId, col, col + 1), columnMoved, { disabled: last }),
+    item("delete", labels.deleteColumn, _lucidereact.Trash, removeColumn(blockId, col), columnDeleted, {
+      disabled: cols === 1,
+      destructive: true
+    })
+  ];
+}
+var alignItems = (labels) => [
+  { value: "left", label: labels.alignLeft, icon: _lucidereact.AlignLeft, done: labels.alignedLeft },
+  { value: "center", label: labels.alignCenter, icon: _lucidereact.AlignCenter, done: labels.alignedCenter },
+  { value: "right", label: labels.alignRight, icon: _lucidereact.AlignRight, done: labels.alignedRight }
+];
+
+// src/extensions/table/TableHandles.tsx
+
+var BESIDE = 4;
+var end = (span) => span.start + span.size;
+function edgeOf(spans, edge) {
+  if (edge === null || !Number.isInteger(edge) || edge < 0 || edge > spans.length || spans.length === 0) return null;
+  return edge === spans.length ? end(spans[edge - 1]) : spans[edge].start;
+}
+var middle = (span) => span.start + span.size / 2;
+var isTab = (event) => event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+function TableHandles(props) {
+  const { controller, labels, block, target, geometry, menu, onMenu, onHold, focusRequested, onFocused } = props;
+  const rowHandle = _react.useRef.call(void 0, null);
+  const columnHandle = _react.useRef.call(void 0, null);
+  const resizer = _react.useRef.call(void 0, null);
+  const shape = tableShape(block);
+  const row = Math.min(target.row, shape.rows - 1);
+  const col = Math.min(target.col, shape.cols - 1);
+  const align = columnAligns(block, shape.cols)[col];
+  const drawn = geometry.cols.map((span) => span.size);
+  const { rowEdge, colEdge } = target;
+  const rowInsertAt = edgeOf(geometry.rows, rowEdge);
+  const columnInsertAt = edgeOf(geometry.cols, colEdge);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    if (!focusRequested) return;
+    _optionalChain([(_nullishCoalesce(columnHandle.current, () => ( rowHandle.current))), 'optionalAccess', _50 => _50.focus, 'call', _51 => _51()]);
+    onFocused();
+  }, [focusRequested, onFocused]);
+  const run = (command, done) => {
+    if (controller.run(command)) controller.announce(done);
+  };
+  const onKeyDown = (event) => {
+    const handles = [rowHandle.current, columnHandle.current].filter((handle) => handle !== null);
+    const index = handles.indexOf(event.target);
+    if (index === -1 || _chunkGTTPVJSDcjs.isComposingKey.call(void 0, controller, event.nativeEvent)) return;
+    if (event.key === "ArrowLeft" || event.key === "ArrowRight") handles[(index + 1) % handles.length].focus();
+    else if (isTab(event) && !event.shiftKey && resizer.current !== null) resizer.current.focus();
+    else if (isTab(event) || event.key === "Escape") controller.focus();
+    else return;
+    event.preventDefault();
+  };
+  const place = (left, top) => ({ left, top });
+  const opener = (kind) => (open) => onMenu(open ? kind : null);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+    geometry.cols.map((span, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      ColumnResizer,
+      {
+        controller,
+        labels,
+        blockId: block.id,
+        col: index,
+        drawn,
+        style: { left: end(span), top: geometry.top, height: geometry.height },
+        resizerRef: index === col ? resizer : void 0,
+        onHold,
+        onBack: () => _optionalChain([(_nullishCoalesce(columnHandle.current, () => ( rowHandle.current))), 'optionalAccess', _52 => _52.focus, 'call', _53 => _53()])
+      },
+      index
+    )),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { role: "toolbar", "aria-label": labels.tableControls, className: "quoin-table-toolbar", onKeyDown, children: [
+      rowInsertAt === null && geometry.rows[row] && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        HandleMenu,
+        {
+          controller,
+          axis: "row",
+          label: labels.rowOptions(row + 1),
+          style: place(geometry.left - BESIDE, middle(geometry.rows[row])),
+          items: rowMenuItems(labels, block.id, row, shape),
+          open: menu === "row",
+          onOpenChange: opener("row"),
+          buttonRef: rowHandle,
+          children: row === 0 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _chunk2VDK27IFcjs.DropdownMenuCheckboxItem,
+            {
+              checked: block.attrs.header !== false,
+              onCheckedChange: (on) => run(toggleHeaderRow(block.id), on ? labels.headerRowOn : labels.headerRowOff),
+              children: labels.headerRow
+            }
+          )
+        }
+      ),
+      columnInsertAt === null && geometry.cols[col] && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+        HandleMenu,
+        {
+          controller,
+          axis: "column",
+          label: labels.columnOptions(col + 1),
+          style: place(middle(geometry.cols[col]), geometry.top),
+          items: columnMenuItems(labels, block.id, col, shape),
+          open: menu === "column",
+          onOpenChange: opener("column"),
+          buttonRef: columnHandle,
+          children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.DropdownMenuSeparator, {}),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.DropdownMenuRadioGroup, { value: _nullishCoalesce(align, () => ( "")), children: alignItems(labels).map(({ value, label, icon, done }) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              _chunk2VDK27IFcjs.DropdownMenuRadioItem,
+              {
+                value,
+                onSelect: () => align === value ? run(setColumnAlign(block.id, col, null), labels.alignmentCleared) : run(setColumnAlign(block.id, col, value), done),
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.MenuIcon, { icon }),
+                  label
+                ]
+              },
+              value
+            )) })
+          ]
+        }
+      )
+    ] }),
+    rowEdge !== null && rowInsertAt !== null && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "button",
+      {
+        type: "button",
+        tabIndex: -1,
+        "aria-label": labels.insertRowAt(rowEdge + 1),
+        "data-axis": "row",
+        className: "quoin-table-insert",
+        style: place(geometry.left - BESIDE, rowInsertAt),
+        onPointerDown: _chunk2VDK27IFcjs.keepFocus,
+        onMouseDown: _chunk2VDK27IFcjs.keepFocus,
+        onClick: () => run(addRow(block.id, rowEdge), labels.rowInserted),
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Plus, { "aria-hidden": "true" })
+      }
+    ),
+    colEdge !== null && columnInsertAt !== null && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "button",
+      {
+        type: "button",
+        tabIndex: -1,
+        "aria-label": labels.insertColumnAt(colEdge + 1),
+        "data-axis": "column",
+        className: "quoin-table-insert",
+        style: place(columnInsertAt, geometry.top),
+        onPointerDown: _chunk2VDK27IFcjs.keepFocus,
+        onMouseDown: _chunk2VDK27IFcjs.keepFocus,
+        onClick: () => run(addColumn(block.id, colEdge), labels.columnInserted),
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Plus, { "aria-hidden": "true" })
+      }
+    )
+  ] });
+}
+
+// src/extensions/table/use-table-geometry.ts
+
+
+// src/extensions/table/table-geometry.ts
+function measureTable(table, origin) {
+  const box = table.getBoundingClientRect();
+  const first = table.rows[0];
+  return {
+    left: box.left - origin.left,
+    top: box.top - origin.top,
+    width: box.width,
+    height: box.height,
+    rows: Array.from(table.rows, (row) => {
+      const rect = row.getBoundingClientRect();
+      return { start: rect.top - origin.top, size: rect.height };
+    }),
+    cols: Array.from(_nullishCoalesce(_optionalChain([first, 'optionalAccess', _54 => _54.cells]), () => ( [])), (cell) => {
+      const rect = cell.getBoundingClientRect();
+      return { start: rect.left - origin.left, size: rect.width };
+    })
+  };
+}
+var sameSpans = (a, b) => a.length === b.length && a.every((span, i) => span.start === b[i].start && span.size === b[i].size);
+var sameGeometry = (a, b) => a === b || a !== null && b !== null && a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height && sameSpans(a.rows, b.rows) && sameSpans(a.cols, b.cols);
+function spanAt(spans, at) {
+  const inside = spans.findIndex((span) => at < span.start + span.size);
+  return inside === -1 ? spans.length - 1 : inside;
+}
+function edgeNear(spans, at, reach) {
+  if (spans.length === 0) return null;
+  const edges = [spans[0].start, ...spans.map((span) => span.start + span.size)];
+  const index = edges.findIndex((edge) => Math.abs(edge - at) <= reach);
+  return index === -1 ? null : index;
+}
+
+// src/extensions/table/use-table-geometry.ts
+function useTableGeometry(controller, blockId, slot) {
+  const [geometry, setGeometry] = _react.useState.call(void 0, null);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const table = _optionalChain([controller, 'access', _55 => _55.blockElement, 'call', _56 => _56(blockId), 'optionalAccess', _57 => _57.querySelector, 'call', _58 => _58("table")]);
+    const view = slot.ownerDocument.defaultView;
+    if (!table || !view) return;
+    const measure = () => {
+      const next = measureTable(table, slot.getBoundingClientRect());
+      setGeometry((current) => sameGeometry(current, next) ? current : next);
+    };
+    measure();
+    let frame = 0;
+    const later = () => {
+      view.cancelAnimationFrame(frame);
+      frame = view.requestAnimationFrame(measure);
+    };
+    const unsubscribe = controller.editor.subscribe(later);
+    const observer = new ResizeObserver(later);
+    observer.observe(table);
+    view.addEventListener("resize", later);
+    return () => {
+      view.cancelAnimationFrame(frame);
+      unsubscribe();
+      observer.disconnect();
+      view.removeEventListener("resize", later);
+    };
+  }, [controller, blockId, slot]);
+  return geometry;
+}
+
+// src/extensions/table/use-cut-cells.ts
+
+function useCutCells(controller) {
+  _react.useEffect.call(void 0, () => {
+    const root = controller.root;
+    if (root === null) return;
+    const onCut = (event) => {
+      if (controller.readOnly || cellSelection(controller.editor.state) === null) return;
+      event.stopPropagation();
+      _chunkGTTPVJSDcjs.handleCopy.call(void 0, controller, event, false);
+      controller.run(deleteCellContents);
+    };
+    root.addEventListener("cut", onCut, true);
+    return () => root.removeEventListener("cut", onCut, true);
+  }, [controller]);
+}
+
+// src/extensions/table/use-table-target.ts
+
+var EDGE_ZONE = 24;
+var EDGE_REACH = 8;
+var VIEWPORT = { left: 0, top: 0 };
+var CONTROLS = `[${CONTROLS_SLOT}]`;
+var sameTarget = (a, b) => a === b || a !== null && b !== null && a.block === b.block && a.row === b.row && a.col === b.col && a.rowEdge === b.rowEdge && a.colEdge === b.colEdge;
+function caretTarget(state) {
+  const caret = headCell(state);
+  return caret && { block: caret.block.id, row: caret.cell[0], col: caret.cell[1], rowEdge: null, colEdge: null };
+}
+function pointerTarget(controller, event) {
+  const blockId = controller.blockAt(event.target);
+  const block = blockId === void 0 ? null : tableBlock(controller.editor.state.doc, blockId);
+  const table = block && _optionalChain([controller, 'access', _59 => _59.blockElement, 'call', _60 => _60(block.id), 'optionalAccess', _61 => _61.querySelector, 'call', _62 => _62("table")]);
+  if (!block || !table) return null;
+  const geometry = measureTable(table, VIEWPORT);
+  const { clientX: x, clientY: y } = event;
+  const row = spanAt(geometry.rows, y);
+  const col = spanAt(geometry.cols, x);
+  if (row < 0 || col < 0) return null;
+  const rowEdge = x < geometry.left + EDGE_ZONE ? edgeNear(geometry.rows, y, EDGE_REACH) : null;
+  const colEdge = y < geometry.top + EDGE_ZONE ? edgeNear(geometry.cols, x, EDGE_REACH) : null;
+  return { block: block.id, row, col, rowEdge, colEdge };
+}
+function shapeOf(state, blockId) {
+  const block = tableBlock(state.doc, blockId);
+  if (block === null) return null;
+  const { rows, cols } = tableShape(block);
+  return `${rows}x${cols}`;
+}
+function focusOf(root) {
+  const active = root.ownerDocument.activeElement;
+  if (active === null || !root.contains(active)) return "none";
+  return active.closest(CONTROLS) === null ? "editor" : "controls";
+}
+function useTableTarget(controller, held) {
+  const [hovered, setHovered] = _react.useState.call(void 0, null);
+  const [focus, setFocus] = _react.useState.call(void 0, "none");
+  const caret = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, caretTarget, sameTarget);
+  const hoveredBlock = _nullishCoalesce(_optionalChain([hovered, 'optionalAccess', _63 => _63.target, 'access', _64 => _64.block]), () => ( null));
+  const shape = _chunkGTTPVJSDcjs.useEditorState.call(void 0, 
+    controller,
+    _react.useCallback.call(void 0, (state) => hoveredBlock === null ? null : shapeOf(state, hoveredBlock), [hoveredBlock])
+  );
+  const pointed = hovered !== null && hovered.shape === shape ? hovered.target : null;
+  _react.useEffect.call(void 0, () => {
+    const root = controller.root;
+    if (root === null) return;
+    const onPointerMove = (event) => {
+      if (event.pointerType === "touch") return;
+      const target = pointerTarget(controller, event);
+      const next = target && { target, shape: shapeOf(controller.editor.state, target.block) };
+      setHovered(
+        (current) => current !== null && next !== null && sameTarget(current.target, next.target) && current.shape === next.shape ? current : next
+      );
+    };
+    const onPointerLeave = () => setHovered(null);
+    const onFocusChange = () => setFocus(focusOf(root));
+    const onFocusOut = (event) => {
+      const next = event.relatedTarget;
+      setFocus(next !== null && root.contains(next) ? next.closest(CONTROLS) ? "controls" : "editor" : "none");
+    };
+    setFocus(focusOf(root));
+    root.addEventListener("pointermove", onPointerMove);
+    root.addEventListener("pointerleave", onPointerLeave);
+    root.addEventListener("focusin", onFocusChange);
+    root.addEventListener("focusout", onFocusOut);
+    return () => {
+      root.removeEventListener("pointermove", onPointerMove);
+      root.removeEventListener("pointerleave", onPointerLeave);
+      root.removeEventListener("focusin", onFocusChange);
+      root.removeEventListener("focusout", onFocusOut);
+    };
+  }, [controller]);
+  if (held !== null) return held;
+  if (focus === "controls") return _nullishCoalesce(caret, () => ( pointed));
+  return _nullishCoalesce(pointed, () => ( (focus === "editor" ? caret : null)));
+}
+
+// src/extensions/table/TableControls.tsx
+
+var isFocusKey = (event) => event.key === "F10" && event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey;
+var takesFocusKey = (state) => _chunkPZ4GT5JOcjs.isCollapsed.call(void 0, state.selection) || cellSelection(state) !== null;
+function TableControls({ controller, labels }) {
+  const readOnly = _chunkGTTPVJSDcjs.useReadOnly.call(void 0, controller);
+  const [held, setHeld] = _react.useState.call(void 0, null);
+  const [focusFor, setFocusFor] = _react.useState.call(void 0, null);
+  const [slot, setSlot] = _react.useState.call(void 0, null);
+  const target = useTableTarget(controller, _nullishCoalesce(_optionalChain([held, 'optionalAccess', _65 => _65.target]), () => ( null)));
+  useCutCells(controller);
+  const blockId = _nullishCoalesce(_optionalChain([target, 'optionalAccess', _66 => _66.block]), () => ( null));
+  const block = _chunkGTTPVJSDcjs.useEditorState.call(void 0, 
+    controller,
+    _react.useCallback.call(void 0, (state) => blockId === null ? null : tableBlock(state.doc, blockId), [blockId])
+  );
+  if (_optionalChain([held, 'optionalAccess', _67 => _67.menu]) && held.opened && block && !sameMenuCells(held.opened, block, held.target, held.menu)) setHeld(null);
+  _react.useEffect.call(void 0, () => {
+    if (!readOnly && block !== null) return;
+    setHeld(null);
+    setFocusFor(null);
+  }, [readOnly, block]);
+  _react.useEffect.call(void 0, () => {
+    if (readOnly) return;
+    const intercept = (event) => {
+      const { state } = controller.editor;
+      const caret = caretTarget(state);
+      if (!isFocusKey(event) || _chunkGTTPVJSDcjs.isComposingKey.call(void 0, controller, event) || caret === null || !takesFocusKey(state)) return false;
+      event.preventDefault();
+      setHeld({ target: caret, menu: null });
+      setFocusFor(caret.block);
+      return true;
+    };
+    return _chunk2VDK27IFcjs.interceptKeys.call(void 0, controller, intercept);
+  }, [controller, readOnly]);
+  const onMenu = _react.useCallback.call(void 0, 
+    (menu) => setHeld(menu === null || target === null || block === null ? null : { target, menu, opened: block }),
+    [target, block]
+  );
+  const onHold = _react.useCallback.call(void 0, (hold) => setHeld(hold && target !== null ? { target, menu: null } : null), [target]);
+  const onFocused = _react.useCallback.call(void 0, () => {
+    setFocusFor(null);
+    setHeld((current) => _optionalChain([current, 'optionalAccess', _68 => _68.menu]) === null ? null : current);
+  }, []);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const drawn = block === null || readOnly ? null : controlsSlot(controller, block.id);
+    setSlot((current) => current === drawn ? current : drawn);
+  });
+  if (target === null || block === null || readOnly || slot === null || !slot.isConnected) return null;
+  return _reactdom.createPortal.call(void 0, 
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      PlacedHandles,
+      {
+        controller,
+        labels,
+        block,
+        target,
+        slot,
+        menu: _nullishCoalesce(_optionalChain([held, 'optionalAccess', _69 => _69.menu]), () => ( null)),
+        onMenu,
+        onHold,
+        focusRequested: focusFor === block.id,
+        onFocused
+      },
+      block.id
+    ),
+    slot
+  );
+}
+function PlacedHandles({ slot, ...props }) {
+  const geometry = useTableGeometry(props.controller, props.block.id, slot);
+  return geometry === null ? null : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TableHandles, { ...props, geometry });
+}
+
+// src/extensions/table/table-labels.ts
+var englishTableLabels = {
+  table: "Table",
+  tableDescription: "Rows and columns of text",
+  cell: (row, col) => `Row ${row}, column ${col}`,
+  tableControls: "Table controls",
+  rowOptions: (row) => `Row ${row} options`,
+  columnOptions: (col) => `Column ${col} options`,
+  insertRowAbove: "Insert row above",
+  insertRowBelow: "Insert row below",
+  insertColumnLeft: "Insert column left",
+  insertColumnRight: "Insert column right",
+  moveRowUp: "Move row up",
+  moveRowDown: "Move row down",
+  moveColumnLeft: "Move column left",
+  moveColumnRight: "Move column right",
+  deleteRow: "Delete row",
+  deleteColumn: "Delete column",
+  headerRow: "Header row",
+  alignLeft: "Align left",
+  alignCenter: "Align center",
+  alignRight: "Align right",
+  insertRowAt: (row) => `Insert row ${row}`,
+  insertColumnAt: (col) => `Insert column ${col}`,
+  resizeColumn: (col) => `Resize column ${col}`,
+  columnWidth: (px) => `${px} pixels`,
+  rowInserted: "Row inserted",
+  rowDeleted: "Row deleted",
+  rowMoved: "Row moved",
+  columnInserted: "Column inserted",
+  columnDeleted: "Column deleted",
+  columnMoved: "Column moved",
+  headerRowOn: "Header row on",
+  headerRowOff: "Header row off",
+  alignedLeft: "Column aligned left",
+  alignedCenter: "Column aligned center",
+  alignedRight: "Column aligned right",
+  alignmentCleared: "Column alignment cleared"
+};
+function resolveTableLabels(overrides) {
+  const given = Object.entries(_nullishCoalesce(overrides, () => ( {}))).filter(([, value]) => value !== void 0);
+  return given.length === 0 ? englishTableLabels : { ...englishTableLabels, ...Object.fromEntries(given) };
+}
+
+// src/extensions/table/table-slash-item.ts
+
+var NEW_TABLE = { rows: 3, cols: 3 };
+var tableSlashItem = (labels) => ({
+  id: "table",
+  title: labels.table,
+  description: labels.tableDescription,
+  group: "advanced",
+  icon: _lucidereact.Table,
+  keywords: ["grid", "rows", "columns", "spreadsheet", "|"],
+  command: () => insertTable(NEW_TABLE.rows, NEW_TABLE.cols)
+});
+
+// src/extensions/table/table-extension.tsx
+
+var ABOVE_CORE_KEYS = 200;
+var pasteOverCells = {
+  name: "table-cells",
+  match: (text, state) => cellSelection(state) === null ? null : typeOverCells(text.replace(/\r\n?/g, "\n"))
+};
+function tableExtension(options = {}) {
+  const labels = resolveTableLabels(options.labels);
+  const TableRenderer = (props) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TableBlock, { ...props, labels });
+  const TableOverlay = ({ controller }) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TableControls, { controller, labels });
+  const ui = {
+    slashItems: [tableSlashItem(labels)],
+    renderers: { TABLE: TableRenderer },
+    blockNames: { TABLE: labels.table },
+    overlays: [TableOverlay]
+  };
+  return _chunkPZ4GT5JOcjs.defineExtension.call(void 0, {
+    name: "table",
+    priority: ABOVE_CORE_KEYS,
+    plugins: [cellSelectionPlugin],
+    keymap: tableKeymap,
+    pasteRules: [pasteOverCells],
+    ui
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.cellSelectionKey = cellSelectionKey; exports.cellSelectionPlugin = cellSelectionPlugin; exports.cellSelection = cellSelection; exports.cellsInRange = cellsInRange; exports.selectCells = selectCells; exports.deleteCellContents = deleteCellContents; exports.setCellsMark = setCellsMark; exports.addRow = addRow; exports.removeRow = removeRow; exports.moveRow = moveRow; exports.addColumn = addColumn; exports.removeColumn = removeColumn; exports.moveColumn = moveColumn; exports.toggleHeaderRow = toggleHeaderRow; exports.setColumnAlign = setColumnAlign; exports.setColumnWidth = setColumnWidth; exports.insertTable = insertTable; exports.englishTableLabels = englishTableLabels; exports.tableExtension = tableExtension;
+//# sourceMappingURL=chunk-AEJXZBVR.cjs.map