slate-vue3 1.0.1 → 1.0.2

package/dist/dom.js

@@ -1,2 +1,2 @@
-import { $ as getSelection, A as CAN_USE_DOM, B as IS_IOS, C as MARK_PLACEHOLDER_SYMBOL, D as NODE_TO_PARENT, E as NODE_TO_KEY, F as IS_CHROME, G as closestShadowAware, H as IS_UC_MOBILE, I as IS_CHROME_LEGACY, J as getClipboardData, K as containsShadowAware, L as IS_EDGE_LEGACY, M as IS_ANDROID, N as IS_ANDROID_CHROME_LEGACY, O as PLACEHOLDER_SYMBOL, P as IS_APPLE, Q as getPlainText, R as IS_FIREFOX, S as IS_READ_ONLY, T as NODE_TO_INDEX, U as IS_WEBKIT, V as IS_SAFARI_LEGACY, W as IS_WECHATBROWSER, X as getEditableChild, Y as getDefaultView, Z as getEditableChildAndIndex, _ as EDITOR_TO_USER_SELECTION, a as Hotkeys, at as isDOMElement, b as IS_COMPOSING, c as withDOM, ct as isDOMText, dt as normalizeDOMPoint, et as getSlateFragmentAttribute, f as DOMEditor, g as EDITOR_TO_USER_MARKS, h as EDITOR_TO_ON_CHANGE, i as splitDecorationsByChild, it as isDOMComment, j as HAS_BEFORE_INPUT_SUPPORT, k as Key, lt as isPlainTextOnlyPaste, m as EDITOR_TO_KEY_TO_ELEMENT, n as isTextDecorationsEqual, nt as isAfter, o as applyStringDiff, ot as isDOMNode, p as EDITOR_TO_ELEMENT, q as getActiveElement, r as shallowCompare, rt as isBefore, s as normalizeStringDiff, st as isDOMSelection, t as isElementDecorationsEqual, tt as hasShadowRoot, ut as isTrackedMutation, v as EDITOR_TO_WINDOW, w as NODE_TO_ELEMENT, x as IS_FOCUSED, y as ELEMENT_TO_NODE, z as IS_FIREFOX_LEGACY } from "./slate-dom-cOXt9FLf.js";
-export { CAN_USE_DOM, DOMEditor, EDITOR_TO_ELEMENT, EDITOR_TO_KEY_TO_ELEMENT, EDITOR_TO_ON_CHANGE, EDITOR_TO_USER_MARKS, EDITOR_TO_USER_SELECTION, EDITOR_TO_WINDOW, ELEMENT_TO_NODE, HAS_BEFORE_INPUT_SUPPORT, Hotkeys, IS_ANDROID, IS_ANDROID_CHROME_LEGACY, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_COMPOSING, IS_EDGE_LEGACY, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_FOCUSED, IS_IOS, IS_READ_ONLY, IS_SAFARI_LEGACY, IS_UC_MOBILE, IS_WEBKIT, IS_WECHATBROWSER, Key, MARK_PLACEHOLDER_SYMBOL, NODE_TO_ELEMENT, NODE_TO_INDEX, NODE_TO_KEY, NODE_TO_PARENT, PLACEHOLDER_SYMBOL, applyStringDiff, closestShadowAware, containsShadowAware, getActiveElement, getClipboardData, getDefaultView, getEditableChild, getEditableChildAndIndex, getPlainText, getSelection, getSlateFragmentAttribute, hasShadowRoot, isAfter, isBefore, isDOMComment, isDOMElement, isDOMNode, isDOMSelection, isDOMText, isElementDecorationsEqual, isPlainTextOnlyPaste, isTextDecorationsEqual, isTrackedMutation, normalizeDOMPoint, normalizeStringDiff, shallowCompare, splitDecorationsByChild, withDOM };
+import { $ as getSelection, A as CAN_USE_DOM, B as IS_IOS, C as MARK_PLACEHOLDER_SYMBOL, D as NODE_TO_PARENT, E as NODE_TO_KEY, F as IS_CHROME, G as closestShadowAware, H as IS_UC_MOBILE, I as IS_CHROME_LEGACY, J as getClipboardData, K as containsShadowAware, L as IS_EDGE_LEGACY, M as IS_ANDROID, N as IS_ANDROID_CHROME_LEGACY, O as PLACEHOLDER_SYMBOL, P as IS_APPLE, Q as getPlainText, R as IS_FIREFOX, S as IS_READ_ONLY, T as NODE_TO_INDEX, U as IS_WEBKIT, V as IS_SAFARI_LEGACY, W as IS_WECHATBROWSER, X as getEditableChild, Y as getDefaultView, Z as getEditableChildAndIndex, _ as EDITOR_TO_USER_SELECTION, a as isTextDecorationsEqual, at as isDOMElement, b as IS_COMPOSING, c as Hotkeys, ct as isDOMText, d as withDOM, dt as normalizeDOMPoint, et as getSlateFragmentAttribute, f as DOMEditor, g as EDITOR_TO_USER_MARKS, h as EDITOR_TO_ON_CHANGE, i as isElementDecorationsEqual, it as isDOMComment, j as HAS_BEFORE_INPUT_SUPPORT, k as Key, l as applyStringDiff, lt as isPlainTextOnlyPaste, m as EDITOR_TO_KEY_TO_ELEMENT, n as getFragment, nt as isAfter, o as shallowCompare, ot as isDOMNode, p as EDITOR_TO_ELEMENT, q as getActiveElement, r as nodeFragment, rt as isBefore, s as splitDecorationsByChild, st as isDOMSelection, t as fragment, tt as hasShadowRoot, u as normalizeStringDiff, ut as isTrackedMutation, v as EDITOR_TO_WINDOW, w as NODE_TO_ELEMENT, x as IS_FOCUSED, y as ELEMENT_TO_NODE, z as IS_FIREFOX_LEGACY } from "./slate-dom-CNAZgdb8.js";
+export { CAN_USE_DOM, DOMEditor, EDITOR_TO_ELEMENT, EDITOR_TO_KEY_TO_ELEMENT, EDITOR_TO_ON_CHANGE, EDITOR_TO_USER_MARKS, EDITOR_TO_USER_SELECTION, EDITOR_TO_WINDOW, ELEMENT_TO_NODE, HAS_BEFORE_INPUT_SUPPORT, Hotkeys, IS_ANDROID, IS_ANDROID_CHROME_LEGACY, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_COMPOSING, IS_EDGE_LEGACY, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_FOCUSED, IS_IOS, IS_READ_ONLY, IS_SAFARI_LEGACY, IS_UC_MOBILE, IS_WEBKIT, IS_WECHATBROWSER, Key, MARK_PLACEHOLDER_SYMBOL, NODE_TO_ELEMENT, NODE_TO_INDEX, NODE_TO_KEY, NODE_TO_PARENT, PLACEHOLDER_SYMBOL, applyStringDiff, closestShadowAware, containsShadowAware, fragment, getActiveElement, getClipboardData, getDefaultView, getEditableChild, getEditableChildAndIndex, getFragment, getPlainText, getSelection, getSlateFragmentAttribute, hasShadowRoot, isAfter, isBefore, isDOMComment, isDOMElement, isDOMNode, isDOMSelection, isDOMText, isElementDecorationsEqual, isPlainTextOnlyPaste, isTextDecorationsEqual, isTrackedMutation, nodeFragment, normalizeDOMPoint, normalizeStringDiff, shallowCompare, splitDecorationsByChild, withDOM };

