@jvs-milkdown/prose 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present Mirone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @jvs-milkdown/prose
+
+The prose module of [milkdown](https://milkdown.dev/).
+
+# Official Documentation
+
+Documentation can be found on the [Milkdown website](https://milkdown.dev/).
+
+# License
+
+Milkdown is open sourced software licensed under [MIT license](https://github.com/Milkdown/milkdown/blob/main/LICENSE).

package/lib/changeset.d.ts

@@ -0,0 +1,2 @@
+export * from 'prosemirror-changeset';
+//# sourceMappingURL=changeset.d.ts.map

package/lib/changeset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeset.d.ts","sources":[],"mappings":"","names":[]}

package/lib/changeset.js

@@ -0,0 +1,2 @@
+export * from 'prosemirror-changeset';
+//# sourceMappingURL=changeset.js.map

package/lib/changeset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeset.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/commands.d.ts

@@ -0,0 +1,2 @@
+export * from 'prosemirror-commands';
+//# sourceMappingURL=commands.d.ts.map

package/lib/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sources":[],"mappings":"","names":[]}

package/lib/commands.js

@@ -0,0 +1,2 @@
+export * from 'prosemirror-commands';
+//# sourceMappingURL=commands.js.map

package/lib/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/dropcursor.d.ts

@@ -0,0 +1,2 @@
+export * from 'prosemirror-dropcursor';
+//# sourceMappingURL=dropcursor.d.ts.map

package/lib/dropcursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropcursor.d.ts","sources":[],"mappings":"","names":[]}

package/lib/dropcursor.js

@@ -0,0 +1,2 @@
+export * from 'prosemirror-dropcursor';
+//# sourceMappingURL=dropcursor.js.map

package/lib/dropcursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropcursor.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/gapcursor.d.ts

@@ -0,0 +1,2 @@
+export * from 'prosemirror-gapcursor';
+//# sourceMappingURL=gapcursor.d.ts.map

package/lib/gapcursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gapcursor.d.ts","sources":[],"mappings":"","names":[]}

package/lib/gapcursor.js

@@ -0,0 +1,2 @@
+export * from 'prosemirror-gapcursor';
+//# sourceMappingURL=gapcursor.js.map

package/lib/gapcursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gapcursor.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/history.d.ts

@@ -0,0 +1,2 @@
+export * from 'prosemirror-history';
+//# sourceMappingURL=history.d.ts.map

package/lib/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sources":[],"mappings":"","names":[]}

package/lib/history.js

@@ -0,0 +1,2 @@
+export * from 'prosemirror-history';
+//# sourceMappingURL=history.js.map

package/lib/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/index.d.ts

@@ -0,0 +1,132 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { Plugin, PluginKey, Transaction, EditorState, Selection } from 'prosemirror-state';
+import { Attrs, MarkType, NodeType, Node, Slice, ResolvedPos, Schema } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+
+/**
+ * Copy paste from:
+ * https://github.com/ProseMirror/prosemirror-view/blob/master/src/browser.ts
+ */
+declare const ie: boolean;
+declare const ie_version: unknown;
+declare const gecko: boolean;
+declare const gecko_version: number | false;
+declare const chrome: boolean;
+declare const chrome_version: number;
+declare const safari: boolean;
+declare const ios: boolean;
+declare const mac: boolean;
+declare const android: boolean;
+declare const webkit: boolean;
+declare const webkit_version: number;
+
+declare const browser_android: typeof android;
+declare const browser_chrome: typeof chrome;
+declare const browser_chrome_version: typeof chrome_version;
+declare const browser_gecko: typeof gecko;
+declare const browser_gecko_version: typeof gecko_version;
+declare const browser_ie: typeof ie;
+declare const browser_ie_version: typeof ie_version;
+declare const browser_ios: typeof ios;
+declare const browser_mac: typeof mac;
+declare const browser_safari: typeof safari;
+declare const browser_webkit: typeof webkit;
+declare const browser_webkit_version: typeof webkit_version;
+declare namespace browser {
+  export {
+    browser_android as android,
+    browser_chrome as chrome,
+    browser_chrome_version as chrome_version,
+    browser_gecko as gecko,
+    browser_gecko_version as gecko_version,
+    browser_ie as ie,
+    browser_ie_version as ie_version,
+    browser_ios as ios,
+    browser_mac as mac,
+    browser_safari as safari,
+    browser_webkit as webkit,
+    browser_webkit_version as webkit_version,
+  };
+}
+
+declare const customInputRulesKey: PluginKey<any>;
+declare function customInputRules({ rules }: {
+    rules: InputRule[];
+}): Plugin;
+
+interface Captured {
+    group: string | undefined;
+    fullMatch: string;
+    start: number;
+    end: number;
+}
+interface BeforeDispatch {
+    match: string[];
+    start: number;
+    end: number;
+    tr: Transaction;
+}
+interface Options {
+    getAttr?: (match: RegExpMatchArray) => Attrs;
+    updateCaptured?: (captured: Captured) => Partial<Captured>;
+    beforeDispatch?: (options: BeforeDispatch) => void;
+}
+
+declare function markRule(regexp: RegExp, markType: MarkType, options?: Options): InputRule;
+
+declare function nodeRule(regexp: RegExp, nodeType: NodeType, options?: Options): InputRule;
+
+type Point = [top: number, left: number];
+declare function calculateNodePosition(view: EditorView, target: HTMLElement, handler: (selectedRect: DOMRect, targetRect: DOMRect, parentRect: DOMRect) => Point): void;
+interface Rect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+declare function calculateTextPosition(view: EditorView, target: HTMLElement, handler: (start: Rect, end: Rect, targetRect: DOMRect, parentRect: DOMRect) => Point): void;
+declare function posToDOMRect(view: EditorView, from: number, to: number): DOMRect;
+
+declare function cloneTr(tr: Transaction): Transaction;
+declare function equalNodeType(nodeType: NodeType | NodeType[], node: Node): boolean;
+declare function isTextOnlySlice(slice: Slice): Node | false;
+
+type Predicate = (node: Node) => boolean;
+
+interface NodeWithPos {
+    pos: number;
+    node: Node;
+}
+interface NodeWithFromTo {
+    from: number;
+    to: number;
+    node: Node;
+}
+declare function flatten(node: Node, descend?: boolean): NodeWithPos[];
+declare function findChildren(predicate: Predicate): (node: Node, descend?: boolean) => NodeWithPos[];
+declare function findChildrenByMark(node: Node, markType: MarkType, descend?: boolean): NodeWithPos[];
+declare function findParent(predicate: Predicate): ($pos: ResolvedPos) => NodeWithFromTo | undefined;
+declare function findParentNodeType($pos: ResolvedPos, nodeType: NodeType): NodeWithFromTo | undefined;
+
+declare function getNodeFromSchema(type: string, schema: Schema): NodeType;
+declare function getMarkFromSchema(type: string, schema: Schema): MarkType;
+
+interface ContentNodeWithPos {
+    pos: number;
+    start: number;
+    depth: number;
+    node: Node;
+}
+declare function findParentNodeClosestToPos(predicate: Predicate): ($pos: ResolvedPos) => ContentNodeWithPos | undefined;
+declare function findParentNode(predicate: Predicate): (selection: Selection) => ContentNodeWithPos | undefined;
+declare function findSelectedNodeOfType(selection: Selection, nodeType: NodeType): ContentNodeWithPos | undefined;
+type FindNodeInSelectionResult = {
+    hasNode: boolean;
+    pos: number;
+    target: Node | null;
+};
+declare const findNodeInSelection: (state: EditorState, node: NodeType) => FindNodeInSelectionResult;
+
+export { browser, calculateNodePosition, calculateTextPosition, cloneTr, customInputRules, customInputRulesKey, equalNodeType, findChildren, findChildrenByMark, findNodeInSelection, findParent, findParentNode, findParentNodeClosestToPos, findParentNodeType, findSelectedNodeOfType, flatten, getMarkFromSchema, getNodeFromSchema, isTextOnlySlice, markRule, nodeRule, posToDOMRect };
+export type { BeforeDispatch, Captured, ContentNodeWithPos, FindNodeInSelectionResult, NodeWithFromTo, NodeWithPos, Options };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../src/toolkit/browser.ts","../src/toolkit/input-rules/custom-input-rules.ts","../src/toolkit/input-rules/common.ts","../src/toolkit/input-rules/mark-rule.ts","../src/toolkit/input-rules/node-rule.ts","../src/toolkit/position/index.ts","../src/toolkit/prose/helper.ts","../src/toolkit/prose/types.ts","../src/toolkit/prose/node.ts","../src/toolkit/prose/schema.ts","../src/toolkit/prose/selection.ts"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA,cAAc,EAAE;AAChB,cAAc,UAAU;AACxB,cAAc,KAAK;AACnB,cAAc,aAAa;AAC3B,cAAc,MAAM;AACpB,cAAc,cAAc;AAC5B,cAAc,MAAM;AACpB,cAAc,GAAG;AACjB,cAAc,GAAG;AACjB,cAAc,OAAO;AACrB,cAAc,MAAM;AACpB,cAAc,cAAc;;;;;;;;;;;;;;;;;;ACb5B,cAAc,mBAAmB,EAAE,SAAS;AAC5C,iBAAiB,gBAAgB;AACjC,WAAW,SAAS;AACpB,IAAI,MAAM;;ACHV,UAAU,QAAQ;AAClB;AACA;AACA;AACA;AACA;AACA,UAAU,cAAc;AACxB;AACA;AACA;AACA,QAAQ,WAAW;AACnB;AACA,UAAU,OAAO;AACjB,sBAAsB,gBAAgB,KAAK,KAAK;AAChD,gCAAgC,QAAQ,KAAK,OAAO,CAAC,QAAQ;AAC7D,+BAA+B,cAAc;AAC7C;;ACfA,iBAAiB,QAAQ,SAAS,MAAM,YAAY,QAAQ,YAAY,OAAO,GAAG,SAAS;;ACA3F,iBAAiB,QAAQ,SAAS,MAAM,YAAY,QAAQ,YAAY,OAAO,GAAG,SAAS;;ACF3F,KAAK,KAAK;AACV,iBAAiB,qBAAqB,OAAO,UAAU,UAAU,WAAW,0BAA0B,OAAO,cAAc,OAAO,cAAc,OAAO,KAAK,KAAK;AACjK,UAAU,IAAI;AACd;AACA;AACA;AACA;AACA;AACA,iBAAiB,qBAAqB,OAAO,UAAU,UAAU,WAAW,mBAAmB,IAAI,OAAO,IAAI,cAAc,OAAO,cAAc,OAAO,KAAK,KAAK;AAClK,iBAAiB,YAAY,OAAO,UAAU,6BAA6B,OAAO;;ACRlF,iBAAiB,OAAO,KAAK,WAAW,GAAG,WAAW;AACtD,iBAAiB,aAAa,WAAW,QAAQ,GAAG,QAAQ,UAAUA,IAAS;AAC/E,iBAAiB,eAAe,QAAQ,KAAK,GAAGA,IAAS;;ACHzD,KAAK,SAAS,UAAU,IAAI;;ACC5B,UAAU,WAAW;AACrB;AACA,UAAU,IAAI;AACd;AACA,UAAU,cAAc;AACxB;AACA;AACA,UAAU,IAAI;AACd;AACA,iBAAiB,OAAO,OAAO,IAAI,sBAAsB,WAAW;AACpE,iBAAiB,YAAY,YAAY,SAAS,UAAU,IAAI,wBAAwB,WAAW;AACnG,iBAAiB,kBAAkB,OAAO,IAAI,YAAY,QAAQ,sBAAsB,WAAW;AACnG,iBAAiB,UAAU,YAAY,SAAS,UAAU,WAAW,KAAK,cAAc;AACxF,iBAAiB,kBAAkB,OAAO,WAAW,YAAY,QAAQ,GAAG,cAAc;;ACd1F,iBAAiB,iBAAiB,uBAAuB,MAAM,GAAG,QAAQ;AAC1E,iBAAiB,iBAAiB,uBAAuB,MAAM,GAAG,QAAQ;;ACC1E,UAAU,kBAAkB;AAC5B;AACA;AACA;AACA,UAAUA,IAAS;AACnB;AACA,iBAAiB,0BAA0B,YAAY,SAAS,UAAU,WAAW,KAAK,kBAAkB;AAC5G,iBAAiB,cAAc,YAAY,SAAS,eAAe,SAAS,KAAK,kBAAkB;AACnG,iBAAiB,sBAAsB,YAAY,SAAS,YAAY,QAAQ,GAAG,kBAAkB;AACrG,KAAK,yBAAyB;AAC9B;AACA;AACA,YAAYA,IAAS;AACrB;AACA,cAAc,mBAAmB,UAAU,WAAW,QAAQ,QAAQ,KAAK,yBAAyB;;;;","names":["ProseNode"]}

package/lib/index.js

@@ -0,0 +1,402 @@
+import { PluginKey, Plugin, NodeSelection } from 'prosemirror-state';
+import { InputRule } from 'prosemirror-inputrules';
+import { expectDomTypeError, missingRootElement, getAtomFromSchemaFail } from '@jvs-milkdown/exception';
+
+const nav = typeof navigator != "undefined" ? navigator : null;
+const doc = typeof document != "undefined" ? document : null;
+const agent = nav && nav.userAgent || "";
+const ie_edge = /Edge\/(\d+)/.exec(agent);
+const ie_upto10 = /MSIE \d/.exec(agent);
+const ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
+const ie = !!(ie_upto10 || ie_11up || ie_edge);
+const ie_version = ie_upto10 ? document.documentMode : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0;
+const gecko = !ie && /gecko\/(\d+)/i.test(agent);
+const gecko_version = gecko && +(/Firefox\/(\d+)/.exec(agent) || [0, 0])[1];
+const _chrome = !ie && /Chrome\/(\d+)/.exec(agent);
+const chrome = !!_chrome;
+const chrome_version = _chrome ? +_chrome[1] : 0;
+const safari = !ie && !!nav && /Apple Computer/.test(nav.vendor);
+const ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints > 2);
+const mac = ios || (nav ? /Mac/.test(nav.platform) : false);
+const android = /Android \d/.test(agent);
+const webkit = !!doc && "webkitFontSmoothing" in doc.documentElement.style;
+const webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
+
+var browser = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  android: android,
+  chrome: chrome,
+  chrome_version: chrome_version,
+  gecko: gecko,
+  gecko_version: gecko_version,
+  ie: ie,
+  ie_version: ie_version,
+  ios: ios,
+  mac: mac,
+  safari: safari,
+  webkit: webkit,
+  webkit_version: webkit_version
+});
+
+function run(view, from, to, text, rules, plugin) {
+  if (view.composing) return false;
+  const state = view.state;
+  const $from = state.doc.resolve(from);
+  if ($from.parent.type.spec.code) return false;
+  const textBefore = $from.parent.textBetween(
+    Math.max(0, $from.parentOffset - 500),
+    $from.parentOffset,
+    void 0,
+    "\uFFFC"
+  ) + text;
+  for (let _matcher of rules) {
+    const matcher = _matcher;
+    const match = matcher.match.exec(textBefore);
+    const tr = match && match[0] && matcher.handler(state, match, from - (match[0].length - text.length), to);
+    if (!tr) continue;
+    if (matcher.undoable !== false)
+      tr.setMeta(plugin, { transform: tr, from, to, text });
+    view.dispatch(tr);
+    return true;
+  }
+  return false;
+}
+const customInputRulesKey = new PluginKey("MILKDOWN_CUSTOM_INPUTRULES");
+function customInputRules({ rules }) {
+  const plugin = new Plugin({
+    key: customInputRulesKey,
+    isInputRules: true,
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev) {
+        const stored = tr.getMeta(this);
+        if (stored) return stored;
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run(view, from, to, text, rules, plugin);
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            const { $cursor } = view.state.selection;
+            if ($cursor) run(view, $cursor.pos, $cursor.pos, "", rules, plugin);
+          });
+          return false;
+        },
+        keydown: (view, event) => {
+          if (!(android && chrome && event.key === "Enter"))
+            return false;
+          if (view.composing) return false;
+          if (view.someProp(
+            "handleKeyDown",
+            (f) => f(view, event)
+          )) {
+            event.preventDefault();
+            return true;
+          }
+          return false;
+        }
+      },
+      handleKeyDown(view, event) {
+        if (event.key !== "Enter") return false;
+        const { $cursor } = view.state.selection;
+        if ($cursor)
+          return run(view, $cursor.pos, $cursor.pos, "\n", rules, plugin);
+        return false;
+      }
+    }
+  });
+  return plugin;
+}
+
+function markRule(regexp, markType, options = {}) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    var _a, _b, _c, _d;
+    const { tr } = state;
+    const matchLength = match.length;
+    let group = match[matchLength - 1];
+    let fullMatch = match[0];
+    let initialStoredMarks = [];
+    let markEnd;
+    const captured = {
+      group,
+      fullMatch,
+      start,
+      end
+    };
+    const result = (_a = options.updateCaptured) == null ? void 0 : _a.call(options, captured);
+    Object.assign(captured, result);
+    ({ group, fullMatch, start, end } = captured);
+    if (fullMatch === null) return null;
+    if ((group == null ? void 0 : group.trim()) === "") return null;
+    if (group) {
+      const startSpaces = fullMatch.search(/\S/);
+      const textStart = start + fullMatch.indexOf(group);
+      const textEnd = textStart + group.length;
+      initialStoredMarks = (_b = tr.storedMarks) != null ? _b : [];
+      if (textEnd < end) tr.delete(textEnd, end);
+      if (textStart > start) tr.delete(start + startSpaces, textStart);
+      markEnd = start + startSpaces + group.length;
+      const attrs = (_c = options.getAttr) == null ? void 0 : _c.call(options, match);
+      tr.addMark(start, markEnd, markType.create(attrs));
+      tr.setStoredMarks(initialStoredMarks);
+      (_d = options.beforeDispatch) == null ? void 0 : _d.call(options, { match, start, end, tr });
+    }
+    return tr;
+  });
+}
+
+function nodeRule(regexp, nodeType, options = {}) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    var _a, _b, _c;
+    const { tr } = state;
+    let group = match[1];
+    let fullMatch = match[0];
+    const captured = {
+      group,
+      fullMatch,
+      start,
+      end
+    };
+    const result = (_a = options.updateCaptured) == null ? void 0 : _a.call(options, captured);
+    Object.assign(captured, result);
+    ({ group, fullMatch, start, end } = captured);
+    if (fullMatch === null) return null;
+    if (!group || group.trim() === "") return null;
+    const attrs = (_b = options.getAttr) == null ? void 0 : _b.call(options, match);
+    const node = nodeType.createAndFill(attrs);
+    if (node) {
+      tr.replaceRangeWith(
+        nodeType.isBlock ? tr.doc.resolve(start).before() : start,
+        end,
+        node
+      );
+      (_c = options.beforeDispatch) == null ? void 0 : _c.call(options, {
+        match: [fullMatch, group],
+        start,
+        end,
+        tr
+      });
+    }
+    return tr;
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function calculateNodePosition(view, target, handler) {
+  const state = view.state;
+  const { from } = state.selection;
+  const { node } = view.domAtPos(from);
+  const element = node instanceof Text ? node.parentElement : node;
+  if (!(element instanceof HTMLElement)) throw expectDomTypeError(element);
+  const selectedNodeRect = element.getBoundingClientRect();
+  const targetNodeRect = target.getBoundingClientRect();
+  const parent = target.parentElement;
+  if (!parent) throw expectDomTypeError(parent);
+  const parentNodeRect = parent.getBoundingClientRect();
+  const [top, left] = handler(selectedNodeRect, targetNodeRect, parentNodeRect);
+  target.style.top = `${top}px`;
+  target.style.left = `${left}px`;
+}
+function calculateTextPosition(view, target, handler) {
+  const state = view.state;
+  const { from, to } = state.selection;
+  const start = view.coordsAtPos(from);
+  const end = view.coordsAtPos(to);
+  const targetNodeRect = target.getBoundingClientRect();
+  const parent = target.parentElement;
+  if (!parent) throw missingRootElement();
+  const parentNodeRect = parent.getBoundingClientRect();
+  const [top, left] = handler(start, end, targetNodeRect, parentNodeRect);
+  target.style.top = `${top}px`;
+  target.style.left = `${left}px`;
+}
+function minMax(value = 0, min = 0, max = 0) {
+  return Math.min(Math.max(value, min), max);
+}
+function posToDOMRect(view, from, to) {
+  const minPos = 0;
+  const maxPos = view.state.doc.content.size;
+  const resolvedFrom = minMax(from, minPos, maxPos);
+  const resolvedEnd = minMax(to, minPos, maxPos);
+  const start = view.coordsAtPos(resolvedFrom);
+  const end = view.coordsAtPos(resolvedEnd, -1);
+  const top = Math.min(start.top, end.top);
+  const bottom = Math.max(start.bottom, end.bottom);
+  const left = Math.min(start.left, end.left);
+  const right = Math.max(start.right, end.right);
+  const width = right - left;
+  const height = bottom - top;
+  const x = left;
+  const y = top;
+  const data = {
+    top,
+    bottom,
+    left,
+    right,
+    width,
+    height,
+    x,
+    y
+  };
+  return __spreadProps(__spreadValues({}, data), {
+    toJSON: () => data
+  });
+}
+
+function cloneTr(tr) {
+  return Object.assign(Object.create(tr), tr).setTime(Date.now());
+}
+function equalNodeType(nodeType, node) {
+  return Array.isArray(nodeType) && nodeType.includes(node.type) || node.type === nodeType;
+}
+function isTextOnlySlice(slice) {
+  if (slice.content.childCount === 1) {
+    const node = slice.content.firstChild;
+    if ((node == null ? void 0 : node.type.name) === "text" && node.marks.length === 0) return node;
+    if ((node == null ? void 0 : node.type.name) === "paragraph" && node.childCount === 1) {
+      const _node = node.firstChild;
+      if ((_node == null ? void 0 : _node.type.name) === "text" && _node.marks.length === 0) return _node;
+    }
+  }
+  return false;
+}
+
+function flatten(node, descend = true) {
+  const result = [];
+  node.descendants((child, pos) => {
+    result.push({ node: child, pos });
+    if (!descend) return false;
+    return void 0;
+  });
+  return result;
+}
+function findChildren(predicate) {
+  return (node, descend) => flatten(node, descend).filter((child) => predicate(child.node));
+}
+function findChildrenByMark(node, markType, descend) {
+  return findChildren((child) => Boolean(markType.isInSet(child.marks)))(
+    node,
+    descend
+  );
+}
+function findParent(predicate) {
+  return ($pos) => {
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth);
+      if (predicate(node)) {
+        const from = $pos.before(depth);
+        const to = $pos.after(depth);
+        return {
+          from,
+          to,
+          node
+        };
+      }
+    }
+    return void 0;
+  };
+}
+function findParentNodeType($pos, nodeType) {
+  return findParent((node) => node.type === nodeType)($pos);
+}
+
+function getNodeFromSchema(type, schema) {
+  const target = schema.nodes[type];
+  if (!target) throw getAtomFromSchemaFail("node", type);
+  return target;
+}
+function getMarkFromSchema(type, schema) {
+  const target = schema.marks[type];
+  if (!target) throw getAtomFromSchemaFail("mark", type);
+  return target;
+}
+
+function findParentNodeClosestToPos(predicate) {
+  return ($pos) => {
+    for (let i = $pos.depth; i > 0; i--) {
+      const node = $pos.node(i);
+      if (predicate(node)) {
+        return {
+          pos: $pos.before(i),
+          start: $pos.start(i),
+          depth: i,
+          node
+        };
+      }
+    }
+    return void 0;
+  };
+}
+function findParentNode(predicate) {
+  return (selection) => {
+    return findParentNodeClosestToPos(predicate)(selection.$from);
+  };
+}
+function findSelectedNodeOfType(selection, nodeType) {
+  if (!(selection instanceof NodeSelection)) return;
+  const { node, $from } = selection;
+  if (equalNodeType(nodeType, node))
+    return {
+      node,
+      pos: $from.pos,
+      start: $from.start($from.depth),
+      depth: $from.depth
+    };
+  return void 0;
+}
+const findNodeInSelection = (state, node) => {
+  const { selection, doc } = state;
+  if (selection instanceof NodeSelection) {
+    return {
+      hasNode: selection.node.type === node,
+      pos: selection.from,
+      target: selection.node
+    };
+  }
+  const { from, to } = selection;
+  let hasNode = false;
+  let pos = -1;
+  let target = null;
+  doc.nodesBetween(from, to, (n, p) => {
+    if (target) return false;
+    if (n.type === node) {
+      hasNode = true;
+      pos = p;
+      target = n;
+      return false;
+    }
+    return true;
+  });
+  return {
+    hasNode,
+    pos,
+    target
+  };
+};
+
+export { browser, calculateNodePosition, calculateTextPosition, cloneTr, customInputRules, customInputRulesKey, equalNodeType, findChildren, findChildrenByMark, findNodeInSelection, findParent, findParentNode, findParentNodeClosestToPos, findParentNodeType, findSelectedNodeOfType, flatten, getMarkFromSchema, getNodeFromSchema, isTextOnlySlice, markRule, nodeRule, posToDOMRect };
+//# sourceMappingURL=index.js.map