@youcan/celeste 0.6.98 → 0.6.99

package/dist/cjs/chunks/menus.cjs

@@ -0,0 +1,1173 @@
+const require_dist = require("./dist.cjs");
+const require_dist$1 = require("./dist2.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/prosemirror-tables@1.7.1/node_modules/prosemirror-tables/dist/index.js
+var readFromCache;
+var addToCache;
+if (typeof WeakMap != "undefined") {
+	let cache = /* @__PURE__ */ new WeakMap();
+	readFromCache = (key) => cache.get(key);
+	addToCache = (key, value) => {
+		cache.set(key, value);
+		return value;
+	};
+} else {
+	const cache = [];
+	const cacheSize = 10;
+	let cachePos = 0;
+	readFromCache = (key) => {
+		for (let i = 0; i < cache.length; i += 2) if (cache[i] == key) return cache[i + 1];
+	};
+	addToCache = (key, value) => {
+		if (cachePos == cacheSize) cachePos = 0;
+		cache[cachePos++] = key;
+		return cache[cachePos++] = value;
+	};
+}
+var TableMap = class {
+	constructor(width, height, map, problems) {
+		this.width = width;
+		this.height = height;
+		this.map = map;
+		this.problems = problems;
+	}
+	findCell(pos) {
+		for (let i = 0; i < this.map.length; i++) {
+			const curPos = this.map[i];
+			if (curPos != pos) continue;
+			const left = i % this.width;
+			const top = i / this.width | 0;
+			let right = left + 1;
+			let bottom = top + 1;
+			for (let j = 1; right < this.width && this.map[i + j] == curPos; j++) right++;
+			for (let j = 1; bottom < this.height && this.map[i + this.width * j] == curPos; j++) bottom++;
+			return {
+				left,
+				top,
+				right,
+				bottom
+			};
+		}
+		throw new RangeError(`No cell with offset ${pos} found`);
+	}
+	colCount(pos) {
+		for (let i = 0; i < this.map.length; i++) if (this.map[i] == pos) return i % this.width;
+		throw new RangeError(`No cell with offset ${pos} found`);
+	}
+	nextCell(pos, axis, dir) {
+		const { left, right, top, bottom } = this.findCell(pos);
+		if (axis == "horiz") {
+			if (dir < 0 ? left == 0 : right == this.width) return null;
+			return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
+		} else {
+			if (dir < 0 ? top == 0 : bottom == this.height) return null;
+			return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
+		}
+	}
+	rectBetween(a, b) {
+		const { left: leftA, right: rightA, top: topA, bottom: bottomA } = this.findCell(a);
+		const { left: leftB, right: rightB, top: topB, bottom: bottomB } = this.findCell(b);
+		return {
+			left: Math.min(leftA, leftB),
+			top: Math.min(topA, topB),
+			right: Math.max(rightA, rightB),
+			bottom: Math.max(bottomA, bottomB)
+		};
+	}
+	cellsInRect(rect) {
+		const result = [];
+		const seen = {};
+		for (let row = rect.top; row < rect.bottom; row++) for (let col = rect.left; col < rect.right; col++) {
+			const index = row * this.width + col;
+			const pos = this.map[index];
+			if (seen[pos]) continue;
+			seen[pos] = true;
+			if (col == rect.left && col && this.map[index - 1] == pos || row == rect.top && row && this.map[index - this.width] == pos) continue;
+			result.push(pos);
+		}
+		return result;
+	}
+	positionAt(row, col, table) {
+		for (let i = 0, rowStart = 0;; i++) {
+			const rowEnd = rowStart + table.child(i).nodeSize;
+			if (i == row) {
+				let index = col + row * this.width;
+				const rowEndIndex = (row + 1) * this.width;
+				while (index < rowEndIndex && this.map[index] < rowStart) index++;
+				return index == rowEndIndex ? rowEnd - 1 : this.map[index];
+			}
+			rowStart = rowEnd;
+		}
+	}
+	static get(table) {
+		return readFromCache(table) || addToCache(table, computeMap(table));
+	}
+};
+function computeMap(table) {
+	if (table.type.spec.tableRole != "table") throw new RangeError("Not a table node: " + table.type.name);
+	const width = findWidth(table), height = table.childCount;
+	const map = [];
+	let mapPos = 0;
+	let problems = null;
+	const colWidths = [];
+	for (let i = 0, e = width * height; i < e; i++) map[i] = 0;
+	for (let row = 0, pos = 0; row < height; row++) {
+		const rowNode = table.child(row);
+		pos++;
+		for (let i = 0;; i++) {
+			while (mapPos < map.length && map[mapPos] != 0) mapPos++;
+			if (i == rowNode.childCount) break;
+			const cellNode = rowNode.child(i);
+			const { colspan, rowspan, colwidth } = cellNode.attrs;
+			for (let h = 0; h < rowspan; h++) {
+				if (h + row >= height) {
+					(problems || (problems = [])).push({
+						type: "overlong_rowspan",
+						pos,
+						n: rowspan - h
+					});
+					break;
+				}
+				const start = mapPos + h * width;
+				for (let w = 0; w < colspan; w++) {
+					if (map[start + w] == 0) map[start + w] = pos;
+					else (problems || (problems = [])).push({
+						type: "collision",
+						row,
+						pos,
+						n: colspan - w
+					});
+					const colW = colwidth && colwidth[w];
+					if (colW) {
+						const widthIndex = (start + w) % width * 2, prev = colWidths[widthIndex];
+						if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {
+							colWidths[widthIndex] = colW;
+							colWidths[widthIndex + 1] = 1;
+						} else if (prev == colW) colWidths[widthIndex + 1]++;
+					}
+				}
+			}
+			mapPos += colspan;
+			pos += cellNode.nodeSize;
+		}
+		const expectedPos = (row + 1) * width;
+		let missing = 0;
+		while (mapPos < expectedPos) if (map[mapPos++] == 0) missing++;
+		if (missing) (problems || (problems = [])).push({
+			type: "missing",
+			row,
+			n: missing
+		});
+		pos++;
+	}
+	if (width === 0 || height === 0) (problems || (problems = [])).push({ type: "zero_sized" });
+	const tableMap = new TableMap(width, height, map, problems);
+	let badWidths = false;
+	for (let i = 0; !badWidths && i < colWidths.length; i += 2) if (colWidths[i] != null && colWidths[i + 1] < height) badWidths = true;
+	if (badWidths) findBadColWidths(tableMap, colWidths, table);
+	return tableMap;
+}
+function findWidth(table) {
+	let width = -1;
+	let hasRowSpan = false;
+	for (let row = 0; row < table.childCount; row++) {
+		const rowNode = table.child(row);
+		let rowWidth = 0;
+		if (hasRowSpan) for (let j = 0; j < row; j++) {
+			const prevRow = table.child(j);
+			for (let i = 0; i < prevRow.childCount; i++) {
+				const cell = prevRow.child(i);
+				if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
+			}
+		}
+		for (let i = 0; i < rowNode.childCount; i++) {
+			const cell = rowNode.child(i);
+			rowWidth += cell.attrs.colspan;
+			if (cell.attrs.rowspan > 1) hasRowSpan = true;
+		}
+		if (width == -1) width = rowWidth;
+		else if (width != rowWidth) width = Math.max(width, rowWidth);
+	}
+	return width;
+}
+function findBadColWidths(map, colWidths, table) {
+	if (!map.problems) map.problems = [];
+	const seen = {};
+	for (let i = 0; i < map.map.length; i++) {
+		const pos = map.map[i];
+		if (seen[pos]) continue;
+		seen[pos] = true;
+		const node = table.nodeAt(pos);
+		if (!node) throw new RangeError(`No cell with offset ${pos} found`);
+		let updated = null;
+		const attrs = node.attrs;
+		for (let j = 0; j < attrs.colspan; j++) {
+			const colWidth = colWidths[(i + j) % map.width * 2];
+			if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth)) (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
+		}
+		if (updated) map.problems.unshift({
+			type: "colwidth mismatch",
+			pos,
+			colwidth: updated
+		});
+	}
+}
+function freshColWidth(attrs) {
+	if (attrs.colwidth) return attrs.colwidth.slice();
+	const result = [];
+	for (let i = 0; i < attrs.colspan; i++) result.push(0);
+	return result;
+}
+function tableNodeTypes(schema) {
+	let result = schema.cached.tableNodeTypes;
+	if (!result) {
+		result = schema.cached.tableNodeTypes = {};
+		for (const name in schema.nodes) {
+			const type = schema.nodes[name], role = type.spec.tableRole;
+			if (role) result[role] = type;
+		}
+	}
+	return result;
+}
+new require_dist$1.PluginKey("selectingCells");
+function cellAround($pos) {
+	for (let d = $pos.depth - 1; d > 0; d--) if ($pos.node(d).type.spec.tableRole == "row") return $pos.node(0).resolve($pos.before(d + 1));
+	return null;
+}
+function isInTable(state) {
+	const $head = state.selection.$head;
+	for (let d = $head.depth; d > 0; d--) if ($head.node(d).type.spec.tableRole == "row") return true;
+	return false;
+}
+function selectionCell(state) {
+	const sel = state.selection;
+	if ("$anchorCell" in sel && sel.$anchorCell) return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
+	else if ("node" in sel && sel.node && sel.node.type.spec.tableRole == "cell") return sel.$anchor;
+	const $cell = cellAround(sel.$head) || cellNear(sel.$head);
+	if ($cell) return $cell;
+	throw new RangeError(`No cell found around position ${sel.head}`);
+}
+function cellNear($pos) {
+	for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
+		const role = after.type.spec.tableRole;
+		if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos);
+	}
+	for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
+		const role = before.type.spec.tableRole;
+		if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos - before.nodeSize);
+	}
+}
+function pointsAtCell($pos) {
+	return $pos.parent.type.spec.tableRole == "row" && !!$pos.nodeAfter;
+}
+function inSameTable($cellA, $cellB) {
+	return $cellA.depth == $cellB.depth && $cellA.pos >= $cellB.start(-1) && $cellA.pos <= $cellB.end(-1);
+}
+function nextCell($pos, axis, dir) {
+	const table = $pos.node(-1);
+	const map = TableMap.get(table);
+	const tableStart = $pos.start(-1);
+	const moved = map.nextCell($pos.pos - tableStart, axis, dir);
+	return moved == null ? null : $pos.node(0).resolve(tableStart + moved);
+}
+function removeColSpan(attrs, pos, n = 1) {
+	const result = {
+		...attrs,
+		colspan: attrs.colspan - n
+	};
+	if (result.colwidth) {
+		result.colwidth = result.colwidth.slice();
+		result.colwidth.splice(pos, n);
+		if (!result.colwidth.some((w) => w > 0)) result.colwidth = null;
+	}
+	return result;
+}
+var CellSelection = class _CellSelection extends require_dist$1.Selection {
+	constructor($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const rect = map.rectBetween($anchorCell.pos - tableStart, $headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - tableStart);
+		cells.unshift($headCell.pos - tableStart);
+		const ranges = cells.map((pos) => {
+			const cell = table.nodeAt(pos);
+			if (!cell) throw RangeError(`No cell with offset ${pos} found`);
+			const from = tableStart + pos + 1;
+			return new require_dist$1.SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
+		});
+		super(ranges[0].$from, ranges[0].$to, ranges);
+		this.$anchorCell = $anchorCell;
+		this.$headCell = $headCell;
+	}
+	map(doc, mapping) {
+		const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
+		const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
+		if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
+			const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);
+			if (tableChanged && this.isRowSelection()) return _CellSelection.rowSelection($anchorCell, $headCell);
+			else if (tableChanged && this.isColSelection()) return _CellSelection.colSelection($anchorCell, $headCell);
+			else return new _CellSelection($anchorCell, $headCell);
+		}
+		return require_dist$1.TextSelection.between($anchorCell, $headCell);
+	}
+	content() {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const rect = map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart);
+		const seen = {};
+		const rows = [];
+		for (let row = rect.top; row < rect.bottom; row++) {
+			const rowContent = [];
+			for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
+				const pos = map.map[index];
+				if (seen[pos]) continue;
+				seen[pos] = true;
+				const cellRect = map.findCell(pos);
+				let cell = table.nodeAt(pos);
+				if (!cell) throw RangeError(`No cell with offset ${pos} found`);
+				const extraLeft = rect.left - cellRect.left;
+				const extraRight = cellRect.right - rect.right;
+				if (extraLeft > 0 || extraRight > 0) {
+					let attrs = cell.attrs;
+					if (extraLeft > 0) attrs = removeColSpan(attrs, 0, extraLeft);
+					if (extraRight > 0) attrs = removeColSpan(attrs, attrs.colspan - extraRight, extraRight);
+					if (cellRect.left < rect.left) {
+						cell = cell.type.createAndFill(attrs);
+						if (!cell) throw RangeError(`Could not create cell with attrs ${JSON.stringify(attrs)}`);
+					} else cell = cell.type.create(attrs, cell.content);
+				}
+				if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
+					const attrs = {
+						...cell.attrs,
+						rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)
+					};
+					if (cellRect.top < rect.top) cell = cell.type.createAndFill(attrs);
+					else cell = cell.type.create(attrs, cell.content);
+				}
+				rowContent.push(cell);
+			}
+			rows.push(table.child(row).copy(require_dist$1.Fragment.from(rowContent)));
+		}
+		const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
+		return new require_dist$1.Slice(require_dist$1.Fragment.from(fragment), 1, 1);
+	}
+	replace(tr, content = require_dist$1.Slice.empty) {
+		const mapFrom = tr.steps.length, ranges = this.ranges;
+		for (let i = 0; i < ranges.length; i++) {
+			const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+			tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? require_dist$1.Slice.empty : content);
+		}
+		const sel = require_dist$1.Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
+		if (sel) tr.setSelection(sel);
+	}
+	replaceWith(tr, node) {
+		this.replace(tr, new require_dist$1.Slice(require_dist$1.Fragment.from(node), 0, 0));
+	}
+	forEachCell(f) {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart));
+		for (let i = 0; i < cells.length; i++) f(table.nodeAt(cells[i]), tableStart + cells[i]);
+	}
+	isColSelection() {
+		const anchorTop = this.$anchorCell.index(-1);
+		const headTop = this.$headCell.index(-1);
+		if (Math.min(anchorTop, headTop) > 0) return false;
+		const anchorBottom = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
+		const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;
+		return Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount;
+	}
+	static colSelection($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const anchorRect = map.findCell($anchorCell.pos - tableStart);
+		const headRect = map.findCell($headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		if (anchorRect.top <= headRect.top) {
+			if (anchorRect.top > 0) $anchorCell = doc.resolve(tableStart + map.map[anchorRect.left]);
+			if (headRect.bottom < map.height) $headCell = doc.resolve(tableStart + map.map[map.width * (map.height - 1) + headRect.right - 1]);
+		} else {
+			if (headRect.top > 0) $headCell = doc.resolve(tableStart + map.map[headRect.left]);
+			if (anchorRect.bottom < map.height) $anchorCell = doc.resolve(tableStart + map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
+		}
+		return new _CellSelection($anchorCell, $headCell);
+	}
+	isRowSelection() {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const anchorLeft = map.colCount(this.$anchorCell.pos - tableStart);
+		const headLeft = map.colCount(this.$headCell.pos - tableStart);
+		if (Math.min(anchorLeft, headLeft) > 0) return false;
+		const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
+		const headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;
+		return Math.max(anchorRight, headRight) == map.width;
+	}
+	eq(other) {
+		return other instanceof _CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
+	}
+	static rowSelection($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const anchorRect = map.findCell($anchorCell.pos - tableStart);
+		const headRect = map.findCell($headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		if (anchorRect.left <= headRect.left) {
+			if (anchorRect.left > 0) $anchorCell = doc.resolve(tableStart + map.map[anchorRect.top * map.width]);
+			if (headRect.right < map.width) $headCell = doc.resolve(tableStart + map.map[map.width * (headRect.top + 1) - 1]);
+		} else {
+			if (headRect.left > 0) $headCell = doc.resolve(tableStart + map.map[headRect.top * map.width]);
+			if (anchorRect.right < map.width) $anchorCell = doc.resolve(tableStart + map.map[map.width * (anchorRect.top + 1) - 1]);
+		}
+		return new _CellSelection($anchorCell, $headCell);
+	}
+	toJSON() {
+		return {
+			type: "cell",
+			anchor: this.$anchorCell.pos,
+			head: this.$headCell.pos
+		};
+	}
+	static fromJSON(doc, json) {
+		return new _CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+	}
+	static create(doc, anchorCell, headCell = anchorCell) {
+		return new _CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
+	}
+	getBookmark() {
+		return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+	}
+};
+CellSelection.prototype.visible = false;
+require_dist$1.Selection.jsonID("cell", CellSelection);
+var CellBookmark = class _CellBookmark {
+	constructor(anchor, head) {
+		this.anchor = anchor;
+		this.head = head;
+	}
+	map(mapping) {
+		return new _CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+	}
+	resolve(doc) {
+		const $anchorCell = doc.resolve(this.anchor), $headCell = doc.resolve(this.head);
+		if ($anchorCell.parent.type.spec.tableRole == "row" && $headCell.parent.type.spec.tableRole == "row" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell)) return new CellSelection($anchorCell, $headCell);
+		else return require_dist$1.Selection.near($headCell, 1);
+	}
+};
+new require_dist$1.PluginKey("fix-tables");
+function selectedRect(state) {
+	const sel = state.selection;
+	const $pos = selectionCell(state);
+	const table = $pos.node(-1);
+	const tableStart = $pos.start(-1);
+	const map = TableMap.get(table);
+	return {
+		...sel instanceof CellSelection ? map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart) : map.findCell($pos.pos - tableStart),
+		tableStart,
+		map,
+		table
+	};
+}
+function deprecated_toggleHeader(type) {
+	return function(state, dispatch) {
+		if (!isInTable(state)) return false;
+		if (dispatch) {
+			const types = tableNodeTypes(state.schema);
+			const rect = selectedRect(state), tr = state.tr;
+			const cells = rect.map.cellsInRect(type == "column" ? {
+				left: rect.left,
+				top: 0,
+				right: rect.right,
+				bottom: rect.map.height
+			} : type == "row" ? {
+				left: 0,
+				top: rect.top,
+				right: rect.map.width,
+				bottom: rect.bottom
+			} : rect);
+			const nodes = cells.map((pos) => rect.table.nodeAt(pos));
+			for (let i = 0; i < cells.length; i++) if (nodes[i].type == types.header_cell) tr.setNodeMarkup(rect.tableStart + cells[i], types.cell, nodes[i].attrs);
+			if (tr.steps.length == 0) for (let i = 0; i < cells.length; i++) tr.setNodeMarkup(rect.tableStart + cells[i], types.header_cell, nodes[i].attrs);
+			dispatch(tr);
+		}
+		return true;
+	};
+}
+function isHeaderEnabledByType(type, rect, types) {
+	const cellPositions = rect.map.cellsInRect({
+		left: 0,
+		top: 0,
+		right: type == "row" ? rect.map.width : 1,
+		bottom: type == "column" ? rect.map.height : 1
+	});
+	for (let i = 0; i < cellPositions.length; i++) {
+		const cell = rect.table.nodeAt(cellPositions[i]);
+		if (cell && cell.type !== types.header_cell) return false;
+	}
+	return true;
+}
+function toggleHeader(type, options) {
+	options = options || { useDeprecatedLogic: false };
+	if (options.useDeprecatedLogic) return deprecated_toggleHeader(type);
+	return function(state, dispatch) {
+		if (!isInTable(state)) return false;
+		if (dispatch) {
+			const types = tableNodeTypes(state.schema);
+			const rect = selectedRect(state), tr = state.tr;
+			const isHeaderRowEnabled = isHeaderEnabledByType("row", rect, types);
+			const isHeaderColumnEnabled = isHeaderEnabledByType("column", rect, types);
+			const selectionStartsAt = (type === "column" ? isHeaderRowEnabled : type === "row" ? isHeaderColumnEnabled : false) ? 1 : 0;
+			const cellsRect = type == "column" ? {
+				left: 0,
+				top: selectionStartsAt,
+				right: 1,
+				bottom: rect.map.height
+			} : type == "row" ? {
+				left: selectionStartsAt,
+				top: 0,
+				right: rect.map.width,
+				bottom: 1
+			} : rect;
+			const newType = type == "column" ? isHeaderColumnEnabled ? types.cell : types.header_cell : type == "row" ? isHeaderRowEnabled ? types.cell : types.header_cell : types.cell;
+			rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {
+				const cellPos = relativeCellPos + rect.tableStart;
+				const cell = tr.doc.nodeAt(cellPos);
+				if (cell) tr.setNodeMarkup(cellPos, newType, cell.attrs);
+			});
+			dispatch(tr);
+		}
+		return true;
+	};
+}
+toggleHeader("row", { useDeprecatedLogic: true });
+toggleHeader("column", { useDeprecatedLogic: true });
+toggleHeader("cell", { useDeprecatedLogic: true });
+function deleteCellSelection(state, dispatch) {
+	const sel = state.selection;
+	if (!(sel instanceof CellSelection)) return false;
+	if (dispatch) {
+		const tr = state.tr;
+		const baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;
+		sel.forEachCell((cell, pos) => {
+			if (!cell.content.eq(baseContent)) tr.replace(tr.mapping.map(pos + 1), tr.mapping.map(pos + cell.nodeSize - 1), new require_dist$1.Slice(baseContent, 0, 0));
+		});
+		if (tr.docChanged) dispatch(tr);
+	}
+	return true;
+}
+require_dist$1.keydownHandler({
+	ArrowLeft: arrow("horiz", -1),
+	ArrowRight: arrow("horiz", 1),
+	ArrowUp: arrow("vert", -1),
+	ArrowDown: arrow("vert", 1),
+	"Shift-ArrowLeft": shiftArrow("horiz", -1),
+	"Shift-ArrowRight": shiftArrow("horiz", 1),
+	"Shift-ArrowUp": shiftArrow("vert", -1),
+	"Shift-ArrowDown": shiftArrow("vert", 1),
+	Backspace: deleteCellSelection,
+	"Mod-Backspace": deleteCellSelection,
+	Delete: deleteCellSelection,
+	"Mod-Delete": deleteCellSelection
+});
+function maybeSetSelection(state, dispatch, selection) {
+	if (selection.eq(state.selection)) return false;
+	if (dispatch) dispatch(state.tr.setSelection(selection).scrollIntoView());
+	return true;
+}
+function arrow(axis, dir) {
+	return (state, dispatch, view) => {
+		if (!view) return false;
+		const sel = state.selection;
+		if (sel instanceof CellSelection) return maybeSetSelection(state, dispatch, require_dist$1.Selection.near(sel.$headCell, dir));
+		if (axis != "horiz" && !sel.empty) return false;
+		const end = atEndOfCell(view, axis, dir);
+		if (end == null) return false;
+		if (axis == "horiz") return maybeSetSelection(state, dispatch, require_dist$1.Selection.near(state.doc.resolve(sel.head + dir), dir));
+		else {
+			const $cell = state.doc.resolve(end);
+			const $next = nextCell($cell, axis, dir);
+			let newSel;
+			if ($next) newSel = require_dist$1.Selection.near($next, 1);
+			else if (dir < 0) newSel = require_dist$1.Selection.near(state.doc.resolve($cell.before(-1)), -1);
+			else newSel = require_dist$1.Selection.near(state.doc.resolve($cell.after(-1)), 1);
+			return maybeSetSelection(state, dispatch, newSel);
+		}
+	};
+}
+function shiftArrow(axis, dir) {
+	return (state, dispatch, view) => {
+		if (!view) return false;
+		const sel = state.selection;
+		let cellSel;
+		if (sel instanceof CellSelection) cellSel = sel;
+		else {
+			const end = atEndOfCell(view, axis, dir);
+			if (end == null) return false;
+			cellSel = new CellSelection(state.doc.resolve(end));
+		}
+		const $head = nextCell(cellSel.$headCell, axis, dir);
+		if (!$head) return false;
+		return maybeSetSelection(state, dispatch, new CellSelection(cellSel.$anchorCell, $head));
+	};
+}
+function atEndOfCell(view, axis, dir) {
+	if (!(view.state.selection instanceof require_dist$1.TextSelection)) return null;
+	const { $head } = view.state.selection;
+	for (let d = $head.depth - 1; d >= 0; d--) {
+		const parent = $head.node(d);
+		if ((dir < 0 ? $head.index(d) : $head.indexAfter(d)) != (dir < 0 ? 0 : parent.childCount)) return null;
+		if (parent.type.spec.tableRole == "cell" || parent.type.spec.tableRole == "header_cell") {
+			const cellPos = $head.before(d);
+			const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
+			return view.endOfTextblock(dirStr) ? cellPos : null;
+		}
+	}
+	return null;
+}
+new require_dist$1.PluginKey("tableColumnResizing");
+//#endregion
+//#region ../../node_modules/.pnpm/@tiptap+vue-3@3.11.0_@floating-ui+dom@1.6.13_@tiptap+core@3.11.0_@tiptap+pm@3.11.0__@tiptap+p_6dhb34rvoqevq5xeb47hxntupe/node_modules/@tiptap/vue-3/dist/menus/index.js
+function combineDOMRects(rect1, rect2) {
+	const top = Math.min(rect1.top, rect2.top);
+	const bottom = Math.max(rect1.bottom, rect2.bottom);
+	const left = Math.min(rect1.left, rect2.left);
+	const width = Math.max(rect1.right, rect2.right) - left;
+	const height = bottom - top;
+	return new DOMRect(left, top, width, height);
+}
+var BubbleMenuView = class {
+	constructor({ editor, element, view, updateDelay = 250, resizeDelay = 60, shouldShow, appendTo, getReferencedVirtualElement, options }) {
+		this.preventHide = false;
+		this.isVisible = false;
+		this.scrollTarget = window;
+		this.floatingUIOptions = {
+			strategy: "absolute",
+			placement: "top",
+			offset: 8,
+			flip: {},
+			shift: {},
+			arrow: false,
+			size: false,
+			autoPlacement: false,
+			hide: false,
+			inline: false,
+			onShow: void 0,
+			onHide: void 0,
+			onUpdate: void 0,
+			onDestroy: void 0
+		};
+		this.shouldShow = ({ view, state, from, to }) => {
+			const { doc, selection } = state;
+			const { empty } = selection;
+			const isEmptyTextBlock = !doc.textBetween(from, to).length && require_dist$1.isTextSelection(state.selection);
+			const isChildOfMenu = this.element.contains(document.activeElement);
+			if (!(view.hasFocus() || isChildOfMenu) || empty || isEmptyTextBlock || !this.editor.isEditable) return false;
+			return true;
+		};
+		this.mousedownHandler = () => {
+			this.preventHide = true;
+		};
+		this.dragstartHandler = () => {
+			this.hide();
+		};
+		/**
+		* Handles the window resize event to update the position of the bubble menu.
+		* It uses a debounce mechanism to prevent excessive updates.
+		* The delay is defined by the `resizeDelay` property.
+		*/
+		this.resizeHandler = () => {
+			if (this.resizeDebounceTimer) clearTimeout(this.resizeDebounceTimer);
+			this.resizeDebounceTimer = window.setTimeout(() => {
+				this.updatePosition();
+			}, this.resizeDelay);
+		};
+		this.focusHandler = () => {
+			setTimeout(() => this.update(this.editor.view));
+		};
+		this.blurHandler = ({ event }) => {
+			var _a;
+			if (this.editor.isDestroyed) {
+				this.destroy();
+				return;
+			}
+			if (this.preventHide) {
+				this.preventHide = false;
+				return;
+			}
+			if ((event == null ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) == null ? void 0 : _a.contains(event.relatedTarget))) return;
+			if ((event == null ? void 0 : event.relatedTarget) === this.editor.view.dom) return;
+			this.hide();
+		};
+		this.handleDebouncedUpdate = (view, oldState) => {
+			const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view.state.selection));
+			const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view.state.doc));
+			if (!selectionChanged && !docChanged) return;
+			if (this.updateDebounceTimer) clearTimeout(this.updateDebounceTimer);
+			this.updateDebounceTimer = window.setTimeout(() => {
+				this.updateHandler(view, selectionChanged, docChanged, oldState);
+			}, this.updateDelay);
+		};
+		this.updateHandler = (view, selectionChanged, docChanged, oldState) => {
+			const { composing } = view;
+			if (composing || !selectionChanged && !docChanged) return;
+			if (!this.getShouldShow(oldState)) {
+				this.hide();
+				return;
+			}
+			this.updatePosition();
+			this.show();
+		};
+		this.transactionHandler = ({ transaction: tr }) => {
+			if (tr.getMeta("bubbleMenu") === "updatePosition") this.updatePosition();
+		};
+		var _a;
+		this.editor = editor;
+		this.element = element;
+		this.view = view;
+		this.updateDelay = updateDelay;
+		this.resizeDelay = resizeDelay;
+		this.appendTo = appendTo;
+		this.scrollTarget = (_a = options == null ? void 0 : options.scrollTarget) != null ? _a : window;
+		this.getReferencedVirtualElement = getReferencedVirtualElement;
+		this.floatingUIOptions = {
+			...this.floatingUIOptions,
+			...options
+		};
+		this.element.tabIndex = 0;
+		if (shouldShow) this.shouldShow = shouldShow;
+		this.element.addEventListener("mousedown", this.mousedownHandler, { capture: true });
+		this.view.dom.addEventListener("dragstart", this.dragstartHandler);
+		this.editor.on("focus", this.focusHandler);
+		this.editor.on("blur", this.blurHandler);
+		this.editor.on("transaction", this.transactionHandler);
+		window.addEventListener("resize", this.resizeHandler);
+		this.scrollTarget.addEventListener("scroll", this.resizeHandler);
+		this.update(view, view.state);
+		if (this.getShouldShow()) {
+			this.show();
+			this.updatePosition();
+		}
+	}
+	get middlewares() {
+		const middlewares = [];
+		if (this.floatingUIOptions.flip) middlewares.push(require_dist.flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
+		if (this.floatingUIOptions.shift) middlewares.push(require_dist.shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0));
+		if (this.floatingUIOptions.offset) middlewares.push(require_dist.offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0));
+		if (this.floatingUIOptions.arrow) middlewares.push(require_dist.arrow(this.floatingUIOptions.arrow));
+		if (this.floatingUIOptions.size) middlewares.push(require_dist.size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
+		if (this.floatingUIOptions.autoPlacement) middlewares.push(require_dist.autoPlacement(typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0));
+		if (this.floatingUIOptions.hide) middlewares.push(require_dist.hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
+		if (this.floatingUIOptions.inline) middlewares.push(require_dist.inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0));
+		return middlewares;
+	}
+	get virtualElement() {
+		var _a;
+		const { selection } = this.editor.state;
+		const referencedVirtualElement = (_a = this.getReferencedVirtualElement) == null ? void 0 : _a.call(this);
+		if (referencedVirtualElement) return referencedVirtualElement;
+		const domRect = require_dist$1.posToDOMRect(this.view, selection.from, selection.to);
+		let virtualElement = {
+			getBoundingClientRect: () => domRect,
+			getClientRects: () => [domRect]
+		};
+		if (selection instanceof require_dist$1.NodeSelection) {
+			let node = this.view.nodeDOM(selection.from);
+			const nodeViewWrapper = node.dataset.nodeViewWrapper ? node : node.querySelector("[data-node-view-wrapper]");
+			if (nodeViewWrapper) node = nodeViewWrapper;
+			if (node) virtualElement = {
+				getBoundingClientRect: () => node.getBoundingClientRect(),
+				getClientRects: () => [node.getBoundingClientRect()]
+			};
+		}
+		if (selection instanceof CellSelection) {
+			const { $anchorCell, $headCell } = selection;
+			const from = $anchorCell ? $anchorCell.pos : $headCell.pos;
+			const to = $headCell ? $headCell.pos : $anchorCell.pos;
+			const fromDOM = this.view.nodeDOM(from);
+			const toDOM = this.view.nodeDOM(to);
+			if (!fromDOM || !toDOM) return;
+			const clientRect = fromDOM === toDOM ? fromDOM.getBoundingClientRect() : combineDOMRects(fromDOM.getBoundingClientRect(), toDOM.getBoundingClientRect());
+			virtualElement = {
+				getBoundingClientRect: () => clientRect,
+				getClientRects: () => [clientRect]
+			};
+		}
+		return virtualElement;
+	}
+	updatePosition() {
+		const virtualElement = this.virtualElement;
+		if (!virtualElement) return;
+		require_dist.computePosition(virtualElement, this.element, {
+			placement: this.floatingUIOptions.placement,
+			strategy: this.floatingUIOptions.strategy,
+			middleware: this.middlewares
+		}).then(({ x, y, strategy }) => {
+			this.element.style.width = "max-content";
+			this.element.style.position = strategy;
+			this.element.style.left = `${x}px`;
+			this.element.style.top = `${y}px`;
+			if (this.isVisible && this.floatingUIOptions.onUpdate) this.floatingUIOptions.onUpdate();
+		});
+	}
+	update(view, oldState) {
+		const { state } = view;
+		const hasValidSelection = state.selection.from !== state.selection.to;
+		if (this.updateDelay > 0 && hasValidSelection) {
+			this.handleDebouncedUpdate(view, oldState);
+			return;
+		}
+		const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view.state.selection));
+		const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view.state.doc));
+		this.updateHandler(view, selectionChanged, docChanged, oldState);
+	}
+	getShouldShow(oldState) {
+		var _a;
+		const { state } = this.view;
+		const { selection } = state;
+		const { ranges } = selection;
+		const from = Math.min(...ranges.map((range) => range.$from.pos));
+		const to = Math.max(...ranges.map((range) => range.$to.pos));
+		return ((_a = this.shouldShow) == null ? void 0 : _a.call(this, {
+			editor: this.editor,
+			element: this.element,
+			view: this.view,
+			state,
+			oldState,
+			from,
+			to
+		})) || false;
+	}
+	show() {
+		var _a;
+		if (this.isVisible) return;
+		this.element.style.visibility = "visible";
+		this.element.style.opacity = "1";
+		const appendToElement = typeof this.appendTo === "function" ? this.appendTo() : this.appendTo;
+		(_a = appendToElement != null ? appendToElement : this.view.dom.parentElement) == null || _a.appendChild(this.element);
+		if (this.floatingUIOptions.onShow) this.floatingUIOptions.onShow();
+		this.isVisible = true;
+	}
+	hide() {
+		if (!this.isVisible) return;
+		this.element.style.visibility = "hidden";
+		this.element.style.opacity = "0";
+		this.element.remove();
+		if (this.floatingUIOptions.onHide) this.floatingUIOptions.onHide();
+		this.isVisible = false;
+	}
+	destroy() {
+		this.hide();
+		this.element.removeEventListener("mousedown", this.mousedownHandler, { capture: true });
+		this.view.dom.removeEventListener("dragstart", this.dragstartHandler);
+		window.removeEventListener("resize", this.resizeHandler);
+		this.scrollTarget.removeEventListener("scroll", this.resizeHandler);
+		this.editor.off("focus", this.focusHandler);
+		this.editor.off("blur", this.blurHandler);
+		this.editor.off("transaction", this.transactionHandler);
+		if (this.floatingUIOptions.onDestroy) this.floatingUIOptions.onDestroy();
+	}
+};
+var BubbleMenuPlugin = (options) => {
+	return new require_dist$1.Plugin({
+		key: typeof options.pluginKey === "string" ? new require_dist$1.PluginKey(options.pluginKey) : options.pluginKey,
+		view: (view) => new BubbleMenuView({
+			view,
+			...options
+		})
+	});
+};
+var BubbleMenu = (0, vue.defineComponent)({
+	name: "BubbleMenu",
+	inheritAttrs: false,
+	props: {
+		pluginKey: {
+			type: [String, Object],
+			default: "bubbleMenu"
+		},
+		editor: {
+			type: Object,
+			required: true
+		},
+		updateDelay: {
+			type: Number,
+			default: void 0
+		},
+		resizeDelay: {
+			type: Number,
+			default: void 0
+		},
+		options: {
+			type: Object,
+			default: () => ({})
+		},
+		appendTo: {
+			type: Object,
+			default: void 0
+		},
+		shouldShow: {
+			type: Function,
+			default: null
+		},
+		getReferencedVirtualElement: {
+			type: Function,
+			default: void 0
+		}
+	},
+	setup(props, { slots, attrs }) {
+		const root = (0, vue.ref)(null);
+		(0, vue.onMounted)(() => {
+			const { editor, options, pluginKey, resizeDelay, appendTo, shouldShow, getReferencedVirtualElement, updateDelay } = props;
+			const el = root.value;
+			if (!el) return;
+			el.style.visibility = "hidden";
+			el.style.position = "absolute";
+			el.remove();
+			(0, vue.nextTick)(() => {
+				editor.registerPlugin(BubbleMenuPlugin({
+					editor,
+					element: el,
+					options,
+					pluginKey,
+					resizeDelay,
+					appendTo,
+					shouldShow,
+					getReferencedVirtualElement,
+					updateDelay
+				}));
+			});
+		});
+		(0, vue.onBeforeUnmount)(() => {
+			const { pluginKey, editor } = props;
+			editor.unregisterPlugin(pluginKey);
+		});
+		return () => {
+			var _a;
+			return (0, vue.h)("div", {
+				ref: root,
+				...attrs
+			}, (_a = slots.default) == null ? void 0 : _a.call(slots));
+		};
+	}
+});
+var FloatingMenuView = class {
+	constructor({ editor, element, view, options, appendTo, shouldShow }) {
+		this.preventHide = false;
+		this.isVisible = false;
+		this.shouldShow = ({ view, state }) => {
+			const { selection } = state;
+			const { $anchor, empty } = selection;
+			const isRootDepth = $anchor.depth === 1;
+			const isEmptyTextBlock = $anchor.parent.isTextblock && !$anchor.parent.type.spec.code && !$anchor.parent.textContent && $anchor.parent.childCount === 0 && !this.getTextContent($anchor.parent);
+			if (!view.hasFocus() || !empty || !isRootDepth || !isEmptyTextBlock || !this.editor.isEditable) return false;
+			return true;
+		};
+		this.floatingUIOptions = {
+			strategy: "absolute",
+			placement: "right",
+			offset: 8,
+			flip: {},
+			shift: {},
+			arrow: false,
+			size: false,
+			autoPlacement: false,
+			hide: false,
+			inline: false
+		};
+		this.updateHandler = (view, selectionChanged, docChanged, oldState) => {
+			const { composing } = view;
+			if (composing || !selectionChanged && !docChanged) return;
+			if (!this.getShouldShow(oldState)) {
+				this.hide();
+				return;
+			}
+			this.updatePosition();
+			this.show();
+		};
+		this.mousedownHandler = () => {
+			this.preventHide = true;
+		};
+		this.focusHandler = () => {
+			setTimeout(() => this.update(this.editor.view));
+		};
+		this.blurHandler = ({ event }) => {
+			var _a;
+			if (this.preventHide) {
+				this.preventHide = false;
+				return;
+			}
+			if ((event == null ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) == null ? void 0 : _a.contains(event.relatedTarget))) return;
+			if ((event == null ? void 0 : event.relatedTarget) === this.editor.view.dom) return;
+			this.hide();
+		};
+		this.editor = editor;
+		this.element = element;
+		this.view = view;
+		this.appendTo = appendTo;
+		this.floatingUIOptions = {
+			...this.floatingUIOptions,
+			...options
+		};
+		this.element.tabIndex = 0;
+		if (shouldShow) this.shouldShow = shouldShow;
+		this.element.addEventListener("mousedown", this.mousedownHandler, { capture: true });
+		this.editor.on("focus", this.focusHandler);
+		this.editor.on("blur", this.blurHandler);
+		this.update(view, view.state);
+		if (this.getShouldShow()) {
+			this.show();
+			this.updatePosition();
+		}
+	}
+	getTextContent(node) {
+		return require_dist$1.getText(node, { textSerializers: require_dist$1.getTextSerializersFromSchema(this.editor.schema) });
+	}
+	get middlewares() {
+		const middlewares = [];
+		if (this.floatingUIOptions.flip) middlewares.push(require_dist.flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
+		if (this.floatingUIOptions.shift) middlewares.push(require_dist.shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0));
+		if (this.floatingUIOptions.offset) middlewares.push(require_dist.offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0));
+		if (this.floatingUIOptions.arrow) middlewares.push(require_dist.arrow(this.floatingUIOptions.arrow));
+		if (this.floatingUIOptions.size) middlewares.push(require_dist.size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
+		if (this.floatingUIOptions.autoPlacement) middlewares.push(require_dist.autoPlacement(typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0));
+		if (this.floatingUIOptions.hide) middlewares.push(require_dist.hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
+		if (this.floatingUIOptions.inline) middlewares.push(require_dist.inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0));
+		return middlewares;
+	}
+	getShouldShow(oldState) {
+		var _a;
+		const { state } = this.view;
+		const { selection } = state;
+		const { ranges } = selection;
+		const from = Math.min(...ranges.map((range) => range.$from.pos));
+		const to = Math.max(...ranges.map((range) => range.$to.pos));
+		return (_a = this.shouldShow) == null ? void 0 : _a.call(this, {
+			editor: this.editor,
+			view: this.view,
+			state,
+			oldState,
+			from,
+			to
+		});
+	}
+	updatePosition() {
+		const { selection } = this.editor.state;
+		const domRect = require_dist$1.posToDOMRect(this.view, selection.from, selection.to);
+		require_dist.computePosition({
+			getBoundingClientRect: () => domRect,
+			getClientRects: () => [domRect]
+		}, this.element, {
+			placement: this.floatingUIOptions.placement,
+			strategy: this.floatingUIOptions.strategy,
+			middleware: this.middlewares
+		}).then(({ x, y, strategy }) => {
+			this.element.style.width = "max-content";
+			this.element.style.position = strategy;
+			this.element.style.left = `${x}px`;
+			this.element.style.top = `${y}px`;
+			if (this.isVisible && this.floatingUIOptions.onUpdate) this.floatingUIOptions.onUpdate();
+		});
+	}
+	update(view, oldState) {
+		const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view.state.selection));
+		const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view.state.doc));
+		this.updateHandler(view, selectionChanged, docChanged, oldState);
+	}
+	show() {
+		var _a;
+		if (this.isVisible) return;
+		this.element.style.visibility = "visible";
+		this.element.style.opacity = "1";
+		const appendToElement = typeof this.appendTo === "function" ? this.appendTo() : this.appendTo;
+		(_a = appendToElement != null ? appendToElement : this.view.dom.parentElement) == null || _a.appendChild(this.element);
+		if (this.floatingUIOptions.onShow) this.floatingUIOptions.onShow();
+		this.isVisible = true;
+	}
+	hide() {
+		if (!this.isVisible) return;
+		this.element.style.visibility = "hidden";
+		this.element.style.opacity = "0";
+		this.element.remove();
+		if (this.floatingUIOptions.onHide) this.floatingUIOptions.onHide();
+		this.isVisible = false;
+	}
+	destroy() {
+		this.hide();
+		this.element.removeEventListener("mousedown", this.mousedownHandler, { capture: true });
+		this.editor.off("focus", this.focusHandler);
+		this.editor.off("blur", this.blurHandler);
+		if (this.floatingUIOptions.onDestroy) this.floatingUIOptions.onDestroy();
+	}
+};
+var FloatingMenuPlugin = (options) => {
+	return new require_dist$1.Plugin({
+		key: typeof options.pluginKey === "string" ? new require_dist$1.PluginKey(options.pluginKey) : options.pluginKey,
+		view: (view) => new FloatingMenuView({
+			view,
+			...options
+		})
+	});
+};
+(0, vue.defineComponent)({
+	name: "FloatingMenu",
+	inheritAttrs: false,
+	props: {
+		pluginKey: {
+			type: null,
+			default: "floatingMenu"
+		},
+		editor: {
+			type: Object,
+			required: true
+		},
+		options: {
+			type: Object,
+			default: () => ({})
+		},
+		appendTo: {
+			type: Object,
+			default: void 0
+		},
+		shouldShow: {
+			type: Function,
+			default: null
+		}
+	},
+	setup(props, { slots, attrs }) {
+		const root = (0, vue.ref)(null);
+		(0, vue.onMounted)(() => {
+			const { pluginKey, editor, options, appendTo, shouldShow } = props;
+			const el = root.value;
+			if (!el) return;
+			el.style.visibility = "hidden";
+			el.style.position = "absolute";
+			el.remove();
+			editor.registerPlugin(FloatingMenuPlugin({
+				pluginKey,
+				editor,
+				element: el,
+				options,
+				appendTo,
+				shouldShow
+			}));
+		});
+		(0, vue.onBeforeUnmount)(() => {
+			const { pluginKey, editor } = props;
+			editor.unregisterPlugin(pluginKey);
+		});
+		return () => {
+			var _a;
+			return (0, vue.h)("div", {
+				ref: root,
+				...attrs
+			}, (_a = slots.default) == null ? void 0 : _a.call(slots));
+		};
+	}
+});
+//#endregion
+exports.BubbleMenu = BubbleMenu;