package/dist/index.js

@@ -1,3 +1,2 @@
-import { d as reconcileChildren, l as KEY_TO_CHUNK_TREE, u as getChunkTreeForNode } from "./slate-dom-cOXt9FLf.js";
-import { C as isEventHandled, D as SLATE_USE_FOCUSED, E as SLATE_USE_ELEMENT, O as SLATE_USE_READ_ONLY, S as isDOMEventTargetInput, T as SLATE_USE_EDITOR, _ as DEFAULT_PLACEHOLDER_RENDER, a as useFocused, b as handleNativeHistoryEvents, c as useReadOnly, d as useEditor, f as Slate, g as DEFAULT_LEAF_RENDER, h as DEFAULT_ELEMENT_RENDER, i as useSelected, k as SLATE_USE_SELECTION, l as useElement, m as DEFAULT_DECORATE_FN, n as useInheritRef, o as Editable, p as DEFAULT_CHUNK_RENDER, r as useSelection, s as useComposing, t as createReactiveEditor, u as useElementIf, v as DEFAULT_SCROLL_INTO_VIEW, w as SLATE_USE_COMPOSING, x as isDOMEventHandled, y as DEFAULT_TEXT_RENDER } from "./slate-vue-CluiGoan.js";
+import { A as SLATE_USE_FOCUSED, C as handleNativeHistoryEvents, D as SLATE_USE_COMPOSING, E as isEventHandled, M as SLATE_USE_SELECTION, O as SLATE_USE_EDITOR, S as DEFAULT_TEXT_RENDER, T as isDOMEventTargetInput, _ as DEFAULT_DECORATE_FN, a as useFocused, b as DEFAULT_PLACEHOLDER_RENDER, c as KEY_TO_CHUNK_TREE, d as useReadOnly, f as useElement, g as DEFAULT_CHUNK_RENDER, h as Slate, i as useSelected, j as SLATE_USE_READ_ONLY, k as SLATE_USE_ELEMENT, l as getChunkTreeForNode, m as useEditor, n as useInheritRef, o as Editable, p as useElementIf, r as useSelection, s as useComposing, t as createReactiveEditor, u as reconcileChildren, v as DEFAULT_ELEMENT_RENDER, w as isDOMEventHandled, x as DEFAULT_SCROLL_INTO_VIEW, y as DEFAULT_LEAF_RENDER } from "./slate-vue-BivbsnlR.js";
 export { DEFAULT_CHUNK_RENDER, DEFAULT_DECORATE_FN, DEFAULT_ELEMENT_RENDER, DEFAULT_LEAF_RENDER, DEFAULT_PLACEHOLDER_RENDER, DEFAULT_SCROLL_INTO_VIEW, DEFAULT_TEXT_RENDER, Editable, KEY_TO_CHUNK_TREE, SLATE_USE_COMPOSING, SLATE_USE_EDITOR, SLATE_USE_ELEMENT, SLATE_USE_FOCUSED, SLATE_USE_READ_ONLY, SLATE_USE_SELECTION, Slate, createReactiveEditor, getChunkTreeForNode, handleNativeHistoryEvents, isDOMEventHandled, isDOMEventTargetInput, isEventHandled, reconcileChildren, useComposing, useEditor, useElement, useElementIf, useFocused, useInheritRef, useReadOnly, useSelected, useSelection };

