@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/managers/HistoryManager.d.ts

@@ -0,0 +1,92 @@
+import { Subscribable } from "./Subscribable.js";
+
+//#region src/managers/HistoryManager.d.ts
+/** History entry containing state and metadata. */
+type HistoryEntry<T> = {
+  /** The state at this point. */state: T; /** Timestamp when this entry was created. */
+  timestamp: number; /** Optional description of what changed. */
+  description?: string;
+};
+/** Reactive snapshot adapters render from. */
+type HistorySnapshot<T> = {
+  /** Current state. */state: T; /** Whether undo is available. */
+  canUndo: boolean; /** Whether redo is available. */
+  canRedo: boolean; /** Number of entries in the undo stack. */
+  undoCount: number; /** Number of entries in the redo stack. */
+  redoCount: number;
+};
+type HistoryManagerOptions<T> = {
+  /** Maximum number of entries in the undo stack (default: 100). */maxEntries?: number; /** Time in ms within which rapid pushes are grouped (default: 500). */
+  groupingInterval?: number; /** Custom comparison used to skip no-op pushes (default: JSON compare). */
+  isEqual?: (a: T, b: T) => boolean;
+};
+/** Default equality check using JSON stringify. */
+declare const defaultHistoryIsEqual: <T>(a: T, b: T) => boolean;
+/** History action a keyboard chord maps to. */
+type HistoryShortcut = "undo" | "redo";
+/** Minimal keyboard-event shape the shortcut classifier reads. */
+type HistoryShortcutEvent = {
+  key: string;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+};
+/**
+ * Classify a keydown as an undo/redo shortcut, framework-agnostically.
+ *
+ * `key` is compared case-insensitively: while Shift is held the browser reports
+ * the uppercase `"Z"`, so the standard redo chord Ctrl/Cmd+Shift+Z would slip
+ * past an exact `=== "z"` check and never trigger redo. Ctrl/Cmd+Z is undo;
+ * Ctrl/Cmd+Shift+Z and Ctrl/Cmd+Y are redo.
+ */
+declare const classifyHistoryShortcut: (event: HistoryShortcutEvent) => HistoryShortcut | null;
+declare class HistoryManager<T> extends Subscribable<HistorySnapshot<T>> {
+  private currentState;
+  private readonly initialState;
+  private undoStack;
+  private redoStack;
+  private lastPushTime;
+  /**
+   * Raised while an undo/redo is settling. Pushes that arrive during this
+   * window (e.g. the editor re-syncing to the restored document) adopt the new
+   * state without creating a fresh history entry. The adapter lowers it once
+   * its render cycle has flushed.
+   */
+  private undoRedoActive;
+  private readonly maxEntries;
+  private readonly groupingInterval;
+  private readonly isEqual;
+  constructor(initialState: T, options?: HistoryManagerOptions<T>);
+  /** The current state (satisfies `DocumentLoaderHistory.state`). */
+  get state(): T;
+  /** Whether the undo/redo re-entrancy guard is currently raised. */
+  get isUndoRedoActive(): boolean;
+  /** Push a new state to history. */
+  push(newState: T, description?: string): void;
+  /** Undo to the previous state, raising the re-entrancy guard. */
+  undo(): T | undefined;
+  /** Redo to the next state, raising the re-entrancy guard. */
+  redo(): T | undefined;
+  /**
+   * Lower the undo/redo re-entrancy guard. The adapter calls this once its
+   * render cycle (and the effects it triggered) has flushed, so a follow-up
+   * edit records a fresh entry again.
+   */
+  endUndoRedo(): void;
+  /** Clear both stacks, keeping the current state. */
+  clear(): void;
+  /** Reset to the initial (or a supplied) state and clear history. */
+  reset(newInitialState?: T): void;
+  /** Snapshot copy of the undo stack (for debugging/display). */
+  getUndoStack(): HistoryEntry<T>[];
+  /** Snapshot copy of the redo stack (for debugging/display). */
+  getRedoStack(): HistoryEntry<T>[];
+  /**
+   * Transform every stored state (current + both stacks). Useful for bulk
+   * cleanup such as stripping cached snapshots.
+   */
+  transformAll(fn: (state: T) => T): void;
+  private emit;
+}
+//#endregion
+export { HistoryEntry, HistoryManager, HistoryManagerOptions, HistoryShortcut, HistoryShortcutEvent, HistorySnapshot, classifyHistoryShortcut, defaultHistoryIsEqual };

