raydit-editor 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,31 +1,43 @@
-// src/NotionEditor.tsx
-import { useEditor, EditorContent } from "@tiptap/react";
-import StarterKit from "@tiptap/starter-kit";
-import Placeholder from "@tiptap/extension-placeholder";
-import Underline2 from "@tiptap/extension-underline";
-import { Color } from "@tiptap/extension-color";
-import Highlight from "@tiptap/extension-highlight";
-import Link3 from "@tiptap/extension-link";
-import {
-  Table as Table2,
-  TableRow,
-  TableCell,
-  TableHeader
-} from "@tiptap/extension-table";
-import { TextStyle } from "@tiptap/extension-text-style";
-import Superscript from "@tiptap/extension-superscript";
-import Subscript from "@tiptap/extension-subscript";
-import TextAlign from "@tiptap/extension-text-align";
-import TaskList from "@tiptap/extension-task-list";
-import TaskItem from "@tiptap/extension-task-item";
-import { BubbleMenu } from "@tiptap/react/menus";
-import { useEffect as useEffect5, useRef as useRef3 } from "react";
-import clsx from "clsx";
+'use strict';
 
-// src/slash/SlashExtension.ts
-import { Extension } from "@tiptap/core";
-import Suggestion from "@tiptap/suggestion";
-import { ReactRenderer } from "@tiptap/react";
+var React = require('react');
+var react = require('@tiptap/react');
+var StarterKit = require('@tiptap/starter-kit');
+var Placeholder = require('@tiptap/extension-placeholder');
+var Underline = require('@tiptap/extension-underline');
+var extensionColor = require('@tiptap/extension-color');
+var Highlight = require('@tiptap/extension-highlight');
+var Link2 = require('@tiptap/extension-link');
+var extensionTable = require('@tiptap/extension-table');
+var extensionTextStyle = require('@tiptap/extension-text-style');
+var Superscript = require('@tiptap/extension-superscript');
+var Subscript = require('@tiptap/extension-subscript');
+var TextAlign = require('@tiptap/extension-text-align');
+var TaskList = require('@tiptap/extension-task-list');
+var TaskItem = require('@tiptap/extension-task-item');
+var clsx = require('clsx');
+var core = require('@tiptap/core');
+var Suggestion = require('@tiptap/suggestion');
+var jsxRuntime = require('react/jsx-runtime');
+var lucideReact = require('lucide-react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var StarterKit__default = /*#__PURE__*/_interopDefault(StarterKit);
+var Placeholder__default = /*#__PURE__*/_interopDefault(Placeholder);
+var Underline__default = /*#__PURE__*/_interopDefault(Underline);
+var Highlight__default = /*#__PURE__*/_interopDefault(Highlight);
+var Link2__default = /*#__PURE__*/_interopDefault(Link2);
+var Superscript__default = /*#__PURE__*/_interopDefault(Superscript);
+var Subscript__default = /*#__PURE__*/_interopDefault(Subscript);
+var TextAlign__default = /*#__PURE__*/_interopDefault(TextAlign);
+var TaskList__default = /*#__PURE__*/_interopDefault(TaskList);
+var TaskItem__default = /*#__PURE__*/_interopDefault(TaskItem);
+var clsx__default = /*#__PURE__*/_interopDefault(clsx);
+var Suggestion__default = /*#__PURE__*/_interopDefault(Suggestion);
+
+// src/NotionEditor.tsx
 
 // node_modules/prosemirror-model/dist/index.js
 function findDiffStart(a, b, pos) {
@@ -350,1523 +362,147 @@ var Fragment = class _Fragment {
         if (!joined)
           joined = array.slice(0, i);
         joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
-      } else if (joined) {
-        joined.push(node);
-      }
-    }
-    return new _Fragment(joined || array, size);
-  }
-  /**
-  Create a fragment from something that can be interpreted as a
-  set of nodes. For `null`, it returns the empty fragment. For a
-  fragment, the fragment itself. For a node or array of nodes, a
-  fragment containing those nodes.
-  */
-  static from(nodes) {
-    if (!nodes)
-      return _Fragment.empty;
-    if (nodes instanceof _Fragment)
-      return nodes;
-    if (Array.isArray(nodes))
-      return this.fromArray(nodes);
-    if (nodes.attrs)
-      return new _Fragment([nodes], nodes.nodeSize);
-    throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
-  }
-};
-Fragment.empty = new Fragment([], 0);
-var found = { index: 0, offset: 0 };
-function retIndex(index, offset2) {
-  found.index = index;
-  found.offset = offset2;
-  return found;
-}
-function compareDeep(a, b) {
-  if (a === b)
-    return true;
-  if (!(a && typeof a == "object") || !(b && typeof b == "object"))
-    return false;
-  let array = Array.isArray(a);
-  if (Array.isArray(b) != array)
-    return false;
-  if (array) {
-    if (a.length != b.length)
-      return false;
-    for (let i = 0; i < a.length; i++)
-      if (!compareDeep(a[i], b[i]))
-        return false;
-  } else {
-    for (let p in a)
-      if (!(p in b) || !compareDeep(a[p], b[p]))
-        return false;
-    for (let p in b)
-      if (!(p in a))
-        return false;
-  }
-  return true;
-}
-var Mark = class _Mark {
-  /**
-  @internal
-  */
-  constructor(type, attrs) {
-    this.type = type;
-    this.attrs = attrs;
-  }
-  /**
-  Given a set of marks, create a new set which contains this one as
-  well, in the right position. If this mark is already in the set,
-  the set itself is returned. If any marks that are set to be
-  [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
-  those are replaced by this one.
-  */
-  addToSet(set) {
-    let copy, placed = false;
-    for (let i = 0; i < set.length; i++) {
-      let other = set[i];
-      if (this.eq(other))
-        return set;
-      if (this.type.excludes(other.type)) {
-        if (!copy)
-          copy = set.slice(0, i);
-      } else if (other.type.excludes(this.type)) {
-        return set;
-      } else {
-        if (!placed && other.type.rank > this.type.rank) {
-          if (!copy)
-            copy = set.slice(0, i);
-          copy.push(this);
-          placed = true;
-        }
-        if (copy)
-          copy.push(other);
-      }
-    }
-    if (!copy)
-      copy = set.slice();
-    if (!placed)
-      copy.push(this);
-    return copy;
-  }
-  /**
-  Remove this mark from the given set, returning a new set. If this
-  mark is not in the set, the set itself is returned.
-  */
-  removeFromSet(set) {
-    for (let i = 0; i < set.length; i++)
-      if (this.eq(set[i]))
-        return set.slice(0, i).concat(set.slice(i + 1));
-    return set;
-  }
-  /**
-  Test whether this mark is in the given set of marks.
-  */
-  isInSet(set) {
-    for (let i = 0; i < set.length; i++)
-      if (this.eq(set[i]))
-        return true;
-    return false;
-  }
-  /**
-  Test whether this mark has the same type and attributes as
-  another mark.
-  */
-  eq(other) {
-    return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
-  }
-  /**
-  Convert this mark to a JSON-serializeable representation.
-  */
-  toJSON() {
-    let obj = { type: this.type.name };
-    for (let _ in this.attrs) {
-      obj.attrs = this.attrs;
-      break;
-    }
-    return obj;
-  }
-  /**
-  Deserialize a mark from JSON.
-  */
-  static fromJSON(schema, json) {
-    if (!json)
-      throw new RangeError("Invalid input for Mark.fromJSON");
-    let type = schema.marks[json.type];
-    if (!type)
-      throw new RangeError(`There is no mark type ${json.type} in this schema`);
-    let mark = type.create(json.attrs);
-    type.checkAttrs(mark.attrs);
-    return mark;
-  }
-  /**
-  Test whether two sets of marks are identical.
-  */
-  static sameSet(a, b) {
-    if (a == b)
-      return true;
-    if (a.length != b.length)
-      return false;
-    for (let i = 0; i < a.length; i++)
-      if (!a[i].eq(b[i]))
-        return false;
-    return true;
-  }
-  /**
-  Create a properly sorted mark set from null, a single mark, or an
-  unsorted array of marks.
-  */
-  static setFrom(marks) {
-    if (!marks || Array.isArray(marks) && marks.length == 0)
-      return _Mark.none;
-    if (marks instanceof _Mark)
-      return [marks];
-    let copy = marks.slice();
-    copy.sort((a, b) => a.type.rank - b.type.rank);
-    return copy;
-  }
-};
-Mark.none = [];
-var ReplaceError = class extends Error {
-};
-var Slice = class _Slice {
-  /**
-  Create a slice. When specifying a non-zero open depth, you must
-  make sure that there are nodes of at least that depth at the
-  appropriate side of the fragment—i.e. if the fragment is an
-  empty paragraph node, `openStart` and `openEnd` can't be greater
-  than 1.
-  
-  It is not necessary for the content of open nodes to conform to
-  the schema's content constraints, though it should be a valid
-  start/end/middle for such a node, depending on which sides are
-  open.
-  */
-  constructor(content, openStart, openEnd) {
-    this.content = content;
-    this.openStart = openStart;
-    this.openEnd = openEnd;
-  }
-  /**
-  The size this slice would add when inserted into a document.
-  */
-  get size() {
-    return this.content.size - this.openStart - this.openEnd;
-  }
-  /**
-  @internal
-  */
-  insertAt(pos, fragment) {
-    let content = insertInto(this.content, pos + this.openStart, fragment);
-    return content && new _Slice(content, this.openStart, this.openEnd);
-  }
-  /**
-  @internal
-  */
-  removeBetween(from, to) {
-    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
-  }
-  /**
-  Tests whether this slice is equal to another slice.
-  */
-  eq(other) {
-    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
-  }
-  /**
-  @internal
-  */
-  toString() {
-    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
-  }
-  /**
-  Convert a slice to a JSON-serializable representation.
-  */
-  toJSON() {
-    if (!this.content.size)
-      return null;
-    let json = { content: this.content.toJSON() };
-    if (this.openStart > 0)
-      json.openStart = this.openStart;
-    if (this.openEnd > 0)
-      json.openEnd = this.openEnd;
-    return json;
-  }
-  /**
-  Deserialize a slice from its JSON representation.
-  */
-  static fromJSON(schema, json) {
-    if (!json)
-      return _Slice.empty;
-    let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
-    if (typeof openStart != "number" || typeof openEnd != "number")
-      throw new RangeError("Invalid input for Slice.fromJSON");
-    return new _Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
-  }
-  /**
-  Create a slice from a fragment by taking the maximum possible
-  open value on both side of the fragment.
-  */
-  static maxOpen(fragment, openIsolating = true) {
-    let openStart = 0, openEnd = 0;
-    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
-      openStart++;
-    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
-      openEnd++;
-    return new _Slice(fragment, openStart, openEnd);
-  }
-};
-Slice.empty = new Slice(Fragment.empty, 0, 0);
-function removeRange(content, from, to) {
-  let { index, offset: offset2 } = content.findIndex(from), child = content.maybeChild(index);
-  let { index: indexTo, offset: offsetTo } = content.findIndex(to);
-  if (offset2 == from || child.isText) {
-    if (offsetTo != to && !content.child(indexTo).isText)
-      throw new RangeError("Removing non-flat range");
-    return content.cut(0, from).append(content.cut(to));
-  }
-  if (index != indexTo)
-    throw new RangeError("Removing non-flat range");
-  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset2 - 1, to - offset2 - 1)));
-}
-function insertInto(content, dist, insert, parent) {
-  let { index, offset: offset2 } = content.findIndex(dist), child = content.maybeChild(index);
-  if (offset2 == dist || child.isText) {
-    if (parent && !parent.canReplace(index, index, insert))
-      return null;
-    return content.cut(0, dist).append(insert).append(content.cut(dist));
-  }
-  let inner = insertInto(child.content, dist - offset2 - 1, insert, child);
-  return inner && content.replaceChild(index, child.copy(inner));
-}
-function replace($from, $to, slice) {
-  if (slice.openStart > $from.depth)
-    throw new ReplaceError("Inserted content deeper than insertion position");
-  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
-    throw new ReplaceError("Inconsistent open depths");
-  return replaceOuter($from, $to, slice, 0);
-}
-function replaceOuter($from, $to, slice, depth) {
-  let index = $from.index(depth), node = $from.node(depth);
-  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
-    let inner = replaceOuter($from, $to, slice, depth + 1);
-    return node.copy(node.content.replaceChild(index, inner));
-  } else if (!slice.content.size) {
-    return close(node, replaceTwoWay($from, $to, depth));
-  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
-    let parent = $from.parent, content = parent.content;
-    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
-  } else {
-    let { start: start2, end: end2 } = prepareSliceForReplace(slice, $from);
-    return close(node, replaceThreeWay($from, start2, end2, $to, depth));
-  }
-}
-function checkJoin(main2, sub) {
-  if (!sub.type.compatibleContent(main2.type))
-    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main2.type.name);
-}
-function joinable($before, $after, depth) {
-  let node = $before.node(depth);
-  checkJoin(node, $after.node(depth));
-  return node;
-}
-function addNode(child, target) {
-  let last = target.length - 1;
-  if (last >= 0 && child.isText && child.sameMarkup(target[last]))
-    target[last] = child.withText(target[last].text + child.text);
-  else
-    target.push(child);
-}
-function addRange($start, $end, depth, target) {
-  let node = ($end || $start).node(depth);
-  let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
-  if ($start) {
-    startIndex = $start.index(depth);
-    if ($start.depth > depth) {
-      startIndex++;
-    } else if ($start.textOffset) {
-      addNode($start.nodeAfter, target);
-      startIndex++;
-    }
-  }
-  for (let i = startIndex; i < endIndex; i++)
-    addNode(node.child(i), target);
-  if ($end && $end.depth == depth && $end.textOffset)
-    addNode($end.nodeBefore, target);
-}
-function close(node, content) {
-  node.type.checkContent(content);
-  return node.copy(content);
-}
-function replaceThreeWay($from, $start, $end, $to, depth) {
-  let openStart = $from.depth > depth && joinable($from, $start, depth + 1);
-  let openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
-  let content = [];
-  addRange(null, $from, depth, content);
-  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
-    checkJoin(openStart, openEnd);
-    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
-  } else {
-    if (openStart)
-      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
-    addRange($start, $end, depth, content);
-    if (openEnd)
-      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
-  }
-  addRange($to, null, depth, content);
-  return new Fragment(content);
-}
-function replaceTwoWay($from, $to, depth) {
-  let content = [];
-  addRange(null, $from, depth, content);
-  if ($from.depth > depth) {
-    let type = joinable($from, $to, depth + 1);
-    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
-  }
-  addRange($to, null, depth, content);
-  return new Fragment(content);
-}
-function prepareSliceForReplace(slice, $along) {
-  let extra = $along.depth - slice.openStart, parent = $along.node(extra);
-  let node = parent.copy(slice.content);
-  for (let i = extra - 1; i >= 0; i--)
-    node = $along.node(i).copy(Fragment.from(node));
-  return {
-    start: node.resolveNoCache(slice.openStart + extra),
-    end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
-  };
-}
-var ResolvedPos = class _ResolvedPos {
-  /**
-  @internal
-  */
-  constructor(pos, path, parentOffset) {
-    this.pos = pos;
-    this.path = path;
-    this.parentOffset = parentOffset;
-    this.depth = path.length / 3 - 1;
-  }
-  /**
-  @internal
-  */
-  resolveDepth(val) {
-    if (val == null)
-      return this.depth;
-    if (val < 0)
-      return this.depth + val;
-    return val;
-  }
-  /**
-  The parent node that the position points into. Note that even if
-  a position points into a text node, that node is not considered
-  the parent—text nodes are ‘flat’ in this model, and have no content.
-  */
-  get parent() {
-    return this.node(this.depth);
-  }
-  /**
-  The root node in which the position was resolved.
-  */
-  get doc() {
-    return this.node(0);
-  }
-  /**
-  The ancestor node at the given level. `p.node(p.depth)` is the
-  same as `p.parent`.
-  */
-  node(depth) {
-    return this.path[this.resolveDepth(depth) * 3];
-  }
-  /**
-  The index into the ancestor at the given level. If this points
-  at the 3rd node in the 2nd paragraph on the top level, for
-  example, `p.index(0)` is 1 and `p.index(1)` is 2.
-  */
-  index(depth) {
-    return this.path[this.resolveDepth(depth) * 3 + 1];
-  }
-  /**
-  The index pointing after this position into the ancestor at the
-  given level.
-  */
-  indexAfter(depth) {
-    depth = this.resolveDepth(depth);
-    return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
-  }
-  /**
-  The (absolute) position at the start of the node at the given
-  level.
-  */
-  start(depth) {
-    depth = this.resolveDepth(depth);
-    return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
-  }
-  /**
-  The (absolute) position at the end of the node at the given
-  level.
-  */
-  end(depth) {
-    depth = this.resolveDepth(depth);
-    return this.start(depth) + this.node(depth).content.size;
-  }
-  /**
-  The (absolute) position directly before the wrapping node at the
-  given level, or, when `depth` is `this.depth + 1`, the original
-  position.
-  */
-  before(depth) {
-    depth = this.resolveDepth(depth);
-    if (!depth)
-      throw new RangeError("There is no position before the top-level node");
-    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
-  }
-  /**
-  The (absolute) position directly after the wrapping node at the
-  given level, or the original position when `depth` is `this.depth + 1`.
-  */
-  after(depth) {
-    depth = this.resolveDepth(depth);
-    if (!depth)
-      throw new RangeError("There is no position after the top-level node");
-    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
-  }
-  /**
-  When this position points into a text node, this returns the
-  distance between the position and the start of the text node.
-  Will be zero for positions that point between nodes.
-  */
-  get textOffset() {
-    return this.pos - this.path[this.path.length - 1];
-  }
-  /**
-  Get the node directly after the position, if any. If the position
-  points into a text node, only the part of that node after the
-  position is returned.
-  */
-  get nodeAfter() {
-    let parent = this.parent, index = this.index(this.depth);
-    if (index == parent.childCount)
-      return null;
-    let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
-    return dOff ? parent.child(index).cut(dOff) : child;
-  }
-  /**
-  Get the node directly before the position, if any. If the
-  position points into a text node, only the part of that node
-  before the position is returned.
-  */
-  get nodeBefore() {
-    let index = this.index(this.depth);
-    let dOff = this.pos - this.path[this.path.length - 1];
-    if (dOff)
-      return this.parent.child(index).cut(0, dOff);
-    return index == 0 ? null : this.parent.child(index - 1);
-  }
-  /**
-  Get the position at the given index in the parent node at the
-  given depth (which defaults to `this.depth`).
-  */
-  posAtIndex(index, depth) {
-    depth = this.resolveDepth(depth);
-    let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
-    for (let i = 0; i < index; i++)
-      pos += node.child(i).nodeSize;
-    return pos;
-  }
-  /**
-  Get the marks at this position, factoring in the surrounding
-  marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
-  position is at the start of a non-empty node, the marks of the
-  node after it (if any) are returned.
-  */
-  marks() {
-    let parent = this.parent, index = this.index();
-    if (parent.content.size == 0)
-      return Mark.none;
-    if (this.textOffset)
-      return parent.child(index).marks;
-    let main2 = parent.maybeChild(index - 1), other = parent.maybeChild(index);
-    if (!main2) {
-      let tmp = main2;
-      main2 = other;
-      other = tmp;
-    }
-    let marks = main2.marks;
-    for (var i = 0; i < marks.length; i++)
-      if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks)))
-        marks = marks[i--].removeFromSet(marks);
-    return marks;
-  }
-  /**
-  Get the marks after the current position, if any, except those
-  that are non-inclusive and not present at position `$end`. This
-  is mostly useful for getting the set of marks to preserve after a
-  deletion. Will return `null` if this position is at the end of
-  its parent node or its parent node isn't a textblock (in which
-  case no marks should be preserved).
-  */
-  marksAcross($end) {
-    let after = this.parent.maybeChild(this.index());
-    if (!after || !after.isInline)
-      return null;
-    let marks = after.marks, next = $end.parent.maybeChild($end.index());
-    for (var i = 0; i < marks.length; i++)
-      if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks)))
-        marks = marks[i--].removeFromSet(marks);
-    return marks;
-  }
-  /**
-  The depth up to which this position and the given (non-resolved)
-  position share the same parent nodes.
-  */
-  sharedDepth(pos) {
-    for (let depth = this.depth; depth > 0; depth--)
-      if (this.start(depth) <= pos && this.end(depth) >= pos)
-        return depth;
-    return 0;
-  }
-  /**
-  Returns a range based on the place where this position and the
-  given position diverge around block content. If both point into
-  the same textblock, for example, a range around that textblock
-  will be returned. If they point into different blocks, the range
-  around those blocks in their shared ancestor is returned. You can
-  pass in an optional predicate that will be called with a parent
-  node to see if a range into that parent is acceptable.
-  */
-  blockRange(other = this, pred) {
-    if (other.pos < this.pos)
-      return other.blockRange(this);
-    for (let d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--)
-      if (other.pos <= this.end(d) && (!pred || pred(this.node(d))))
-        return new NodeRange(this, other, d);
-    return null;
-  }
-  /**
-  Query whether the given position shares the same parent node.
-  */
-  sameParent(other) {
-    return this.pos - this.parentOffset == other.pos - other.parentOffset;
-  }
-  /**
-  Return the greater of this and the given position.
-  */
-  max(other) {
-    return other.pos > this.pos ? other : this;
-  }
-  /**
-  Return the smaller of this and the given position.
-  */
-  min(other) {
-    return other.pos < this.pos ? other : this;
-  }
-  /**
-  @internal
-  */
-  toString() {
-    let str = "";
-    for (let i = 1; i <= this.depth; i++)
-      str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
-    return str + ":" + this.parentOffset;
-  }
-  /**
-  @internal
-  */
-  static resolve(doc, pos) {
-    if (!(pos >= 0 && pos <= doc.content.size))
-      throw new RangeError("Position " + pos + " out of range");
-    let path = [];
-    let start2 = 0, parentOffset = pos;
-    for (let node = doc; ; ) {
-      let { index, offset: offset2 } = node.content.findIndex(parentOffset);
-      let rem = parentOffset - offset2;
-      path.push(node, index, start2 + offset2);
-      if (!rem)
-        break;
-      node = node.child(index);
-      if (node.isText)
-        break;
-      parentOffset = rem - 1;
-      start2 += offset2 + 1;
-    }
-    return new _ResolvedPos(pos, path, parentOffset);
-  }
-  /**
-  @internal
-  */
-  static resolveCached(doc, pos) {
-    let cache = resolveCache.get(doc);
-    if (cache) {
-      for (let i = 0; i < cache.elts.length; i++) {
-        let elt = cache.elts[i];
-        if (elt.pos == pos)
-          return elt;
-      }
-    } else {
-      resolveCache.set(doc, cache = new ResolveCache());
-    }
-    let result = cache.elts[cache.i] = _ResolvedPos.resolve(doc, pos);
-    cache.i = (cache.i + 1) % resolveCacheSize;
-    return result;
-  }
-};
-var ResolveCache = class {
-  constructor() {
-    this.elts = [];
-    this.i = 0;
-  }
-};
-var resolveCacheSize = 12;
-var resolveCache = /* @__PURE__ */ new WeakMap();
-var NodeRange = class {
-  /**
-  Construct a node range. `$from` and `$to` should point into the
-  same node until at least the given `depth`, since a node range
-  denotes an adjacent set of nodes in a single parent node.
-  */
-  constructor($from, $to, depth) {
-    this.$from = $from;
-    this.$to = $to;
-    this.depth = depth;
-  }
-  /**
-  The position at the start of the range.
-  */
-  get start() {
-    return this.$from.before(this.depth + 1);
-  }
-  /**
-  The position at the end of the range.
-  */
-  get end() {
-    return this.$to.after(this.depth + 1);
-  }
-  /**
-  The parent node that the range points into.
-  */
-  get parent() {
-    return this.$from.node(this.depth);
-  }
-  /**
-  The start index of the range in the parent node.
-  */
-  get startIndex() {
-    return this.$from.index(this.depth);
-  }
-  /**
-  The end index of the range in the parent node.
-  */
-  get endIndex() {
-    return this.$to.indexAfter(this.depth);
-  }
-};
-var emptyAttrs = /* @__PURE__ */ Object.create(null);
-var Node = class _Node {
-  /**
-  @internal
-  */
-  constructor(type, attrs, content, marks = Mark.none) {
-    this.type = type;
-    this.attrs = attrs;
-    this.marks = marks;
-    this.content = content || Fragment.empty;
-  }
-  /**
-  The array of this node's child nodes.
-  */
-  get children() {
-    return this.content.content;
-  }
-  /**
-  The size of this node, as defined by the integer-based [indexing
-  scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
-  amount of characters. For other leaf nodes, it is one. For
-  non-leaf nodes, it is the size of the content plus two (the
-  start and end token).
-  */
-  get nodeSize() {
-    return this.isLeaf ? 1 : 2 + this.content.size;
-  }
-  /**
-  The number of children that the node has.
-  */
-  get childCount() {
-    return this.content.childCount;
-  }
-  /**
-  Get the child node at the given index. Raises an error when the
-  index is out of range.
-  */
-  child(index) {
-    return this.content.child(index);
-  }
-  /**
-  Get the child node at the given index, if it exists.
-  */
-  maybeChild(index) {
-    return this.content.maybeChild(index);
-  }
-  /**
-  Call `f` for every child node, passing the node, its offset
-  into this parent node, and its index.
-  */
-  forEach(f) {
-    this.content.forEach(f);
-  }
-  /**
-  Invoke a callback for all descendant nodes recursively between
-  the given two positions that are relative to start of this
-  node's content. The callback is invoked with the node, its
-  position relative to the original node (method receiver),
-  its parent node, and its child index. When the callback returns
-  false for a given node, that node's children will not be
-  recursed over. The last parameter can be used to specify a
-  starting position to count from.
-  */
-  nodesBetween(from, to, f, startPos = 0) {
-    this.content.nodesBetween(from, to, f, startPos, this);
-  }
-  /**
-  Call the given callback for every descendant node. Doesn't
-  descend into a node when the callback returns `false`.
-  */
-  descendants(f) {
-    this.nodesBetween(0, this.content.size, f);
-  }
-  /**
-  Concatenates all the text nodes found in this fragment and its
-  children.
-  */
-  get textContent() {
-    return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
-  }
-  /**
-  Get all text between positions `from` and `to`. When
-  `blockSeparator` is given, it will be inserted to separate text
-  from different block nodes. If `leafText` is given, it'll be
-  inserted for every non-text leaf node encountered, otherwise
-  [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
-  */
-  textBetween(from, to, blockSeparator, leafText) {
-    return this.content.textBetween(from, to, blockSeparator, leafText);
-  }
-  /**
-  Returns this node's first child, or `null` if there are no
-  children.
-  */
-  get firstChild() {
-    return this.content.firstChild;
-  }
-  /**
-  Returns this node's last child, or `null` if there are no
-  children.
-  */
-  get lastChild() {
-    return this.content.lastChild;
-  }
-  /**
-  Test whether two nodes represent the same piece of document.
-  */
-  eq(other) {
-    return this == other || this.sameMarkup(other) && this.content.eq(other.content);
-  }
-  /**
-  Compare the markup (type, attributes, and marks) of this node to
-  those of another. Returns `true` if both have the same markup.
-  */
-  sameMarkup(other) {
-    return this.hasMarkup(other.type, other.attrs, other.marks);
-  }
-  /**
-  Check whether this node's markup correspond to the given type,
-  attributes, and marks.
-  */
-  hasMarkup(type, attrs, marks) {
-    return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
-  }
-  /**
-  Create a new node with the same markup as this node, containing
-  the given content (or empty, if no content is given).
-  */
-  copy(content = null) {
-    if (content == this.content)
-      return this;
-    return new _Node(this.type, this.attrs, content, this.marks);
-  }
-  /**
-  Create a copy of this node, with the given set of marks instead
-  of the node's own marks.
-  */
-  mark(marks) {
-    return marks == this.marks ? this : new _Node(this.type, this.attrs, this.content, marks);
-  }
-  /**
-  Create a copy of this node with only the content between the
-  given positions. If `to` is not given, it defaults to the end of
-  the node.
-  */
-  cut(from, to = this.content.size) {
-    if (from == 0 && to == this.content.size)
-      return this;
-    return this.copy(this.content.cut(from, to));
-  }
-  /**
-  Cut out the part of the document between the given positions, and
-  return it as a `Slice` object.
-  */
-  slice(from, to = this.content.size, includeParents = false) {
-    if (from == to)
-      return Slice.empty;
-    let $from = this.resolve(from), $to = this.resolve(to);
-    let depth = includeParents ? 0 : $from.sharedDepth(to);
-    let start2 = $from.start(depth), node = $from.node(depth);
-    let content = node.content.cut($from.pos - start2, $to.pos - start2);
-    return new Slice(content, $from.depth - depth, $to.depth - depth);
-  }
-  /**
-  Replace the part of the document between the given positions with
-  the given slice. The slice must 'fit', meaning its open sides
-  must be able to connect to the surrounding content, and its
-  content nodes must be valid children for the node they are placed
-  into. If any of this is violated, an error of type
-  [`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
-  */
-  replace(from, to, slice) {
-    return replace(this.resolve(from), this.resolve(to), slice);
-  }
-  /**
-  Find the node directly after the given position.
-  */
-  nodeAt(pos) {
-    for (let node = this; ; ) {
-      let { index, offset: offset2 } = node.content.findIndex(pos);
-      node = node.maybeChild(index);
-      if (!node)
-        return null;
-      if (offset2 == pos || node.isText)
-        return node;
-      pos -= offset2 + 1;
-    }
-  }
-  /**
-  Find the (direct) child node after the given offset, if any,
-  and return it along with its index and offset relative to this
-  node.
-  */
-  childAfter(pos) {
-    let { index, offset: offset2 } = this.content.findIndex(pos);
-    return { node: this.content.maybeChild(index), index, offset: offset2 };
-  }
-  /**
-  Find the (direct) child node before the given offset, if any,
-  and return it along with its index and offset relative to this
-  node.
-  */
-  childBefore(pos) {
-    if (pos == 0)
-      return { node: null, index: 0, offset: 0 };
-    let { index, offset: offset2 } = this.content.findIndex(pos);
-    if (offset2 < pos)
-      return { node: this.content.child(index), index, offset: offset2 };
-    let node = this.content.child(index - 1);
-    return { node, index: index - 1, offset: offset2 - node.nodeSize };
-  }
-  /**
-  Resolve the given position in the document, returning an
-  [object](https://prosemirror.net/docs/ref/#model.ResolvedPos) with information about its context.
-  */
-  resolve(pos) {
-    return ResolvedPos.resolveCached(this, pos);
-  }
-  /**
-  @internal
-  */
-  resolveNoCache(pos) {
-    return ResolvedPos.resolve(this, pos);
-  }
-  /**
-  Test whether a given mark or mark type occurs in this document
-  between the two given positions.
-  */
-  rangeHasMark(from, to, type) {
-    let found2 = false;
-    if (to > from)
-      this.nodesBetween(from, to, (node) => {
-        if (type.isInSet(node.marks))
-          found2 = true;
-        return !found2;
-      });
-    return found2;
-  }
-  /**
-  True when this is a block (non-inline node)
-  */
-  get isBlock() {
-    return this.type.isBlock;
-  }
-  /**
-  True when this is a textblock node, a block node with inline
-  content.
-  */
-  get isTextblock() {
-    return this.type.isTextblock;
-  }
-  /**
-  True when this node allows inline content.
-  */
-  get inlineContent() {
-    return this.type.inlineContent;
-  }
-  /**
-  True when this is an inline node (a text node or a node that can
-  appear among text).
-  */
-  get isInline() {
-    return this.type.isInline;
-  }
-  /**
-  True when this is a text node.
-  */
-  get isText() {
-    return this.type.isText;
-  }
-  /**
-  True when this is a leaf node.
-  */
-  get isLeaf() {
-    return this.type.isLeaf;
-  }
-  /**
-  True when this is an atom, i.e. when it does not have directly
-  editable content. This is usually the same as `isLeaf`, but can
-  be configured with the [`atom` property](https://prosemirror.net/docs/ref/#model.NodeSpec.atom)
-  on a node's spec (typically used when the node is displayed as
-  an uneditable [node view](https://prosemirror.net/docs/ref/#view.NodeView)).
-  */
-  get isAtom() {
-    return this.type.isAtom;
-  }
-  /**
-  Return a string representation of this node for debugging
-  purposes.
-  */
-  toString() {
-    if (this.type.spec.toDebugString)
-      return this.type.spec.toDebugString(this);
-    let name = this.type.name;
-    if (this.content.size)
-      name += "(" + this.content.toStringInner() + ")";
-    return wrapMarks(this.marks, name);
-  }
-  /**
-  Get the content match in this node at the given index.
-  */
-  contentMatchAt(index) {
-    let match = this.type.contentMatch.matchFragment(this.content, 0, index);
-    if (!match)
-      throw new Error("Called contentMatchAt on a node with invalid content");
-    return match;
-  }
-  /**
-  Test whether replacing the range between `from` and `to` (by
-  child index) with the given replacement fragment (which defaults
-  to the empty fragment) would leave the node's content valid. You
-  can optionally pass `start` and `end` indices into the
-  replacement fragment.
-  */
-  canReplace(from, to, replacement = Fragment.empty, start2 = 0, end2 = replacement.childCount) {
-    let one = this.contentMatchAt(from).matchFragment(replacement, start2, end2);
-    let two = one && one.matchFragment(this.content, to);
-    if (!two || !two.validEnd)
-      return false;
-    for (let i = start2; i < end2; i++)
-      if (!this.type.allowsMarks(replacement.child(i).marks))
-        return false;
-    return true;
-  }
-  /**
-  Test whether replacing the range `from` to `to` (by index) with
-  a node of the given type would leave the node's content valid.
-  */
-  canReplaceWith(from, to, type, marks) {
-    if (marks && !this.type.allowsMarks(marks))
-      return false;
-    let start2 = this.contentMatchAt(from).matchType(type);
-    let end2 = start2 && start2.matchFragment(this.content, to);
-    return end2 ? end2.validEnd : false;
-  }
-  /**
-  Test whether the given node's content could be appended to this
-  node. If that node is empty, this will only return true if there
-  is at least one node type that can appear in both nodes (to avoid
-  merging completely incompatible nodes).
-  */
-  canAppend(other) {
-    if (other.content.size)
-      return this.canReplace(this.childCount, this.childCount, other.content);
-    else
-      return this.type.compatibleContent(other.type);
-  }
-  /**
-  Check whether this node and its descendants conform to the
-  schema, and raise an exception when they do not.
-  */
-  check() {
-    this.type.checkContent(this.content);
-    this.type.checkAttrs(this.attrs);
-    let copy = Mark.none;
-    for (let i = 0; i < this.marks.length; i++) {
-      let mark = this.marks[i];
-      mark.type.checkAttrs(mark.attrs);
-      copy = mark.addToSet(copy);
-    }
-    if (!Mark.sameSet(copy, this.marks))
-      throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((m) => m.type.name)}`);
-    this.content.forEach((node) => node.check());
-  }
-  /**
-  Return a JSON-serializeable representation of this node.
-  */
-  toJSON() {
-    let obj = { type: this.type.name };
-    for (let _ in this.attrs) {
-      obj.attrs = this.attrs;
-      break;
-    }
-    if (this.content.size)
-      obj.content = this.content.toJSON();
-    if (this.marks.length)
-      obj.marks = this.marks.map((n) => n.toJSON());
-    return obj;
-  }
-  /**
-  Deserialize a node from its JSON representation.
-  */
-  static fromJSON(schema, json) {
-    if (!json)
-      throw new RangeError("Invalid input for Node.fromJSON");
-    let marks = void 0;
-    if (json.marks) {
-      if (!Array.isArray(json.marks))
-        throw new RangeError("Invalid mark data for Node.fromJSON");
-      marks = json.marks.map(schema.markFromJSON);
-    }
-    if (json.type == "text") {
-      if (typeof json.text != "string")
-        throw new RangeError("Invalid text node in JSON");
-      return schema.text(json.text, marks);
-    }
-    let content = Fragment.fromJSON(schema, json.content);
-    let node = schema.nodeType(json.type).create(json.attrs, content, marks);
-    node.type.checkAttrs(node.attrs);
-    return node;
-  }
-};
-Node.prototype.text = void 0;
-function wrapMarks(marks, str) {
-  for (let i = marks.length - 1; i >= 0; i--)
-    str = marks[i].type.name + "(" + str + ")";
-  return str;
-}
-var ContentMatch = class _ContentMatch {
-  /**
-  @internal
-  */
-  constructor(validEnd) {
-    this.validEnd = validEnd;
-    this.next = [];
-    this.wrapCache = [];
-  }
-  /**
-  @internal
-  */
-  static parse(string, nodeTypes) {
-    let stream = new TokenStream(string, nodeTypes);
-    if (stream.next == null)
-      return _ContentMatch.empty;
-    let expr = parseExpr(stream);
-    if (stream.next)
-      stream.err("Unexpected trailing text");
-    let match = dfa(nfa(expr));
-    checkForDeadEnds(match, stream);
-    return match;
-  }
-  /**
-  Match a node type, returning a match after that node if
-  successful.
-  */
-  matchType(type) {
-    for (let i = 0; i < this.next.length; i++)
-      if (this.next[i].type == type)
-        return this.next[i].next;
-    return null;
+      } else if (joined) {
+        joined.push(node);
+      }
+    }
+    return new _Fragment(joined || array, size);
   }
   /**
-  Try to match a fragment. Returns the resulting match when
-  successful.
+  Create a fragment from something that can be interpreted as a
+  set of nodes. For `null`, it returns the empty fragment. For a
+  fragment, the fragment itself. For a node or array of nodes, a
+  fragment containing those nodes.
   */
-  matchFragment(frag, start2 = 0, end2 = frag.childCount) {
-    let cur = this;
-    for (let i = start2; cur && i < end2; i++)
-      cur = cur.matchType(frag.child(i).type);
-    return cur;
+  static from(nodes) {
+    if (!nodes)
+      return _Fragment.empty;
+    if (nodes instanceof _Fragment)
+      return nodes;
+    if (Array.isArray(nodes))
+      return this.fromArray(nodes);
+    if (nodes.attrs)
+      return new _Fragment([nodes], nodes.nodeSize);
+    throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
   }
+};
+Fragment.empty = new Fragment([], 0);
+var found = { index: 0, offset: 0 };
+function retIndex(index, offset2) {
+  found.index = index;
+  found.offset = offset2;
+  return found;
+}
+var ReplaceError = class extends Error {
+};
+var Slice = class _Slice {
   /**
-  @internal
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
   */
-  get inlineContent() {
-    return this.next.length != 0 && this.next[0].type.isInline;
+  constructor(content, openStart, openEnd) {
+    this.content = content;
+    this.openStart = openStart;
+    this.openEnd = openEnd;
   }
   /**
-  Get the first matching node type at this match position that can
-  be generated.
+  The size this slice would add when inserted into a document.
   */
-  get defaultType() {
-    for (let i = 0; i < this.next.length; i++) {
-      let { type } = this.next[i];
-      if (!(type.isText || type.hasRequiredAttrs()))
-        return type;
-    }
-    return null;
+  get size() {
+    return this.content.size - this.openStart - this.openEnd;
   }
   /**
   @internal
   */
-  compatible(other) {
-    for (let i = 0; i < this.next.length; i++)
-      for (let j = 0; j < other.next.length; j++)
-        if (this.next[i].type == other.next[j].type)
-          return true;
-    return false;
+  insertAt(pos, fragment) {
+    let content = insertInto(this.content, pos + this.openStart, fragment);
+    return content && new _Slice(content, this.openStart, this.openEnd);
   }
   /**
-  Try to match the given fragment, and if that fails, see if it can
-  be made to match by inserting nodes in front of it. When
-  successful, return a fragment of inserted nodes (which may be
-  empty if nothing had to be inserted). When `toEnd` is true, only
-  return a fragment if the resulting match goes to the end of the
-  content expression.
+  @internal
   */
-  fillBefore(after, toEnd = false, startIndex = 0) {
-    let seen = [this];
-    function search(match, types) {
-      let finished = match.matchFragment(after, startIndex);
-      if (finished && (!toEnd || finished.validEnd))
-        return Fragment.from(types.map((tp) => tp.createAndFill()));
-      for (let i = 0; i < match.next.length; i++) {
-        let { type, next } = match.next[i];
-        if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) == -1) {
-          seen.push(next);
-          let found2 = search(next, types.concat(type));
-          if (found2)
-            return found2;
-        }
-      }
-      return null;
-    }
-    return search(this, []);
+  removeBetween(from, to) {
+    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
   }
   /**
-  Find a set of wrapping node types that would allow a node of the
-  given type to appear at this position. The result may be empty
-  (when it fits directly) and will be null when no such wrapping
-  exists.
+  Tests whether this slice is equal to another slice.
   */
-  findWrapping(target) {
-    for (let i = 0; i < this.wrapCache.length; i += 2)
-      if (this.wrapCache[i] == target)
-        return this.wrapCache[i + 1];
-    let computed = this.computeWrapping(target);
-    this.wrapCache.push(target, computed);
-    return computed;
+  eq(other) {
+    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
   }
   /**
   @internal
   */
-  computeWrapping(target) {
-    let seen = /* @__PURE__ */ Object.create(null), active = [{ match: this, type: null, via: null }];
-    while (active.length) {
-      let current = active.shift(), match = current.match;
-      if (match.matchType(target)) {
-        let result = [];
-        for (let obj = current; obj.type; obj = obj.via)
-          result.push(obj.type);
-        return result.reverse();
-      }
-      for (let i = 0; i < match.next.length; i++) {
-        let { type, next } = match.next[i];
-        if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
-          active.push({ match: type.contentMatch, type, via: current });
-          seen[type.name] = true;
-        }
-      }
-    }
-    return null;
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
   }
   /**
-  The number of outgoing edges this node has in the finite
-  automaton that describes the content expression.
+  Convert a slice to a JSON-serializable representation.
   */
-  get edgeCount() {
-    return this.next.length;
+  toJSON() {
+    if (!this.content.size)
+      return null;
+    let json = { content: this.content.toJSON() };
+    if (this.openStart > 0)
+      json.openStart = this.openStart;
+    if (this.openEnd > 0)
+      json.openEnd = this.openEnd;
+    return json;
   }
   /**
-  Get the _n_​th outgoing edge from this node in the finite
-  automaton that describes the content expression.
+  Deserialize a slice from its JSON representation.
   */
-  edge(n) {
-    if (n >= this.next.length)
-      throw new RangeError(`There's no ${n}th edge in this content match`);
-    return this.next[n];
+  static fromJSON(schema, json) {
+    if (!json)
+      return _Slice.empty;
+    let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
+    if (typeof openStart != "number" || typeof openEnd != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new _Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
   }
   /**
-  @internal
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
   */
-  toString() {
-    let seen = [];
-    function scan(m) {
-      seen.push(m);
-      for (let i = 0; i < m.next.length; i++)
-        if (seen.indexOf(m.next[i].next) == -1)
-          scan(m.next[i].next);
-    }
-    scan(this);
-    return seen.map((m, i) => {
-      let out = i + (m.validEnd ? "*" : " ") + " ";
-      for (let i2 = 0; i2 < m.next.length; i2++)
-        out += (i2 ? ", " : "") + m.next[i2].type.name + "->" + seen.indexOf(m.next[i2].next);
-      return out;
-    }).join("\n");
-  }
-};
-ContentMatch.empty = new ContentMatch(true);
-var TokenStream = class {
-  constructor(string, nodeTypes) {
-    this.string = string;
-    this.nodeTypes = nodeTypes;
-    this.inline = null;
-    this.pos = 0;
-    this.tokens = string.split(/\s*(?=\b|\W|$)/);
-    if (this.tokens[this.tokens.length - 1] == "")
-      this.tokens.pop();
-    if (this.tokens[0] == "")
-      this.tokens.shift();
-  }
-  get next() {
-    return this.tokens[this.pos];
-  }
-  eat(tok) {
-    return this.next == tok && (this.pos++ || true);
-  }
-  err(str) {
-    throw new SyntaxError(str + " (in content expression '" + this.string + "')");
+  static maxOpen(fragment, openIsolating = true) {
+    let openStart = 0, openEnd = 0;
+    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
+      openStart++;
+    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
+      openEnd++;
+    return new _Slice(fragment, openStart, openEnd);
   }
 };
-function parseExpr(stream) {
-  let exprs = [];
-  do {
-    exprs.push(parseExprSeq(stream));
-  } while (stream.eat("|"));
-  return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
-}
-function parseExprSeq(stream) {
-  let exprs = [];
-  do {
-    exprs.push(parseExprSubscript(stream));
-  } while (stream.next && stream.next != ")" && stream.next != "|");
-  return exprs.length == 1 ? exprs[0] : { type: "seq", exprs };
-}
-function parseExprSubscript(stream) {
-  let expr = parseExprAtom(stream);
-  for (; ; ) {
-    if (stream.eat("+"))
-      expr = { type: "plus", expr };
-    else if (stream.eat("*"))
-      expr = { type: "star", expr };
-    else if (stream.eat("?"))
-      expr = { type: "opt", expr };
-    else if (stream.eat("{"))
-      expr = parseExprRange(stream, expr);
-    else
-      break;
-  }
-  return expr;
-}
-function parseNum(stream) {
-  if (/\D/.test(stream.next))
-    stream.err("Expected number, got '" + stream.next + "'");
-  let result = Number(stream.next);
-  stream.pos++;
-  return result;
-}
-function parseExprRange(stream, expr) {
-  let min2 = parseNum(stream), max2 = min2;
-  if (stream.eat(",")) {
-    if (stream.next != "}")
-      max2 = parseNum(stream);
-    else
-      max2 = -1;
-  }
-  if (!stream.eat("}"))
-    stream.err("Unclosed braced range");
-  return { type: "range", min: min2, max: max2, expr };
-}
-function resolveName(stream, name) {
-  let types = stream.nodeTypes, type = types[name];
-  if (type)
-    return [type];
-  let result = [];
-  for (let typeName in types) {
-    let type2 = types[typeName];
-    if (type2.isInGroup(name))
-      result.push(type2);
-  }
-  if (result.length == 0)
-    stream.err("No node type or group '" + name + "' found");
-  return result;
-}
-function parseExprAtom(stream) {
-  if (stream.eat("(")) {
-    let expr = parseExpr(stream);
-    if (!stream.eat(")"))
-      stream.err("Missing closing paren");
-    return expr;
-  } else if (!/\W/.test(stream.next)) {
-    let exprs = resolveName(stream, stream.next).map((type) => {
-      if (stream.inline == null)
-        stream.inline = type.isInline;
-      else if (stream.inline != type.isInline)
-        stream.err("Mixing inline and block content");
-      return { type: "name", value: type };
-    });
-    stream.pos++;
-    return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
-  } else {
-    stream.err("Unexpected token '" + stream.next + "'");
-  }
-}
-function nfa(expr) {
-  let nfa2 = [[]];
-  connect(compile(expr, 0), node());
-  return nfa2;
-  function node() {
-    return nfa2.push([]) - 1;
-  }
-  function edge(from, to, term) {
-    let edge2 = { term, to };
-    nfa2[from].push(edge2);
-    return edge2;
-  }
-  function connect(edges, to) {
-    edges.forEach((edge2) => edge2.to = to);
-  }
-  function compile(expr2, from) {
-    if (expr2.type == "choice") {
-      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from)), []);
-    } else if (expr2.type == "seq") {
-      for (let i = 0; ; i++) {
-        let next = compile(expr2.exprs[i], from);
-        if (i == expr2.exprs.length - 1)
-          return next;
-        connect(next, from = node());
-      }
-    } else if (expr2.type == "star") {
-      let loop = node();
-      edge(from, loop);
-      connect(compile(expr2.expr, loop), loop);
-      return [edge(loop)];
-    } else if (expr2.type == "plus") {
-      let loop = node();
-      connect(compile(expr2.expr, from), loop);
-      connect(compile(expr2.expr, loop), loop);
-      return [edge(loop)];
-    } else if (expr2.type == "opt") {
-      return [edge(from)].concat(compile(expr2.expr, from));
-    } else if (expr2.type == "range") {
-      let cur = from;
-      for (let i = 0; i < expr2.min; i++) {
-        let next = node();
-        connect(compile(expr2.expr, cur), next);
-        cur = next;
-      }
-      if (expr2.max == -1) {
-        connect(compile(expr2.expr, cur), cur);
-      } else {
-        for (let i = expr2.min; i < expr2.max; i++) {
-          let next = node();
-          edge(cur, next);
-          connect(compile(expr2.expr, cur), next);
-          cur = next;
-        }
-      }
-      return [edge(cur)];
-    } else if (expr2.type == "name") {
-      return [edge(from, void 0, expr2.value)];
-    } else {
-      throw new Error("Unknown expr type");
-    }
-  }
-}
-function cmp(a, b) {
-  return b - a;
-}
-function nullFrom(nfa2, node) {
-  let result = [];
-  scan(node);
-  return result.sort(cmp);
-  function scan(node2) {
-    let edges = nfa2[node2];
-    if (edges.length == 1 && !edges[0].term)
-      return scan(edges[0].to);
-    result.push(node2);
-    for (let i = 0; i < edges.length; i++) {
-      let { term, to } = edges[i];
-      if (!term && result.indexOf(to) == -1)
-        scan(to);
-    }
-  }
-}
-function dfa(nfa2) {
-  let labeled = /* @__PURE__ */ Object.create(null);
-  return explore(nullFrom(nfa2, 0));
-  function explore(states) {
-    let out = [];
-    states.forEach((node) => {
-      nfa2[node].forEach(({ term, to }) => {
-        if (!term)
-          return;
-        let set;
-        for (let i = 0; i < out.length; i++)
-          if (out[i][0] == term)
-            set = out[i][1];
-        nullFrom(nfa2, to).forEach((node2) => {
-          if (!set)
-            out.push([term, set = []]);
-          if (set.indexOf(node2) == -1)
-            set.push(node2);
-        });
-      });
-    });
-    let state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa2.length - 1) > -1);
-    for (let i = 0; i < out.length; i++) {
-      let states2 = out[i][1].sort(cmp);
-      state.next.push({ type: out[i][0], next: labeled[states2.join(",")] || explore(states2) });
-    }
-    return state;
+Slice.empty = new Slice(Fragment.empty, 0, 0);
+function removeRange(content, from, to) {
+  let { index, offset: offset2 } = content.findIndex(from), child = content.maybeChild(index);
+  let { index: indexTo, offset: offsetTo } = content.findIndex(to);
+  if (offset2 == from || child.isText) {
+    if (offsetTo != to && !content.child(indexTo).isText)
+      throw new RangeError("Removing non-flat range");
+    return content.cut(0, from).append(content.cut(to));
   }
+  if (index != indexTo)
+    throw new RangeError("Removing non-flat range");
+  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset2 - 1, to - offset2 - 1)));
 }