package/dist/slate-dom/index.d.ts

@@ -8,3 +8,4 @@ export * from './utils/hotkeys';
 export * from './utils/key';
 export * from './utils/range-list';
 export * from './utils/weak-maps';
+export * from './override';

package/dist/slate-dom/override/fragment.d.ts

@@ -0,0 +1,2 @@
+import { EditorInterface } from 'slate';
+export declare const fragment: EditorInterface["fragment"];

package/dist/slate-dom/override/get-fragment.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from 'slate';
+import { WithEditorFirstArg } from 'slate/dist/utils';
+export declare const getFragment: WithEditorFirstArg<Editor["getFragment"]>;

package/dist/slate-dom/override/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get-fragment';
+export * from './fragment';
+export * from './node-fragment';

package/dist/slate-dom/override/node-fragment.d.ts

@@ -0,0 +1,2 @@
+import { Ancestor, Editor, Range } from 'slate';
+export declare const nodeFragment: <T extends Ancestor = Editor>(editor: Editor, range: Range) => T["children"];

package/dist/{slate-dom-cOXt9FLf.js → slate-dom-CNAZgdb8.js}

@@ -770,545 +770,6 @@ var findCurrentLineRange = (editor, parentRange) => {
 	return Editor.range(editor, positions[left], parentRangeBoundary);
 };
 //#endregion