package/dist/managers/HistoryManager.js

@@ -0,0 +1,193 @@
+import { Subscribable } from "./Subscribable.js";
+//#region src/managers/HistoryManager.ts
+/**
+* HistoryManager
+*
+* Framework-agnostic undo/redo stack and document-snapshot history, extracted
+* from the React `useHistory` hook. Owns the current state plus the undo/redo
+* stacks and runs push (with rapid-change grouping), undo, redo, redo
+* invalidation, stack-size capping, and bulk state transforms.
+*
+* Adapters bind to it through `Subscribable` (React:
+* `useSyncExternalStore(manager.subscribe, manager.getSnapshot)`). The adapter
+* keeps the genuinely framework-bound concerns: keyboard shortcuts, the
+* render-cycle timing that lowers the undo/redo re-entrancy guard, and routing
+* the optional `onUndo` / `onRedo` host callbacks.
+*
+* `HistoryManager<Document | null>` structurally satisfies the
+* `DocumentLoaderHistory` shape that `DocumentLoaderManager` consumes
+* (`{ readonly state; reset(document) }`).
+*/
+/** Default equality check using JSON stringify. */
+const defaultHistoryIsEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* Classify a keydown as an undo/redo shortcut, framework-agnostically.
+*
+* `key` is compared case-insensitively: while Shift is held the browser reports
+* the uppercase `"Z"`, so the standard redo chord Ctrl/Cmd+Shift+Z would slip
+* past an exact `=== "z"` check and never trigger redo. Ctrl/Cmd+Z is undo;
+* Ctrl/Cmd+Shift+Z and Ctrl/Cmd+Y are redo.
+*/
+const classifyHistoryShortcut = (event) => {
+	if (!event.ctrlKey && !event.metaKey) return null;
+	const key = event.key.toLowerCase();
+	if (key === "y") return "redo";
+	if (key === "z") return event.shiftKey ? "redo" : "undo";
+	return null;
+};
+var HistoryManager = class extends Subscribable {
+	currentState;
+	initialState;
+	undoStack = [];
+	redoStack = [];
+	lastPushTime = 0;
+	/**
+	* Raised while an undo/redo is settling. Pushes that arrive during this
+	* window (e.g. the editor re-syncing to the restored document) adopt the new
+	* state without creating a fresh history entry. The adapter lowers it once
+	* its render cycle has flushed.
+	*/
+	undoRedoActive = false;
+	maxEntries;
+	groupingInterval;
+	isEqual;
+	constructor(initialState, options = {}) {
+		super({
+			state: initialState,
+			canUndo: false,
+			canRedo: false,
+			undoCount: 0,
+			redoCount: 0
+		});
+		this.currentState = initialState;
+		this.initialState = initialState;
+		this.maxEntries = options.maxEntries ?? 100;
+		this.groupingInterval = options.groupingInterval ?? 500;
+		this.isEqual = options.isEqual ?? defaultHistoryIsEqual;
+	}
+	/** The current state (satisfies `DocumentLoaderHistory.state`). */
+	get state() {
+		return this.currentState;
+	}
+	/** Whether the undo/redo re-entrancy guard is currently raised. */
+	get isUndoRedoActive() {
+		return this.undoRedoActive;
+	}
+	/** Push a new state to history. */
+	push(newState, description) {
+		if (this.isEqual(this.currentState, newState)) return;
+		if (this.undoRedoActive) {
+			this.currentState = newState;
+			this.emit();
+			return;
+		}
+		const now = Date.now();
+		if (now - this.lastPushTime < this.groupingInterval && this.undoStack.length > 0) {
+			const last = this.undoStack.at(-1);
+			const desc = description || last?.description;
+			this.undoStack[this.undoStack.length - 1] = {
+				state: last?.state ?? this.currentState,
+				timestamp: now,
+				...desc !== void 0 ? { description: desc } : {}
+			};
+		} else {
+			this.undoStack.push({
+				state: this.currentState,
+				timestamp: now,
+				...description !== void 0 ? { description } : {}
+			});
+			if (this.undoStack.length > this.maxEntries) this.undoStack = this.undoStack.slice(this.undoStack.length - this.maxEntries);
+		}
+		this.redoStack = [];
+		this.currentState = newState;
+		this.lastPushTime = now;
+		this.emit();
+	}
+	/** Undo to the previous state, raising the re-entrancy guard. */
+	undo() {
+		if (this.undoStack.length === 0) return;
+		this.undoRedoActive = true;
+		const prevEntry = this.undoStack.at(-1);
+		if (!prevEntry) return;
+		this.undoStack = this.undoStack.slice(0, -1);
+		this.redoStack = [...this.redoStack, {
+			state: this.currentState,
+			timestamp: Date.now()
+		}];
+		this.currentState = prevEntry.state;
+		this.emit();
+		return prevEntry.state;
+	}
+	/** Redo to the next state, raising the re-entrancy guard. */
+	redo() {
+		if (this.redoStack.length === 0) return;
+		this.undoRedoActive = true;
+		const nextEntry = this.redoStack.at(-1);
+		if (!nextEntry) return;
+		this.redoStack = this.redoStack.slice(0, -1);
+		this.undoStack = [...this.undoStack, {
+			state: this.currentState,
+			timestamp: Date.now()
+		}];
+		this.currentState = nextEntry.state;
+		this.emit();
+		return nextEntry.state;
+	}
+	/**
+	* Lower the undo/redo re-entrancy guard. The adapter calls this once its
+	* render cycle (and the effects it triggered) has flushed, so a follow-up
+	* edit records a fresh entry again.
+	*/
+	endUndoRedo() {
+		this.undoRedoActive = false;
+	}
+	/** Clear both stacks, keeping the current state. */
+	clear() {
+		this.undoStack = [];
+		this.redoStack = [];
+		this.emit();
+	}
+	/** Reset to the initial (or a supplied) state and clear history. */
+	reset(newInitialState) {
+		this.currentState = newInitialState ?? this.initialState;
+		this.undoStack = [];
+		this.redoStack = [];
+		this.lastPushTime = 0;
+		this.emit();
+	}
+	/** Snapshot copy of the undo stack (for debugging/display). */
+	getUndoStack() {
+		return [...this.undoStack];
+	}
+	/** Snapshot copy of the redo stack (for debugging/display). */
+	getRedoStack() {
+		return [...this.redoStack];
+	}
+	/**
+	* Transform every stored state (current + both stacks). Useful for bulk
+	* cleanup such as stripping cached snapshots.
+	*/
+	transformAll(fn) {
+		this.currentState = fn(this.currentState);
+		this.undoStack = this.undoStack.map((entry) => ({
+			...entry,
+			state: fn(entry.state)
+		}));
+		this.redoStack = this.redoStack.map((entry) => ({
+			...entry,
+			state: fn(entry.state)
+		}));
+		this.emit();
+	}
+	emit() {
+		this.setSnapshot({
+			state: this.currentState,
+			canUndo: this.undoStack.length > 0,
+			canRedo: this.redoStack.length > 0,
+			undoCount: this.undoStack.length,
+			redoCount: this.redoStack.length
+		});
+	}
+};
+//#endregion
+export { HistoryManager, classifyHistoryShortcut, defaultHistoryIsEqual };