-function checkForDeadEnds(match, stream) {
-  for (let i = 0, work = [match]; i < work.length; i++) {
-    let state = work[i], dead = !state.validEnd, nodes = [];
-    for (let j = 0; j < state.next.length; j++) {
-      let { type, next } = state.next[j];
-      nodes.push(type.name);
-      if (dead && !(type.isText || type.hasRequiredAttrs()))
-        dead = false;
-      if (work.indexOf(next) == -1)
-        work.push(next);
-    }
-    if (dead)
-      stream.err("Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
+function insertInto(content, dist, insert, parent) {
+  let { index, offset: offset2 } = content.findIndex(dist), child = content.maybeChild(index);
+  if (offset2 == dist || child.isText) {
+    if (parent && !parent.canReplace(index, index, insert))
+      return null;
+    return content.cut(0, dist).append(insert).append(content.cut(dist));
   }
+  let inner = insertInto(child.content, dist - offset2 - 1, insert, child);
+  return inner && content.replaceChild(index, child.copy(inner));
 }
 
 // node_modules/prosemirror-transform/dist/index.js
@@ -3001,7 +1637,7 @@ var FieldDesc = class {
     this.apply = bind(desc.apply, self);
   }
 };
-var baseFields = [
+[
   new FieldDesc("doc", {
     init(config) {
       return config.doc || config.schema.topNodeType.createAndFill();
@@ -3858,7 +2494,6 @@ function computeOffsets(_ref) {
       case end:
         offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
         break;
-      default:
     }
   }
   return offsets;
@@ -3879,7 +2514,6 @@ function detectOverflow(state, options) {
   var popperOffsets2 = computeOffsets({
     reference: referenceClientRect,
     element: popperRect,
-    strategy: "absolute",
     placement
   });
   var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
@@ -4136,7 +2770,6 @@ function popperOffsets(_ref) {
   state.modifiersData[name] = computeOffsets({
     reference: state.rects.reference,
     element: state.rects.popper,
-    strategy: "absolute",
     placement: state.placement
   });
 }
@@ -5775,7 +4408,7 @@ function tippy(targets, optionalProps) {
 tippy.defaultProps = defaultProps;
 tippy.setDefaultProps = setDefaultProps;
 tippy.currentInput = currentInput;
-var applyStylesModifier = Object.assign({}, applyStyles_default, {
+Object.assign({}, applyStyles_default, {
   effect: function effect4(_ref) {
     var state = _ref.state;
     var initialStyles = {
@@ -5801,15 +4434,11 @@ tippy.setDefaultProps({
   render
 });
 var tippy_esm_default = tippy;
-
-// src/slash/SlashMenu.tsx
-import { useEffect, useMemo, useRef, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
 function SlashMenu({ items, command }) {
-  const [query, setQuery] = useState("");
-  const [activeIndex, setActiveIndex] = useState(0);
-  const containerRef = useRef(null);
-  const filtered = useMemo(() => {
+  const [query, setQuery] = React.useState("");
+  const [activeIndex, setActiveIndex] = React.useState(0);
+  const containerRef = React.useRef(null);
+  const filtered = React.useMemo(() => {
     return items.filter(
       (item) => {
         var _a;
@@ -5817,7 +4446,7 @@ function SlashMenu({ items, command }) {
       }
     );
   }, [items, query]);
-  const grouped = useMemo(() => {
+  const grouped = React.useMemo(() => {
     return filtered.reduce((acc, item) => {
       var _a, _b;
       (_b = acc[_a = item.category]) != null ? _b : acc[_a] = [];
@@ -5826,14 +4455,14 @@ function SlashMenu({ items, command }) {
     }, {});
   }, [filtered]);
   const flatItems = Object.values(grouped).flat();
-  useEffect(() => {
+  React.useEffect(() => {
     var _a;
     const el = (_a = containerRef.current) == null ? void 0 : _a.querySelector(
       `[data-index="${activeIndex}"]`
     );
     el == null ? void 0 : el.scrollIntoView({ block: "nearest" });
   }, [activeIndex]);
-  useEffect(() => {
+  React.useEffect(() => {
     const handler = (e) => {
       if (e.key === "ArrowDown") {
         e.preventDefault();
@@ -5853,27 +4482,27 @@ function SlashMenu({ items, command }) {
     return () => window.removeEventListener("keydown", handler);
   }, [flatItems, activeIndex, command]);
   let globalIndex = -1;
-  return /* @__PURE__ */ jsx("div", { className: "w-80 rounded-xl border bg-white shadow-2xl dark:bg-black", children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-80 rounded-xl border bg-white shadow-2xl dark:bg-black", children: /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {
       ref: containerRef,
       className: "max-h-[360px] overflow-y-auto p-2",
-      children: Object.entries(grouped).map(([category, commands]) => /* @__PURE__ */ jsxs("div", { children: [
-        /* @__PURE__ */ jsx("div", { className: "px-2 py-1 text-xs font-semibold text-gray-500 dark:text-gray-800", children: category }),
+      children: Object.entries(grouped).map(([category, commands]) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-2 py-1 text-xs font-semibold text-gray-500 dark:text-gray-800", children: category }),
         commands.map((item) => {
           globalIndex += 1;
           const isActive = globalIndex === activeIndex;
-          return /* @__PURE__ */ jsxs(
+          return /* @__PURE__ */ jsxRuntime.jsxs(
             "button",
             {
               "data-index": globalIndex,
               onClick: () => command(item),
               className: `flex w-full items-center gap-3 rounded-md px-3 py-2 text-left ${isActive ? "bg-gray-100" : "hover:bg-gray-100"}`,
               children: [
-                /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: item.icon }),
-                /* @__PURE__ */ jsxs("div", { children: [
-                  /* @__PURE__ */ jsx("div", { className: "text-sm font-medium", children: item.title }),
-                  item.description && /* @__PURE__ */ jsx("div", { className: "text-xs text-gray-500", children: item.description })
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-gray-500", children: item.icon }),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm font-medium", children: item.title }),
+                  item.description && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-500", children: item.description })
                 ] })
               ]
             },
@@ -5884,22 +4513,6 @@ function SlashMenu({ items, command }) {
     }
   ) });
 }
-
-// src/commands/slash-commands.tsx
-import {
-  Type,
-  Heading1,
-  Heading2,
-  Heading3,
-  List,
-  ListOrdered,
-  Quote,
-  Code,
-  Minus,
-  Table,
-  Link
-} from "lucide-react";
-import { jsx as jsx2 } from "react/jsx-runtime";
 var slashCommands = [
   /* ================= AI ================= */
   // {
@@ -5942,7 +4555,7 @@ var slashCommands = [
     title: "Text",
     description: "Normal paragraph",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Type, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Type, { size: 16 }),
     keywords: ["paragraph", "text"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setParagraph().run()
   },
@@ -5951,7 +4564,7 @@ var slashCommands = [
     title: "Heading 1",
     description: "Big section heading",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Heading1, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Heading1, { size: 16 }),
     keywords: ["h1", "title"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setHeading({ level: 1 }).run()
   },
@@ -5960,7 +4573,7 @@ var slashCommands = [
     title: "Heading 2",
     description: "Medium section heading",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Heading2, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Heading2, { size: 16 }),
     keywords: ["h2"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setHeading({ level: 2 }).run()
   },
@@ -5969,7 +4582,7 @@ var slashCommands = [
     title: "Heading 3",
     description: "Small section heading",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Heading3, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Heading3, { size: 16 }),
     keywords: ["h3"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setHeading({ level: 3 }).run()
   },
@@ -5977,7 +4590,7 @@ var slashCommands = [
     id: "bullet-list",
     title: "Bullet List",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(List, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.List, { size: 16 }),
     keywords: ["ul", "bullet"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleBulletList().run()
   },
@@ -5985,7 +4598,7 @@ var slashCommands = [
     id: "ordered-list",
     title: "Numbered List",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(ListOrdered, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ListOrdered, { size: 16 }),
     keywords: ["ol", "number"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleOrderedList().run()
   },
@@ -6001,7 +4614,7 @@ var slashCommands = [
     id: "blockquote",
     title: "Quote",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Quote, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Quote, { size: 16 }),
     keywords: ["quote"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleBlockquote().run()
   },
@@ -6009,7 +4622,7 @@ var slashCommands = [
     id: "code-block",
     title: "Code Block",
     category: "Style",
-    icon: /* @__PURE__ */ jsx2(Code, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Code, { size: 16 }),
     keywords: ["code", "pre"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleCodeBlock().run()
   },
@@ -6018,7 +4631,7 @@ var slashCommands = [
     id: "divider",
     title: "Divider",
     category: "Insert",
-    icon: /* @__PURE__ */ jsx2(Minus, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Minus, { size: 16 }),
     keywords: ["hr", "separator"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setHorizontalRule().run()
   },
@@ -6026,7 +4639,7 @@ var slashCommands = [
     id: "table",
     title: "Table",
     category: "Insert",
-    icon: /* @__PURE__ */ jsx2(Table, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Table, { size: 16 }),
     keywords: ["table", "grid"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()
   },
@@ -6052,7 +4665,7 @@ var slashCommands = [
     id: "link",
     title: "Link",
     category: "Media",
-    icon: /* @__PURE__ */ jsx2(Link, { size: 16 }),
+    icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Link, { size: 16 }),
     keywords: ["url"],
     command: ({ editor, range }) => editor.chain().focus().deleteRange(range).setLink({ href: "https://example.com" }).run()
   }
@@ -6080,12 +4693,12 @@ function getSafeClientRect(clientRect) {
   };
 }
 var SlashPluginKey = new PluginKey("slash-command");
-var SlashExtension = Extension.create({
+var SlashExtension = core.Extension.create({
   name: "slash-command",
   addProseMirrorPlugins() {
     const editor = this.editor;
     return [
-      Suggestion({
+      Suggestion__default.default({
         pluginKey: SlashPluginKey,
         editor,
         char: "/",
@@ -6119,7 +4732,7 @@ var SlashExtension = Extension.create({
               items = props.items;
               selectCommand = props.command;
               if (!editor) return;
-              component = new ReactRenderer(SlashMenu, {
+              component = new react.ReactRenderer(SlashMenu, {
                 props: {
                   ...props,
                   selectedIndex
@@ -6178,444 +4791,9 @@ var SlashExtension = Extension.create({
     ];
   }
 });
-
-// src/SelectionToolbar.tsx
-import { useEffect as useEffect2, useState as useState2 } from "react";
-import {
-  Bold,
-  Italic,
-  Underline,
-  Strikethrough,
-  Code as Code2,
-  Link2,
-  Highlighter,
-  Type as Type2,
-  Heading1 as Heading12,
-  Heading2 as Heading22,
-  Heading3 as Heading32,
-  List as List2,
-  ListOrdered as ListOrdered2,
-  CheckSquare as CheckSquare2,
-  Quote as Quote2,
-  Code2 as Code22,
-  AlignLeft,
-  AlignCenter,
-  AlignRight,
-  AlignJustify,
-  MoreVertical
-} from "lucide-react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function SelectionToolbar({ editor }) {
-  const [showColors, setShowColors] = useState2(false);
-  const [showHighlights, setShowHighlights] = useState2(false);
-  const [showTurnInto, setShowTurnInto] = useState2(false);
-  const [showMore, setShowMore] = useState2(false);
-  useEffect2(() => {
-    if (!editor) return;
-    const closeMenu = () => {
-      setShowTurnInto(false);
-      setShowColors(false);
-      setShowHighlights(false);
-      setShowMore(false);
-    };
-    editor.on("selectionUpdate", closeMenu);
-    editor.on("blur", closeMenu);
-    return () => {
-      editor.off("selectionUpdate", closeMenu);
-      editor.off("blur", closeMenu);
-    };
-  }, [editor]);
-  const colors = [
-    { name: "Default", value: "#000000" },
-    { name: "Gray", value: "#6B7280" },
-    { name: "Red", value: "#EF4444" },
-    { name: "Orange", value: "#F97316" },
-    { name: "Yellow", value: "#EAB308" },
-    { name: "Green", value: "#10B981" },
-    { name: "Blue", value: "#3B82F6" },
-    { name: "Purple", value: "#8B5CF6" }
-  ];
-  const highlights = [
-    { name: "None", value: "transparent" },
-    { name: "Gray", value: "#F3F4F6" },
-    { name: "Red", value: "#FEE2E2" },
-    { name: "Orange", value: "#FFEDD5" },
-    { name: "Yellow", value: "#FEF3C7" },
-    { name: "Green", value: "#D1FAE5" },
-    { name: "Blue", value: "#DBEAFE" },
-    { name: "Purple", value: "#EDE9FE" }
-  ];
-  const setLink = () => {
-    const previousUrl = editor.getAttributes("link").href;
-    const url = window.prompt("Enter URL:", previousUrl);
-    if (url === null) {
-      return;
-    }
-    if (url === "") {
-      editor.chain().focus().extendMarkRange("link").unsetLink().run();
-      return;
-    }
-    editor.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
-  };
-  const currentBlockLabel = () => {
-    if (editor.isActive("heading", { level: 1 })) return "Heading 1";
-    if (editor.isActive("heading", { level: 2 })) return "Heading 2";
-    if (editor.isActive("heading", { level: 3 })) return "Heading 3";
-    if (editor.isActive("bulletList")) return "Bulleted list";
-    if (editor.isActive("orderedList")) return "Numbered list";
-    if (editor.isActive("taskList")) return "To-do list";
-    if (editor.isActive("blockquote")) return "Blockquote";
-    if (editor.isActive("codeBlock")) return "Code block";
-    return "Text";
-  };
-  const turnIntoItems = [
-    {
-      label: "Text",
-      icon: /* @__PURE__ */ jsx3(Type2, { size: 16 }),
-      isActive: () => editor.isActive("paragraph") && !editor.isActive("bulletList") && !editor.isActive("orderedList") && !editor.isActive("taskList"),
-      action: () => {
-        editor.chain().focus().clearNodes().setParagraph().run();
-      }
-    },
-    {
-      label: "Heading 1",
-      icon: /* @__PURE__ */ jsx3(Heading12, { size: 16 }),
-      isActive: () => editor.isActive("heading", { level: 1 }),
-      action: () => editor.chain().focus().toggleHeading({ level: 1 }).run()
-    },
-    {
-      label: "Heading 2",
-      icon: /* @__PURE__ */ jsx3(Heading22, { size: 16 }),
-      isActive: () => editor.isActive("heading", { level: 2 }),
-      action: () => editor.chain().focus().toggleHeading({ level: 2 }).run()
-    },
-    {
-      label: "Heading 3",
-      icon: /* @__PURE__ */ jsx3(Heading32, { size: 16 }),
-      isActive: () => editor.isActive("heading", { level: 3 }),
-      action: () => editor.chain().focus().toggleHeading({ level: 3 }).run()
-    },
-    {
-      label: "To-do list",
-      icon: /* @__PURE__ */ jsx3(CheckSquare2, { size: 16 }),
-      isActive: () => editor.isActive("taskList"),
-      action: () => {
-        if (editor.isActive("taskList")) {
-          editor.chain().focus().liftListItem("taskItem").run();
-        } else {
-          editor.chain().focus().toggleTaskList().run();
-        }
-      }
-    },
-    {
-      label: "Blockquote",
-      icon: /* @__PURE__ */ jsx3(Quote2, { size: 16 }),
-      isActive: () => editor.isActive("blockquote"),
-      action: () => editor.chain().focus().toggleBlockquote().run()
-    },
-    {
-      label: "Code block",
-      icon: /* @__PURE__ */ jsx3(Code22, { size: 16 }),
-      isActive: () => editor.isActive("codeBlock"),
-      action: () => editor.chain().focus().toggleCodeBlock().run()
-    }
-  ];
-  return /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-1 rounded-lg border border-gray-200 bg-white p-1 shadow-xl", children: [
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => {
-          if (editor.isActive("bulletList")) {
-            editor.chain().focus().liftListItem("listItem").run();
-          } else {
-            editor.chain().focus().toggleBulletList().run();
-          }
-        },
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("bulletList") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Bullet List",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(List2, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => {
-          if (editor.isActive("orderedList")) {
-            editor.chain().focus().liftListItem("listItem").run();
-          } else {
-            editor.chain().focus().toggleOrderedList().run();
-          }
-        },
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("orderedList") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Numbered List",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(ListOrdered2, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3("div", { className: "mx-1 h-6 w-px bg-gray-300" }),
-    /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
-      /* @__PURE__ */ jsxs2(
-        "button",
-        {
-          onMouseDown: (e) => e.preventDefault(),
-          onClick: () => setShowTurnInto((v) => !v),
-          className: "rounded-md px-2 py-1 text-sm text-gray-700 hover:bg-gray-100",
-          children: [
-            currentBlockLabel(),
-            " \u25BE"
-          ]
-        }
-      ),
-      showTurnInto && /* @__PURE__ */ jsxs2("div", { className: "absolute left-0 top-full z-50 mt-2 w-52 rounded-lg border bg-white shadow-xl", children: [
-        /* @__PURE__ */ jsx3("div", { className: "px-3 py-2 text-xs font-semibold text-gray-500", children: "Turn into" }),
-        /* @__PURE__ */ jsx3("div", { className: "p-1", children: turnIntoItems.map((item) => {
-          const active = item.isActive();
-          return /* @__PURE__ */ jsxs2(
-            "button",
-            {
-              onMouseDown: (e) => e.preventDefault(),
-              onClick: () => {
-                item.action();
-                setShowTurnInto(false);
-              },
-              className: `flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors ${active ? "bg-gray-100 text-blue-600" : "text-gray-700 hover:bg-gray-100"}`,
-              children: [
-                /* @__PURE__ */ jsx3("span", { className: "flex h-5 w-5 items-center justify-center", children: item.icon }),
-                /* @__PURE__ */ jsx3("span", { children: item.label })
-              ]
-            },
-            item.label
-          );
-        }) })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx3("div", { className: "mx-1 h-6 w-px bg-gray-300" }),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => editor.chain().focus().toggleBold().run(),
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("bold") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Bold (Ctrl+B)",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Bold, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => editor.chain().focus().toggleItalic().run(),
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("italic") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Italic (Ctrl+I)",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Italic, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => editor.chain().focus().toggleUnderline().run(),
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("underline") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Underline (Ctrl+U)",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Underline, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => editor.chain().focus().toggleStrike().run(),
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("strike") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Strikethrough",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Strikethrough, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: () => editor.chain().focus().toggleCode().run(),
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("code") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Code",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Code2, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsx3("div", { className: "mx-1 h-6 w-px bg-gray-300" }),
-    /* @__PURE__ */ jsx3(
-      "button",
-      {
-        onClick: setLink,
-        className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("link") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-        title: "Add Link",
-        type: "button",
-        onMouseDown: (e) => e.preventDefault(),
-        children: /* @__PURE__ */ jsx3(Link2, { size: 16 })
-      }
-    ),
-    /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
-      /* @__PURE__ */ jsx3(
-        "button",
-        {
-          onClick: () => {
-            setShowColors(!showColors);
-            setShowHighlights(false);
-          },
-          className: "rounded p-1.5 text-gray-700 transition-colors hover:bg-gray-100",
-          title: "Text Color",
-          type: "button",
-          onMouseDown: (e) => e.preventDefault(),
-          children: /* @__PURE__ */ jsx3(Type2, { size: 16 })
-        }
-      ),
-      showColors && /* @__PURE__ */ jsx3("div", { className: "absolute left-0 top-full z-50 mt-2 flex gap-1 rounded-lg border bg-white p-2 shadow-xl", children: colors.map((color) => /* @__PURE__ */ jsx3(
-        "button",
-        {
-          onClick: () => {
-            editor.chain().focus().setMark("textStyle", { color: color.value }).run();
-            setShowColors(false);
-          },
-          className: "h-6 w-6 rounded border border-gray-300 transition-transform hover:scale-110",
-          style: { backgroundColor: color.value },
-          title: color.name,
-          type: "button",
-          onMouseDown: (e) => e.preventDefault()
-        },
-        color.value
-      )) })
-    ] }),
-    /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
-      /* @__PURE__ */ jsx3(
-        "button",
-        {
-          onClick: () => {
-            setShowHighlights(!showHighlights);
-            setShowColors(false);
-          },
-          className: `rounded p-1.5 transition-colors hover:bg-gray-100 ${editor.isActive("highlight") ? "bg-gray-100 text-blue-600" : "text-gray-700"}`,
-          title: "Highlight",
-          type: "button",
-          onMouseDown: (e) => e.preventDefault(),
-          children: /* @__PURE__ */ jsx3(Highlighter, { size: 16 })
-        }
-      ),
-      showHighlights && /* @__PURE__ */ jsx3("div", { className: "absolute left-0 top-full z-50 mt-2 flex gap-1 rounded-lg border bg-white p-2 shadow-xl", children: highlights.map((highlight) => /* @__PURE__ */ jsx3(
-        "button",
-        {
-          onClick: () => {
-            if (highlight.value === "transparent") {
-              editor.chain().focus().unsetMark("highlight").run();
-            } else {
-              editor.chain().focus().setMark("highlight", { color: highlight.value }).run();
-            }
-            setShowHighlights(false);
-          },
-          className: "h-6 w-6 rounded border border-gray-300 transition-transform hover:scale-110",
-          style: { backgroundColor: highlight.value },
-          title: highlight.name,
-          type: "button",
-          onMouseDown: (e) => e.preventDefault()
-        },
-        highlight.value
-      )) })
-    ] }),
-    /* @__PURE__ */ jsx3("div", { className: "mx-1 h-6 w-px bg-gray-300" }),
-    /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
-      /* @__PURE__ */ jsx3(
-        "button",
-        {
-          onMouseDown: (e) => e.preventDefault(),
-          onClick: () => setShowMore((v) => !v),
-          className: "rounded p-1.5 hover:bg-gray-100",
-          children: /* @__PURE__ */ jsx3(MoreVertical, { size: 16 })
-        }
-      ),
-      showMore && /* @__PURE__ */ jsxs2("div", { className: "absolute right-0 top-full z-50 mt-2 w-56 rounded-lg border bg-white shadow-xl", children: [
-        /* @__PURE__ */ jsx3("div", { className: "px-3 py-2 text-xs font-semibold text-gray-500", children: "More" }),
-        /* @__PURE__ */ jsx3("div", { className: "p-1", children: [
-          {
-            label: "Align left",
-            icon: /* @__PURE__ */ jsx3(AlignLeft, { size: 16 }),
-            isActive: () => editor.isActive({ textAlign: "left" }),
-            action: () => editor.chain().focus().setTextAlign("left").run()
-          },
-          {
-            label: "Align center",
-            icon: /* @__PURE__ */ jsx3(AlignCenter, { size: 16 }),
-            isActive: () => editor.isActive({ textAlign: "center" }),
-            action: () => editor.chain().focus().setTextAlign("center").run()
-          },
-          {
-            label: "Align right",
-            icon: /* @__PURE__ */ jsx3(AlignRight, { size: 16 }),
-            isActive: () => editor.isActive({ textAlign: "right" }),
-            action: () => editor.chain().focus().setTextAlign("right").run()
-          },
-          {
-            label: "Justify",
-            icon: /* @__PURE__ */ jsx3(AlignJustify, { size: 16 }),
-            isActive: () => editor.isActive({ textAlign: "justify" }),
-            action: () => editor.chain().focus().setTextAlign("justify").run()
-          },
-          { divider: true },
-          {
-            label: "Superscript",
-            icon: /* @__PURE__ */ jsx3("span", { className: "text-sm font-semibold", children: "x\xB2" }),
-            isActive: () => editor.isActive("superscript"),
-            action: () => editor.chain().focus().toggleSuperscript().run()
-          },
-          {
-            label: "Subscript",
-            icon: /* @__PURE__ */ jsx3("span", { className: "text-sm font-semibold", children: "x\u2082" }),
-            isActive: () => editor.isActive("subscript"),
-            action: () => editor.chain().focus().toggleSubscript().run()
-          }
-        ].map((item, index) => {
-          if ("divider" in item) {
-            return /* @__PURE__ */ jsx3(
-              "div",
-              {
-                className: "my-1 h-px bg-gray-200"
-              },
-              `divider-${index}`
-            );
-          }
-          const active = item.isActive();
-          return /* @__PURE__ */ jsxs2(
-            "button",
-            {
-              onMouseDown: (e) => e.preventDefault(),
-              onClick: () => {
-                item.action();
-                setShowMore(false);
-              },
-              className: `flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors ${active ? "bg-gray-100 text-blue-600" : "text-gray-700 hover:bg-gray-100"}`,
-              children: [
-                /* @__PURE__ */ jsx3("span", { className: "flex h-5 w-5 items-center justify-center", children: item.icon }),
-                /* @__PURE__ */ jsx3("span", { children: item.label })
-              ]
-            },
-            item.label
-          );
-        }) })
-      ] })
-    ] })
-  ] });
-}
-var SelectionToolbar_default = SelectionToolbar;
-
-// src/table/useRowHover.ts
-import { useEffect as useEffect3, useState as useState3 } from "react";
 function useRowHover(editor) {
-  const [rowEl, setRowEl] = useState3(null);
-  useEffect3(() => {
+  const [rowEl, setRowEl] = React.useState(null);
+  React.useEffect(() => {
     if (!editor) return;
     const root = editor.view.dom;
     const onMouseMove = (e) => {
@@ -6635,44 +4813,37 @@ function useRowHover(editor) {
   return rowEl;
 }
 
-// src/table/RowAddButton.tsx
-import { MoreHorizontal } from "lucide-react";
-
 // src/table/selectTableCell.ts
 function selectCellByDom(editor, cell) {
   const view = editor.view;
   const pos = view.posAtDOM(cell, 0);
   editor.commands.setTextSelection(pos);
 }
-
-// src/table/RowAddButton.tsx
-import React2 from "react";
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 function RowTableMenu(editor, onClose) {
-  return /* @__PURE__ */ jsxs3("div", { className: "w-56 rounded-lg border bg-white p-1 shadow-xl", children: [
-    /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "w-56 rounded-lg border bg-white p-1 shadow-xl", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem,
       {
         label: "Add row above",
         onClick: () => editor.commands.addRowBefore()
       }
     ),
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem,
       {
         label: "Add row below",
         onClick: () => editor.commands.addRowAfter()
       }
     ),
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem,
       {
         label: "Delete row",
         onClick: () => editor.commands.deleteRow()
       }
     ),
-    /* @__PURE__ */ jsx4("div", { className: "my-1 border-t" }),
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "my-1 border-t" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem,
       {
         label: "Delete table",
@@ -6690,7 +4861,7 @@ function MenuItem({
   onClick,
   danger
 }) {
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsxRuntime.jsx(
     "button",
     {
       onClick,
@@ -6700,12 +4871,12 @@ function MenuItem({
   );
 }
 function RowAddButton({ editor, row }) {
-  const [showRowMenu, setShowRowMenu] = React2.useState(false);
+  const [showRowMenu, setShowRowMenu] = React__default.default.useState(false);
   const firstCell = row.querySelector("td, th");
   if (!firstCell) return null;
   const rect = row.getBoundingClientRect();
-  return /* @__PURE__ */ jsxs3("div", { className: "relative", children: [
-    /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
       "button",
       {
         style: {
@@ -6722,10 +4893,10 @@ function RowAddButton({ editor, row }) {
           setShowRowMenu((v) => !v);
           selectCellByDom(editor, firstCell);
         },
-        children: /* @__PURE__ */ jsx4(MoreHorizontal, { size: 14 })
+        children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MoreHorizontal, { size: 14 })
       }
     ),
-    showRowMenu && /* @__PURE__ */ jsx4(
+    showRowMenu && /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
         className: "z-[1000]",
@@ -6743,12 +4914,9 @@ function RowAddButton({ editor, row }) {
     )
   ] });
 }
-
-// src/table/useColumnHover.ts
-import { useEffect as useEffect4, useState as useState4 } from "react";
 function useColumnHover(editor) {
-  const [hovered, setHovered] = useState4(null);
-  useEffect4(() => {
+  const [hovered, setHovered] = React.useState(null);
+  React.useEffect(() => {
     if (!editor) return;
     const root = editor.view.dom;
     const onMouseMove = (e) => {
@@ -6776,36 +4944,31 @@ function useColumnHover(editor) {
   }, [editor]);
   return hovered;
 }
-
-// src/table/ColumnAddButton.tsx
-import { MoreHorizontal as MoreHorizontal2 } from "lucide-react";
-import React3 from "react";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function ColumnTableMenu(editor, onClose) {
-  return /* @__PURE__ */ jsxs4("div", { className: "w-56 rounded-lg border bg-white p-1 shadow-xl", children: [
-    /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "w-56 rounded-lg border bg-white p-1 shadow-xl", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem2,
       {
         label: "Add column left",
         onClick: () => editor.commands.addColumnBefore()
       }
     ),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem2,
       {
         label: "Add column right",
         onClick: () => editor.commands.addColumnAfter()
       }
     ),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem2,
       {
         label: "Delete column",
         onClick: () => editor.commands.deleteColumn()
       }
     ),
-    /* @__PURE__ */ jsx5("div", { className: "my-1 border-t" }),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "my-1 border-t" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
       MenuItem2,
       {
         label: "Delete table",
@@ -6823,7 +4986,7 @@ function MenuItem2({
   onClick,
   danger
 }) {
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxRuntime.jsx(
     "button",
     {
       onClick,
@@ -6837,15 +5000,15 @@ function MenuItem2({
   );
 }
 function ColumnAddButton({ editor, table, columnIndex }) {
-  const [showColumnMenu, setShowColumnMenu] = React3.useState(false);
+  const [showColumnMenu, setShowColumnMenu] = React__default.default.useState(false);
   const firstRow = table.querySelector("tr");
   if (!firstRow) return null;
   const cells = Array.from(firstRow.children);
   const cell = cells[columnIndex];
   if (!cell) return null;
   const rect = cell.getBoundingClientRect();
-  return /* @__PURE__ */ jsxs4("div", { className: "relative", children: [
-    /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
       "button",
       {
         style: {
@@ -6862,10 +5025,10 @@ function ColumnAddButton({ editor, table, columnIndex }) {
           setShowColumnMenu((v) => !v);
           selectCellByDom(editor, cell);
         },
-        children: /* @__PURE__ */ jsx5(MoreHorizontal2, { size: 14 })
+        children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MoreHorizontal, { size: 14 })
       }
     ),
-    showColumnMenu && /* @__PURE__ */ jsx5(
+    showColumnMenu && /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
         className: "fixed z-[1000]",
@@ -6879,10 +5042,7 @@ function ColumnAddButton({ editor, table, columnIndex }) {
     )
   ] });
 }
-
-// src/NotionEditor.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-var DynamicPlaceholder = Placeholder.configure({
+var DynamicPlaceholder = Placeholder__default.default.configure({
   placeholder: ({ node }) => {
     var _a;
     const type = node.type.name;
@@ -6924,51 +5084,51 @@ var NotionEditor = ({
   showToolbar = true,
   showTableControls = true
 }) => {
-  const lastSavedRef = useRef3("");
-  const isDirtyRef = useRef3(false);
-  const editor = useEditor({
+  const lastSavedRef = React.useRef("");
+  const isDirtyRef = React.useRef(false);
+  const editor = react.useEditor({
     autofocus: autoFocus,
     editable: !disabled,
     extensions: [
-      StarterKit.configure({
+      StarterKit__default.default.configure({
         heading: {
           levels: [1, 2, 3]
         }
       }),
       DynamicPlaceholder,
-      Placeholder.configure({
+      Placeholder__default.default.configure({
         placeholder,
         showOnlyWhenEditable: true,
         includeChildren: false
       }),
       SlashExtension,
-      Underline2,
-      TextStyle,
-      Color,
-      Superscript,
-      Subscript,
-      TextAlign.configure({
+      Underline__default.default,
+      extensionTextStyle.TextStyle,
+      extensionColor.Color,
+      Superscript__default.default,
+      Subscript__default.default,
+      TextAlign__default.default.configure({
         types: ["heading", "paragraph"]
       }),
-      Highlight.configure({
+      Highlight__default.default.configure({
         multicolor: true
       }),
-      Link3.configure({
+      Link2__default.default.configure({
         openOnClick: false,
         HTMLAttributes: {
           class: "text-blue-600 underline cursor-pointer hover:text-blue-800"
         }
       }),
-      Table2.configure({
+      extensionTable.Table.configure({
         resizable: true,
         lastColumnResizable: true,
         allowTableNodeSelection: true
       }),
-      TableRow,
-      TableHeader,
-      TableCell,
-      TaskList,
-      TaskItem.configure({
+      extensionTable.TableRow,
+      extensionTable.TableHeader,
+      extensionTable.TableCell,
+      TaskList__default.default,
+      TaskItem__default.default.configure({
         nested: true,
         HTMLAttributes: {
           class: "task-item"
@@ -7001,23 +5161,22 @@ var NotionEditor = ({
       });
     }
   });
-  useEffect5(() => {
+  React.useEffect(() => {
     if (!editor) return;
     const currentHTML = editor.getHTML();
     if (content !== void 0 && content !== currentHTML) {
       editor.commands.setContent(content || "");
     }
   }, [content, editor]);
-  useEffect5(() => {
+  React.useEffect(() => {
     editor == null ? void 0 : editor.setEditable(!disabled);
   }, [disabled, editor]);
   const hoveredRow = useRowHover(editor);
   const hoveredColumn = useColumnHover(editor);
   if (!editor) return null;
-  return /* @__PURE__ */ jsxs5("div", { className: clsx("relative rounded-lg border bg-white", className), children: [
-    showToolbar && /* @__PURE__ */ jsx6(BubbleMenu, { editor, children: /* @__PURE__ */ jsx6(SelectionToolbar_default, { editor }) }),
-    showTableControls && editor && hoveredRow && /* @__PURE__ */ jsx6(RowAddButton, { editor, row: hoveredRow }),
-    showTableControls && editor && hoveredColumn && /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: clsx__default.default("relative rounded-lg border bg-white", className), children: [
+    showTableControls && editor && hoveredRow && /* @__PURE__ */ jsxRuntime.jsx(RowAddButton, { editor, row: hoveredRow }),
+    showTableControls && editor && hoveredColumn && /* @__PURE__ */ jsxRuntime.jsx(
       ColumnAddButton,
       {
         editor,
@@ -7025,11 +5184,11 @@ var NotionEditor = ({
         columnIndex: hoveredColumn.columnIndex
       }
     ),
-    /* @__PURE__ */ jsx6(
-      EditorContent,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.EditorContent,
       {
         editor,
-        className: clsx(
+        className: clsx__default.default(
           "prose max-w-none border border-gray-300 p-6",
           disabled && "cursor-not-allowed opacity-60",
           editorClassName
@@ -7039,7 +5198,7 @@ var NotionEditor = ({
   ] });
 };
 var NotionEditor_default = NotionEditor;
-export {
-  NotionEditor_default as NotionEditor
-};
+
+exports.NotionEditor = NotionEditor_default;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map