@edifice.io/react 2.6.8 → 2.6.9-chore-tiptap-v3.20261013175230

package/dist/node_modules/.pnpm/prosemirror-state@1.4.4/node_modules/prosemirror-state/dist/index.js

@@ -0,0 +1,489 @@
+import { Slice, Fragment } from "../../../../prosemirror-model@1.25.12/node_modules/prosemirror-model/dist/index.js";
+import { ReplaceStep, ReplaceAroundStep } from "../../../../prosemirror-transform@1.12.2/node_modules/prosemirror-transform/dist/index.js";
+const classesById = /* @__PURE__ */ Object.create(null);
+class Selection {
+  /**
+  Initialize a selection with the head and anchor and ranges. If no
+  ranges are given, constructs a single range across `$anchor` and
+  `$head`.
+  */
+  constructor($anchor, $head, ranges) {
+    this.$anchor = $anchor, this.$head = $head, this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
+  }
+  /**
+  The selection's anchor, as an unresolved position.
+  */
+  get anchor() {
+    return this.$anchor.pos;
+  }
+  /**
+  The selection's head.
+  */
+  get head() {
+    return this.$head.pos;
+  }
+  /**
+  The lower bound of the selection's main range.
+  */
+  get from() {
+    return this.$from.pos;
+  }
+  /**
+  The upper bound of the selection's main range.
+  */
+  get to() {
+    return this.$to.pos;
+  }
+  /**
+  The resolved lower  bound of the selection's main range.
+  */
+  get $from() {
+    return this.ranges[0].$from;
+  }
+  /**
+  The resolved upper bound of the selection's main range.
+  */
+  get $to() {
+    return this.ranges[0].$to;
+  }
+  /**
+  Indicates whether the selection contains any content.
+  */
+  get empty() {
+    let ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++)
+      if (ranges[i].$from.pos != ranges[i].$to.pos)
+        return !1;
+    return !0;
+  }
+  /**
+  Get the content of this selection as a slice.
+  */
+  content() {
+    return this.$from.doc.slice(this.from, this.to, !0);
+  }
+  /**
+  Replace the selection with a slice or, if no slice is given,
+  delete the selection. Will append to the given transaction.
+  */
+  replace(tr, content = Slice.empty) {
+    let lastNode = content.content.lastChild, lastParent = null;
+    for (let i = 0; i < content.openEnd; i++)
+      lastParent = lastNode, lastNode = lastNode.lastChild;
+    let mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+      tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content), i == 0 && selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(tr, node) {
+    let mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom), from = mapping.map($from.pos), to = mapping.map($to.pos);
+      i ? tr.deleteRange(from, to) : (tr.replaceRangeWith(from, to, node), selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1));
+    }
+  }
+  /**
+  Find a valid cursor or leaf node selection starting at the given
+  position and searching back if `dir` is negative, and forward if
+  positive. When `textOnly` is true, only consider cursor
+  selections. Will return null when no valid selection position is
+  found.
+  */
+  static findFrom($pos, dir, textOnly = !1) {
+    let inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
+    if (inner)
+      return inner;
+    for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+      let found = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  /**
+  Find a valid cursor or leaf node selection near the given
+  position. Searches forward first by default, but if `bias` is
+  negative, it will search backwards first.
+  */
+  static near($pos, bias = 1) {
+    return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
+  }
+  /**
+  Find the cursor or leaf node selection closest to the start of
+  the given document. Will return an
+  [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
+  exists.
+  */
+  static atStart(doc) {
+    return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(doc) {
+    return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
+  }
+  /**
+  Deserialize the JSON representation of a selection. Must be
+  implemented for custom classes (as a static class method).
+  */
+  static fromJSON(doc, json) {
+    if (!json || !json.type)
+      throw new RangeError("Invalid input for Selection.fromJSON");
+    let cls = classesById[json.type];
+    if (!cls)
+      throw new RangeError(`No selection type ${json.type} defined`);
+    return cls.fromJSON(doc, json);
+  }
+  /**
+  To be able to deserialize selections from JSON, custom selection
+  classes must register themselves with an ID string, so that they
+  can be disambiguated. Try to pick something that's unlikely to
+  clash with classes from other modules.
+  */
+  static jsonID(id, selectionClass) {
+    if (id in classesById)
+      throw new RangeError("Duplicate use of selection JSON ID " + id);
+    return classesById[id] = selectionClass, selectionClass.prototype.jsonID = id, selectionClass;
+  }
+  /**
+  Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
+  which is a value that can be mapped without having access to a
+  current document, and later resolved to a real selection for a
+  given document again. (This is used mostly by the history to
+  track and restore old selections.) The default implementation of
+  this method just converts the selection to a text selection and
+  returns the bookmark for that.
+  */
+  getBookmark() {
+    return TextSelection.between(this.$anchor, this.$head).getBookmark();
+  }
+}
+Selection.prototype.visible = !0;
+class SelectionRange {
+  /**
+  Create a range.
+  */
+  constructor($from, $to) {
+    this.$from = $from, this.$to = $to;
+  }
+}
+let warnedAboutTextSelection = !1;
+function checkTextSelection($pos) {
+  !warnedAboutTextSelection && !$pos.parent.inlineContent && (warnedAboutTextSelection = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")"));
+}
+class TextSelection extends Selection {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor($anchor, $head = $anchor) {
+    checkTextSelection($anchor), checkTextSelection($head), super($anchor, $head);
+  }
+  /**
+  Returns a resolved position if this is a cursor selection (an
+  empty text selection), and null otherwise.
+  */
+  get $cursor() {
+    return this.$anchor.pos == this.$head.pos ? this.$head : null;
+  }
+  map(doc, mapping) {
+    let $head = doc.resolve(mapping.map(this.head));
+    if (!$head.parent.inlineContent)
+      return Selection.near($head);
+    let $anchor = doc.resolve(mapping.map(this.anchor));
+    return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
+  }
+  replace(tr, content = Slice.empty) {
+    if (super.replace(tr, content), content == Slice.empty) {
+      let marks = this.$from.marksAcross(this.$to);
+      marks && tr.ensureMarks(marks);
+    }
+  }
+  eq(other) {
+    return other instanceof TextSelection && other.anchor == this.anchor && other.head == this.head;
+  }
+  getBookmark() {
+    return new TextBookmark(this.anchor, this.head);
+  }
+  toJSON() {
+    return { type: "text", anchor: this.anchor, head: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number" || typeof json.head != "number")
+      throw new RangeError("Invalid input for TextSelection.fromJSON");
+    return new TextSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(doc, anchor, head = anchor) {
+    let $anchor = doc.resolve(anchor);
+    return new this($anchor, head == anchor ? $anchor : doc.resolve(head));
+  }
+  /**
+  Return a text selection that spans the given positions or, if
+  they aren't text positions, find a text selection near them.
+  `bias` determines whether the method searches forward (default)
+  or backwards (negative number) first. Will fall back to calling
+  [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
+  doesn't contain a valid text position.
+  */
+  static between($anchor, $head, bias) {
+    let dPos = $anchor.pos - $head.pos;
+    if ((!bias || dPos) && (bias = dPos >= 0 ? 1 : -1), !$head.parent.inlineContent) {
+      let found = Selection.findFrom($head, bias, !0) || Selection.findFrom($head, -bias, !0);
+      if (found)
+        $head = found.$head;
+      else
+        return Selection.near($head, bias);
+    }
+    return $anchor.parent.inlineContent || (dPos == 0 ? $anchor = $head : ($anchor = (Selection.findFrom($anchor, -bias, !0) || Selection.findFrom($anchor, bias, !0)).$anchor, $anchor.pos < $head.pos != dPos < 0 && ($anchor = $head))), new TextSelection($anchor, $head);
+  }
+}
+Selection.jsonID("text", TextSelection);
+class TextBookmark {
+  constructor(anchor, head) {
+    this.anchor = anchor, this.head = head;
+  }
+  map(mapping) {
+    return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
+  }
+  resolve(doc) {
+    return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head));
+  }
+}
+class NodeSelection extends Selection {
+  /**
+  Create a node selection. Does not verify the validity of its
+  argument.
+  */
+  constructor($pos) {
+    let node = $pos.nodeAfter, $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
+    super($pos, $end), this.node = node;
+  }
+  map(doc, mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor), $pos = doc.resolve(pos);
+    return deleted ? Selection.near($pos) : new NodeSelection($pos);
+  }
+  content() {
+    return new Slice(Fragment.from(this.node), 0, 0);
+  }
+  eq(other) {
+    return other instanceof NodeSelection && other.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new NodeBookmark(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new NodeSelection(doc.resolve(json.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(doc, from) {
+    return new NodeSelection(doc.resolve(from));
+  }
+  /**
+  Determines whether the given node may be selected as a node
+  selection.
+  */
+  static isSelectable(node) {
+    return !node.isText && node.type.spec.selectable !== !1;
+  }
+}
+NodeSelection.prototype.visible = !1;
+Selection.jsonID("node", NodeSelection);
+class NodeBookmark {
+  constructor(anchor) {
+    this.anchor = anchor;
+  }
+  map(mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor);
+    return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos);
+  }
+  resolve(doc) {
+    let $pos = doc.resolve(this.anchor), node = $pos.nodeAfter;
+    return node && NodeSelection.isSelectable(node) ? new NodeSelection($pos) : Selection.near($pos);
+  }
+}
+class AllSelection extends Selection {
+  /**
+  Create an all-selection over the given document.
+  */
+  constructor(doc) {
+    super(doc.resolve(0), doc.resolve(doc.content.size));
+  }
+  replace(tr, content = Slice.empty) {
+    if (content == Slice.empty) {
+      tr.delete(0, tr.doc.content.size);
+      let sel = Selection.atStart(tr.doc);
+      sel.eq(tr.selection) || tr.setSelection(sel);
+    } else
+      super.replace(tr, content);
+  }
+  toJSON() {
+    return { type: "all" };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc) {
+    return new AllSelection(doc);
+  }
+  map(doc) {
+    return new AllSelection(doc);
+  }
+  eq(other) {
+    return other instanceof AllSelection;
+  }
+  getBookmark() {
+    return AllBookmark;
+  }
+}
+Selection.jsonID("all", AllSelection);
+const AllBookmark = {
+  map() {
+    return this;
+  },
+  resolve(doc) {
+    return new AllSelection(doc);
+  }
+};
+function findSelectionIn(doc, node, pos, index, dir, text = !1) {
+  if (node.inlineContent)
+    return TextSelection.create(doc, pos);
+  for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
+    let child = node.child(i);
+    if (child.isAtom) {
+      if (!text && NodeSelection.isSelectable(child))
+        return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0));
+    } else {
+      let inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
+      if (inner)
+        return inner;
+    }
+    pos += child.nodeSize * dir;
+  }
+  return null;
+}
+function selectionToInsertionEnd(tr, startLen, bias) {
+  let last = tr.steps.length - 1;
+  if (last < startLen)
+    return;
+  let step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
+    return;
+  let map = tr.mapping.maps[last], end;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    end == null && (end = newTo);
+  }), tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
+}
+function bind(f, self) {
+  return !self || !f ? f : f.bind(self);
+}
+class FieldDesc {
+  constructor(name, desc, self) {
+    this.name = name, this.init = bind(desc.init, self), this.apply = bind(desc.apply, self);
+  }
+}
+new FieldDesc("doc", {
+  init(config) {
+    return config.doc || config.schema.topNodeType.createAndFill();
+  },
+  apply(tr) {
+    return tr.doc;
+  }
+}), new FieldDesc("selection", {
+  init(config, instance) {
+    return config.selection || Selection.atStart(instance.doc);
+  },
+  apply(tr) {
+    return tr.selection;
+  }
+}), new FieldDesc("storedMarks", {
+  init(config) {
+    return config.storedMarks || null;
+  },
+  apply(tr, _marks, _old, state) {
+    return state.selection.$cursor ? tr.storedMarks : null;
+  }
+}), new FieldDesc("scrollToSelection", {
+  init() {
+    return 0;
+  },
+  apply(tr, prev) {
+    return tr.scrolledIntoView ? prev + 1 : prev;
+  }
+});
+function bindProps(obj, self, target) {
+  for (let prop in obj) {
+    let val = obj[prop];
+    val instanceof Function ? val = val.bind(self) : prop == "handleDOMEvents" && (val = bindProps(val, self, {})), target[prop] = val;
+  }
+  return target;
+}
+class Plugin {
+  /**
+  Create a plugin.
+  */
+  constructor(spec) {
+    this.spec = spec, this.props = {}, spec.props && bindProps(spec.props, this, this.props), this.key = spec.key ? spec.key.key : createKey("plugin");
+  }
+  /**
+  Extract the plugin's state field from an editor state.
+  */
+  getState(state) {
+    return state[this.key];
+  }
+}
+const keys = /* @__PURE__ */ Object.create(null);
+function createKey(name) {
+  return name in keys ? name + "$" + ++keys[name] : (keys[name] = 0, name + "$");
+}
+class PluginKey {
+  /**
+  Create a plugin key.
+  */
+  constructor(name = "key") {
+    this.key = createKey(name);
+  }
+  /**
+  Get the active plugin with this key, if any, from an editor
+  state.
+  */
+  get(state) {
+    return state.config.pluginsByKey[this.key];
+  }
+  /**
+  Get the plugin's state from an editor state.
+  */
+  getState(state) {
+    return state[this.key];
+  }
+}
+export {
+  AllSelection,
+  NodeSelection,
+  Plugin,
+  PluginKey,
+  Selection,
+  SelectionRange,
+  TextSelection
+};