package/dist/managers/Subscribable.d.ts

@@ -0,0 +1,34 @@
+//#region src/managers/Subscribable.d.ts
+/**
+ * Subscribable Base Class
+ *
+ * Framework-agnostic base for manager classes that need to notify
+ * UI frameworks of state changes.
+ *
+ * Compatible with:
+ * - React: useSyncExternalStore(manager.subscribe, manager.getSnapshot)
+ * - Vue: watchEffect(() => { manager.subscribe(triggerRef) })
+ */
+declare abstract class Subscribable<TSnapshot> {
+  private readonly listeners;
+  private snapshot;
+  constructor(initialSnapshot: TSnapshot);
+  /**
+   * Subscribe to state changes. Returns an unsubscribe function.
+   * Bound method — safe to pass as `useSyncExternalStore(manager.subscribe, ...)`.
+   */
+  subscribe: (listener: () => void) => (() => void);
+  /**
+   * Get the current snapshot. Returns a stable reference unless state has changed.
+   * Bound method — safe to pass as `useSyncExternalStore(..., manager.getSnapshot)`.
+   */
+  getSnapshot: () => TSnapshot;
+  /**
+   * Update the snapshot and notify all subscribers.
+   * Subclasses should call this whenever their state changes.
+   */
+  protected setSnapshot(snapshot: TSnapshot): void;
+  private notify;
+}
+//#endregion
+export { Subscribable };

