@servicetitan/anvil2 3.15.1 → 3.16.0

package/dist/{index-Dt0zG4YB.js → index-C2dOrf4N.js}

@@ -1,4 +1,4 @@
-import { P as PluginKey, a as Plugin, S as Slice, F as Fragment, T as TextSelection, A as AllSelection, N as NodeSelection, E as Extension, g as getUpdatedPosition$1, M as MappablePosition, b as NodeRange, c as SelectionRange, d as Selection, D as DecorationSet, e as Decoration, f as computePosition, i as isFirefox } from './RichTextEditor-BpzUo8dB.js';
+import { P as PluginKey, a as Plugin, S as Slice, F as Fragment, T as TextSelection, A as AllSelection, N as NodeSelection, E as Extension, g as getUpdatedPosition$1, M as MappablePosition, b as NodeRange, c as SelectionRange, d as Selection, D as DecorationSet, e as Decoration, f as computePosition, i as isFirefox } from './RichTextEditor-DcAVqd2d.js';
 import { useRef, useMemo, useEffect } from 'react';
 import { createPortal } from 'react-dom';
 
@@ -1153,6 +1153,10 @@ const unexpectedCase = () => {
  * decoding.hasContent(decoder) // => false - all data is read
  * ```
  *
+ * Security: Decoders process untrusted input, and `decoder.arr` may be a view on a larger (possibly pooled) ArrayBuffer.
+ * Never create views via `new Uint8Array(arr.buffer, ..)` / `new DataView(arr.buffer, ..)`; use the private `subarray` /
+ * `subdataview` helpers, which throw on out-of-bounds access instead of exposing foreign memory.
+ *
  * @module decoding
  */
 
@@ -1160,6 +1164,42 @@ const unexpectedCase = () => {
 const errorUnexpectedEndOfArray = create$3('Unexpected end of array');
 const errorIntegerOutOfRange = create$3('Integer out of Range');
 
+/**
+ * Create a view of `len` bytes of `arr`, starting at `begin`. Throws if the range exceeds `arr`.
+ *
+ * Security: Always use this (or `subdataview`) instead of `new Uint8Array(arr.buffer, ..)`. `arr` may be a view on a
+ * larger (possibly shared/pooled) ArrayBuffer. An unchecked view could expose memory outside of `arr`.
+ *
+ * @template {ArrayBufferLike} Buf
+ * @param {Uint8Array<Buf>} arr
+ * @param {number} begin
+ * @param {number} len
+ * @return {Uint8Array<Buf>}
+ */
+const subarray = (arr, begin, len) => {
+  if (begin < 0 || len < 0 || begin + len > arr.length) {
+    throw errorUnexpectedEndOfArray
+  }
+  return new Uint8Array(arr.buffer, arr.byteOffset + begin, len)
+};
+
+/**
+ * Create a DataView of `len` bytes of `arr`, starting at `begin`. Throws if the range exceeds `arr`.
+ *
+ * Security: See `subarray`.
+ *
+ * @param {Uint8Array} arr
+ * @param {number} begin
+ * @param {number} len
+ * @return {DataView}
+ */
+const subdataview = (arr, begin, len) => {
+  if (begin < 0 || len < 0 || begin + len > arr.length) {
+    throw errorUnexpectedEndOfArray
+  }
+  return new DataView(arr.buffer, arr.byteOffset + begin, len)
+};
+
 /**
  * A Decoder handles the decoding of an Uint8Array.
  * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
@@ -1212,7 +1252,7 @@ const hasContent = decoder => decoder.pos !== decoder.arr.length;
  * @return {Uint8Array<Buf>}
  */
 const readUint8Array = (decoder, len) => {
-  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  const view = subarray(decoder.arr, decoder.pos, len);
   decoder.pos += len;
   return view
 };
@@ -1373,7 +1413,7 @@ const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPol
  * @return {DataView}
  */
 const readFromDataView = (decoder, len) => {
-  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
+  const dv = subdataview(decoder.arr, decoder.pos, len);
   decoder.pos += len;
   return dv
 };
@@ -14563,1667 +14603,1594 @@ const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins =
   }
 });
 
-// src/collaboration.ts
+//#region src/helpers/isChangeOrigin.ts
+/**
+* Checks if a transaction was originated from a Yjs change.
+* @param {Transaction} transaction - The transaction to check.
+* @returns {boolean} - True if the transaction was originated from a Yjs change, false otherwise.
+* @example
+* const transaction = new Transaction(doc)
+* const isOrigin = isChangeOrigin(transaction) // returns false
+*/
 function isChangeOrigin(transaction) {
-  return !!transaction.getMeta(ySyncPluginKey);
+	return !!transaction.getMeta(ySyncPluginKey);
 }
+//#endregion
+//#region src/helpers/yRelativePosition.ts
+/**
+* Converts a Y.js relative position to a position in the Tiptap document.
+*/
 function getYAbsolutePosition(state, relativePos) {
-  const ystate = ySyncPluginKey.getState(state);
-  return relativePositionToAbsolutePosition(
-    ystate.doc,
-    ystate.type,
-    relativePos,
-    ystate.binding.mapping
-  ) || 0;
+	const ystate = ySyncPluginKey.getState(state);
+	return relativePositionToAbsolutePosition(ystate.doc, ystate.type, relativePos, ystate.binding.mapping) || 0;
 }
+/**
+* Converts a position in the Tiptap document to a Y.js relative position.
+*/
 function getYRelativePosition(state, absolutePos) {
-  const ystate = ySyncPluginKey.getState(state);
-  return absolutePositionToRelativePosition(absolutePos, ystate.type, ystate.binding.mapping);
+	const ystate = ySyncPluginKey.getState(state);
+	return absolutePositionToRelativePosition(absolutePos, ystate.type, ystate.binding.mapping);
 }
-
-// src/helpers/CollaborationMappablePosition.ts
-var CollaborationMappablePosition = class _CollaborationMappablePosition extends MappablePosition {
-  constructor(position, yRelativePosition) {
-    super(position);
-    this.yRelativePosition = yRelativePosition;
-  }
-  /**
-   * Creates a CollaborationMappablePosition from a JSON object.
-   */
-  static fromJSON(json) {
-    return new _CollaborationMappablePosition(json.position, json.yRelativePosition);
-  }
-  /**
-   * Converts the CollaborationMappablePosition to a JSON object.
-   */
-  toJSON() {
-    return {
-      position: this.position,
-      yRelativePosition: this.yRelativePosition
-    };
-  }
-};
+//#endregion
+//#region src/helpers/CollaborationMappablePosition.ts
+/**
+* A MappablePosition subclass that includes Y.js relative position information
+* to track positions in collaborative transactions.
+*/
+var CollaborationMappablePosition = class CollaborationMappablePosition extends MappablePosition {
+	constructor(position, yRelativePosition) {
+		super(position);
+		this.yRelativePosition = yRelativePosition;
+	}
+	/**
+	* Creates a CollaborationMappablePosition from a JSON object.
+	*/
+	static fromJSON(json) {
+		return new CollaborationMappablePosition(json.position, json.yRelativePosition);
+	}
+	/**
+	* Converts the CollaborationMappablePosition to a JSON object.
+	*/
+	toJSON() {
+		return {
+			position: this.position,
+			yRelativePosition: this.yRelativePosition
+		};
+	}
+};
+/**
+* Creates a MappablePosition from a position number.
+* This is the collaboration implementation that returns a CollaborationMappablePosition.
+*/
 function createMappablePosition(position, state) {
-  const yRelativePosition = getYRelativePosition(state, position);
-  return new CollaborationMappablePosition(position, yRelativePosition);
+	return new CollaborationMappablePosition(position, getYRelativePosition(state, position));
 }
+/**
+* Returns the new position after applying a transaction. Handles both Y.js
+* transactions and regular transactions.
+*/
 function getUpdatedPosition(position, transaction, state) {
-  const yRelativePosition = position instanceof CollaborationMappablePosition ? position.yRelativePosition : null;
-  if (isChangeOrigin(transaction) && yRelativePosition) {
-    const absolutePosition2 = getYAbsolutePosition(state, yRelativePosition);
-    return {
-      position: new CollaborationMappablePosition(absolutePosition2, yRelativePosition),
-      mapResult: null
-    };
-  }
-  const result = getUpdatedPosition$1(position, transaction);
-  const absolutePosition = result.position.position;
-  return {
-    position: new CollaborationMappablePosition(
-      absolutePosition,
-      yRelativePosition != null ? yRelativePosition : getYRelativePosition(state, absolutePosition)
-    ),
-    mapResult: result.mapResult
-  };
+	const yRelativePosition = position instanceof CollaborationMappablePosition ? position.yRelativePosition : null;
+	if (isChangeOrigin(transaction) && yRelativePosition) return {
+		position: new CollaborationMappablePosition(getYAbsolutePosition(state, yRelativePosition), yRelativePosition),
+		mapResult: null
+	};
+	const result = getUpdatedPosition$1(position, transaction);
+	const absolutePosition = result.position.position;
+	return {
+		position: new CollaborationMappablePosition(absolutePosition, yRelativePosition !== null && yRelativePosition !== void 0 ? yRelativePosition : getYRelativePosition(state, absolutePosition)),
+		mapResult: result.mapResult
+	};
 }
-
-// src/collaboration.ts
+//#endregion
+//#region src/collaboration.ts
+/**
+* This extension allows you to collaborate with others in real-time.
+* @see https://tiptap.dev/api/extensions/collaboration
+*/
 Extension.create({
-  name: "collaboration",
-  priority: 1e3,
-  addOptions() {
-    return {
-      document: null,
-      field: "default",
-      fragment: null,
-      provider: null
-    };
-  },
-  addStorage() {
-    return {
-      isDisabled: false
-    };
-  },
-  onCreate() {
-    if (this.editor.extensionManager.extensions.find((extension) => extension.name === "undoRedo")) {
-      console.warn(
-        '[tiptap warn]: "@tiptap/extension-collaboration" comes with its own history support and is not compatible with "@tiptap/extension-undo-redo".'
-      );
-    }
-  },
-  onBeforeCreate() {
-    this.editor.utils.getUpdatedPosition = (position, transaction) => getUpdatedPosition(position, transaction, this.editor.state);
-    this.editor.utils.createMappablePosition = (position) => createMappablePosition(position, this.editor.state);
-  },
-  addCommands() {
-    return {
-      undo: () => ({ tr, state, dispatch }) => {
-        tr.setMeta("preventDispatch", true);
-        const undoManager = yUndoPluginKey.getState(state).undoManager;
-        if (undoManager.undoStack.length === 0) {
-          return false;
-        }
-        if (!dispatch) {
-          return true;
-        }
-        return undo(state);
-      },
-      redo: () => ({ tr, state, dispatch }) => {
-        tr.setMeta("preventDispatch", true);
-        const undoManager = yUndoPluginKey.getState(state).undoManager;
-        if (undoManager.redoStack.length === 0) {
-          return false;
-        }
-        if (!dispatch) {
-          return true;
-        }
-        return redo(state);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-z": () => this.editor.commands.undo(),
-      "Mod-y": () => this.editor.commands.redo(),
-      "Shift-Mod-z": () => this.editor.commands.redo()
-    };
-  },
-  addProseMirrorPlugins() {
-    const fragment = this.options.fragment ? this.options.fragment : this.options.document.getXmlFragment(this.options.field);
-    const yUndoPluginInstance = yUndoPlugin(this.options.yUndoOptions);
-    const originalUndoPluginView = yUndoPluginInstance.spec.view;
-    yUndoPluginInstance.spec.view = (view) => {
-      const { undoManager } = yUndoPluginKey.getState(view.state);
-      if (undoManager.restore) {
-        undoManager.restore();
-        undoManager.restore = () => {
-        };
-      }
-      const viewRet = originalUndoPluginView ? originalUndoPluginView(view) : void 0;
-      return {
-        destroy: () => {
-          const hasUndoManSelf = undoManager.trackedOrigins.has(undoManager);
-          const observers = undoManager._observers;
-          undoManager.restore = () => {
-            if (hasUndoManSelf) {
-              undoManager.trackedOrigins.add(undoManager);
-            }
-            undoManager.doc.on("afterTransaction", undoManager.afterTransactionHandler);
-            undoManager._observers = observers;
-          };
-          if (viewRet == null ? void 0 : viewRet.destroy) {
-            viewRet.destroy();
-          }
-        }
-      };
-    };
-    const ySyncPluginOptions = {
-      ...this.options.ySyncOptions,
-      onFirstRender: this.options.onFirstRender
-    };
-    const ySyncPluginInstance = ySyncPlugin(fragment, ySyncPluginOptions);
-    return [
-      ySyncPluginInstance,
-      yUndoPluginInstance,
-      // Only add the filterInvalidContent plugin if content checking is enabled
-      this.editor.options.enableContentCheck && new Plugin({
-        key: new PluginKey("filterInvalidContent"),
-        filterTransaction: (transaction) => {
-          if (!isChangeOrigin(transaction)) {
-            return true;
-          }
-          if (this.storage.isDisabled) {
-            return false;
-          }
-          if (!transaction.docChanged) {
-            return true;
-          }
-          try {
-            transaction.doc.check();
-            return true;
-          } catch (error) {
-            this.storage.isDisabled = true;
-            this.editor.emit("contentError", {
-              error,
-              editor: this.editor,
-              disableCollaboration: () => {
-                var _a;
-                (_a = fragment.doc) == null ? void 0 : _a.destroy();
-              }
-            });
-            return true;
-          }
-        }
-      })
-    ].filter(Boolean);
-  }
+	name: "collaboration",
+	priority: 1e3,
+	addOptions() {
+		return {
+			document: null,
+			field: "default",
+			fragment: null,
+			provider: null
+		};
+	},
+	addStorage() {
+		return { isDisabled: false };
+	},
+	onCreate() {
+		if (this.editor.extensionManager.extensions.find((extension) => extension.name === "undoRedo")) console.warn("[tiptap warn]: \"@tiptap/extension-collaboration\" comes with its own history support and is not compatible with \"@tiptap/extension-undo-redo\".");
+	},
+	onBeforeCreate() {
+		this.editor.utils.getUpdatedPosition = (position, transaction) => getUpdatedPosition(position, transaction, this.editor.state);
+		this.editor.utils.createMappablePosition = (position) => createMappablePosition(position, this.editor.state);
+	},
+	addCommands() {
+		return {
+			undo: () => ({ tr, state, dispatch }) => {
+				tr.setMeta("preventDispatch", true);
+				if (yUndoPluginKey.getState(state).undoManager.undoStack.length === 0) return false;
+				if (!dispatch) return true;
+				return undo(state);
+			},
+			redo: () => ({ tr, state, dispatch }) => {
+				tr.setMeta("preventDispatch", true);
+				if (yUndoPluginKey.getState(state).undoManager.redoStack.length === 0) return false;
+				if (!dispatch) return true;
+				return redo(state);
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-z": () => this.editor.commands.undo(),
+			"Mod-y": () => this.editor.commands.redo(),
+			"Shift-Mod-z": () => this.editor.commands.redo()
+		};
+	},
+	addProseMirrorPlugins() {
+		const fragment = this.options.fragment ? this.options.fragment : this.options.document.getXmlFragment(this.options.field);
+		const yUndoPluginInstance = yUndoPlugin(this.options.yUndoOptions);
+		const originalUndoPluginView = yUndoPluginInstance.spec.view;
+		yUndoPluginInstance.spec.view = (view) => {
+			const { undoManager } = yUndoPluginKey.getState(view.state);
+			if (undoManager.restore) {
+				undoManager.restore();
+				undoManager.restore = () => {};
+			}
+			const viewRet = originalUndoPluginView ? originalUndoPluginView(view) : void 0;
+			return { destroy: () => {
+				const hasUndoManSelf = undoManager.trackedOrigins.has(undoManager);
+				const observers = undoManager._observers;
+				undoManager.restore = () => {
+					if (hasUndoManSelf) undoManager.trackedOrigins.add(undoManager);
+					undoManager.doc.on("afterTransaction", undoManager.afterTransactionHandler);
+					undoManager._observers = observers;
+				};
+				if (viewRet === null || viewRet === void 0 ? void 0 : viewRet.destroy) viewRet.destroy();
+			} };
+		};
+		const ySyncPluginOptions = {
+			...this.options.ySyncOptions,
+			onFirstRender: this.options.onFirstRender
+		};
+		return [
+			ySyncPlugin(fragment, ySyncPluginOptions),
+			yUndoPluginInstance,
+			new Plugin({ filterTransaction: (transaction, state) => {
+				if (transaction.getMeta("inputRule")) yUndoPluginKey.getState(state).undoManager.stopCapturing();
+				return true;
+			} }),
+			this.editor.options.enableContentCheck && new Plugin({
+				key: new PluginKey("filterInvalidContent"),
+				filterTransaction: (transaction) => {
+					if (!isChangeOrigin(transaction)) return true;
+					if (this.storage.isDisabled) return false;
+					if (!transaction.docChanged) return true;
+					try {
+						transaction.doc.check();
+						return true;
+					} catch (error) {
+						this.storage.isDisabled = true;
+						this.editor.emit("contentError", {
+							error,
+							editor: this.editor,
+							disableCollaboration: () => {
+								var _fragment$doc;
+								(_fragment$doc = fragment.doc) === null || _fragment$doc === void 0 || _fragment$doc.destroy();
+							}
+						});
+						return true;
+					}
+				}
+			})
+		].filter(Boolean);
+	}
 });
 
-// src/node-range.ts
+//#region src/helpers/getNodeRangeDecorations.ts
 function getNodeRangeDecorations(ranges) {
-  if (!ranges.length) {
-    return DecorationSet.empty;
-  }
-  const decorations = [];
-  const doc = ranges[0].$from.node(0);
-  ranges.forEach((range) => {
-    const pos = range.$from.pos;
-    const node = range.$from.nodeAfter;
-    if (!node) {
-      return;
-    }
-    decorations.push(
-      Decoration.node(pos, pos + node.nodeSize, {
-        class: "ProseMirror-selectednoderange"
-      })
-    );
-  });
-  return DecorationSet.create(doc, decorations);
+	if (!ranges.length) return DecorationSet.empty;
+	const decorations = [];
+	const doc = ranges[0].$from.node(0);
+	ranges.forEach((range) => {
+		const pos = range.$from.pos;
+		const node = range.$from.nodeAfter;
+		if (!node) return;
+		decorations.push(Decoration.node(pos, pos + node.nodeSize, { class: "ProseMirror-selectednoderange" }));
+	});
+	return DecorationSet.create(doc, decorations);
 }
+//#endregion
+//#region src/helpers/getSelectionRanges.ts
 function getNodeContentBounds(nodeStart, nodeSize, node) {
-  const contentOffset = node.isText || node.isAtom ? 0 : 1;
-  return {
-    start: nodeStart + contentOffset,
-    end: nodeStart + nodeSize - contentOffset
-  };
+	const contentOffset = node.isText || node.isAtom ? 0 : 1;
+	return {
+		start: nodeStart + contentOffset,
+		end: nodeStart + nodeSize - contentOffset
+	};
 }
+/**
+* Calculates node-aligned selection ranges between two resolved positions.
+*
+* The helper derives a suitable depth when none is provided and returns a
+* `SelectionRange` for each matching child node in the computed `NodeRange`.
+* Each returned range exposes `$from` as the resolved start position of the
+* node selection and `$to` as the resolved end position.
+*
+* @param $from The resolved anchor position where the selection starts.
+* @param $to The resolved head position where the selection ends.
+* @param depth An optional depth to force when creating the ProseMirror `NodeRange`.
+* When omitted, the depth is inferred from the shared depth of `$from` and `$to`.
+* @param options Optional behavior flags for how boundary nodes are handled.
+* @param options.extendOnBoundaryOverlap Whether touching only a node's start
+* or end content boundary should still include that node in the returned ranges.
+* @returns An array of `SelectionRange` objects for the nodes covered at the
+* computed depth.
+* @example
+* ```ts
+* const { $from, $to } = editor.state.selection
+* const ranges = getSelectionRanges($from, $to, undefined, {
+*   extendOnBoundaryOverlap: false,
+* })
+*
+* ranges.forEach(range => {
+*   console.log(range.$from.pos, range.$to.pos)
+* })
+* ```
+*/
 function getSelectionRanges($from, $to, depth, options = {}) {
-  const ranges = [];
-  const doc = $from.node(0);
-  const { extendOnBoundaryOverlap = true } = options;
-  if (typeof depth === "number" && depth >= 0) ; else if ($from.sameParent($to)) {
-    depth = Math.max(0, $from.sharedDepth($to.pos) - 1);
-  } else {
-    depth = $from.sharedDepth($to.pos);
-  }
-  const nodeRange = new NodeRange($from, $to, depth);
-  const offset = nodeRange.depth === 0 ? 0 : doc.resolve(nodeRange.start).posAtIndex(0);
-  nodeRange.parent.forEach((node, pos) => {
-    const from = offset + pos;
-    const to = from + node.nodeSize;
-    const contentBounds = getNodeContentBounds(from, node.nodeSize, node);
-    const overlapsNodeContent = extendOnBoundaryOverlap ? $to.pos >= contentBounds.start && $from.pos <= contentBounds.end : $to.pos > contentBounds.start && $from.pos < contentBounds.end;
-    if (from < nodeRange.start || from >= nodeRange.end) {
-      return;
-    }
-    if (!overlapsNodeContent) {
-      return;
-    }
-    const selectionRange = new SelectionRange(doc.resolve(from), doc.resolve(to));
-    ranges.push(selectionRange);
-  });
-  return ranges;
+	const ranges = [];
+	const doc = $from.node(0);
+	const { extendOnBoundaryOverlap = true } = options;
+	if (typeof depth === "number" && depth >= 0) ; else if ($from.sameParent($to)) depth = Math.max(0, $from.sharedDepth($to.pos) - 1);
+	else depth = $from.sharedDepth($to.pos);
+	const nodeRange = new NodeRange($from, $to, depth);
+	const offset = nodeRange.depth === 0 ? 0 : doc.resolve(nodeRange.start).posAtIndex(0);
+	nodeRange.parent.forEach((node, pos) => {
+		const from = offset + pos;
+		const to = from + node.nodeSize;
+		const contentBounds = getNodeContentBounds(from, node.nodeSize, node);
+		const overlapsNodeContent = extendOnBoundaryOverlap ? $to.pos >= contentBounds.start && $from.pos <= contentBounds.end : $to.pos > contentBounds.start && $from.pos < contentBounds.end;
+		if (from < nodeRange.start || from >= nodeRange.end) return;
+		if (!overlapsNodeContent) return;
+		const selectionRange = new SelectionRange(doc.resolve(from), doc.resolve(to));
+		ranges.push(selectionRange);
+	});
+	return ranges;
 }
-
-// src/helpers/NodeRangeBookmark.ts
-var NodeRangeBookmark = class _NodeRangeBookmark {
-  constructor(anchor, head, depth) {
-    this.anchor = anchor;
-    this.head = head;
-    this.depth = depth != null ? depth : 0;
-  }
-  map(mapping) {
-    return new _NodeRangeBookmark(mapping.map(this.anchor), mapping.map(this.head), this.depth);
-  }
-  resolve(doc) {
-    const $anchor = doc.resolve(this.anchor);
-    const $head = doc.resolve(this.head);
-    return new NodeRangeSelection($anchor, $head, this.depth);
-  }
-};
-
-// src/helpers/NodeRangeSelection.ts
-var NodeRangeSelection = class _NodeRangeSelection extends Selection {
-  constructor($anchor, $head, depth, bias = 1) {
-    const { doc } = $anchor;
-    const isCursor = $anchor === $head;
-    const isCursorAtEnd = $anchor.pos === doc.content.size && $head.pos === doc.content.size;
-    const $correctedHead = isCursor && !isCursorAtEnd ? doc.resolve($head.pos + (bias > 0 ? 1 : -1)) : $head;
-    const $correctedAnchor = isCursor && isCursorAtEnd ? doc.resolve($anchor.pos - (bias > 0 ? 1 : -1)) : $anchor;
-    const ranges = getSelectionRanges(
-      $correctedAnchor.min($correctedHead),
-      $correctedAnchor.max($correctedHead),
-      depth
-    );
-    const $rangeFrom = $correctedHead.pos >= $anchor.pos ? ranges[0].$from : ranges[ranges.length - 1].$to;
-    const $rangeTo = $correctedHead.pos >= $anchor.pos ? ranges[ranges.length - 1].$to : ranges[0].$from;
-    super($rangeFrom, $rangeTo, ranges);
-    this.depth = depth;
-  }
-  // we can safely ignore this TypeScript error: https://github.com/Microsoft/TypeScript/issues/338
-  // @ts-ignore
-  get $to() {
-    return this.ranges[this.ranges.length - 1].$to;
-  }
-  eq(other) {
-    return other instanceof _NodeRangeSelection && other.$from.pos === this.$from.pos && other.$to.pos === this.$to.pos;
-  }
-  map(doc, mapping) {
-    const $anchor = doc.resolve(mapping.map(this.anchor));
-    const $head = doc.resolve(mapping.map(this.head));
-    return new _NodeRangeSelection($anchor, $head, this.depth);
-  }
-  toJSON() {
-    return {
-      type: "nodeRange",
-      anchor: this.anchor,
-      head: this.head,
-      depth: this.depth
-    };
-  }
-  get isForwards() {
-    return this.head >= this.anchor;
-  }
-  get isBackwards() {
-    return !this.isForwards;
-  }
-  extendBackwards() {
-    const { doc } = this.$from;
-    if (this.isForwards && this.ranges.length > 1) {
-      const ranges = this.ranges.slice(0, -1);
-      const $from2 = ranges[0].$from;
-      const $to = ranges[ranges.length - 1].$to;
-      return new _NodeRangeSelection($from2, $to, this.depth);
-    }
-    const firstRange = this.ranges[0];
-    const $from = doc.resolve(Math.max(0, firstRange.$from.pos - 1));
-    return new _NodeRangeSelection(this.$anchor, $from, this.depth);
-  }
-  extendForwards() {
-    const { doc } = this.$from;
-    if (this.isBackwards && this.ranges.length > 1) {
-      const ranges = this.ranges.slice(1);
-      const $from = ranges[0].$from;
-      const $to2 = ranges[ranges.length - 1].$to;
-      return new _NodeRangeSelection($to2, $from, this.depth);
-    }
-    const lastRange = this.ranges[this.ranges.length - 1];
-    const $to = doc.resolve(Math.min(doc.content.size, lastRange.$to.pos + 1));
-    return new _NodeRangeSelection(this.$anchor, $to, this.depth);
-  }
-  static fromJSON(doc, json) {
-    return new _NodeRangeSelection(doc.resolve(json.anchor), doc.resolve(json.head), json.depth);
-  }
-  static create(doc, anchor, head, depth, bias = 1) {
-    return new this(doc.resolve(anchor), doc.resolve(head), depth, bias);
-  }
-  getBookmark() {
-    return new NodeRangeBookmark(this.anchor, this.head, this.depth);
-  }
+//#endregion
+//#region src/helpers/NodeRangeBookmark.ts
+var NodeRangeBookmark = class NodeRangeBookmark {
+	constructor(anchor, head, depth) {
+		this.anchor = anchor;
+		this.head = head;
+		this.depth = depth !== null && depth !== void 0 ? depth : 0;
+	}
+	map(mapping) {
+		return new NodeRangeBookmark(mapping.map(this.anchor), mapping.map(this.head), this.depth);
+	}
+	resolve(doc) {
+		return new NodeRangeSelection(doc.resolve(this.anchor), doc.resolve(this.head), this.depth);
+	}
+};
+//#endregion
+//#region src/helpers/NodeRangeSelection.ts
+var NodeRangeSelection = class NodeRangeSelection extends Selection {
+	constructor($anchor, $head, depth, bias = 1) {
+		const { doc } = $anchor;
+		const isCursor = $anchor === $head;
+		const isCursorAtEnd = $anchor.pos === doc.content.size && $head.pos === doc.content.size;
+		const $correctedHead = isCursor && !isCursorAtEnd ? doc.resolve($head.pos + (bias > 0 ? 1 : -1)) : $head;
+		const $correctedAnchor = isCursor && isCursorAtEnd ? doc.resolve($anchor.pos - (bias > 0 ? 1 : -1)) : $anchor;
+		const ranges = getSelectionRanges($correctedAnchor.min($correctedHead), $correctedAnchor.max($correctedHead), depth);
+		const $rangeFrom = $correctedHead.pos >= $anchor.pos ? ranges[0].$from : ranges[ranges.length - 1].$to;
+		const $rangeTo = $correctedHead.pos >= $anchor.pos ? ranges[ranges.length - 1].$to : ranges[0].$from;
+		super($rangeFrom, $rangeTo, ranges);
+		this.depth = depth;
+	}
+	get $to() {
+		return this.ranges[this.ranges.length - 1].$to;
+	}
+	eq(other) {
+		return other instanceof NodeRangeSelection && other.$from.pos === this.$from.pos && other.$to.pos === this.$to.pos;
+	}
+	map(doc, mapping) {
+		const $anchor = doc.resolve(mapping.map(this.anchor));
+		const $head = doc.resolve(mapping.map(this.head));
+		return new NodeRangeSelection($anchor, $head, this.depth);
+	}
+	toJSON() {
+		return {
+			type: "nodeRange",
+			anchor: this.anchor,
+			head: this.head,
+			depth: this.depth
+		};
+	}
+	get isForwards() {
+		return this.head >= this.anchor;
+	}
+	get isBackwards() {
+		return !this.isForwards;
+	}
+	extendBackwards() {
+		const { doc } = this.$from;
+		if (this.isForwards && this.ranges.length > 1) {
+			const ranges = this.ranges.slice(0, -1);
+			const $from = ranges[0].$from;
+			const $to = ranges[ranges.length - 1].$to;
+			return new NodeRangeSelection($from, $to, this.depth);
+		}
+		const firstRange = this.ranges[0];
+		const $from = doc.resolve(Math.max(0, firstRange.$from.pos - 1));
+		return new NodeRangeSelection(this.$anchor, $from, this.depth);
+	}
+	extendForwards() {
+		const { doc } = this.$from;
+		if (this.isBackwards && this.ranges.length > 1) {
+			const ranges = this.ranges.slice(1);
+			const $from = ranges[0].$from;
+			const $to = ranges[ranges.length - 1].$to;
+			return new NodeRangeSelection($to, $from, this.depth);
+		}
+		const lastRange = this.ranges[this.ranges.length - 1];
+		const $to = doc.resolve(Math.min(doc.content.size, lastRange.$to.pos + 1));
+		return new NodeRangeSelection(this.$anchor, $to, this.depth);
+	}
+	static fromJSON(doc, json) {
+		return new NodeRangeSelection(doc.resolve(json.anchor), doc.resolve(json.head), json.depth);
+	}
+	static create(doc, anchor, head, depth, bias = 1) {
+		return new this(doc.resolve(anchor), doc.resolve(head), depth, bias);
+	}
+	getBookmark() {
+		return new NodeRangeBookmark(this.anchor, this.head, this.depth);
+	}
 };
 NodeRangeSelection.prototype.visible = false;
 try {
-  Selection.jsonID("nodeRange", NodeRangeSelection);
-} catch {
-}
-
-// src/helpers/isNodeRangeSelection.ts
+	Selection.jsonID("nodeRange", NodeRangeSelection);
+} catch {}
+//#endregion
+//#region src/helpers/isNodeRangeSelection.ts
 function isNodeRangeSelection(value) {
-  return value instanceof NodeRangeSelection;
+	return value instanceof NodeRangeSelection;
 }
-
-// src/node-range.ts
+//#endregion
+//#region src/node-range.ts
 Extension.create({
-  name: "nodeRange",
-  addOptions() {
-    return {
-      depth: void 0,
-      key: "Mod"
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      // extend NodeRangeSelection upwards
-      "Shift-ArrowUp": ({ editor }) => {
-        const { depth } = this.options;
-        const { view, state } = editor;
-        const { doc, selection, tr } = state;
-        const { anchor, head } = selection;
-        if (!isNodeRangeSelection(selection)) {
-          const nodeRangeSelection2 = NodeRangeSelection.create(doc, anchor, head, depth, -1);
-          tr.setSelection(nodeRangeSelection2);
-          view.dispatch(tr);
-          return true;
-        }
-        const nodeRangeSelection = selection.extendBackwards();
-        tr.setSelection(nodeRangeSelection);
-        view.dispatch(tr);
-        return true;
-      },
-      // extend NodeRangeSelection downwards
-      "Shift-ArrowDown": ({ editor }) => {
-        const { depth } = this.options;
-        const { view, state } = editor;
-        const { doc, selection, tr } = state;
-        const { anchor, head } = selection;
-        if (!isNodeRangeSelection(selection)) {
-          const nodeRangeSelection2 = NodeRangeSelection.create(doc, anchor, head, depth);
-          tr.setSelection(nodeRangeSelection2);
-          view.dispatch(tr);
-          return true;
-        }
-        const nodeRangeSelection = selection.extendForwards();
-        tr.setSelection(nodeRangeSelection);
-        view.dispatch(tr);
-        return true;
-      },
-      // add `NodeRangeSelection` to all nodes
-      "Mod-a": ({ editor }) => {
-        const { depth } = this.options;
-        const { view, state } = editor;
-        const { doc, tr } = state;
-        const nodeRangeSelection = NodeRangeSelection.create(doc, 0, doc.content.size, depth);
-        tr.setSelection(nodeRangeSelection);
-        view.dispatch(tr);
-        return true;
-      }
-    };
-  },
-  onSelectionUpdate() {
-    const { selection } = this.editor.state;
-    if (isNodeRangeSelection(selection)) {
-      this.editor.view.dom.classList.add("ProseMirror-noderangeselection");
-    }
-  },
-  addProseMirrorPlugins() {
-    let hideTextSelection = false;
-    let activeMouseSelection = false;
-    return [
-      new Plugin({
-        key: new PluginKey("nodeRange"),
-        props: {
-          attributes: () => {
-            if (hideTextSelection) {
-              return {
-                class: "ProseMirror-noderangeselection"
-              };
-            }
-            return { class: "" };
-          },
-          handleDOMEvents: {
-            mousedown: (view, event) => {
-              const { key } = this.options;
-              const isMac = /Mac/.test(navigator.platform);
-              const isShift = !!event.shiftKey;
-              const isControl = !!event.ctrlKey;
-              const isAlt = !!event.altKey;
-              const isMeta = !!event.metaKey;
-              const isMod = isMac ? isMeta : isControl;
-              if (key === null || key === void 0 || key === "Shift" && isShift || key === "Control" && isControl || key === "Alt" && isAlt || key === "Meta" && isMeta || key === "Mod" && isMod) {
-                activeMouseSelection = true;
-              }
-              if (!activeMouseSelection) {
-                return false;
-              }
-              document.addEventListener(
-                "mouseup",
-                () => {
-                  activeMouseSelection = false;
-                  const { state } = view;
-                  const { doc, selection, tr } = state;
-                  const { $anchor, $head } = selection;
-                  if ($anchor.sameParent($head)) {
-                    return;
-                  }
-                  const nodeRangeSelection = NodeRangeSelection.create(
-                    doc,
-                    $anchor.pos,
-                    $head.pos,
-                    this.options.depth
-                  );
-                  tr.setSelection(nodeRangeSelection);
-                  view.dispatch(tr);
-                },
-                { once: true }
-              );
-              return false;
-            }
-          },
-          // when selecting some text we want to render some decorations
-          // to preview a `NodeRangeSelection`
-          decorations: (state) => {
-            const { selection } = state;
-            const isNodeRange = isNodeRangeSelection(selection);
-            hideTextSelection = false;
-            if (!activeMouseSelection) {
-              if (!isNodeRange) {
-                return null;
-              }
-              hideTextSelection = true;
-              return getNodeRangeDecorations(selection.ranges);
-            }
-            const { $from, $to } = selection;
-            if (!isNodeRange && $from.sameParent($to)) {
-              return null;
-            }
-            const nodeRanges = getSelectionRanges($from, $to, this.options.depth);
-            if (!nodeRanges.length) {
-              return null;
-            }
-            hideTextSelection = true;
-            return getNodeRangeDecorations(nodeRanges);
-          }
-        }
-      })
-    ];
-  }
+	name: "nodeRange",
+	addOptions() {
+		return {
+			depth: void 0,
+			key: "Mod"
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Shift-ArrowUp": ({ editor }) => {
+				const { depth } = this.options;
+				const { view, state } = editor;
+				const { doc, selection, tr } = state;
+				const { anchor, head } = selection;
+				if (!isNodeRangeSelection(selection)) {
+					const nodeRangeSelection = NodeRangeSelection.create(doc, anchor, head, depth, -1);
+					tr.setSelection(nodeRangeSelection);
+					view.dispatch(tr);
+					return true;
+				}
+				const nodeRangeSelection = selection.extendBackwards();
+				tr.setSelection(nodeRangeSelection);
+				view.dispatch(tr);
+				return true;
+			},
+			"Shift-ArrowDown": ({ editor }) => {
+				const { depth } = this.options;
+				const { view, state } = editor;
+				const { doc, selection, tr } = state;
+				const { anchor, head } = selection;
+				if (!isNodeRangeSelection(selection)) {
+					const nodeRangeSelection = NodeRangeSelection.create(doc, anchor, head, depth);
+					tr.setSelection(nodeRangeSelection);
+					view.dispatch(tr);
+					return true;
+				}
+				const nodeRangeSelection = selection.extendForwards();
+				tr.setSelection(nodeRangeSelection);
+				view.dispatch(tr);
+				return true;
+			},
+			"Mod-a": ({ editor }) => {
+				const { depth } = this.options;
+				const { view, state } = editor;
+				const { doc, tr } = state;
+				const nodeRangeSelection = NodeRangeSelection.create(doc, 0, doc.content.size, depth);
+				tr.setSelection(nodeRangeSelection);
+				view.dispatch(tr);
+				return true;
+			}
+		};
+	},
+	onSelectionUpdate() {
+		const { selection } = this.editor.state;
+		if (isNodeRangeSelection(selection)) this.editor.view.dom.classList.add("ProseMirror-noderangeselection");
+	},
+	addProseMirrorPlugins() {
+		let hideTextSelection = false;
+		let activeMouseSelection = false;
+		return [new Plugin({
+			key: new PluginKey("nodeRange"),
+			props: {
+				attributes: () => {
+					if (hideTextSelection) return { class: "ProseMirror-noderangeselection" };
+					return { class: "" };
+				},
+				handleDOMEvents: { mousedown: (view, event) => {
+					const { key } = this.options;
+					const isMac = /Mac/.test(navigator.platform);
+					const isShift = !!event.shiftKey;
+					const isControl = !!event.ctrlKey;
+					const isAlt = !!event.altKey;
+					const isMeta = !!event.metaKey;
+					if (key === null || key === void 0 || key === "Shift" && isShift || key === "Control" && isControl || key === "Alt" && isAlt || key === "Meta" && isMeta || key === "Mod" && (isMac ? isMeta : isControl)) activeMouseSelection = true;
+					if (!activeMouseSelection) return false;
+					document.addEventListener("mouseup", () => {
+						activeMouseSelection = false;
+						const { state } = view;
+						const { doc, selection, tr } = state;
+						const { $anchor, $head } = selection;
+						if ($anchor.sameParent($head)) return;
+						const nodeRangeSelection = NodeRangeSelection.create(doc, $anchor.pos, $head.pos, this.options.depth);
+						tr.setSelection(nodeRangeSelection);
+						view.dispatch(tr);
+					}, { once: true });
+					return false;
+				} },
+				decorations: (state) => {
+					const { selection } = state;
+					const isNodeRange = isNodeRangeSelection(selection);
+					hideTextSelection = false;
+					if (!activeMouseSelection) {
+						if (!isNodeRange) return null;
+						hideTextSelection = true;
+						return getNodeRangeDecorations(selection.ranges);
+					}
+					const { $from, $to } = selection;
+					if (!isNodeRange && $from.sameParent($to)) return null;
+					const nodeRanges = getSelectionRanges($from, $to, this.options.depth);
+					if (!nodeRanges.length) return null;
+					hideTextSelection = true;
+					return getNodeRangeDecorations(nodeRanges);
+				}
+			}
+		})];
+	}
 });
 
-// src/drag-handle.ts
-
-// src/helpers/cloneElement.ts
+//#region src/helpers/cloneElement.ts
 function getCSSText(element, properties) {
-  const style = getComputedStyle(element);
-  if (properties) {
-    return properties.map((property) => property.trim()).filter((property) => property.length > 0).map((property) => `${property}:${style.getPropertyValue(property)};`).join("");
-  }
-  let value = "";
-  for (let i = 0; i < style.length; i += 1) {
-    value += `${style[i]}:${style.getPropertyValue(style[i])};`;
-  }
-  return value;
+	const style = getComputedStyle(element);
+	if (properties) return properties.map((property) => property.trim()).filter((property) => property.length > 0).map((property) => `${property}:${style.getPropertyValue(property)};`).join("");
+	let value = "";
+	for (let i = 0; i < style.length; i += 1) value += `${style[i]}:${style.getPropertyValue(style[i])};`;
+	return value;
 }
 function cloneElement(node, properties) {
-  const clonedNode = node.cloneNode(true);
-  const sourceElements = [node, ...Array.from(node.getElementsByTagName("*"))];
-  const targetElements = [
-    clonedNode,
-    ...Array.from(clonedNode.getElementsByTagName("*"))
-  ];
-  sourceElements.forEach((sourceElement, index) => {
-    targetElements[index].style.cssText = getCSSText(sourceElement, properties);
-  });
-  return clonedNode;
+	const clonedNode = node.cloneNode(true);
+	const sourceElements = [node, ...Array.from(node.getElementsByTagName("*"))];
+	const targetElements = [clonedNode, ...Array.from(clonedNode.getElementsByTagName("*"))];
+	sourceElements.forEach((sourceElement, index) => {
+		targetElements[index].style.cssText = getCSSText(sourceElement, properties);
+	});
+	return clonedNode;
 }
-
-// src/helpers/defaultRules.ts
-var listItemFirstChild = {
-  id: "listItemFirstChild",
-  evaluate: ({ parent, isFirst }) => {
-    if (!isFirst) {
-      return 0;
-    }
-    const listItemTypes = ["listItem", "taskItem"];
-    if (parent && listItemTypes.includes(parent.type.name)) {
-      return 1e3;
-    }
-    return 0;
-  }
-};
-var listWrapperDeprioritize = {
-  id: "listWrapperDeprioritize",
-  evaluate: ({ node }) => {
-    const listItemTypes = ["listItem", "taskItem"];
-    const firstChild = node.firstChild;
-    if (firstChild && listItemTypes.includes(firstChild.type.name)) {
-      return 1e3;
-    }
-    return 0;
-  }
-};
-var tableStructure = {
-  id: "tableStructure",
-  evaluate: ({ node, parent }) => {
-    const tableStructureTypes = ["tableRow", "tableCell", "tableHeader"];
-    if (tableStructureTypes.includes(node.type.name)) {
-      return 1e3;
-    }
-    if (parent && parent.type.name === "tableHeader") {
-      return 1e3;
-    }
-    return 0;
-  }
-};
-var inlineContent = {
-  id: "inlineContent",
-  evaluate: ({ node }) => {
-    if (node.isInline || node.isText) {
-      return 1e3;
-    }
-    return 0;
-  }
-};
-var defaultRules = [
-  listItemFirstChild,
-  listWrapperDeprioritize,
-  tableStructure,
-  inlineContent
+/**
+* All default rules.
+* Users can extend these or replace them entirely.
+*/
+const defaultRules = [
+	{
+		id: "listItemFirstChild",
+		evaluate: ({ parent, isFirst }) => {
+			if (!isFirst) return 0;
+			if (parent && ["listItem", "taskItem"].includes(parent.type.name)) return 1e3;
+			return 0;
+		}
+	},
+	{
+		id: "listWrapperDeprioritize",
+		evaluate: ({ node }) => {
+			const listItemTypes = ["listItem", "taskItem"];
+			const firstChild = node.firstChild;
+			if (firstChild && listItemTypes.includes(firstChild.type.name)) return 1e3;
+			return 0;
+		}
+	},
+	{
+		id: "tableStructure",
+		evaluate: ({ node, parent }) => {
+			if ([
+				"tableRow",
+				"tableCell",
+				"tableHeader"
+			].includes(node.type.name)) return 1e3;
+			if (parent && parent.type.name === "tableHeader") return 1e3;
+			return 0;
+		}
+	},
+	{
+		id: "inlineContent",
+		evaluate: ({ node }) => {
+			if (node.isInline || node.isText) return 1e3;
+			return 0;
+		}
+	}
 ];
-
-// src/helpers/edgeDetection.ts
-var DEFAULT_EDGE_CONFIG = {
-  edges: ["left", "top"],
-  threshold: 12,
-  strength: 500
-};
+//#endregion
+//#region src/helpers/edgeDetection.ts
+/**
+* Default edge detection configuration.
+*/
+const DEFAULT_EDGE_CONFIG = {
+	edges: ["left", "top"],
+	threshold: 12,
+	strength: 500
+};
+/**
+* Normalizes edge detection presets or custom config into a full config object.
+* Partial configs are merged with defaults.
+*
+* @param input - The preset string or partial/full config
+* @returns A complete EdgeDetectionConfig
+*/
 function normalizeEdgeDetection(input) {
-  if (input === void 0 || input === "left") {
-    return { ...DEFAULT_EDGE_CONFIG };
-  }
-  if (input === "right") {
-    return { edges: ["right", "top"], threshold: 12, strength: 500 };
-  }
-  if (input === "both") {
-    return { edges: ["left", "right", "top"], threshold: 12, strength: 500 };
-  }
-  if (input === "none") {
-    return { edges: [], threshold: 0, strength: 0 };
-  }
-  return { ...DEFAULT_EDGE_CONFIG, ...input };
+	if (input === void 0 || input === "left") return { ...DEFAULT_EDGE_CONFIG };
+	if (input === "right") return {
+		edges: ["right", "top"],
+		threshold: 12,
+		strength: 500
+	};
+	if (input === "both") return {
+		edges: [
+			"left",
+			"right",
+			"top"
+		],
+		threshold: 12,
+		strength: 500
+	};
+	if (input === "none") return {
+		edges: [],
+		threshold: 0,
+		strength: 0
+	};
+	return {
+		...DEFAULT_EDGE_CONFIG,
+		...input
+	};
 }
+/**
+* Determines if cursor is near specified edges of an element.
+*
+* @param coords - The cursor coordinates
+* @param element - The element to check against
+* @param config - The edge detection configuration
+* @returns True if the cursor is near any of the configured edges
+*/
 function isNearEdge(coords, element, config) {
-  if (config.edges.length === 0) {
-    return false;
-  }
-  const rect = element.getBoundingClientRect();
-  const { threshold, edges } = config;
-  return edges.some((edge) => {
-    if (edge === "left") {
-      return coords.x - rect.left < threshold;
-    }
-    if (edge === "right") {
-      return rect.right - coords.x < threshold;
-    }
-    if (edge === "top") {
-      return coords.y - rect.top < threshold;
-    }
-    if (edge === "bottom") {
-      return rect.bottom - coords.y < threshold;
-    }
-    return false;
-  });
+	if (config.edges.length === 0) return false;
+	const rect = element.getBoundingClientRect();
+	const { threshold, edges } = config;
+	return edges.some((edge) => {
+		if (edge === "left") return coords.x - rect.left < threshold;
+		if (edge === "right") return rect.right - coords.x < threshold;
+		if (edge === "top") return coords.y - rect.top < threshold;
+		if (edge === "bottom") return rect.bottom - coords.y < threshold;
+		return false;
+	});
 }
+/**
+* Calculates score deduction for edge proximity.
+* Deeper nodes get larger deductions when near edges,
+* making shallower (parent) nodes win.
+*
+* @param coords - The cursor coordinates
+* @param element - The element to check against (may be null)
+* @param config - The edge detection configuration
+* @param depth - The depth of the node in the document tree
+* @returns The score deduction to apply
+*/
 function calculateEdgeDeduction(coords, element, config, depth) {
-  if (!element || config.edges.length === 0) {
-    return 0;
-  }
-  if (isNearEdge(coords, element, config)) {
-    return config.strength * depth;
-  }
-  return 0;
+	if (!element || config.edges.length === 0) return 0;
+	if (isNearEdge(coords, element, config)) return config.strength * depth;
+	return 0;
 }
-
-// src/helpers/scoring.ts
-var BASE_SCORE = 1e3;
+//#endregion
+//#region src/helpers/scoring.ts
+/**
+* Base score for all nodes. Rules deduct from this score.
+* A node with score <= 0 is excluded from being a drag target.
+*/
+const BASE_SCORE = 1e3;
+/**
+* Calculates the drag target score for a node.
+* Higher score = more likely to be selected.
+*
+* @param context - The rule context containing node information
+* @param rules - The rules to apply
+* @param edgeConfig - The edge detection configuration
+* @param coords - The cursor coordinates
+* @returns The calculated score, or -1 if the node is excluded
+*/
 function calculateScore(context, rules, edgeConfig, coords) {
-  let score = BASE_SCORE;
-  let excluded = false;
-  rules.every((rule) => {
-    const deduction = rule.evaluate(context);
-    score -= deduction;
-    if (score <= 0) {
-      excluded = true;
-      return false;
-    }
-    return true;
-  });
-  if (excluded) {
-    return -1;
-  }
-  const dom = context.view.nodeDOM(context.pos);
-  score -= calculateEdgeDeduction(coords, dom, edgeConfig, context.depth);
-  if (score <= 0) {
-    return -1;
-  }
-  return score;
+	let score = BASE_SCORE;
+	let excluded = false;
+	rules.every((rule) => {
+		const deduction = rule.evaluate(context);
+		score -= deduction;
+		if (score <= 0) {
+			excluded = true;
+			return false;
+		}
+		return true;
+	});
+	if (excluded) return -1;
+	const dom = context.view.nodeDOM(context.pos);
+	score -= calculateEdgeDeduction(coords, dom, edgeConfig, context.depth);
+	if (score <= 0) return -1;
+	return score;
 }
-
-// src/helpers/findBestDragTarget.ts
+//#endregion
+//#region src/helpers/findBestDragTarget.ts
+/**
+* Checks if any ancestor at or above the given depth is in the allowed list.
+*
+* @param $pos - The resolved position
+* @param depth - The current depth being checked
+* @param allowedTypes - The list of allowed node type names
+* @returns True if any ancestor is in the allowed list
+*/
 function hasAncestorOfType($pos, depth, allowedTypes) {
-  const ancestorDepths = Array.from({ length: depth }, (_, i) => depth - 1 - i);
-  return ancestorDepths.some((d) => allowedTypes.includes($pos.node(d).type.name));
+	return Array.from({ length: depth }, (_, i) => depth - 1 - i).some((d) => allowedTypes.includes($pos.node(d).type.name));
 }
+/**
+* Finds the best drag target at the given coordinates using the scoring system.
+*
+* @param view - The editor view
+* @param coords - The cursor coordinates
+* @param options - The normalized nested options
+* @returns The best drag target, or null if none found
+*/
 function findBestDragTarget(view, coords, options) {
-  if (!Number.isFinite(coords.x) || !Number.isFinite(coords.y)) {
-    return null;
-  }
-  const posInfo = view.posAtCoords({ left: coords.x, top: coords.y });
-  if (!posInfo) {
-    return null;
-  }
-  const { doc } = view.state;
-  const $pos = doc.resolve(posInfo.pos);
-  const rules = [];
-  if (options.defaultRules) {
-    rules.push(...defaultRules);
-  }
-  rules.push(...options.rules);
-  const depthLevels = Array.from({ length: $pos.depth }, (_, i) => $pos.depth - i);
-  const candidates = depthLevels.map((depth) => {
-    const node = $pos.node(depth);
-    const nodePos = $pos.before(depth);
-    if (options.allowedContainers && depth > 0) {
-      const inAllowedContainer = hasAncestorOfType($pos, depth, options.allowedContainers);
-      if (!inAllowedContainer) {
-        return null;
-      }
-    }
-    const parent = depth > 0 ? $pos.node(depth - 1) : null;
-    const index = depth > 0 ? $pos.index(depth - 1) : 0;
-    const siblingCount = parent ? parent.childCount : 1;
-    const context = {
-      node,
-      pos: nodePos,
-      depth,
-      parent,
-      index,
-      isFirst: index === 0,
-      isLast: index === siblingCount - 1,
-      $pos,
-      view
-    };
-    const score = calculateScore(context, rules, options.edgeDetection, coords);
-    if (score < 0) {
-      return null;
-    }
-    const dom = view.nodeDOM(nodePos);
-    return { node, pos: nodePos, depth, score, dom };
-  }).filter((candidate) => candidate !== null);
-  const nodeAfter = $pos.nodeAfter;
-  if (nodeAfter && nodeAfter.isAtom && !nodeAfter.isInline) {
-    const nodePos = posInfo.pos;
-    const depth = $pos.depth + 1;
-    const parent = $pos.parent;
-    const index = $pos.index();
-    const siblingCount = parent.childCount;
-    let inAllowedContainer = true;
-    if (options.allowedContainers) {
-      inAllowedContainer = hasAncestorOfType($pos, depth, options.allowedContainers);
-    }
-    if (inAllowedContainer) {
-      const context = {
-        node: nodeAfter,
-        pos: nodePos,
-        depth,
-        parent,
-        index,
-        isFirst: index === 0,
-        isLast: index === siblingCount - 1,
-        $pos,
-        view
-      };
-      const score = calculateScore(context, rules, options.edgeDetection, coords);
-      if (score >= 0) {
-        const dom = view.nodeDOM(nodePos);
-        if (dom) {
-          candidates.push({ node: nodeAfter, pos: nodePos, depth, score, dom });
-        }
-      }
-    }
-  }
-  if (candidates.length === 0) {
-    return null;
-  }
-  candidates.sort((a, b) => {
-    if (b.score !== a.score) {
-      return b.score - a.score;
-    }
-    return b.depth - a.depth;
-  });
-  const winner = candidates[0];
-  if (!winner.dom) {
-    return null;
-  }
-  return {
-    node: winner.node,
-    pos: winner.pos,
-    dom: winner.dom
-  };
+	if (!Number.isFinite(coords.x) || !Number.isFinite(coords.y)) return null;
+	const posInfo = view.posAtCoords({
+		left: coords.x,
+		top: coords.y
+	});
+	if (!posInfo) return null;
+	const { doc } = view.state;
+	const $pos = doc.resolve(posInfo.pos);
+	const rules = [];
+	if (options.defaultRules) rules.push(...defaultRules);
+	rules.push(...options.rules);
+	const candidates = Array.from({ length: $pos.depth }, (_, i) => $pos.depth - i).map((depth) => {
+		const node = $pos.node(depth);
+		const nodePos = $pos.before(depth);
+		if (options.allowedContainers && depth > 0) {
+			if (!hasAncestorOfType($pos, depth, options.allowedContainers)) return null;
+		}
+		const parent = depth > 0 ? $pos.node(depth - 1) : null;
+		const index = depth > 0 ? $pos.index(depth - 1) : 0;
+		const siblingCount = parent ? parent.childCount : 1;
+		const score = calculateScore({
+			node,
+			pos: nodePos,
+			depth,
+			parent,
+			index,
+			isFirst: index === 0,
+			isLast: index === siblingCount - 1,
+			$pos,
+			view
+		}, rules, options.edgeDetection, coords);
+		if (score < 0) return null;
+		return {
+			node,
+			pos: nodePos,
+			depth,
+			score,
+			dom: view.nodeDOM(nodePos)
+		};
+	}).filter((candidate) => candidate !== null);
+	const nodeAfter = $pos.nodeAfter;
+	if (nodeAfter && nodeAfter.isAtom && !nodeAfter.isInline) {
+		const nodePos = posInfo.pos;
+		const depth = $pos.depth + 1;
+		const parent = $pos.parent;
+		const index = $pos.index();
+		const siblingCount = parent.childCount;
+		let inAllowedContainer = true;
+		if (options.allowedContainers) inAllowedContainer = hasAncestorOfType($pos, depth, options.allowedContainers);
+		if (inAllowedContainer) {
+			const score = calculateScore({
+				node: nodeAfter,
+				pos: nodePos,
+				depth,
+				parent,
+				index,
+				isFirst: index === 0,
+				isLast: index === siblingCount - 1,
+				$pos,
+				view
+			}, rules, options.edgeDetection, coords);
+			if (score >= 0) {
+				const dom = view.nodeDOM(nodePos);
+				if (dom) candidates.push({
+					node: nodeAfter,
+					pos: nodePos,
+					depth,
+					score,
+					dom
+				});
+			}
+		}
+	}
+	if (candidates.length === 0) return null;
+	candidates.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		return b.depth - a.depth;
+	});
+	const winner = candidates[0];
+	if (!winner.dom) return null;
+	return {
+		node: winner.node,
+		pos: winner.pos,
+		dom: winner.dom
+	};
 }
-
-// src/helpers/findNextElementFromCursor.ts
+//#endregion
+//#region src/helpers/findNextElementFromCursor.ts
+/**
+* Finds the draggable block element that is a direct child of view.dom.
+*
+* Direct children that are widget decorations rather than document content are
+* skipped — they are not draggable blocks, and treating them as such would
+* align the drag handle to the decoration (e.g. the page header) instead of the
+* actual first block on the page.
+*/
 function findClosestTopLevelBlock(element, view) {
-  var _a;
-  let current = element;
-  while ((current == null ? void 0 : current.parentElement) && current.parentElement !== view.dom) {
-    current = current.parentElement;
-  }
-  if ((current == null ? void 0 : current.parentElement) !== view.dom) {
-    return void 0;
-  }
-  if (!((_a = current.pmViewDesc) == null ? void 0 : _a.node)) {
-    return void 0;
-  }
-  return current;
+	var _pmViewDesc;
+	let current = element;
+	while ((current === null || current === void 0 ? void 0 : current.parentElement) && current.parentElement !== view.dom) current = current.parentElement;
+	if ((current === null || current === void 0 ? void 0 : current.parentElement) !== view.dom) return;
+	if (!((_pmViewDesc = current.pmViewDesc) === null || _pmViewDesc === void 0 ? void 0 : _pmViewDesc.node)) return;
+	return current;
 }
+/**
+* Checks if a DOMRect has valid, finite dimensions.
+*/
 function isValidRect(rect) {
-  return Number.isFinite(rect.top) && Number.isFinite(rect.bottom) && Number.isFinite(rect.left) && Number.isFinite(rect.right) && rect.width > 0 && rect.height > 0;
+	return Number.isFinite(rect.top) && Number.isFinite(rect.bottom) && Number.isFinite(rect.left) && Number.isFinite(rect.right) && rect.width > 0 && rect.height > 0;
 }
+/**
+* Returns the bounding rect of the first or last child of `container` that has
+* a valid (non-zero) layout box.
+*
+* Some extensions insert zero-size widget decorations as the first/last child
+* of the editor — for example the Pages extension anchors its page-chrome
+* overlay in a zero-height `<div>` as the first child. Reading `firstElementChild`
+* / `lastElementChild` directly would yield an invalid rect and abort clamping,
+* so we skip over any edge children without a valid box.
+*/
 function edgeBlockRect(container, edge) {
-  let current = edge === "first" ? container.firstElementChild : container.lastElementChild;
-  while (current) {
-    const rect = current.getBoundingClientRect();
-    if (isValidRect(rect)) {
-      return rect;
-    }
-    current = edge === "first" ? current.nextElementSibling : current.previousElementSibling;
-  }
-  return null;
+	let current = edge === "first" ? container.firstElementChild : container.lastElementChild;
+	while (current) {
+		const rect = current.getBoundingClientRect();
+		if (isValidRect(rect)) return rect;
+		current = edge === "first" ? current.nextElementSibling : current.previousElementSibling;
+	}
+	return null;
 }
+/**
+* Clamps coordinates to content bounds with O(1) layout reads
+*/
 function clampToContent(view, x, y, inset = 5) {
-  if (!Number.isFinite(x) || !Number.isFinite(y)) {
-    return null;
-  }
-  const container = view.dom;
-  const topRect = edgeBlockRect(container, "first");
-  const botRect = edgeBlockRect(container, "last");
-  if (!topRect || !botRect) {
-    return null;
-  }
-  const clampedY = Math.min(Math.max(topRect.top + inset, y), botRect.bottom - inset);
-  const epsilon = 0.5;
-  const sameLeft = Math.abs(topRect.left - botRect.left) < epsilon;
-  const sameRight = Math.abs(topRect.right - botRect.right) < epsilon;
-  let rowRect = topRect;
-  if (sameLeft && sameRight) {
-    rowRect = topRect;
-  }
-  const clampedX = Math.min(Math.max(rowRect.left + inset, x), rowRect.right - inset);
-  if (!Number.isFinite(clampedX) || !Number.isFinite(clampedY)) {
-    return null;
-  }
-  return { x: clampedX, y: clampedY };
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+	const container = view.dom;
+	const topRect = edgeBlockRect(container, "first");
+	const botRect = edgeBlockRect(container, "last");
+	if (!topRect || !botRect) return null;
+	const clampedY = Math.min(Math.max(topRect.top + inset, y), botRect.bottom - inset);
+	const epsilon = .5;
+	const sameLeft = Math.abs(topRect.left - botRect.left) < epsilon;
+	const sameRight = Math.abs(topRect.right - botRect.right) < epsilon;
+	let rowRect = topRect;
+	if (sameLeft && sameRight) rowRect = topRect;
+	const clampedX = Math.min(Math.max(rowRect.left + inset, x), rowRect.right - inset);
+	if (!Number.isFinite(clampedX) || !Number.isFinite(clampedY)) return null;
+	return {
+		x: clampedX,
+		y: clampedY
+	};
 }
-var findElementNextToCoords = (options) => {
-  const { x, y, editor, nestedOptions } = options;
-  const { view, state } = editor;
-  const clamped = clampToContent(view, x, y, 5);
-  if (!clamped) {
-    return { resultElement: null, resultNode: null, pos: null };
-  }
-  const { x: clampedX, y: clampedY } = clamped;
-  if (nestedOptions == null ? void 0 : nestedOptions.enabled) {
-    const target = findBestDragTarget(view, { x: clampedX, y: clampedY }, nestedOptions);
-    if (!target) {
-      return { resultElement: null, resultNode: null, pos: null };
-    }
-    return {
-      resultElement: target.dom,
-      resultNode: target.node,
-      pos: target.pos
-    };
-  }
-  const elements = view.root.elementsFromPoint(clampedX, clampedY);
-  let block;
-  Array.prototype.some.call(elements, (el) => {
-    if (!view.dom.contains(el)) {
-      return false;
-    }
-    const candidate = findClosestTopLevelBlock(el, view);
-    if (candidate) {
-      block = candidate;
-      return true;
-    }
-    return false;
-  });
-  if (!block) {
-    const coords = view.posAtCoords({ left: clampedX, top: clampedY });
-    if (coords) {
-      const $pos = state.doc.resolve(coords.pos);
-      const depth = Math.min($pos.depth, 1);
-      const blockPos = depth > 0 ? $pos.before(depth) : $pos.pos;
-      const blockNode = state.doc.nodeAt(blockPos);
-      if (blockNode) {
-        const dom = view.nodeDOM(blockPos);
-        return {
-          resultElement: dom instanceof HTMLElement ? dom : null,
-          resultNode: blockNode,
-          pos: blockPos
-        };
-      }
-    }
-    return { resultElement: null, resultNode: null, pos: null };
-  }
-  let pos;
-  try {
-    pos = view.posAtDOM(block, 0);
-  } catch {
-    return { resultElement: null, resultNode: null, pos: null };
-  }
-  const node = state.doc.nodeAt(pos);
-  if (!node) {
-    const resolvedPos = state.doc.resolve(pos);
-    const parent = resolvedPos.parent;
-    return {
-      resultElement: block,
-      resultNode: parent,
-      pos: resolvedPos.start()
-    };
-  }
-  return {
-    resultElement: block,
-    resultNode: node,
-    pos
-  };
-};
-
-// src/helpers/getDraggedBlockDir.ts
+const findElementNextToCoords = (options) => {
+	const { x, y, editor, nestedOptions } = options;
+	const { view, state } = editor;
+	const clamped = clampToContent(view, x, y, 5);
+	if (!clamped) return {
+		resultElement: null,
+		resultNode: null,
+		pos: null
+	};
+	const { x: clampedX, y: clampedY } = clamped;
+	if (nestedOptions === null || nestedOptions === void 0 ? void 0 : nestedOptions.enabled) {
+		const target = findBestDragTarget(view, {
+			x: clampedX,
+			y: clampedY
+		}, nestedOptions);
+		if (!target) return {
+			resultElement: null,
+			resultNode: null,
+			pos: null
+		};
+		return {
+			resultElement: target.dom,
+			resultNode: target.node,
+			pos: target.pos
+		};
+	}
+	const elements = view.root.elementsFromPoint(clampedX, clampedY);
+	let block;
+	Array.prototype.some.call(elements, (el) => {
+		if (!view.dom.contains(el)) return false;
+		const candidate = findClosestTopLevelBlock(el, view);
+		if (candidate) {
+			block = candidate;
+			return true;
+		}
+		return false;
+	});
+	if (!block) {
+		const coords = view.posAtCoords({
+			left: clampedX,
+			top: clampedY
+		});
+		if (coords) {
+			const $pos = state.doc.resolve(coords.pos);
+			const depth = Math.min($pos.depth, 1);
+			const blockPos = depth > 0 ? $pos.before(depth) : $pos.pos;
+			const blockNode = state.doc.nodeAt(blockPos);
+			if (blockNode) {
+				const dom = view.nodeDOM(blockPos);
+				return {
+					resultElement: dom instanceof HTMLElement ? dom : null,
+					resultNode: blockNode,
+					pos: blockPos
+				};
+			}
+		}
+		return {
+			resultElement: null,
+			resultNode: null,
+			pos: null
+		};
+	}
+	let pos;
+	try {
+		pos = view.posAtDOM(block, 0);
+	} catch {
+		return {
+			resultElement: null,
+			resultNode: null,
+			pos: null
+		};
+	}
+	const node = state.doc.nodeAt(pos);
+	if (!node) {
+		const resolvedPos = state.doc.resolve(pos);
+		const parent = resolvedPos.parent;
+		return {
+			resultElement: block,
+			resultNode: parent,
+			pos: resolvedPos.start()
+		};
+	}
+	return {
+		resultElement: block,
+		resultNode: node,
+		pos
+	};
+};
+//#endregion
+//#region src/helpers/getDraggedBlockDir.ts
+/**
+* Resolves the DOM element that visually represents the dragged block.
+*/
 function getDraggedBlockElement(view, pos) {
-  const nodeDom = view.nodeDOM(pos);
-  if (nodeDom instanceof Element && nodeDom !== view.dom) {
-    return nodeDom;
-  }
-  const { node, offset } = view.domAtPos(pos);
-  const child = node.childNodes[offset];
-  if (child instanceof Element) {
-    return child;
-  }
-  if (node instanceof Element) {
-    return node;
-  }
-  if (node.nodeType === Node.TEXT_NODE && node.parentElement) {
-    return node.parentElement;
-  }
-  return null;
+	const nodeDom = view.nodeDOM(pos);
+	if (nodeDom instanceof Element && nodeDom !== view.dom) return nodeDom;
+	const { node, offset } = view.domAtPos(pos);
+	const child = node.childNodes[offset];
+	if (child instanceof Element) return child;
+	if (node instanceof Element) return node;
+	if (node.nodeType === Node.TEXT_NODE && node.parentElement) return node.parentElement;
+	return null;
 }
+/**
+* Resolves the text direction (`dir` attribute value) for the block being
+* dragged. Uses `view.nodeDOM` first because it maps a ProseMirror position
+* directly to the block-level DOM element. Falls back to `view.domAtPos` with
+* proper child-at-offset resolution when `nodeDOM` doesn't return an element,
+* and ultimately to the editor root direction.
+*/
 function getDraggedBlockDir(view, pos) {
-  const draggedDom = getDraggedBlockElement(view, pos);
-  const contentDir = draggedDom ? getComputedStyle(draggedDom).direction : getComputedStyle(view.dom).direction;
-  return contentDir || "ltr";
+	const draggedDom = getDraggedBlockElement(view, pos);
+	return (draggedDom ? getComputedStyle(draggedDom).direction : getComputedStyle(view.dom).direction) || "ltr";
 }
-
-// src/helpers/removeNode.ts
+//#endregion
+//#region src/helpers/removeNode.ts
 function removeNode(node) {
-  var _a;
-  (_a = node.parentNode) == null ? void 0 : _a.removeChild(node);
+	var _node$parentNode;
+	(_node$parentNode = node.parentNode) === null || _node$parentNode === void 0 || _node$parentNode.removeChild(node);
 }
-
-// src/helpers/dragHandler.ts
+//#endregion
+//#region src/helpers/dragHandler.ts
 function getDragImageOffset(direction, wrapperWidth) {
-  return direction === "rtl" ? wrapperWidth : 0;
+	return direction === "rtl" ? wrapperWidth : 0;
 }
 function shouldResetMargin(dragImageProperties) {
-  if (!dragImageProperties) {
-    return true;
-  }
-  return !dragImageProperties.some((property) => {
-    const p = property.trim().toLowerCase();
-    return p === "margin" || p.startsWith("margin-");
-  });
+	if (!dragImageProperties) return true;
+	return !dragImageProperties.some((property) => {
+		const p = property.trim().toLowerCase();
+		return p === "margin" || p.startsWith("margin-");
+	});
 }
 function getDragHandleRanges(event, editor, nestedOptions, dragContext) {
-  const { doc } = editor.view.state;
-  if ((nestedOptions == null ? void 0 : nestedOptions.enabled) && (dragContext == null ? void 0 : dragContext.node) && dragContext.pos >= 0) {
-    const nodeStart = dragContext.pos;
-    const nodeEnd = dragContext.pos + dragContext.node.nodeSize;
-    return [
-      {
-        $from: doc.resolve(nodeStart),
-        $to: doc.resolve(nodeEnd)
-      }
-    ];
-  }
-  const result = findElementNextToCoords({
-    editor,
-    x: event.clientX,
-    y: event.clientY,
-    nestedOptions
-  });
-  if (!result.resultNode || result.pos === null) {
-    return [];
-  }
-  const offset = result.resultNode.isText || result.resultNode.isAtom ? 0 : -1;
-  const $from = doc.resolve(result.pos);
-  const $to = doc.resolve(result.pos + result.resultNode.nodeSize + offset);
-  return getSelectionRanges($from, $to, 0, { extendOnBoundaryOverlap: false });
+	const { doc } = editor.view.state;
+	if ((nestedOptions === null || nestedOptions === void 0 ? void 0 : nestedOptions.enabled) && (dragContext === null || dragContext === void 0 ? void 0 : dragContext.node) && dragContext.pos >= 0) {
+		const nodeStart = dragContext.pos;
+		const nodeEnd = dragContext.pos + dragContext.node.nodeSize;
+		return [{
+			$from: doc.resolve(nodeStart),
+			$to: doc.resolve(nodeEnd)
+		}];
+	}
+	const result = findElementNextToCoords({
+		editor,
+		x: event.clientX,
+		y: event.clientY,
+		nestedOptions
+	});
+	if (!result.resultNode || result.pos === null) return [];
+	const offset = result.resultNode.isText || result.resultNode.isAtom ? 0 : -1;
+	const $from = doc.resolve(result.pos);
+	const $to = doc.resolve(result.pos + result.resultNode.nodeSize + offset);
+	return getSelectionRanges($from, $to, 0, { extendOnBoundaryOverlap: false });
 }
 function dragHandler(event, editor, nestedOptions, dragContext, dragImageProperties) {
-  const { view } = editor;
-  if (!event.dataTransfer) {
-    return;
-  }
-  const { empty, $from, $to } = view.state.selection;
-  const dragHandleRanges = getDragHandleRanges(event, editor, nestedOptions, dragContext);
-  const selectionRanges = getSelectionRanges($from, $to, 0, { extendOnBoundaryOverlap: false });
-  const isDragHandleWithinSelection = selectionRanges.some((range) => {
-    return dragHandleRanges.find((dragHandleRange) => {
-      return dragHandleRange.$from === range.$from && dragHandleRange.$to === range.$to;
-    });
-  });
-  const ranges = empty || !isDragHandleWithinSelection ? dragHandleRanges : selectionRanges;
-  if (!ranges.length) {
-    return;
-  }
-  const { tr } = view.state;
-  const wrapper = document.createElement("div");
-  const from = ranges[0].$from.pos;
-  const to = ranges[ranges.length - 1].$to.pos;
-  const direction = getDraggedBlockDir(view, from);
-  wrapper.setAttribute("dir", direction);
-  const isNestedDrag = (nestedOptions == null ? void 0 : nestedOptions.enabled) && (dragContext == null ? void 0 : dragContext.node);
-  const isSingleBlock = ranges.length === 1;
-  let slice;
-  let selection;
-  if (isNestedDrag && isSingleBlock) {
-    slice = view.state.doc.slice(from, to);
-    selection = NodeSelection.create(view.state.doc, from);
-  } else {
-    selection = NodeRangeSelection.create(view.state.doc, from, to);
-    slice = selection.content();
-  }
-  const resetMargin = shouldResetMargin(dragImageProperties);
-  ranges.forEach((range) => {
-    const element = getDraggedBlockElement(view, range.$from.pos);
-    if (!element) {
-      return;
-    }
-    const clonedElement = cloneElement(element, dragImageProperties);
-    if (resetMargin) {
-      clonedElement.style.margin = "0";
-    }
-    wrapper.append(clonedElement);
-  });
-  wrapper.style.position = "absolute";
-  wrapper.style.top = "-10000px";
-  document.body.append(wrapper);
-  event.dataTransfer.clearData();
-  const wrapperRect = wrapper.getBoundingClientRect();
-  const dragImageX = getDragImageOffset(direction, wrapperRect.width);
-  event.dataTransfer.setDragImage(wrapper, dragImageX, 0);
-  let cleanedUp = false;
-  const cleanupDragPreview = () => {
-    if (cleanedUp) {
-      return;
-    }
-    cleanedUp = true;
-    removeNode(wrapper);
-    document.removeEventListener("drop", cleanupDragPreview);
-    document.removeEventListener("dragend", cleanupDragPreview);
-  };
-  const nodeSelection = selection instanceof NodeSelection ? selection : void 0;
-  view.dragging = { slice, move: true, node: nodeSelection };
-  tr.setSelection(selection);
-  view.dispatch(tr);
-  document.addEventListener("drop", cleanupDragPreview);
-  document.addEventListener("dragend", cleanupDragPreview);
+	const { view } = editor;
+	if (!event.dataTransfer) return;
+	const { empty, $from, $to } = view.state.selection;
+	const dragHandleRanges = getDragHandleRanges(event, editor, nestedOptions, dragContext);
+	const selectionRanges = getSelectionRanges($from, $to, 0, { extendOnBoundaryOverlap: false });
+	const isDragHandleWithinSelection = selectionRanges.some((range) => {
+		return dragHandleRanges.find((dragHandleRange) => {
+			return dragHandleRange.$from === range.$from && dragHandleRange.$to === range.$to;
+		});
+	});
+	const ranges = empty || !isDragHandleWithinSelection ? dragHandleRanges : selectionRanges;
+	if (!ranges.length) return;
+	const { tr } = view.state;
+	const wrapper = document.createElement("div");
+	const from = ranges[0].$from.pos;
+	const to = ranges[ranges.length - 1].$to.pos;
+	const direction = getDraggedBlockDir(view, from);
+	wrapper.setAttribute("dir", direction);
+	const isNestedDrag = (nestedOptions === null || nestedOptions === void 0 ? void 0 : nestedOptions.enabled) && (dragContext === null || dragContext === void 0 ? void 0 : dragContext.node);
+	const isSingleBlock = ranges.length === 1;
+	let slice;
+	let selection;
+	if (isNestedDrag && isSingleBlock) {
+		slice = view.state.doc.slice(from, to);
+		selection = NodeSelection.create(view.state.doc, from);
+	} else {
+		selection = NodeRangeSelection.create(view.state.doc, from, to);
+		slice = selection.content();
+	}
+	const resetMargin = shouldResetMargin(dragImageProperties);
+	ranges.forEach((range) => {
+		const element = getDraggedBlockElement(view, range.$from.pos);
+		if (!element) return;
+		const clonedElement = cloneElement(element, dragImageProperties);
+		if (resetMargin) clonedElement.style.margin = "0";
+		wrapper.append(clonedElement);
+	});
+	wrapper.style.position = "absolute";
+	wrapper.style.top = "-10000px";
+	document.body.append(wrapper);
+	event.dataTransfer.clearData();
+	const dragImageX = getDragImageOffset(direction, wrapper.getBoundingClientRect().width);
+	event.dataTransfer.setDragImage(wrapper, dragImageX, 0);
+	let cleanedUp = false;
+	const cleanupDragPreview = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		removeNode(wrapper);
+		document.removeEventListener("drop", cleanupDragPreview);
+		document.removeEventListener("dragend", cleanupDragPreview);
+	};
+	const nodeSelection = selection instanceof NodeSelection ? selection : void 0;
+	view.dragging = {
+		slice,
+		move: true,
+		node: nodeSelection
+	};
+	tr.setSelection(selection);
+	view.dispatch(tr);
+	document.addEventListener("drop", cleanupDragPreview);
+	document.addEventListener("dragend", cleanupDragPreview);
 }
-
-// src/helpers/getOuterNode.ts
-var getOuterNodePos = (doc, pos) => {
-  const resolvedPos = doc.resolve(pos);
-  const { depth } = resolvedPos;
-  if (depth === 0) {
-    return pos;
-  }
-  const a = resolvedPos.pos - resolvedPos.parentOffset;
-  return a - 1;
-};
-var getOuterNode = (doc, pos) => {
-  const node = doc.nodeAt(pos);
-  const resolvedPos = doc.resolve(pos);
-  let { depth } = resolvedPos;
-  let parent = node;
-  while (depth > 0) {
-    const currentNode = resolvedPos.node(depth);
-    depth -= 1;
-    if (depth === 0) {
-      parent = currentNode;
-    }
-  }
-  return parent;
-};
+//#endregion
+//#region src/helpers/getOuterNode.ts
+const getOuterNodePos = (doc, pos) => {
+	const resolvedPos = doc.resolve(pos);
+	const { depth } = resolvedPos;
+	if (depth === 0) return pos;
+	return resolvedPos.pos - resolvedPos.parentOffset - 1;
+};
+const getOuterNode = (doc, pos) => {
+	const node = doc.nodeAt(pos);
+	const resolvedPos = doc.resolve(pos);
+	let { depth } = resolvedPos;
+	let parent = node;
+	while (depth > 0) {
+		const currentNode = resolvedPos.node(depth);
+		depth -= 1;
+		if (depth === 0) parent = currentNode;
+	}
+	return parent;
+};
+//#endregion
+//#region src/helpers/nodeRangeDrop.ts
 function mapPendingRestoreAnchor(pendingRestore, tr, options) {
-  if (!tr.docChanged) {
-    return pendingRestore;
-  }
-  if (options.isChangeOrigin && pendingRestore.relativeAnchorPos != null) {
-    const newPos = options.getAbsolutePos(pendingRestore.relativeAnchorPos);
-    if (!Number.isFinite(newPos) || newPos <= 0) {
-      return null;
-    }
-    return {
-      ...pendingRestore,
-      anchorPos: newPos
-    };
-  }
-  const mappedResult = tr.mapping.mapResult(pendingRestore.anchorPos, 1);
-  if (mappedResult.deleted) {
-    return null;
-  }
-  return {
-    ...pendingRestore,
-    anchorPos: mappedResult.pos
-  };
+	if (!tr.docChanged) return pendingRestore;
+	if (options.isChangeOrigin && pendingRestore.relativeAnchorPos != null) {
+		const newPos = options.getAbsolutePos(pendingRestore.relativeAnchorPos);
+		if (!Number.isFinite(newPos) || newPos <= 0) return null;
+		return {
+			...pendingRestore,
+			anchorPos: newPos
+		};
+	}
+	const mappedResult = tr.mapping.mapResult(pendingRestore.anchorPos, 1);
+	if (mappedResult.deleted) return null;
+	return {
+		...pendingRestore,
+		anchorPos: mappedResult.pos
+	};
 }
 function sumNodeSizes(parent, from, to) {
-  let size = 0;
-  for (let i = from; i < to; i += 1) {
-    size += parent.child(i).nodeSize;
-  }
-  return size;
+	let size = 0;
+	for (let i = from; i < to; i += 1) size += parent.child(i).nodeSize;
+	return size;
 }
 function getActiveDragRange(selection) {
-  var _a;
-  if (!isNodeRangeSelection(selection)) {
-    return null;
-  }
-  return {
-    anchorPos: selection.from,
-    nodeCount: selection.ranges.length,
-    depth: (_a = selection.depth) != null ? _a : 0
-  };
+	var _selection$depth;
+	if (!isNodeRangeSelection(selection)) return null;
+	return {
+		anchorPos: selection.from,
+		nodeCount: selection.ranges.length,
+		depth: (_selection$depth = selection.depth) !== null && _selection$depth !== void 0 ? _selection$depth : 0
+	};
 }
+/**
+* Computes the position range of the freshly dropped blocks so a
+* `NodeRangeSelection` can be restored over them after a drag-and-drop.
+*/
 function getDroppedBlockRange(doc, anchorPos, nodeCount, depth) {
-  const $pos = doc.resolve(anchorPos);
-  const parent = $pos.node(depth);
-  let index = $pos.index(depth);
-  if (index >= parent.childCount) {
-    index = Math.max(0, parent.childCount - nodeCount);
-  }
-  const count = Math.min(nodeCount, parent.childCount - index);
-  if (count <= 0) {
-    return null;
-  }
-  const blockStart = $pos.start(depth) + sumNodeSizes(parent, 0, index);
-  const blockEnd = blockStart + sumNodeSizes(parent, index, index + count);
-  return { anchor: blockStart, head: blockEnd, count };
+	const $pos = doc.resolve(anchorPos);
+	const parent = $pos.node(depth);
+	let index = $pos.index(depth);
+	if (index >= parent.childCount) index = Math.max(0, parent.childCount - nodeCount);
+	const count = Math.min(nodeCount, parent.childCount - index);
+	if (count <= 0) return null;
+	const blockStart = $pos.start(depth) + sumNodeSizes(parent, 0, index);
+	return {
+		anchor: blockStart,
+		head: blockStart + sumNodeSizes(parent, index, index + count),
+		count
+	};
 }
 function createDroppedNodeRangeSelection(doc, anchorPos, nodeCount, depth) {
-  try {
-    const range = getDroppedBlockRange(doc, anchorPos, nodeCount, depth);
-    if (!range) {
-      return null;
-    }
-    const selection = NodeRangeSelection.create(doc, range.anchor, range.head, depth);
-    return selection.ranges.length === nodeCount ? selection : null;
-  } catch {
-    return null;
-  }
+	try {
+		const range = getDroppedBlockRange(doc, anchorPos, nodeCount, depth);
+		if (!range) return null;
+		const selection = NodeRangeSelection.create(doc, range.anchor, range.head, depth);
+		return selection.ranges.length === nodeCount ? selection : null;
+	} catch {
+		return null;
+	}
 }
-
-// src/drag-handle-plugin.ts
-var getRelativePos = (state, absolutePos) => {
-  const ystate = ySyncPluginKey.getState(state);
-  if (!ystate) {
-    return null;
-  }
-  return absolutePositionToRelativePosition(absolutePos, ystate.type, ystate.binding.mapping);
-};
-var getAbsolutePos = (state, relativePos) => {
-  const ystate = ySyncPluginKey.getState(state);
-  if (!ystate) {
-    return -1;
-  }
-  return relativePositionToAbsolutePosition(
-    ystate.doc,
-    ystate.type,
-    relativePos,
-    ystate.binding.mapping
-  ) || 0;
-};
-var getOuterDomNode = (view, domNode) => {
-  let tmpDomNode = domNode;
-  while (tmpDomNode == null ? void 0 : tmpDomNode.parentNode) {
-    if (tmpDomNode.parentNode === view.dom) {
-      break;
-    }
-    tmpDomNode = tmpDomNode.parentNode;
-  }
-  return tmpDomNode;
-};
-var dragHandlePluginDefaultKey = new PluginKey("dragHandle");
-var DragHandlePlugin = ({
-  pluginKey = dragHandlePluginDefaultKey,
-  element,
-  editor,
-  computePositionConfig,
-  getReferencedVirtualElement,
-  onNodeChange,
-  onElementDragStart,
-  onElementDragEnd,
-  nestedOptions,
-  dragImageProperties
-}) => {
-  const wrapper = document.createElement("div");
-  let locked = false;
-  let currentNode = null;
-  let currentNodePos = -1;
-  let currentNodeRelPos;
-  let rafId = null;
-  let pendingMouseCoords = null;
-  let activeDragRange = null;
-  let pendingRestore = null;
-  function clearDragRangeState() {
-    activeDragRange = null;
-    pendingRestore = null;
-  }
-  function remapPendingRestore(tr, state) {
-    if (!pendingRestore) {
-      return;
-    }
-    pendingRestore = mapPendingRestoreAnchor(pendingRestore, tr, {
-      isChangeOrigin: isChangeOrigin(tr),
-      getAbsolutePos: (relativePos) => getAbsolutePos(state, relativePos)
-    });
-  }
-  function buildRestoreTransaction(state) {
-    if (!pendingRestore) {
-      return null;
-    }
-    const nodeRangeSelection = createDroppedNodeRangeSelection(
-      state.doc,
-      pendingRestore.anchorPos,
-      pendingRestore.nodeCount,
-      pendingRestore.depth
-    );
-    if (!nodeRangeSelection) {
-      pendingRestore = null;
-      activeDragRange = null;
-      return null;
-    }
-    clearDragRangeState();
-    return state.tr.setSelection(nodeRangeSelection);
-  }
-  function hideHandle() {
-    if (!element) {
-      return;
-    }
-    element.style.visibility = "hidden";
-    element.style.pointerEvents = "none";
-  }
-  function showHandle() {
-    if (!element) {
-      return;
-    }
-    if (!editor.isEditable) {
-      hideHandle();
-      return;
-    }
-    element.style.visibility = "";
-    element.style.pointerEvents = "auto";
-  }
-  function repositionDragHandle(dom) {
-    const virtualElement = (getReferencedVirtualElement == null ? void 0 : getReferencedVirtualElement()) || {
-      getBoundingClientRect: () => dom.getBoundingClientRect()
-    };
-    computePosition(virtualElement, element, computePositionConfig).then((val) => {
-      Object.assign(element.style, {
-        position: val.strategy,
-        left: `${val.x}px`,
-        top: `${val.y}px`
-      });
-    });
-  }
-  function onDragStart(e) {
-    onElementDragStart == null ? void 0 : onElementDragStart(e);
-    dragHandler(
-      e,
-      editor,
-      nestedOptions,
-      { node: currentNode, pos: currentNodePos },
-      dragImageProperties
-    );
-    activeDragRange = getActiveDragRange(editor.state.selection);
-    if (element) {
-      element.dataset.dragging = "true";
-    }
-    setTimeout(() => {
-      if (element) {
-        element.style.pointerEvents = "none";
-      }
-    }, 0);
-  }
-  function onDragEnd(e) {
-    onElementDragEnd == null ? void 0 : onElementDragEnd(e);
-    activeDragRange = null;
-    hideHandle();
-    if (element) {
-      element.style.pointerEvents = "auto";
-      element.dataset.dragging = "false";
-    }
-  }
-  function onDrop(e) {
-    if (!e.target || !editor.view.dom.contains(e.target)) {
-      return;
-    }
-    if (isFirefox()) {
-      const editorElement = editor.view.dom;
-      requestAnimationFrame(() => {
-        if (editorElement.isContentEditable) {
-          editorElement.contentEditable = "false";
-          editorElement.contentEditable = "true";
-        }
-      });
-    }
-    if (!activeDragRange || editor.view.state.selection.empty) {
-      return;
-    }
-    const anchorPos = editor.state.selection.from;
-    const relativeAnchorPos = getRelativePos(editor.state, anchorPos);
-    pendingRestore = {
-      ...activeDragRange,
-      anchorPos,
-      relativeAnchorPos: relativeAnchorPos != null ? relativeAnchorPos : void 0
-    };
-    editor.view.dispatch(editor.state.tr.setMeta("addToHistory", false));
-  }
-  function cleanup() {
-    element.removeEventListener("dragstart", onDragStart);
-    element.removeEventListener("dragend", onDragEnd);
-    document.removeEventListener("drop", onDrop);
-    if (rafId) {
-      cancelAnimationFrame(rafId);
-      rafId = null;
-      pendingMouseCoords = null;
-    }
-    clearDragRangeState();
-  }
-  wrapper.appendChild(element);
-  return {
-    unbind() {
-      cleanup();
-    },
-    plugin: new Plugin({
-      key: typeof pluginKey === "string" ? new PluginKey(pluginKey) : pluginKey,
-      state: {
-        init() {
-          return { locked: false };
-        },
-        apply(tr, value, _oldState, state) {
-          remapPendingRestore(tr, state);
-          const isLocked = tr.getMeta("lockDragHandle");
-          const hideDragHandle = tr.getMeta("hideDragHandle");
-          if (isLocked !== void 0) {
-            locked = isLocked;
-          }
-          if (hideDragHandle) {
-            hideHandle();
-            locked = false;
-            currentNode = null;
-            currentNodePos = -1;
-            onNodeChange == null ? void 0 : onNodeChange({ editor, node: null, pos: -1 });
-            return value;
-          }
-          if (tr.docChanged && currentNodePos !== -1 && element) {
-            if (isChangeOrigin(tr)) {
-              const newPos = getAbsolutePos(state, currentNodeRelPos);
-              if (newPos !== currentNodePos) {
-                currentNodePos = newPos;
-              }
-            } else {
-              const newPos = tr.mapping.map(currentNodePos);
-              if (newPos !== currentNodePos) {
-                currentNodePos = newPos;
-                currentNodeRelPos = getRelativePos(state, currentNodePos);
-              }
-            }
-          }
-          return value;
-        }
-      },
-      appendTransaction(_transactions, _oldState, newState) {
-        return buildRestoreTransaction(newState);
-      },
-      view: (view) => {
-        var _a;
-        element.draggable = true;
-        element.style.pointerEvents = "auto";
-        element.dataset.dragging = "false";
-        (_a = editor.view.dom.parentElement) == null ? void 0 : _a.appendChild(wrapper);
-        wrapper.style.pointerEvents = "none";
-        wrapper.style.position = "absolute";
-        wrapper.style.top = "0";
-        wrapper.style.left = "0";
-        wrapper.style.zIndex = "10";
-        element.addEventListener("dragstart", onDragStart);
-        element.addEventListener("dragend", onDragEnd);
-        document.addEventListener("drop", onDrop);
-        return {
-          update(_, oldState) {
-            if (!element) {
-              return;
-            }
-            if (!editor.isEditable) {
-              hideHandle();
-              return;
-            }
-            if (locked) {
-              element.draggable = false;
-            } else {
-              element.draggable = true;
-            }
-            if (view.state.doc.eq(oldState.doc) || currentNodePos === -1) {
-              return;
-            }
-            let domNode = view.nodeDOM(currentNodePos);
-            domNode = getOuterDomNode(view, domNode);
-            if (domNode === view.dom) {
-              return;
-            }
-            if ((domNode == null ? void 0 : domNode.nodeType) !== 1) {
-              return;
-            }
-            const domNodePos = view.posAtDOM(domNode, 0);
-            const outerNode = getOuterNode(editor.state.doc, domNodePos);
-            const outerNodePos = getOuterNodePos(editor.state.doc, domNodePos);
-            currentNode = outerNode;
-            currentNodePos = outerNodePos;
-            currentNodeRelPos = getRelativePos(view.state, currentNodePos);
-            onNodeChange == null ? void 0 : onNodeChange({ editor, node: currentNode, pos: currentNodePos });
-            repositionDragHandle(domNode);
-          },
-          // TODO: Kills even on hot reload
-          destroy() {
-            cleanup();
-            if (element) {
-              removeNode(wrapper);
-            }
-          }
-        };
-      },
-      props: {
-        handleDOMEvents: {
-          keydown(view) {
-            if (!element || locked) {
-              return false;
-            }
-            if (view.hasFocus()) {
-              hideHandle();
-              currentNode = null;
-              currentNodePos = -1;
-              onNodeChange == null ? void 0 : onNodeChange({ editor, node: null, pos: -1 });
-              return false;
-            }
-            return false;
-          },
-          mouseleave(_view, e) {
-            if (locked) {
-              return false;
-            }
-            if (e.target && !wrapper.contains(e.relatedTarget)) {
-              hideHandle();
-              currentNode = null;
-              currentNodePos = -1;
-              onNodeChange == null ? void 0 : onNodeChange({ editor, node: null, pos: -1 });
-            }
-            return false;
-          },
-          mousemove(view, e) {
-            if (!element || locked) {
-              return false;
-            }
-            pendingMouseCoords = { x: e.clientX, y: e.clientY };
-            if (rafId) {
-              return false;
-            }
-            rafId = requestAnimationFrame(() => {
-              rafId = null;
-              if (!pendingMouseCoords) {
-                return;
-              }
-              const { x, y } = pendingMouseCoords;
-              pendingMouseCoords = null;
-              const nodeData = findElementNextToCoords({
-                x,
-                y,
-                editor,
-                nestedOptions
-              });
-              if (!nodeData.resultElement) {
-                return;
-              }
-              let domNode = nodeData.resultElement;
-              let targetNode = nodeData.resultNode;
-              let targetPos = nodeData.pos;
-              if (!(nestedOptions == null ? void 0 : nestedOptions.enabled)) {
-                domNode = getOuterDomNode(view, domNode);
-                if (domNode === view.dom) {
-                  return;
-                }
-                if ((domNode == null ? void 0 : domNode.nodeType) !== 1) {
-                  return;
-                }
-                const domNodePos = view.posAtDOM(domNode, 0);
-                targetNode = getOuterNode(editor.state.doc, domNodePos);
-                targetPos = getOuterNodePos(editor.state.doc, domNodePos);
-              }
-              if (targetNode !== currentNode) {
-                currentNode = targetNode;
-                currentNodePos = targetPos != null ? targetPos : -1;
-                currentNodeRelPos = getRelativePos(view.state, currentNodePos);
-                onNodeChange == null ? void 0 : onNodeChange({ editor, node: currentNode, pos: currentNodePos });
-                repositionDragHandle(domNode);
-                showHandle();
-              }
-            });
-            return false;
-          }
-        }
-      }
-    })
-  };
-};
-
-// src/helpers/normalizeOptions.ts
+//#endregion
+//#region src/drag-handle-plugin.ts
+const getRelativePos = (state, absolutePos) => {
+	const ystate = ySyncPluginKey.getState(state);
+	if (!ystate) return null;
+	return absolutePositionToRelativePosition(absolutePos, ystate.type, ystate.binding.mapping);
+};
+const getAbsolutePos = (state, relativePos) => {
+	const ystate = ySyncPluginKey.getState(state);
+	if (!ystate) return -1;
+	return relativePositionToAbsolutePosition(ystate.doc, ystate.type, relativePos, ystate.binding.mapping) || 0;
+};
+const getOuterDomNode = (view, domNode) => {
+	let tmpDomNode = domNode;
+	while (tmpDomNode === null || tmpDomNode === void 0 ? void 0 : tmpDomNode.parentNode) {
+		if (tmpDomNode.parentNode === view.dom) break;
+		tmpDomNode = tmpDomNode.parentNode;
+	}
+	return tmpDomNode;
+};
+const dragHandlePluginDefaultKey = new PluginKey("dragHandle");
+const DragHandlePlugin = ({ pluginKey = dragHandlePluginDefaultKey, element, editor, computePositionConfig, getReferencedVirtualElement, onNodeChange, onElementDragStart, onElementDragEnd, nestedOptions, dragImageProperties }) => {
+	const wrapper = document.createElement("div");
+	let locked = false;
+	let currentNode = null;
+	let currentNodePos = -1;
+	let currentNodeRelPos;
+	let rafId = null;
+	let pendingMouseCoords = null;
+	let activeDragRange = null;
+	let pendingRestore = null;
+	function clearDragRangeState() {
+		activeDragRange = null;
+		pendingRestore = null;
+	}
+	function remapPendingRestore(tr, state) {
+		if (!pendingRestore) return;
+		pendingRestore = mapPendingRestoreAnchor(pendingRestore, tr, {
+			isChangeOrigin: isChangeOrigin(tr),
+			getAbsolutePos: (relativePos) => getAbsolutePos(state, relativePos)
+		});
+	}
+	function buildRestoreTransaction(state) {
+		if (!pendingRestore) return null;
+		const nodeRangeSelection = createDroppedNodeRangeSelection(state.doc, pendingRestore.anchorPos, pendingRestore.nodeCount, pendingRestore.depth);
+		if (!nodeRangeSelection) {
+			pendingRestore = null;
+			activeDragRange = null;
+			return null;
+		}
+		clearDragRangeState();
+		return state.tr.setSelection(nodeRangeSelection);
+	}
+	function hideHandle() {
+		if (!element) return;
+		element.style.visibility = "hidden";
+		element.style.pointerEvents = "none";
+	}
+	function showHandle() {
+		if (!element) return;
+		if (!editor.isEditable) {
+			hideHandle();
+			return;
+		}
+		element.style.visibility = "";
+		element.style.pointerEvents = "auto";
+	}
+	function repositionDragHandle(dom) {
+		const virtualElement = (getReferencedVirtualElement === null || getReferencedVirtualElement === void 0 ? void 0 : getReferencedVirtualElement()) || { getBoundingClientRect: () => dom.getBoundingClientRect() };
+		computePosition(virtualElement, element, computePositionConfig).then((val) => {
+			Object.assign(element.style, {
+				position: val.strategy,
+				left: `${val.x}px`,
+				top: `${val.y}px`
+			});
+		});
+	}
+	function onDragStart(e) {
+		onElementDragStart === null || onElementDragStart === void 0 || onElementDragStart(e);
+		dragHandler(e, editor, nestedOptions, {
+			node: currentNode,
+			pos: currentNodePos
+		}, dragImageProperties);
+		activeDragRange = getActiveDragRange(editor.state.selection);
+		if (element) element.dataset.dragging = "true";
+		setTimeout(() => {
+			if (element) element.style.pointerEvents = "none";
+		}, 0);
+	}
+	function onDragEnd(e) {
+		onElementDragEnd === null || onElementDragEnd === void 0 || onElementDragEnd(e);
+		activeDragRange = null;
+		hideHandle();
+		if (element) {
+			element.style.pointerEvents = "auto";
+			element.dataset.dragging = "false";
+		}
+	}
+	function onDrop(e) {
+		if (!e.target || !editor.view.dom.contains(e.target)) return;
+		if (isFirefox()) {
+			const editorElement = editor.view.dom;
+			requestAnimationFrame(() => {
+				if (editorElement.isContentEditable) {
+					editorElement.contentEditable = "false";
+					editorElement.contentEditable = "true";
+				}
+			});
+		}
+		if (!activeDragRange || editor.view.state.selection.empty) return;
+		const anchorPos = editor.state.selection.from;
+		const relativeAnchorPos = getRelativePos(editor.state, anchorPos);
+		pendingRestore = {
+			...activeDragRange,
+			anchorPos,
+			relativeAnchorPos: relativeAnchorPos !== null && relativeAnchorPos !== void 0 ? relativeAnchorPos : void 0
+		};
+		editor.view.dispatch(editor.state.tr.setMeta("addToHistory", false));
+	}
+	function cleanup() {
+		element.removeEventListener("dragstart", onDragStart);
+		element.removeEventListener("dragend", onDragEnd);
+		document.removeEventListener("drop", onDrop);
+		if (rafId) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+			pendingMouseCoords = null;
+		}
+		clearDragRangeState();
+	}
+	wrapper.appendChild(element);
+	return {
+		unbind() {
+			cleanup();
+		},
+		plugin: new Plugin({
+			key: typeof pluginKey === "string" ? new PluginKey(pluginKey) : pluginKey,
+			state: {
+				init() {
+					return { locked: false };
+				},
+				apply(tr, value, _oldState, state) {
+					remapPendingRestore(tr, state);
+					const isLocked = tr.getMeta("lockDragHandle");
+					const hideDragHandle = tr.getMeta("hideDragHandle");
+					if (isLocked !== void 0) locked = isLocked;
+					if (hideDragHandle) {
+						hideHandle();
+						locked = false;
+						currentNode = null;
+						currentNodePos = -1;
+						onNodeChange === null || onNodeChange === void 0 || onNodeChange({
+							editor,
+							node: null,
+							pos: -1
+						});
+						return value;
+					}
+					if (tr.docChanged && currentNodePos !== -1 && element) {
+						if (isChangeOrigin(tr)) {
+							const newPos = getAbsolutePos(state, currentNodeRelPos);
+							if (newPos !== currentNodePos) currentNodePos = newPos;
+						} else {
+							const newPos = tr.mapping.map(currentNodePos);
+							if (newPos !== currentNodePos) {
+								currentNodePos = newPos;
+								currentNodeRelPos = getRelativePos(state, currentNodePos);
+							}
+						}
+					}
+					return value;
+				}
+			},
+			appendTransaction(_transactions, _oldState, newState) {
+				return buildRestoreTransaction(newState);
+			},
+			view: (view) => {
+				var _editor$view$dom$pare;
+				element.draggable = true;
+				element.style.pointerEvents = "auto";
+				element.dataset.dragging = "false";
+				(_editor$view$dom$pare = editor.view.dom.parentElement) === null || _editor$view$dom$pare === void 0 || _editor$view$dom$pare.appendChild(wrapper);
+				wrapper.style.pointerEvents = "none";
+				wrapper.style.position = "absolute";
+				wrapper.style.top = "0";
+				wrapper.style.left = "0";
+				wrapper.style.zIndex = "10";
+				element.addEventListener("dragstart", onDragStart);
+				element.addEventListener("dragend", onDragEnd);
+				document.addEventListener("drop", onDrop);
+				return {
+					update(_, oldState) {
+						if (!element) return;
+						if (!editor.isEditable) {
+							hideHandle();
+							return;
+						}
+						if (locked) element.draggable = false;
+						else element.draggable = true;
+						if (view.state.doc.eq(oldState.doc) || currentNodePos === -1) return;
+						let domNode = view.nodeDOM(currentNodePos);
+						domNode = getOuterDomNode(view, domNode);
+						if (domNode === view.dom) return;
+						if ((domNode === null || domNode === void 0 ? void 0 : domNode.nodeType) !== 1) return;
+						const domNodePos = view.posAtDOM(domNode, 0);
+						const outerNode = getOuterNode(editor.state.doc, domNodePos);
+						const outerNodePos = getOuterNodePos(editor.state.doc, domNodePos);
+						currentNode = outerNode;
+						currentNodePos = outerNodePos;
+						currentNodeRelPos = getRelativePos(view.state, currentNodePos);
+						onNodeChange === null || onNodeChange === void 0 || onNodeChange({
+							editor,
+							node: currentNode,
+							pos: currentNodePos
+						});
+						repositionDragHandle(domNode);
+					},
+					destroy() {
+						cleanup();
+						if (element) removeNode(wrapper);
+					}
+				};
+			},
+			props: { handleDOMEvents: {
+				keydown(view) {
+					if (!element || locked) return false;
+					if (view.hasFocus()) {
+						hideHandle();
+						currentNode = null;
+						currentNodePos = -1;
+						onNodeChange === null || onNodeChange === void 0 || onNodeChange({
+							editor,
+							node: null,
+							pos: -1
+						});
+						return false;
+					}
+					return false;
+				},
+				mouseleave(_view, e) {
+					if (locked) return false;
+					if (e.target && !wrapper.contains(e.relatedTarget)) {
+						hideHandle();
+						currentNode = null;
+						currentNodePos = -1;
+						onNodeChange === null || onNodeChange === void 0 || onNodeChange({
+							editor,
+							node: null,
+							pos: -1
+						});
+					}
+					return false;
+				},
+				mousemove(view, e) {
+					if (!element || locked) return false;
+					pendingMouseCoords = {
+						x: e.clientX,
+						y: e.clientY
+					};
+					if (rafId) return false;
+					rafId = requestAnimationFrame(() => {
+						rafId = null;
+						if (!pendingMouseCoords) return;
+						const { x, y } = pendingMouseCoords;
+						pendingMouseCoords = null;
+						const nodeData = findElementNextToCoords({
+							x,
+							y,
+							editor,
+							nestedOptions
+						});
+						if (!nodeData.resultElement) return;
+						let domNode = nodeData.resultElement;
+						let targetNode = nodeData.resultNode;
+						let targetPos = nodeData.pos;
+						if (!(nestedOptions === null || nestedOptions === void 0 ? void 0 : nestedOptions.enabled)) {
+							domNode = getOuterDomNode(view, domNode);
+							if (domNode === view.dom) return;
+							if ((domNode === null || domNode === void 0 ? void 0 : domNode.nodeType) !== 1) return;
+							const domNodePos = view.posAtDOM(domNode, 0);
+							targetNode = getOuterNode(editor.state.doc, domNodePos);
+							targetPos = getOuterNodePos(editor.state.doc, domNodePos);
+						}
+						if (targetNode !== currentNode) {
+							var _targetPos;
+							currentNode = targetNode;
+							currentNodePos = (_targetPos = targetPos) !== null && _targetPos !== void 0 ? _targetPos : -1;
+							currentNodeRelPos = getRelativePos(view.state, currentNodePos);
+							onNodeChange === null || onNodeChange === void 0 || onNodeChange({
+								editor,
+								node: currentNode,
+								pos: currentNodePos
+							});
+							repositionDragHandle(domNode);
+							showHandle();
+						}
+					});
+					return false;
+				}
+			} }
+		})
+	};
+};
+//#endregion
+//#region src/helpers/normalizeOptions.ts
+/**
+* Normalizes the nested options input into a complete configuration object.
+*
+* @param input - The nested option (boolean, object, or undefined)
+* @returns A fully normalized options object
+*
+* @example
+* // Simple enable
+* normalizeNestedOptions(true)
+* // Returns: { enabled: true, rules: [], defaultRules: true, ... }
+*
+* @example
+* // Custom config
+* normalizeNestedOptions({ rules: [myRule], edgeDetection: 'none' })
+* // Returns: { enabled: true, rules: [myRule], edgeDetection: { edges: [], ... } }
+*/
 function normalizeNestedOptions(input) {
-  var _a, _b;
-  if (input === false || input === void 0) {
-    return {
-      enabled: false,
-      rules: [],
-      defaultRules: true,
-      allowedContainers: void 0,
-      edgeDetection: normalizeEdgeDetection("none")
-    };
-  }
-  if (input === true) {
-    return {
-      enabled: true,
-      rules: [],
-      defaultRules: true,
-      allowedContainers: void 0,
-      edgeDetection: normalizeEdgeDetection("left")
-    };
-  }
-  return {
-    enabled: true,
-    rules: (_a = input.rules) != null ? _a : [],
-    defaultRules: (_b = input.defaultRules) != null ? _b : true,
-    allowedContainers: input.allowedContainers,
-    edgeDetection: normalizeEdgeDetection(input.edgeDetection)
-  };
+	var _input$rules, _input$defaultRules;
+	if (input === false || input === void 0) return {
+		enabled: false,
+		rules: [],
+		defaultRules: true,
+		allowedContainers: void 0,
+		edgeDetection: normalizeEdgeDetection("none")
+	};
+	if (input === true) return {
+		enabled: true,
+		rules: [],
+		defaultRules: true,
+		allowedContainers: void 0,
+		edgeDetection: normalizeEdgeDetection("left")
+	};
+	return {
+		enabled: true,
+		rules: (_input$rules = input.rules) !== null && _input$rules !== void 0 ? _input$rules : [],
+		defaultRules: (_input$defaultRules = input.defaultRules) !== null && _input$defaultRules !== void 0 ? _input$defaultRules : true,
+		allowedContainers: input.allowedContainers,
+		edgeDetection: normalizeEdgeDetection(input.edgeDetection)
+	};
 }
-
-// src/drag-handle.ts
-var defaultComputePositionConfig = {
-  placement: "left-start",
-  strategy: "absolute"
+//#endregion
+//#region src/drag-handle.ts
+const defaultComputePositionConfig = {
+	placement: "left-start",
+	strategy: "absolute"
 };
 Extension.create({
-  name: "dragHandle",
-  addOptions() {
-    return {
-      render() {
-        const element = document.createElement("div");
-        element.classList.add("drag-handle");
-        return element;
-      },
-      computePositionConfig: {},
-      locked: false,
-      onNodeChange: () => {
-        return null;
-      },
-      onElementDragStart: void 0,
-      onElementDragEnd: void 0,
-      nested: false,
-      dragImageProperties: void 0
-    };
-  },
-  addCommands() {
-    return {
-      lockDragHandle: () => ({ editor }) => {
-        this.options.locked = true;
-        return editor.commands.setMeta("lockDragHandle", this.options.locked);
-      },
-      unlockDragHandle: () => ({ editor }) => {
-        this.options.locked = false;
-        return editor.commands.setMeta("lockDragHandle", this.options.locked);
-      },
-      toggleDragHandle: () => ({ editor }) => {
-        this.options.locked = !this.options.locked;
-        return editor.commands.setMeta("lockDragHandle", this.options.locked);
-      }
-    };
-  },
-  addProseMirrorPlugins() {
-    const element = this.options.render();
-    const nestedOptions = normalizeNestedOptions(this.options.nested);
-    return [
-      DragHandlePlugin({
-        computePositionConfig: {
-          ...defaultComputePositionConfig,
-          ...this.options.computePositionConfig
-        },
-        getReferencedVirtualElement: this.options.getReferencedVirtualElement,
-        element,
-        editor: this.editor,
-        onNodeChange: this.options.onNodeChange,
-        onElementDragStart: this.options.onElementDragStart,
-        onElementDragEnd: this.options.onElementDragEnd,
-        nestedOptions,
-        dragImageProperties: this.options.dragImageProperties
-      }).plugin
-    ];
-  }
+	name: "dragHandle",
+	addOptions() {
+		return {
+			render() {
+				const element = document.createElement("div");
+				element.classList.add("drag-handle");
+				return element;
+			},
+			computePositionConfig: {},
+			locked: false,
+			onNodeChange: () => {
+				return null;
+			},
+			onElementDragStart: void 0,
+			onElementDragEnd: void 0,
+			nested: false,
+			dragImageProperties: void 0
+		};
+	},
+	addCommands() {
+		return {
+			lockDragHandle: () => ({ editor }) => {
+				this.options.locked = true;
+				return editor.commands.setMeta("lockDragHandle", this.options.locked);
+			},
+			unlockDragHandle: () => ({ editor }) => {
+				this.options.locked = false;
+				return editor.commands.setMeta("lockDragHandle", this.options.locked);
+			},
+			toggleDragHandle: () => ({ editor }) => {
+				this.options.locked = !this.options.locked;
+				return editor.commands.setMeta("lockDragHandle", this.options.locked);
+			}
+		};
+	},
+	addProseMirrorPlugins() {
+		const element = this.options.render();
+		const nestedOptions = normalizeNestedOptions(this.options.nested);
+		return [DragHandlePlugin({
+			computePositionConfig: {
+				...defaultComputePositionConfig,
+				...this.options.computePositionConfig
+			},
+			getReferencedVirtualElement: this.options.getReferencedVirtualElement,
+			element,
+			editor: this.editor,
+			onNodeChange: this.options.onNodeChange,
+			onElementDragStart: this.options.onElementDragStart,
+			onElementDragEnd: this.options.onElementDragEnd,
+			nestedOptions,
+			dragImageProperties: this.options.dragImageProperties
+		}).plugin];
+	}
 });
 
-// src/DragHandle.tsx
-var DragHandle = (props) => {
-  const {
-    className = "drag-handle",
-    children,
-    editor,
-    pluginKey = dragHandlePluginDefaultKey,
-    onNodeChange,
-    onElementDragStart,
-    onElementDragEnd,
-    getReferencedVirtualElement,
-    computePositionConfig = defaultComputePositionConfig,
-    nested = false
-  } = props;
-  const elementRef = useRef(null);
-  if (elementRef.current === null && typeof document !== "undefined") {
-    elementRef.current = document.createElement("div");
-  }
-  const nestedOptions = useMemo(() => normalizeNestedOptions(nested), [JSON.stringify(nested)]);
-  useEffect(() => {
-    const element2 = elementRef.current;
-    if (!element2) {
-      return;
-    }
-    element2.className = className;
-  }, [className]);
-  useEffect(() => {
-    if (typeof document === "undefined") {
-      return;
-    }
-    if (editor.isDestroyed) {
-      return;
-    }
-    const element2 = elementRef.current;
-    if (!element2) {
-      return;
-    }
-    element2.style.visibility = "hidden";
-    element2.style.position = "absolute";
-    element2.dataset.dragging = "false";
-    const { plugin, unbind } = DragHandlePlugin({
-      editor,
-      element: element2,
-      pluginKey,
-      computePositionConfig: {
-        ...defaultComputePositionConfig,
-        ...computePositionConfig
-      },
-      onElementDragStart,
-      onElementDragEnd,
-      onNodeChange,
-      getReferencedVirtualElement,
-      nestedOptions
-    });
-    editor.registerPlugin(plugin);
-    return () => {
-      if (!editor.isDestroyed) {
-        editor.unregisterPlugin(pluginKey);
-      }
-      unbind();
-    };
-  }, [
-    editor,
-    onNodeChange,
-    getReferencedVirtualElement,
-    pluginKey,
-    computePositionConfig,
-    onElementDragStart,
-    onElementDragEnd,
-    nestedOptions
-  ]);
-  const element = elementRef.current;
-  if (!element) {
-    return null;
-  }
-  return createPortal(children, element);
+//#region src/DragHandle.tsx
+const DragHandle = (props) => {
+	const { className = "drag-handle", children, editor, pluginKey = dragHandlePluginDefaultKey, onNodeChange, onElementDragStart, onElementDragEnd, getReferencedVirtualElement, computePositionConfig = defaultComputePositionConfig, nested = false } = props;
+	const elementRef = useRef(null);
+	if (elementRef.current === null && typeof document !== "undefined") elementRef.current = document.createElement("div");
+	const callbacks = {
+		onNodeChange,
+		onElementDragStart,
+		onElementDragEnd,
+		getReferencedVirtualElement
+	};
+	const callbacksRef = useRef(callbacks);
+	callbacksRef.current = callbacks;
+	const nestedOptions = useMemo(() => normalizeNestedOptions(nested), [JSON.stringify(nested)]);
+	useEffect(() => {
+		const element = elementRef.current;
+		if (!element) return;
+		element.className = className;
+	}, [className]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		if (editor.isDestroyed) return;
+		const element = elementRef.current;
+		if (!element) return;
+		element.style.visibility = "hidden";
+		element.style.position = "absolute";
+		element.dataset.dragging = "false";
+		const { plugin, unbind } = DragHandlePlugin({
+			editor,
+			element,
+			pluginKey,
+			computePositionConfig: {
+				...defaultComputePositionConfig,
+				...computePositionConfig
+			},
+			onElementDragStart: (event) => {
+				var _callbacksRef$current, _callbacksRef$current2;
+				return (_callbacksRef$current = (_callbacksRef$current2 = callbacksRef.current).onElementDragStart) === null || _callbacksRef$current === void 0 ? void 0 : _callbacksRef$current.call(_callbacksRef$current2, event);
+			},
+			onElementDragEnd: (event) => {
+				var _callbacksRef$current3, _callbacksRef$current4;
+				return (_callbacksRef$current3 = (_callbacksRef$current4 = callbacksRef.current).onElementDragEnd) === null || _callbacksRef$current3 === void 0 ? void 0 : _callbacksRef$current3.call(_callbacksRef$current4, event);
+			},
+			onNodeChange: (data) => {
+				var _callbacksRef$current5, _callbacksRef$current6;
+				return (_callbacksRef$current5 = (_callbacksRef$current6 = callbacksRef.current).onNodeChange) === null || _callbacksRef$current5 === void 0 ? void 0 : _callbacksRef$current5.call(_callbacksRef$current6, data);
+			},
+			getReferencedVirtualElement: () => {
+				var _callbacksRef$current7, _callbacksRef$current8, _callbacksRef$current9;
+				return (_callbacksRef$current7 = (_callbacksRef$current8 = (_callbacksRef$current9 = callbacksRef.current).getReferencedVirtualElement) === null || _callbacksRef$current8 === void 0 ? void 0 : _callbacksRef$current8.call(_callbacksRef$current9)) !== null && _callbacksRef$current7 !== void 0 ? _callbacksRef$current7 : null;
+			},
+			nestedOptions
+		});
+		editor.registerPlugin(plugin);
+		return () => {
+			if (!editor.isDestroyed) editor.unregisterPlugin(pluginKey);
+			unbind();
+		};
+	}, [
+		editor,
+		pluginKey,
+		computePositionConfig,
+		nestedOptions
+	]);
+	const element = elementRef.current;
+	if (!element) return null;
+	return createPortal(children, element);
 };
 
 export { DragHandle };
-//# sourceMappingURL=index-Dt0zG4YB.js.map
+//# sourceMappingURL=index-C2dOrf4N.js.map