-//#region packages/slate-vue/chunking/chunk-tree-helper.ts
-/**
-* Traverse and modify a chunk tree
-*/
-var ChunkTreeHelper = class {
-	/**
-	* The root of the chunk tree
-	*/
-	root;
-	/**
-	* The ideal size of a chunk
-	*/
-	chunkSize;
-	/**
-	* Whether debug mode is enabled
-	*
-	* If enabled, the pointer state will be checked for internal consistency
-	* after each mutating operation.
-	*/
-	debug;
-	/**
-	* Whether the traversal has reached the end of the chunk tree
-	*
-	* When this is true, the pointerChunk and pointerIndex point to the last
-	* top-level node in the chunk tree, although pointerNode returns null.
-	*/
-	reachedEnd;
-	/**
-	* The chunk containing the current node
-	*/
-	pointerChunk;
-	/**
-	* The index of the current node within pointerChunk
-	*
-	* Can be -1 to indicate that the pointer is before the start of the tree.
-	*/
-	pointerIndex;
-	/**
-	* Similar to a Slate path; tracks the path of pointerChunk relative to the
-	* root.
-	*
-	* Used to move the pointer from the current chunk to the parent chunk more
-	* efficiently.
-	*/
-	pointerIndexStack;
-	/**
-	* Indexing the current chunk's children has a slight time cost, which adds up
-	* when traversing very large trees, so the current node is cached.
-	*
-	* A value of undefined means that the current node is not cached. This
-	* property must be set to undefined whenever the pointer is moved, unless
-	* the pointer is guaranteed to point to the same node that it did previously.
-	*/
-	cachedPointerNode;
-	constructor(chunkTree, { chunkSize, debug }) {
-		this.root = chunkTree;
-		this.chunkSize = chunkSize;
-		// istanbul ignore next
-		this.debug = debug ?? false;
-		this.pointerChunk = chunkTree;
-		this.pointerIndex = -1;
-		this.pointerIndexStack = [];
-		this.reachedEnd = false;
-		this.validateState();
-	}
-	/**
-	* Move the pointer to the next leaf in the chunk tree
-	*/
-	readLeaf() {
-		// istanbul ignore next
-		if (this.reachedEnd) return null;
-		while (true) if (this.pointerIndex + 1 < this.pointerSiblings.length) {
-			this.pointerIndex++;
-			this.cachedPointerNode = void 0;
-			break;
-		} else if (this.pointerChunk.type === "root") {
-			this.reachedEnd = true;
-			return null;
-		} else this.exitChunk();
-		this.validateState();
-		this.enterChunkUntilLeaf(false);
-		return this.pointerNode;
-	}
-	/**
-	* Move the pointer to the previous leaf in the chunk tree
-	*/
-	returnToPreviousLeaf() {
-		if (this.reachedEnd) {
-			this.reachedEnd = false;
-			this.enterChunkUntilLeaf(true);
-			return;
-		}
-		while (true) if (this.pointerIndex >= 1) {
-			this.pointerIndex--;
-			this.cachedPointerNode = void 0;
-			break;
-		} else if (this.pointerChunk.type === "root") {
-			this.pointerIndex = -1;
-			return;
-		} else this.exitChunk();
-		this.validateState();
-		this.enterChunkUntilLeaf(true);
-	}
-	/**
-	* Insert leaves before the current leaf, leaving the pointer unchanged
-	*/
-	insertBefore(leaves) {
-		this.returnToPreviousLeaf();
-		this.insertAfter(leaves);
-		this.readLeaf();
-	}
-	/**
-	* Insert leaves after the current leaf, leaving the pointer on the last
-	* inserted leaf
-	*
-	* The insertion algorithm first checks for any chunk we're currently at the
-	* end of that can receive additional leaves. Next, it tries to insert leaves
-	* at the starts of any subsequent chunks.
-	*
-	* Any remaining leaves are passed to rawInsertAfter to be chunked and
-	* inserted at the highest possible level.
-	*/
-	insertAfter(leaves) {
-		// istanbul ignore next
-		if (leaves.length === 0) return;
-		let beforeDepth = 0;
-		let afterDepth = 0;
-		while (this.pointerChunk.type === "chunk" && this.pointerIndex === this.pointerSiblings.length - 1) {
-			const remainingCapacity = this.chunkSize - this.pointerSiblings.length;
-			const toInsertCount = Math.min(remainingCapacity, leaves.length);
-			if (toInsertCount > 0) {
-				const leavesToInsert = leaves.splice(0, toInsertCount);
-				this.rawInsertAfter(leavesToInsert, beforeDepth);
-			}
-			this.exitChunk();
-			beforeDepth++;
-		}
-		if (leaves.length === 0) return;
-		const rawInsertPointer = this.savePointer();
-		let finalPointer = null;
-		if (this.readLeaf()) while (this.pointerChunk.type === "chunk" && this.pointerIndex === 0) {
-			const remainingCapacity = this.chunkSize - this.pointerSiblings.length;
-			const toInsertCount = Math.min(remainingCapacity, leaves.length);
-			if (toInsertCount > 0) {
-				const leavesToInsert = leaves.splice(-toInsertCount, toInsertCount);
-				this.pointerIndex = -1;
-				this.cachedPointerNode = void 0;
-				this.rawInsertAfter(leavesToInsert, afterDepth);
-				if (!finalPointer) finalPointer = this.savePointer();
-			}
-			this.exitChunk();
-			afterDepth++;
-		}
-		this.restorePointer(rawInsertPointer);
-		const minDepth = Math.max(beforeDepth, afterDepth);
-		this.rawInsertAfter(leaves, minDepth);
-		if (finalPointer) this.restorePointer(finalPointer);
-		this.validateState();
-	}
-	/**
-	* Remove the current node and decrement the pointer, deleting any ancestor
-	* chunk that becomes empty as a result
-	*/
-	remove() {
-		this.pointerSiblings.splice(this.pointerIndex--, 1);
-		this.cachedPointerNode = void 0;
-		if (this.pointerSiblings.length === 0 && this.pointerChunk.type === "chunk") {
-			this.exitChunk();
-			this.remove();
-		} else this.invalidateChunk();
-		this.validateState();
-	}
-	/**
-	* Add the current chunk and all ancestor chunks to the list of modified
-	* chunks
-	*/
-	invalidateChunk() {
-		for (let c = this.pointerChunk; c.type === "chunk"; c = c.parent) this.root.modifiedChunks.add(c);
-	}
-	/**
-	* Whether the pointer is at the start of the tree
-	*/
-	get atStart() {
-		return this.pointerChunk.type === "root" && this.pointerIndex === -1;
-	}
-	/**
-	* The siblings of the current node
-	*/
-	get pointerSiblings() {
-		return this.pointerChunk.children;
-	}
-	/**
-	* Get the current node (uncached)
-	*
-	* If the pointer is at the start or end of the document, returns null.
-	*
-	* Usually, the current node is a chunk leaf, although it can be a chunk
-	* while insertions are in progress.
-	*/
-	getPointerNode() {
-		if (this.reachedEnd || this.pointerIndex === -1) return null;
-		return this.pointerSiblings[this.pointerIndex];
-	}
-	/**
-	* Cached getter for the current node
-	*/
-	get pointerNode() {
-		if (this.cachedPointerNode !== void 0) return this.cachedPointerNode;
-		const pointerNode = this.getPointerNode();
-		this.cachedPointerNode = pointerNode;
-		return pointerNode;
-	}
-	/**
-	* Get the path of a chunk relative to the root, returning null if the chunk
-	* is not connected to the root
-	*/
-	getChunkPath(chunk) {
-		const path = [];
-		for (let c = chunk; c.type === "chunk"; c = c.parent) {
-			const index = c.parent.children.indexOf(c);
-			// istanbul ignore next
-			if (index === -1) return null;
-			path.unshift(index);
-		}
-		return path;
-	}
-	/**
-	* Save the current pointer to be restored later
-	*/
-	savePointer() {
-		if (this.atStart) return "start";
-		// istanbul ignore next
-		if (!this.pointerNode) throw new Error("Cannot save pointer when pointerNode is null");
-		return {
-			chunk: this.pointerChunk,
-			node: this.pointerNode
-		};
-	}
-	/**
-	* Restore the pointer to a previous state
-	*/
-	restorePointer(savedPointer) {
-		if (savedPointer === "start") {
-			this.pointerChunk = this.root;
-			this.pointerIndex = -1;
-			this.pointerIndexStack = [];
-			this.reachedEnd = false;
-			this.cachedPointerNode = void 0;
-			return;
-		}
-		const { chunk, node } = savedPointer;
-		const index = chunk.children.indexOf(node);
-		// istanbul ignore next
-		if (index === -1) throw new Error("Cannot restore point because saved node is no longer in saved chunk");
-		const indexStack = this.getChunkPath(chunk);
-		// istanbul ignore next
-		if (!indexStack) throw new Error("Cannot restore point because saved chunk is no longer connected to root");
-		this.pointerChunk = chunk;
-		this.pointerIndex = index;
-		this.pointerIndexStack = indexStack;
-		this.reachedEnd = false;
-		this.cachedPointerNode = node;
-		this.validateState();
-	}
-	/**
-	* Assuming the current node is a chunk, move the pointer into that chunk
-	*
-	* @param end If true, place the pointer on the last node of the chunk.
-	* Otherwise, place the pointer on the first node.
-	*/
-	enterChunk(end) {
-		// istanbul ignore next
-		if (this.pointerNode?.type !== "chunk") throw new Error("Cannot enter non-chunk");
-		this.pointerIndexStack.push(this.pointerIndex);
-		this.pointerChunk = this.pointerNode;
-		this.pointerIndex = end ? this.pointerSiblings.length - 1 : 0;
-		this.cachedPointerNode = void 0;
-		this.validateState();
-		// istanbul ignore next
-		if (this.pointerChunk.children.length === 0) throw new Error("Cannot enter empty chunk");
-	}
-	/**
-	* Assuming the current node is a chunk, move the pointer into that chunk
-	* repeatedly until the current node is a leaf
-	*
-	* @param end If true, place the pointer on the last node of the chunk.
-	* Otherwise, place the pointer on the first node.
-	*/
-	enterChunkUntilLeaf(end) {
-		while (this.pointerNode?.type === "chunk") this.enterChunk(end);
-	}
-	/**
-	* Move the pointer to the parent chunk
-	*/
-	exitChunk() {
-		// istanbul ignore next
-		if (this.pointerChunk.type === "root") throw new Error("Cannot exit root");
-		const previousPointerChunk = this.pointerChunk;
-		this.pointerChunk = previousPointerChunk.parent;
-		this.pointerIndex = this.pointerIndexStack.pop();
-		this.cachedPointerNode = void 0;
-		this.validateState();
-	}
-	/**
-	* Insert leaves immediately after the current node, leaving the pointer on
-	* the last inserted leaf
-	*
-	* Leaves are chunked according to the number of nodes already in the parent
-	* plus the number of nodes being inserted, or the minimum depth if larger
-	*/
-	rawInsertAfter(leaves, minDepth) {
-		if (leaves.length === 0) return;
-		const groupIntoChunks = (leaves, parent, perChunk) => {
-			if (perChunk === 1) return leaves;
-			const chunks = [];
-			for (let i = 0; i < this.chunkSize; i++) {
-				const chunkNodes = leaves.slice(i * perChunk, (i + 1) * perChunk);
-				if (chunkNodes.length === 0) break;
-				const chunk = {
-					type: "chunk",
-					key: new Key(),
-					parent,
-					children: []
-				};
-				chunk.children = groupIntoChunks(chunkNodes, chunk, perChunk / this.chunkSize);
-				chunks.push(chunk);
-			}
-			return chunks;
-		};
-		const newTotal = this.pointerSiblings.length + leaves.length;
-		let depthForTotal = 0;
-		for (let i = this.chunkSize; i < newTotal; i *= this.chunkSize) depthForTotal++;
-		const depth = Math.max(depthForTotal, minDepth);
-		const perTopLevelChunk = Math.pow(this.chunkSize, depth);
-		const chunks = groupIntoChunks(leaves, this.pointerChunk, perTopLevelChunk);
-		this.pointerSiblings.splice(this.pointerIndex + 1, 0, ...chunks);
-		this.pointerIndex += chunks.length;
-		this.cachedPointerNode = void 0;
-		this.invalidateChunk();
-		this.validateState();
-	}
-	/**
-	* If debug mode is enabled, ensure that the state is internally consistent
-	*/
-	// istanbul ignore next
-	validateState() {
-		if (!this.debug) return;
-		const validateDescendant = (node) => {
-			if (node.type === "chunk") {
-				const { parent, children } = node;
-				if (!parent.children.includes(node)) throw new Error(`Debug: Chunk ${node.key.id} has an incorrect parent property`);
-				children.forEach(validateDescendant);
-			}
-		};
-		this.root.children.forEach(validateDescendant);
-		if (this.cachedPointerNode !== void 0 && this.cachedPointerNode !== this.getPointerNode()) throw new Error("Debug: The cached pointer is incorrect and has not been invalidated");
-		const actualIndexStack = this.getChunkPath(this.pointerChunk);
-		if (!actualIndexStack) throw new Error("Debug: The pointer chunk is not connected to the root");
-		if (!Path.equals(this.pointerIndexStack, actualIndexStack)) throw new Error(`Debug: The cached index stack [${this.pointerIndexStack.join(", ")}] does not match the path of the pointer chunk [${actualIndexStack.join(", ")}]`);
-	}
-};
-//#endregion
-//#region packages/slate-vue/chunking/children-helper.ts
-/**
-* Traverse an array of children, providing helpers useful for reconciling the
-* children array with a chunk tree
-*/
-var ChildrenHelper = class {
-	editor;
-	children;
-	/**
-	* Sparse array of Slate node keys, each index corresponding to an index in
-	* the children array
-	*
-	* Fetching the key for a Slate node is expensive, so we cache them here.
-	*/
-	cachedKeys;
-	/**
-	* The index of the next node to be read in the children array
-	*/
-	pointerIndex;
-	constructor(editor, children) {
-		this.editor = editor;
-		this.children = children;
-		this.cachedKeys = new Array(children.length);
-		this.pointerIndex = 0;
-	}
-	/**
-	* Read a given number of nodes, advancing the pointer by that amount
-	*/
-	read(n) {
-		if (n === 1) return [this.children[this.pointerIndex++]];
-		const slicedChildren = this.remaining(n);
-		this.pointerIndex += n;
-		return slicedChildren;
-	}
-	/**
-	* Get the remaining children without advancing the pointer
-	*
-	* @param [maxChildren] Limit the number of children returned.
-	*/
-	remaining(maxChildren) {
-		if (maxChildren === void 0) return this.children.slice(this.pointerIndex);
-		return this.children.slice(this.pointerIndex, this.pointerIndex + maxChildren);
-	}
-	/**
-	* Whether all children have been read
-	*/
-	get reachedEnd() {
-		return this.pointerIndex >= this.children.length;
-	}
-	/**
-	* Determine whether a node with a given key appears in the unread part of the
-	* children array, and return its index relative to the current pointer if so
-	*
-	* Searching for the node object itself using indexOf is most efficient, but
-	* will fail to locate nodes that have been modified. In this case, nodes
-	* should be identified by their keys instead.
-	*
-	* Searching an array of keys using indexOf is very inefficient since fetching
-	* the keys for all children in advance is very slow. Insead, if the node
-	* search fails to return a value, fetch the keys of each remaining child one
-	* by one and compare it to the known key.
-	*/
-	lookAhead(node, key) {
-		const elementResult = this.children.indexOf(node, this.pointerIndex);
-		if (elementResult > -1) return elementResult - this.pointerIndex;
-		for (let i = this.pointerIndex; i < this.children.length; i++) {
-			const candidateNode = this.children[i];
-			if (this.findKey(candidateNode, i) === key) return i - this.pointerIndex;
-		}
-		return -1;
-	}
-	/**
-	* Convert an array of Slate nodes to an array of chunk leaves, each
-	* containing the node and its key
-	*/
-	toChunkLeaves(nodes, startIndex) {
-		return nodes.map((node, i) => ({
-			type: "leaf",
-			node,
-			key: this.findKey(node, startIndex + i),
-			index: startIndex + i
-		}));
-	}
-	/**
-	* Get the key for a Slate node, cached using the node's index
-	*/
-	findKey(node, index) {
-		const cachedKey = this.cachedKeys[index];
-		if (cachedKey) return cachedKey;
-		const key = DOMEditor.findKey(this.editor, node);
-		this.cachedKeys[index] = key;
-		return key;
-	}
-};
-//#endregion
-//#region packages/slate-vue/chunking/reconcile-children.ts
-/**
-* Update the chunk tree to match the children array, inserting, removing and
-* updating differing nodes
-*/
-var reconcileChildren = (editor, { chunkTree, children, chunkSize, rerenderChildren = [], onInsert, onUpdate, onIndexChange, debug }) => {
-	const chunkTreeHelper = new ChunkTreeHelper(chunkTree, {
-		chunkSize,
-		debug
-	});
-	const childrenHelper = new ChildrenHelper(editor, children);
-	let treeLeaf;
-	while (treeLeaf = chunkTreeHelper.readLeaf()) {
-		const lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
-		const wasMoved = lookAhead > 0 && chunkTree.movedNodeKeys.has(treeLeaf.key);
-		if (lookAhead === -1 || wasMoved) {
-			chunkTreeHelper.remove();
-			continue;
-		}
-		const insertedChildrenStartIndex = childrenHelper.pointerIndex;
-		const insertedChildren = childrenHelper.read(lookAhead + 1);
-		const matchingChild = insertedChildren.pop();
-		if (insertedChildren.length) {
-			const leavesToInsert = childrenHelper.toChunkLeaves(insertedChildren, insertedChildrenStartIndex);
-			chunkTreeHelper.insertBefore(leavesToInsert);
-			insertedChildren.forEach((node, relativeIndex) => {
-				onInsert?.(node, insertedChildrenStartIndex + relativeIndex);
-			});
-		}
-		const matchingChildIndex = childrenHelper.pointerIndex - 1;
-		if (treeLeaf.node !== matchingChild) {
-			treeLeaf.node = matchingChild;
-			chunkTreeHelper.invalidateChunk();
-			onUpdate?.(matchingChild, matchingChildIndex);
-		}
-		if (treeLeaf.index !== matchingChildIndex) {
-			treeLeaf.index = matchingChildIndex;
-			onIndexChange?.(matchingChild, matchingChildIndex);
-		}
-		if (rerenderChildren.includes(matchingChildIndex)) chunkTreeHelper.invalidateChunk();
-	}
-	if (!childrenHelper.reachedEnd) {
-		const remainingChildren = childrenHelper.remaining();
-		const leavesToInsert = childrenHelper.toChunkLeaves(remainingChildren, childrenHelper.pointerIndex);
-		chunkTreeHelper.returnToPreviousLeaf();
-		chunkTreeHelper.insertAfter(leavesToInsert);
-		remainingChildren.forEach((node, relativeIndex) => {
-			onInsert?.(node, childrenHelper.pointerIndex + relativeIndex);
-		});
-	}
-	chunkTree.movedNodeKeys.clear();
-};
-//#endregion
-//#region packages/slate-vue/chunking/get-chunk-tree-for-node.ts
-var KEY_TO_CHUNK_TREE = /* @__PURE__ */ new WeakMap();
-/**
-* Get or create the chunk tree for a Slate node
-*
-* If the reconcile option is provided, the chunk tree will be updated to
-* match the current children of the node. The children are chunked
-* automatically using the given chunk size.
-*/
-var getChunkTreeForNode = (editor, node, options = {}) => {
-	const key = DOMEditor.findKey(editor, node);
-	let chunkTree = KEY_TO_CHUNK_TREE.get(key);
-	if (!chunkTree) {
-		chunkTree = {
-			type: "root",
-			movedNodeKeys: /* @__PURE__ */ new Set(),
-			modifiedChunks: /* @__PURE__ */ new Set(),
-			children: []
-		};
-		KEY_TO_CHUNK_TREE.set(key, chunkTree);
-	}
-	if (options.reconcile) reconcileChildren(editor, {
-		chunkTree,
-		children: node.children,
-		...options.reconcile
-	});
-	return chunkTree;
-};
-//#endregion
 //#region packages/slate-dom/plugin/with-dom.ts
 /**
 * `withDOM` adds DOM specific behaviors to the editor.
@@ -1346,15 +807,6 @@ var withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
 		}
 	};
 	e.apply = (op) => {
-		if (op.type === "move_node") {
-			const parent = Node.parent(e, op.path);
-			if (!!e.getChunkSize(parent)) {
-				const node = Node.get(e, op.path);
-				const chunkTree = getChunkTreeForNode(e, parent);
-				const key = DOMEditor.findKey(e, node);
-				chunkTree.movedNodeKeys.add(key);
-			}
-		}
 		const matches = [];
 		const pathRefMatches = [];
 		switch (op.type) {
@@ -1871,4 +1323,82 @@ var splitDecorationsByChild = (editor, node, decorations) => {
 	return decorationsByChild;
 };
 //#endregion
-export { getSelection as $, CAN_USE_DOM as A, IS_IOS as B, MARK_PLACEHOLDER_SYMBOL as C, NODE_TO_PARENT as D, NODE_TO_KEY as E, IS_CHROME as F, closestShadowAware as G, IS_UC_MOBILE as H, IS_CHROME_LEGACY as I, getClipboardData as J, containsShadowAware as K, IS_EDGE_LEGACY as L, IS_ANDROID as M, IS_ANDROID_CHROME_LEGACY as N, PLACEHOLDER_SYMBOL as O, IS_APPLE as P, getPlainText as Q, IS_FIREFOX as R, IS_READ_ONLY as S, NODE_TO_INDEX as T, IS_WEBKIT as U, IS_SAFARI_LEGACY as V, IS_WECHATBROWSER as W, getEditableChild as X, getDefaultView as Y, getEditableChildAndIndex as Z, EDITOR_TO_USER_SELECTION as _, Hotkeys as a, isDOMElement as at, IS_COMPOSING as b, withDOM as c, isDOMText as ct, reconcileChildren as d, normalizeDOMPoint as dt, getSlateFragmentAttribute as et, DOMEditor as f, EDITOR_TO_USER_MARKS as g, EDITOR_TO_ON_CHANGE as h, splitDecorationsByChild as i, isDOMComment as it, HAS_BEFORE_INPUT_SUPPORT as j, Key as k, KEY_TO_CHUNK_TREE as l, isPlainTextOnlyPaste as lt, EDITOR_TO_KEY_TO_ELEMENT as m, isTextDecorationsEqual as n, isAfter as nt, applyStringDiff as o, isDOMNode as ot, EDITOR_TO_ELEMENT as p, getActiveElement as q, shallowCompare as r, isBefore as rt, normalizeStringDiff as s, isDOMSelection as st, isElementDecorationsEqual as t, hasShadowRoot as tt, getChunkTreeForNode as u, isTrackedMutation as ut, EDITOR_TO_WINDOW as v, NODE_TO_ELEMENT as w, IS_FOCUSED as x, ELEMENT_TO_NODE as y, IS_FIREFOX_LEGACY as z };
+//#region packages/slate-dom/override/node-fragment.ts
+var nodeFragment = (editor, range) => {
+	const [start, end] = Range.edges(range);
+	/**
+	* 判断 path 是否是 ancestorPath 的前缀。
+	*/
+	const isPrefix = (ancestorPath, path) => {
+		if (ancestorPath.length > path.length) return false;
+		for (let i = 0; i < ancestorPath.length; i++) if (ancestorPath[i] !== path[i]) return false;
+		return true;
+	};
+	const buildChildren = (children, path) => {
+		const depth = path.length;
+		const startInside = isPrefix(path, start.path);
+		const endInside = isPrefix(path, end.path);
+		let from = 0;
+		let to = children.length;
+		if (startInside) from = start.path[depth];
+		if (endInside) to = end.path[depth] + 1;
+		const result = [];
+		for (let i = from; i < to; i++) {
+			const child = children[i];
+			const childPath = [...path, i];
+			const isStartBoundary = startInside && start.path.length > depth && start.path[depth] === i;
+			const isEndBoundary = endInside && end.path.length > depth && end.path[depth] === i;
+			/**
+			* 这个 child 是 start/end 路径上的边界，
+			* 需要继续进入它。
+			*/
+			if (isStartBoundary || isEndBoundary) {
+				if ("text" in child) {
+					let text = child.text;
+					/**
+					* start 和 end 落在同一个 leaf。
+					*/
+					if (childPath.length === start.path.length && childPath.length === end.path.length && start.path.every((value, index) => value === end.path[index])) text = text.slice(start.offset, end.offset);
+					else {
+						if (childPath.length === start.path.length && start.path.every((value, index) => value === childPath[index])) text = text.slice(start.offset);
+						if (childPath.length === end.path.length && end.path.every((value, index) => value === childPath[index])) text = text.slice(0, end.offset);
+					}
+					result.push({
+						...child,
+						text
+					});
+				} else
+ /**
+				* 只有边界 ancestor 需要 clone。
+				*/
+				result.push({
+					...child,
+					children: buildChildren(child.children, childPath)
+				});
+				continue;
+			}
+			/**
+			* 完整包含在 selection 中的 subtree。
+			*
+			* 不需要 clone。
+			*/
+			result.push(child);
+		}
+		return result;
+	};
+	return buildChildren(editor.children, []);
+};
+//#endregion
+//#region packages/slate-dom/override/get-fragment.ts
+var getFragment = (editor) => {
+	const { selection } = editor;
+	if (selection) return nodeFragment(editor, selection);
+	return [];
+};
+//#endregion
+//#region packages/slate-dom/override/fragment.ts
+var fragment = (editor, at) => {
+	return nodeFragment(editor, Editor.range(editor, at));
+};
+//#endregion
+export { getSelection as $, CAN_USE_DOM as A, IS_IOS as B, MARK_PLACEHOLDER_SYMBOL as C, NODE_TO_PARENT as D, NODE_TO_KEY as E, IS_CHROME as F, closestShadowAware as G, IS_UC_MOBILE as H, IS_CHROME_LEGACY as I, getClipboardData as J, containsShadowAware as K, IS_EDGE_LEGACY as L, IS_ANDROID as M, IS_ANDROID_CHROME_LEGACY as N, PLACEHOLDER_SYMBOL as O, IS_APPLE as P, getPlainText as Q, IS_FIREFOX as R, IS_READ_ONLY as S, NODE_TO_INDEX as T, IS_WEBKIT as U, IS_SAFARI_LEGACY as V, IS_WECHATBROWSER as W, getEditableChild as X, getDefaultView as Y, getEditableChildAndIndex as Z, EDITOR_TO_USER_SELECTION as _, isTextDecorationsEqual as a, isDOMElement as at, IS_COMPOSING as b, Hotkeys as c, isDOMText as ct, withDOM as d, normalizeDOMPoint as dt, getSlateFragmentAttribute as et, DOMEditor as f, EDITOR_TO_USER_MARKS as g, EDITOR_TO_ON_CHANGE as h, isElementDecorationsEqual as i, isDOMComment as it, HAS_BEFORE_INPUT_SUPPORT as j, Key as k, applyStringDiff as l, isPlainTextOnlyPaste as lt, EDITOR_TO_KEY_TO_ELEMENT as m, getFragment as n, isAfter as nt, shallowCompare as o, isDOMNode as ot, EDITOR_TO_ELEMENT as p, getActiveElement as q, nodeFragment as r, isBefore as rt, splitDecorationsByChild as s, isDOMSelection as st, fragment as t, hasShadowRoot as tt, normalizeStringDiff as u, isTrackedMutation as ut, EDITOR_TO_WINDOW as v, NODE_TO_ELEMENT as w, IS_FOCUSED as x, ELEMENT_TO_NODE as y, IS_FIREFOX_LEGACY as z };