package/dist/managers/Subscribable.js

@@ -0,0 +1,46 @@
+//#region src/managers/Subscribable.ts
+/**
+* Subscribable Base Class
+*
+* Framework-agnostic base for manager classes that need to notify
+* UI frameworks of state changes.
+*
+* Compatible with:
+* - React: useSyncExternalStore(manager.subscribe, manager.getSnapshot)
+* - Vue: watchEffect(() => { manager.subscribe(triggerRef) })
+*/
+var Subscribable = class {
+	listeners = /* @__PURE__ */ new Set();
+	snapshot;
+	constructor(initialSnapshot) {
+		this.snapshot = initialSnapshot;
+	}
+	/**
+	* Subscribe to state changes. Returns an unsubscribe function.
+	* Bound method — safe to pass as `useSyncExternalStore(manager.subscribe, ...)`.
+	*/
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	/**
+	* Get the current snapshot. Returns a stable reference unless state has changed.
+	* Bound method — safe to pass as `useSyncExternalStore(..., manager.getSnapshot)`.
+	*/
+	getSnapshot = () => this.snapshot;
+	/**
+	* Update the snapshot and notify all subscribers.
+	* Subclasses should call this whenever their state changes.
+	*/
+	setSnapshot(snapshot) {
+		this.snapshot = snapshot;
+		this.notify();
+	}
+	notify() {
+		for (const listener of this.listeners) listener();
+	}
+};
+//#endregion
+export { Subscribable };

package/dist/managers/TableSelectionManager.d.ts

@@ -0,0 +1,74 @@
+import { document_d_exports } from "../types/document.js";
+import { Subscribable } from "./Subscribable.js";
+import { CellCoordinates } from "./types.js";
+import { TableAction, TableContext } from "../utils/tableOperations.js";
+
+//#region src/managers/TableSelectionManager.d.ts
+/** Data attributes for table elements in the rendered DOM */
+declare const TABLE_DATA_ATTRIBUTES: {
+  readonly TABLE_INDEX: "data-table-index";
+  readonly ROW_INDEX: "data-row";
+  readonly COLUMN_INDEX: "data-col";
+  readonly TABLE_CELL: "data-table-cell";
+};
+/**
+ * Find table cell coordinates from a click target by walking up the DOM
+ * and reading data attributes.
+ */
+declare function findTableFromClick(target: EventTarget | null, container?: HTMLElement | null): CellCoordinates | null;
+/** Get a table from the document by index. */
+declare function getTableFromDocument(doc: document_d_exports.Document, tableIndex: number): document_d_exports.Table | null;
+/** Update a table in the document immutably. */
+declare function updateTableInDocument(doc: document_d_exports.Document, tableIndex: number, newTable: document_d_exports.Table): document_d_exports.Document;
+/** Delete a table from the document immutably. */
+declare function deleteTableFromDocument(doc: document_d_exports.Document, tableIndex: number): document_d_exports.Document;
+/**
+ * Tracked table-selection state: the selected cell coordinates plus the derived
+ * {@link TableContext} (and the resolved table) for the current document.
+ */
+type TableSelectionState = {
+  context: TableContext | null;
+  table: document_d_exports.Table | null;
+  tableIndex: number | null;
+  rowIndex: number | null;
+  columnIndex: number | null;
+};
+/**
+ * Outcome of dispatching a structural {@link TableAction} against a document.
+ *  - `noop`: nothing to apply here (no live selection, or a border/selection
+ *    action that the toolbar handles directly).
+ *  - `deleted`: the table was removed and the selection cleared.
+ *  - `updated`: the table was mutated; the selection now tracks the new table.
+ */
+type TableActionResult = {
+  type: "noop";
+} | {
+  type: "deleted";
+  document: document_d_exports.Document;
+} | {
+  type: "updated";
+  document: document_d_exports.Document;
+  context: TableContext;
+};
+declare class TableSelectionManager extends Subscribable<TableSelectionState> {
+  constructor();
+  /**
+   * Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
+   * derives the full {@link TableContext}. Returns the context, or `null` (and
+   * clears the selection) when that table no longer exists.
+   */
+  selectCell(doc: document_d_exports.Document, coords: CellCoordinates): TableContext | null;
+  /** Clear the current selection. */
+  clearSelection(): void;
+  /** Check if a specific cell is the current selection. */
+  isCellSelected(tableIndex: number, rowIndex: number, columnIndex: number): boolean;
+  /**
+   * Dispatch a structural table action against `doc`. Mutating actions
+   * (add/delete row or column, merge, split, delete table) return the resulting
+   * document and re-track the selection against it; border-style and selection
+   * actions are routed through the toolbar's own handlers and resolve to `noop`.
+   */
+  handleAction(doc: document_d_exports.Document, action: TableAction): TableActionResult;
+}
+//#endregion
+export { TABLE_DATA_ATTRIBUTES, TableActionResult, TableSelectionManager, TableSelectionState, deleteTableFromDocument, findTableFromClick, getTableFromDocument, updateTableInDocument };

package/dist/managers/TableSelectionManager.js

@@ -0,0 +1,225 @@
+import { Subscribable } from "./Subscribable.js";
+import { addColumn, addRow, createTableContext, deleteColumn, deleteRow, getColumnCount, mergeCells, splitCell } from "../utils/tableOperations.js";
+//#region src/managers/TableSelectionManager.ts
+/** Data attributes for table elements in the rendered DOM */
+const TABLE_DATA_ATTRIBUTES = {
+	TABLE_INDEX: "data-table-index",
+	ROW_INDEX: "data-row",
+	COLUMN_INDEX: "data-col",
+	TABLE_CELL: "data-table-cell"
+};
+/**
+* Find table cell coordinates from a click target by walking up the DOM
+* and reading data attributes.
+*/
+function findTableFromClick(target, container) {
+	if (!(target instanceof Element)) return null;
+	let current = target;
+	while (current && current !== container) {
+		if (current.tagName === "TD" || current.tagName === "TH") {
+			const rowAttr = current.getAttribute(TABLE_DATA_ATTRIBUTES.ROW_INDEX);
+			const colAttr = current.getAttribute(TABLE_DATA_ATTRIBUTES.COLUMN_INDEX);
+			if (rowAttr !== null && colAttr !== null) {
+				let tableElement = current;
+				while (tableElement && tableElement !== container) {
+					if (tableElement.tagName === "TABLE") {
+						const tableIndexAttr = tableElement.getAttribute(TABLE_DATA_ATTRIBUTES.TABLE_INDEX);
+						if (tableIndexAttr !== null) return {
+							tableIndex: Number.parseInt(tableIndexAttr, 10),
+							rowIndex: Number.parseInt(rowAttr, 10),
+							columnIndex: Number.parseInt(colAttr, 10)
+						};
+						break;
+					}
+					tableElement = tableElement.parentElement;
+				}
+			}
+			break;
+		}
+		current = current.parentElement;
+	}
+	return null;
+}
+/** Get a table from the document by index. */
+function getTableFromDocument(doc, tableIndex) {
+	let currentTableIndex = 0;
+	for (const block of doc.package.document.content) if (block.type === "table") {
+		if (currentTableIndex === tableIndex) return block;
+		currentTableIndex++;
+	}
+	return null;
+}
+/** Update a table in the document immutably. */
+function updateTableInDocument(doc, tableIndex, newTable) {
+	let currentTableIndex = 0;
+	const newContent = doc.package.document.content.map((block) => {
+		if (block.type === "table") {
+			if (currentTableIndex === tableIndex) {
+				currentTableIndex++;
+				return newTable;
+			}
+			currentTableIndex++;
+		}
+		return block;
+	});
+	return {
+		...doc,
+		package: {
+			...doc.package,
+			document: {
+				...doc.package.document,
+				content: newContent
+			}
+		}
+	};
+}
+/** Delete a table from the document immutably. */
+function deleteTableFromDocument(doc, tableIndex) {
+	let currentTableIndex = 0;
+	const newContent = doc.package.document.content.filter((block) => {
+		if (block.type === "table") {
+			const shouldDelete = currentTableIndex === tableIndex;
+			currentTableIndex++;
+			return !shouldDelete;
+		}
+		return true;
+	});
+	return {
+		...doc,
+		package: {
+			...doc.package,
+			document: {
+				...doc.package.document,
+				content: newContent
+			}
+		}
+	};
+}
+const EMPTY_SELECTION = {
+	context: null,
+	table: null,
+	tableIndex: null,
+	rowIndex: null,
+	columnIndex: null
+};
+var TableSelectionManager = class extends Subscribable {
+	constructor() {
+		super(EMPTY_SELECTION);
+	}
+	/**
+	* Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
+	* derives the full {@link TableContext}. Returns the context, or `null` (and
+	* clears the selection) when that table no longer exists.
+	*/
+	selectCell(doc, coords) {
+		const table = getTableFromDocument(doc, coords.tableIndex);
+		if (!table) {
+			this.setSnapshot(EMPTY_SELECTION);
+			return null;
+		}
+		const context = createTableContext(table, {
+			tableIndex: coords.tableIndex,
+			rowIndex: coords.rowIndex,
+			columnIndex: coords.columnIndex
+		});
+		this.setSnapshot({
+			context,
+			table,
+			tableIndex: coords.tableIndex,
+			rowIndex: coords.rowIndex,
+			columnIndex: coords.columnIndex
+		});
+		return context;
+	}
+	/** Clear the current selection. */
+	clearSelection() {
+		this.setSnapshot(EMPTY_SELECTION);
+	}
+	/** Check if a specific cell is the current selection. */
+	isCellSelected(tableIndex, rowIndex, columnIndex) {
+		const snapshot = this.getSnapshot();
+		return snapshot.tableIndex === tableIndex && snapshot.rowIndex === rowIndex && snapshot.columnIndex === columnIndex;
+	}
+	/**
+	* Dispatch a structural table action against `doc`. Mutating actions
+	* (add/delete row or column, merge, split, delete table) return the resulting
+	* document and re-track the selection against it; border-style and selection
+	* actions are routed through the toolbar's own handlers and resolve to `noop`.
+	*/
+	handleAction(doc, action) {
+		const { context, table, tableIndex, rowIndex, columnIndex } = this.getSnapshot();
+		if (context === null || table === null || tableIndex === null || rowIndex === null || columnIndex === null) return { type: "noop" };
+		let newTable = null;
+		let newRowIndex = rowIndex;
+		let newColumnIndex = columnIndex;
+		switch (action) {
+			case "addRowAbove":
+				newTable = addRow(table, rowIndex, "before");
+				newRowIndex = rowIndex + 1;
+				break;
+			case "addRowBelow":
+				newTable = addRow(table, rowIndex, "after");
+				break;
+			case "addColumnLeft":
+				newTable = addColumn(table, columnIndex, "before");
+				newColumnIndex = columnIndex + 1;
+				break;
+			case "addColumnRight":
+				newTable = addColumn(table, columnIndex, "after");
+				break;
+			case "deleteRow":
+				if (table.rows.length > 1) {
+					newTable = deleteRow(table, rowIndex);
+					if (newRowIndex >= newTable.rows.length) newRowIndex = newTable.rows.length - 1;
+				}
+				break;
+			case "deleteColumn":
+				if (getColumnCount(table) > 1) {
+					newTable = deleteColumn(table, columnIndex);
+					const newColCount = getColumnCount(newTable);
+					if (newColumnIndex >= newColCount) newColumnIndex = newColCount - 1;
+				}
+				break;
+			case "mergeCells":
+				if (context.selection.selectedCells) newTable = mergeCells(table, context.selection);
+				break;
+			case "splitCell":
+				if (context.canSplitCell) newTable = splitCell(table, rowIndex, columnIndex);
+				break;
+			case "deleteTable": {
+				const newDoc = deleteTableFromDocument(doc, tableIndex);
+				this.clearSelection();
+				return {
+					type: "deleted",
+					document: newDoc
+				};
+			}
+			case "borderAll":
+			case "borderBottom":
+			case "borderInside":
+			case "borderLeft":
+			case "borderNone":
+			case "borderOutside":
+			case "borderRight":
+			case "borderTop":
+			case "selectColumn":
+			case "selectRow":
+			case "selectTable": break;
+		}
+		if (!newTable) return { type: "noop" };
+		const newDoc = updateTableInDocument(doc, tableIndex, newTable);
+		const nextContext = this.selectCell(newDoc, {
+			tableIndex,
+			rowIndex: newRowIndex,
+			columnIndex: newColumnIndex
+		});
+		if (!nextContext) return { type: "noop" };
+		return {
+			type: "updated",
+			document: newDoc,
+			context: nextContext
+		};
+	}
+};
+//#endregion
+export { TABLE_DATA_ATTRIBUTES, TableSelectionManager, deleteTableFromDocument, findTableFromClick, getTableFromDocument, updateTableInDocument };