kritzel-stencil 0.0.154 → 0.0.156

package/dist/{components/p-CBYBurdY.js → stencil/text-tool.class-C0GbC5zQ.js}

@@ -1,6 +1,6 @@
-import { O as ObjectHelper } from './p-B0kd2rUI.js';
-import { K as KritzelDevicesHelper } from './p-l10It7Nm.js';
-import { K as KritzelMouseButton } from './p-D8W6LE-c.js';
+import { O as ObjectHelper } from './object.helper-B0kd2rUI.js';
+import { K as KritzelDevicesHelper } from './devices.helper-l10It7Nm.js';
+import { K as KritzelMouseButton } from './event-button.enum-D8W6LE-c.js';
 
 class KritzelToolRegistry {
     static registry = {};
@@ -214,6 +214,7 @@ class KritzelBaseObject {
         const viewportBounds = {
             x: -this._core.store.state.translateX / this._core.store.state.scale,
             y: -this._core.store.state.translateY / this._core.store.state.scale,
+            z: this._core.store.state.scale,
             width: this._core.store.state.viewportWidth / this._core.store.state.scale,
             height: this._core.store.state.viewportHeight / this._core.store.state.scale,
         };
@@ -2725,7 +2726,7 @@ let NodeType$1 = class NodeType {
     @internal
     */
     checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "node");
+        checkAttrs(this.attrs, attrs, "node", this.name);
     }
     /**
     Check whether the given mark type is allowed in this node.
@@ -2876,7 +2877,7 @@ class MarkType {
     @internal
     */
     checkAttrs(attrs) {
-        checkAttrs(this.attrs, attrs, "mark");
+        checkAttrs(this.attrs, attrs, "mark", this.name);
     }
     /**
     Queries whether a given mark type is
@@ -3184,7 +3185,7 @@ function wsOptionsFor(type, preserveWhitespace, base) {
     if (preserveWhitespace != null)
         return (preserveWhitespace ? OPT_PRESERVE_WS : 0) |
             (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
-    return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & -5;
+    return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
 }
 class NodeContext {
     constructor(type, attrs, marks, solid, match, options) {
@@ -4944,7 +4945,7 @@ function liftTarget(range) {
     }
     return null;
 }
-function lift(tr, range, target) {
+function lift$1(tr, range, target) {
     let { $from, $to, depth } = range;
     let gapStart = $from.before(depth + 1), gapEnd = $to.after(depth + 1);
     let start = gapStart, end = gapEnd;
@@ -4970,6 +4971,45 @@ function lift(tr, range, target) {
         }
     tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd, new Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
 }
+/**
+Try to find a valid way to wrap the content in the given range in a
+node of the given type. May introduce extra nodes around and inside
+the wrapper node, if necessary. Returns null if no valid wrapping
+could be found. When `innerRange` is given, that range's content is
+used as the content to fit into the wrapping, instead of the
+content of `range`.
+*/
+function findWrapping(range, nodeType, attrs = null, innerRange = range) {
+    let around = findWrappingOutside(range, nodeType);
+    let inner = around && findWrappingInside(innerRange, nodeType);
+    if (!inner)
+        return null;
+    return around.map(withAttrs)
+        .concat({ type: nodeType, attrs }).concat(inner.map(withAttrs));
+}
+function withAttrs(type) { return { type, attrs: null }; }
+function findWrappingOutside(range, type) {
+    let { parent, startIndex, endIndex } = range;
+    let around = parent.contentMatchAt(startIndex).findWrapping(type);
+    if (!around)
+        return null;
+    let outer = around.length ? around[0] : type;
+    return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null;
+}
+function findWrappingInside(range, type) {
+    let { parent, startIndex, endIndex } = range;
+    let inner = parent.child(startIndex);
+    let inside = type.contentMatch.findWrapping(inner.type);
+    if (!inside)
+        return null;
+    let lastType = inside.length ? inside[inside.length - 1] : type;
+    let innerMatch = lastType.contentMatch;
+    for (let i = startIndex; innerMatch && i < endIndex; i++)
+        innerMatch = innerMatch.matchType(parent.child(i).type);
+    if (!innerMatch || !innerMatch.validEnd)
+        return null;
+    return inside;
+}
 function wrap(tr, range, wrappers) {
     let content = Fragment.empty;
     for (let i = wrappers.length - 1; i >= 0; i--) {
@@ -4983,7 +5023,7 @@ function wrap(tr, range, wrappers) {
     let start = range.start, end = range.end;
     tr.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true));
 }
-function setBlockType(tr, from, to, type, attrs) {
+function setBlockType$1(tr, from, to, type, attrs) {
     if (!type.isTextblock)
         throw new RangeError("Type given to setBlockType should be a textblock");
     let mapFrom = tr.steps.length;
@@ -5115,6 +5155,36 @@ function canAppendWithSubstitutedLinebreaks(a, b) {
 function joinable(a, b) {
     return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebreaks(a, b));
 }
+/**
+Find an ancestor of the given position that can be joined to the
+block before (or after if `dir` is positive). Returns the joinable
+point, if any.
+*/
+function joinPoint(doc, pos, dir = -1) {
+    let $pos = doc.resolve(pos);
+    for (let d = $pos.depth;; d--) {
+        let before, after, index = $pos.index(d);
+        if (d == $pos.depth) {
+            before = $pos.nodeBefore;
+            after = $pos.nodeAfter;
+        }
+        else if (dir > 0) {
+            before = $pos.node(d + 1);
+            index++;
+            after = $pos.node(d).maybeChild(index);
+        }
+        else {
+            before = $pos.node(d).maybeChild(index - 1);
+            after = $pos.node(d + 1);
+        }
+        if (before && !before.isTextblock && joinable(before, after) &&
+            $pos.node(d).canReplace(index, index + 1))
+            return pos;
+        if (d == 0)
+            break;
+        pos = dir < 0 ? $pos.before(d) : $pos.after(d);
+    }
+}
 function join(tr, pos, depth) {
     let convertNewlines = null;
     let { linebreakReplacement } = tr.doc.type.schema;
@@ -5914,7 +5984,7 @@ class Transform {
     sure the lift is valid.
     */
     lift(range, target) {
-        lift(this, range, target);
+        lift$1(this, range, target);
         return this;
     }
     /**
@@ -5939,7 +6009,7 @@ class Transform {
     the given node type with the given attributes.
     */
     setBlockType(from, to = from, type, attrs = null) {
-        setBlockType(this, from, to, type, attrs);
+        setBlockType$1(this, from, to, type, attrs);
         return this;
     }
     /**
@@ -6568,7 +6638,7 @@ class Transaction extends Transform {
             throw new RangeError("Selection passed to setSelection must point at the current document");
         this.curSelection = selection;
         this.curSelectionFor = this.steps.length;
-        this.updated = (this.updated | UPDATED_SEL) & -3;
+        this.updated = (this.updated | UPDATED_SEL) & ~UPDATED_MARKS;
         this.storedMarks = null;
         return this;
     }
@@ -6619,7 +6689,7 @@ class Transaction extends Transform {
     */
     addStep(step, doc) {
         super.addStep(step, doc);
-        this.updated = this.updated & -3;
+        this.updated = this.updated & ~UPDATED_MARKS;
         this.storedMarks = null;
     }
     /**
@@ -7012,6 +7082,27 @@ function createKey(name) {
     keys[name] = 0;
     return name + "$";
 }
+/**
+A key is used to [tag](https://prosemirror.net/docs/ref/#state.PluginSpec.key) plugins in a way
+that makes it possible to find them, given an editor state.
+Assigning a key does mean only one plugin of that type can be
+active in a state.
+*/
+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]; }
+}
 
 const domIndex = function (node) {
     for (var index = 0;; index++) {
@@ -7182,6 +7273,7 @@ const ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
 const ie$1 = !!(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$1 && /gecko\/(\d+)/i.test(agent);
+gecko && +(/Firefox\/(\d+)/.exec(agent) || [0, 0])[1];
 const _chrome = !ie$1 && /Chrome\/(\d+)/.exec(agent);
 const chrome = !!_chrome;
 const chrome_version = _chrome ? +_chrome[1] : 0;
@@ -10224,7 +10316,8 @@ function updateSelection(view, selection, origin) {
     if (view.state.selection.eq(selection))
         return;
     let tr = view.state.tr.setSelection(selection);
-    tr.setMeta("pointer", true);
+    if (origin == "pointer")
+        tr.setMeta("pointer", true);
     view.dispatch(tr);
 }
 function selectClickedLeaf(view, inside) {
@@ -10232,7 +10325,7 @@ function selectClickedLeaf(view, inside) {
         return false;
     let $pos = view.state.doc.resolve(inside), node = $pos.nodeAfter;
     if (node && node.isAtom && NodeSelection.isSelectable(node)) {
-        updateSelection(view, new NodeSelection($pos));
+        updateSelection(view, new NodeSelection($pos), "pointer");
         return true;
     }
     return false;
@@ -10256,7 +10349,7 @@ function selectClickedNode(view, inside) {
         }
     }
     if (selectAt != null) {
-        updateSelection(view, NodeSelection.create(view.state.doc, selectAt));
+        updateSelection(view, NodeSelection.create(view.state.doc, selectAt), "pointer");
         return true;
     }
     else {
@@ -10283,7 +10376,7 @@ function defaultTripleClick(view, inside, event) {
     let doc = view.state.doc;
     if (inside == -1) {
         if (doc.inlineContent) {
-            updateSelection(view, TextSelection.create(doc, 0, doc.content.size));
+            updateSelection(view, TextSelection.create(doc, 0, doc.content.size), "pointer");
             return true;
         }
         return false;
@@ -10293,9 +10386,9 @@ function defaultTripleClick(view, inside, event) {
         let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
         let nodePos = $pos.before(i);
         if (node.inlineContent)
-            updateSelection(view, TextSelection.create(doc, nodePos + 1, nodePos + 1 + node.content.size));
+            updateSelection(view, TextSelection.create(doc, nodePos + 1, nodePos + 1 + node.content.size), "pointer");
         else if (NodeSelection.isSelectable(node))
-            updateSelection(view, NodeSelection.create(doc, nodePos));
+            updateSelection(view, NodeSelection.create(doc, nodePos), "pointer");
         else
             continue;
         return true;
@@ -10424,7 +10517,7 @@ class MouseDown {
                 // works around that.
                 (chrome && !this.view.state.selection.visible &&
                     Math.min(Math.abs(pos.pos - this.view.state.selection.from), Math.abs(pos.pos - this.view.state.selection.to)) <= 2))) {
-            updateSelection(this.view, Selection.near(this.view.state.doc.resolve(pos.pos)));
+            updateSelection(this.view, Selection.near(this.view.state.doc.resolve(pos.pos)), "pointer");
             event.preventDefault();
         }
         else {
@@ -12244,6 +12337,15 @@ function isSurrogatePair(str) {
     let a = str.charCodeAt(0), b = str.charCodeAt(1);
     return a >= 0xDC00 && a <= 0xDFFF && b >= 0xD800 && b <= 0xDBFF;
 }
+
+/**
+@internal
+*/
+const __parseFromClipboard = parseFromClipboard;
+/**
+@internal
+*/
+const __endComposition = endComposition;
 /**
 An editor view manages the DOM structure that represents an
 editable document. Its state and behavior are determined by its
@@ -13060,6 +13162,229 @@ function addListNodes(nodes, itemContent, listGroup) {
         list_item: add(listItem, { content: itemContent })
     });
 }
+/**
+Returns a command function that wraps the selection in a list with
+the given type an attributes. If `dispatch` is null, only return a
+value to indicate whether this is possible, but don't actually
+perform the change.
+*/
+function wrapInList(listType, attrs = null) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to);
+        if (!range)
+            return false;
+        let tr = dispatch ? state.tr : null;
+        if (!wrapRangeInList(tr, range, listType, attrs))
+            return false;
+        if (dispatch)
+            dispatch(tr.scrollIntoView());
+        return true;
+    };
+}
+/**
+Try to wrap the given node range in a list of the given type.
+Return `true` when this is possible, `false` otherwise. When `tr`
+is non-null, the wrapping is added to that transaction. When it is
+`null`, the function only queries whether the wrapping is
+possible.
+*/
+function wrapRangeInList(tr, range, listType, attrs = null) {
+    let doJoin = false, outerRange = range, doc = range.$from.doc;
+    // This is at the top of an existing list item
+    if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+        // Don't do anything if this is the top of the list
+        if (range.$from.index(range.depth - 1) == 0)
+            return false;
+        let $insert = doc.resolve(range.start - 2);
+        outerRange = new NodeRange($insert, $insert, range.depth);
+        if (range.endIndex < range.parent.childCount)
+            range = new NodeRange(range.$from, doc.resolve(range.$to.end(range.depth)), range.depth);
+        doJoin = true;
+    }
+    let wrap = findWrapping(outerRange, listType, attrs, range);
+    if (!wrap)
+        return false;
+    if (tr)
+        doWrapInList(tr, range, wrap, doJoin, listType);
+    return true;
+}
+function doWrapInList(tr, range, wrappers, joinBefore, listType) {
+    let content = Fragment.empty;
+    for (let i = wrappers.length - 1; i >= 0; i--)
+        content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+    tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
+    let found = 0;
+    for (let i = 0; i < wrappers.length; i++)
+        if (wrappers[i].type == listType)
+            found = i + 1;
+    let splitDepth = wrappers.length - found;
+    let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
+    for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
+        if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+            tr.split(splitPos, splitDepth);
+            splitPos += 2 * splitDepth;
+        }
+        splitPos += parent.child(i).nodeSize;
+    }
+    return tr;
+}
+/**
+Build a command that splits a non-empty textblock at the top level
+of a list item by also splitting that list item.
+*/
+function splitListItem(itemType, itemAttrs) {
+    return function (state, dispatch) {
+        let { $from, $to, node } = state.selection;
+        if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to))
+            return false;
+        let grandParent = $from.node(-1);
+        if (grandParent.type != itemType)
+            return false;
+        if ($from.parent.content.size == 0 && $from.node(-1).childCount == $from.indexAfter(-1)) {
+            // In an empty block. If this is a nested list, the wrapping
+            // list item should be split. Otherwise, bail out and let next
+            // command handle lifting.
+            if ($from.depth == 3 || $from.node(-3).type != itemType ||
+                $from.index(-2) != $from.node(-2).childCount - 1)
+                return false;
+            if (dispatch) {
+                let wrap = Fragment.empty;
+                let depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+                // Build a fragment containing empty versions of the structure
+                // from the outer list item to the parent node of the cursor
+                for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--)
+                    wrap = Fragment.from($from.node(d).copy(wrap));
+                let depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1
+                    : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
+                // Add a second list item with an empty default start node
+                wrap = wrap.append(Fragment.from(itemType.createAndFill()));
+                let start = $from.before($from.depth - (depthBefore - 1));
+                let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+                let sel = -1;
+                tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
+                    if (sel > -1)
+                        return false;
+                    if (node.isTextblock && node.content.size == 0)
+                        sel = pos + 1;
+                });
+                if (sel > -1)
+                    tr.setSelection(Selection.near(tr.doc.resolve(sel)));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+        let nextType = $to.pos == $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
+        let tr = state.tr.delete($from.pos, $to.pos);
+        let types = nextType ? [itemAttrs ? { type: itemType, attrs: itemAttrs } : null, { type: nextType }] : undefined;
+        if (!canSplit(tr.doc, $from.pos, 2, types))
+            return false;
+        if (dispatch)
+            dispatch(tr.split($from.pos, 2, types).scrollIntoView());
+        return true;
+    };
+}
+/**
+Acts like [`splitListItem`](https://prosemirror.net/docs/ref/#schema-list.splitListItem), but
+without resetting the set of active marks at the cursor.
+*/
+function splitListItemKeepMarks(itemType, itemAttrs) {
+    let split = splitListItem(itemType, itemAttrs);
+    return (state, dispatch) => {
+        return split(state, dispatch && (tr => {
+            let marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
+            if (marks)
+                tr.ensureMarks(marks);
+            dispatch(tr);
+        }));
+    };
+}
+/**
+Create a command to lift the list item around the selection up into
+a wrapping list.
+*/
+function liftListItem(itemType) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        if (!dispatch)
+            return true;
+        if ($from.node(range.depth - 1).type == itemType) // Inside a parent list
+            return liftToOuterList(state, dispatch, itemType, range);
+        else // Outer list node
+            return liftOutOfList(state, dispatch, range);
+    };
+}
+function liftToOuterList(state, dispatch, itemType, range) {
+    let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
+    if (end < endOfList) {
+        // There are siblings after the lifted items, which must become
+        // children of the last item
+        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
+        range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+    }
+    const target = liftTarget(range);
+    if (target == null)
+        return false;
+    tr.lift(range, target);
+    let $after = tr.doc.resolve(tr.mapping.map(end, -1) - 1);
+    if (canJoin(tr.doc, $after.pos) && $after.nodeBefore.type == $after.nodeAfter.type)
+        tr.join($after.pos);
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+function liftOutOfList(state, dispatch, range) {
+    let tr = state.tr, list = range.parent;
+    // Merge the list items into a single big item
+    for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+        pos -= list.child(i).nodeSize;
+        tr.delete(pos - 1, pos + 1);
+    }
+    let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;
+    if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize)
+        return false;
+    let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;
+    let parent = $start.node(-1), indexBefore = $start.index(-1);
+    if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))
+        return false;
+    let start = $start.pos, end = start + item.nodeSize;
+    // Strip off the surrounding list. At the sides where we're not at
+    // the end of the list, the existing list is closed. At sides where
+    // this is the end, it is overwritten to its end.
+    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))
+        .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+/**
+Create a command to sink the list item around the selection down
+into an inner list.
+*/
+function sinkListItem(itemType) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        let startIndex = range.startIndex;
+        if (startIndex == 0)
+            return false;
+        let parent = range.parent, nodeBefore = parent.child(startIndex - 1);
+        if (nodeBefore.type != itemType)
+            return false;
+        if (dispatch) {
+            let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
+            let inner = Fragment.from(nestedBefore ? itemType.create() : null);
+            let slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+            let before = range.start, after = range.end;
+            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
 
 var base = {
   8: "Backspace",
@@ -13377,6 +13702,60 @@ const joinBackward = (state, dispatch, view) => {
     }
     return false;
 };
+/**
+A more limited form of [`joinBackward`](https://prosemirror.net/docs/ref/#commands.joinBackward)
+that only tries to join the current textblock to the one before
+it, if the cursor is at the start of a textblock.
+*/
+const joinTextblockBackward = (state, dispatch, view) => {
+    let $cursor = atBlockStart(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutBefore($cursor);
+    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+/**
+A more limited form of [`joinForward`](https://prosemirror.net/docs/ref/#commands.joinForward)
+that only tries to join the current textblock to the one after
+it, if the cursor is at the end of a textblock.
+*/
+const joinTextblockForward = (state, dispatch, view) => {
+    let $cursor = atBlockEnd(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutAfter($cursor);
+    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+function joinTextblocksAround(state, $cut, dispatch) {
+    let before = $cut.nodeBefore, beforeText = before, beforePos = $cut.pos - 1;
+    for (; !beforeText.isTextblock; beforePos--) {
+        if (beforeText.type.spec.isolating)
+            return false;
+        let child = beforeText.lastChild;
+        if (!child)
+            return false;
+        beforeText = child;
+    }
+    let after = $cut.nodeAfter, afterText = after, afterPos = $cut.pos + 1;
+    for (; !afterText.isTextblock; afterPos++) {
+        if (afterText.type.spec.isolating)
+            return false;
+        let child = afterText.firstChild;
+        if (!child)
+            return false;
+        afterText = child;
+    }
+    let step = replaceStep(state.doc, beforePos, afterPos, Slice.empty);
+    if (!step || step.from != beforePos ||
+        step instanceof ReplaceStep && step.slice.size >= afterPos - beforePos)
+        return false;
+    if (dispatch) {
+        let tr = state.tr.step(step);
+        tr.setSelection(TextSelection.create(tr.doc, beforePos));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+}
 function textblockAt(node, side, only = false) {
     for (let scan = node; scan; scan = (side == "start" ? scan.firstChild : scan.lastChild)) {
         if (scan.isTextblock)
@@ -13505,6 +13884,64 @@ function findCutAfter($pos) {
     return null;
 }
 /**
+Join the selected block or, if there is a text selection, the
+closest ancestor block of the selection that can be joined, with
+the sibling above it.
+*/
+const joinUp = (state, dispatch) => {
+    let sel = state.selection, nodeSel = sel instanceof NodeSelection, point;
+    if (nodeSel) {
+        if (sel.node.isTextblock || !canJoin(state.doc, sel.from))
+            return false;
+        point = sel.from;
+    }
+    else {
+        point = joinPoint(state.doc, sel.from, -1);
+        if (point == null)
+            return false;
+    }
+    if (dispatch) {
+        let tr = state.tr.join(point);
+        if (nodeSel)
+            tr.setSelection(NodeSelection.create(tr.doc, point - state.doc.resolve(point).nodeBefore.nodeSize));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+Join the selected block, or the closest ancestor of the selection
+that can be joined, with the sibling after it.
+*/
+const joinDown = (state, dispatch) => {
+    let sel = state.selection, point;
+    if (sel instanceof NodeSelection) {
+        if (sel.node.isTextblock || !canJoin(state.doc, sel.to))
+            return false;
+        point = sel.to;
+    }
+    else {
+        point = joinPoint(state.doc, sel.to, 1);
+        if (point == null)
+            return false;
+    }
+    if (dispatch)
+        dispatch(state.tr.join(point).scrollIntoView());
+    return true;
+};
+/**
+Lift the selected block, or the closest ancestor block of the
+selection that can be lifted, out of its parent node.
+*/
+const lift = (state, dispatch) => {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to), target = range && liftTarget(range);
+    if (target == null)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+};
+/**
 If the selection is in a node whose type has a truthy
 [`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, replace the
 selection with a newline character.
@@ -13592,7 +14029,7 @@ a custom function to determine the type of the newly split off block.
 */
 function splitBlockAs(splitNode) {
     return (state, dispatch) => {
-        let { $from} = state.selection;
+        let { $from, $to } = state.selection;
         if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
             if (!$from.parentOffset || !canSplit(state.doc, $from.pos))
                 return false;
@@ -13610,7 +14047,8 @@ function splitBlockAs(splitNode) {
                 atEnd = $from.end(d) == $from.pos + ($from.depth - d);
                 atStart = $from.start(d) == $from.pos - ($from.depth - d);
                 deflt = defaultBlockAt($from.node(d - 1).contentMatchAt($from.indexAfter(d - 1)));
-                types.unshift((atEnd && deflt ? { type: deflt } : null));
+                let splitType = splitNode && splitNode($to.parent, atEnd, $from);
+                types.unshift(splitType || (atEnd && deflt ? { type: deflt } : null));
                 splitDepth = d;
                 break;
             }
@@ -13648,6 +14086,32 @@ selection, also delete its content.
 */
 const splitBlock = splitBlockAs();
 /**
+Acts like [`splitBlock`](https://prosemirror.net/docs/ref/#commands.splitBlock), but without
+resetting the set of active marks at the cursor.
+*/
+const splitBlockKeepMarks = (state, dispatch) => {
+    return splitBlock(state, dispatch && (tr => {
+        let marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
+        if (marks)
+            tr.ensureMarks(marks);
+        dispatch(tr);
+    }));
+};
+/**
+Move the selection to the node wrapping the current selection, if
+any. (Will not select the document node.)
+*/
+const selectParentNode = (state, dispatch) => {
+    let { $from, to } = state.selection, pos;
+    let same = $from.sharedDepth(to);
+    if (same == 0)
+        return false;
+    pos = $from.before(same);
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)));
+    return true;
+};
+/**
 Select the whole document.
 */
 const selectAll = (state, dispatch) => {
@@ -13748,6 +14212,205 @@ const selectTextblockStart = selectTextblockSide(-1);
 Moves the cursor to the end of current text block.
 */
 const selectTextblockEnd = selectTextblockSide(1);
+// Parameterized commands
+/**
+Wrap the selection in a node of the given type with the given
+attributes.
+*/
+function wrapIn(nodeType, attrs = null) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.wrap(range, wrapping).scrollIntoView());
+        return true;
+    };
+}
+/**
+Returns a command that tries to set the selected textblocks to the
+given node type with the given attributes.
+*/
+function setBlockType(nodeType, attrs = null) {
+    return function (state, dispatch) {
+        let applicable = false;
+        for (let i = 0; i < state.selection.ranges.length && !applicable; i++) {
+            let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+            state.doc.nodesBetween(from, to, (node, pos) => {
+                if (applicable)
+                    return false;
+                if (!node.isTextblock || node.hasMarkup(nodeType, attrs))
+                    return;
+                if (node.type == nodeType) {
+                    applicable = true;
+                }
+                else {
+                    let $pos = state.doc.resolve(pos), index = $pos.index();
+                    applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
+                }
+            });
+        }
+        if (!applicable)
+            return false;
+        if (dispatch) {
+            let tr = state.tr;
+            for (let i = 0; i < state.selection.ranges.length; i++) {
+                let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+                tr.setBlockType(from, to, nodeType, attrs);
+            }
+            dispatch(tr.scrollIntoView());
+        }
+        return true;
+    };
+}
+function markApplies(doc, ranges, type, enterAtoms) {
+    for (let i = 0; i < ranges.length; i++) {
+        let { $from, $to } = ranges[i];
+        let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
+        doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+            if (can || !enterAtoms && node.isAtom && node.isInline && pos >= $from.pos && pos + node.nodeSize <= $to.pos)
+                return false;
+            can = node.inlineContent && node.type.allowsMarkType(type);
+        });
+        if (can)
+            return true;
+    }
+    return false;
+}
+function removeInlineAtoms(ranges) {
+    let result = [];
+    for (let i = 0; i < ranges.length; i++) {
+        let { $from, $to } = ranges[i];
+        $from.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+            if (node.isAtom && node.content.size && node.isInline && pos >= $from.pos && pos + node.nodeSize <= $to.pos) {
+                if (pos + 1 > $from.pos)
+                    result.push(new SelectionRange($from, $from.doc.resolve(pos + 1)));
+                $from = $from.doc.resolve(pos + 1 + node.content.size);
+                return false;
+            }
+        });
+        if ($from.pos < $to.pos)
+            result.push(new SelectionRange($from, $to));
+    }
+    return result;
+}
+/**
+Create a command function that toggles the given mark with the
+given attributes. Will return `false` when the current selection
+doesn't support that mark. This will remove the mark if any marks
+of that type exist in the selection, or add it otherwise. If the
+selection is empty, this applies to the [stored
+marks](https://prosemirror.net/docs/ref/#state.EditorState.storedMarks) instead of a range of the
+document.
+*/
+function toggleMark(markType, attrs = null, options) {
+    let removeWhenPresent = (options && options.removeWhenPresent) !== false;
+    let enterAtoms = (options && options.enterInlineAtoms) !== false;
+    let dropSpace = !(options && options.includeWhitespace);
+    return function (state, dispatch) {
+        let { empty, $cursor, ranges } = state.selection;
+        if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType, enterAtoms))
+            return false;
+        if (dispatch) {
+            if ($cursor) {
+                if (markType.isInSet(state.storedMarks || $cursor.marks()))
+                    dispatch(state.tr.removeStoredMark(markType));
+                else
+                    dispatch(state.tr.addStoredMark(markType.create(attrs)));
+            }
+            else {
+                let add, tr = state.tr;
+                if (!enterAtoms)
+                    ranges = removeInlineAtoms(ranges);
+                if (removeWhenPresent) {
+                    add = !ranges.some(r => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType));
+                }
+                else {
+                    add = !ranges.every(r => {
+                        let missing = false;
+                        tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
+                            if (missing)
+                                return false;
+                            missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) &&
+                                !(node.isText && /^\s*$/.test(node.textBetween(Math.max(0, r.$from.pos - pos), Math.min(node.nodeSize, r.$to.pos - pos))));
+                        });
+                        return !missing;
+                    });
+                }
+                for (let i = 0; i < ranges.length; i++) {
+                    let { $from, $to } = ranges[i];
+                    if (!add) {
+                        tr.removeMark($from.pos, $to.pos, markType);
+                    }
+                    else {
+                        let from = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore;
+                        let spaceStart = dropSpace && start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
+                        let spaceEnd = dropSpace && end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
+                        if (from + spaceStart < to) {
+                            from += spaceStart;
+                            to -= spaceEnd;
+                        }
+                        tr.addMark(from, to, markType.create(attrs));
+                    }
+                }
+                dispatch(tr.scrollIntoView());
+            }
+        }
+        return true;
+    };
+}
+function wrapDispatchForJoin(dispatch, isJoinable) {
+    return (tr) => {
+        if (!tr.isGeneric)
+            return dispatch(tr);
+        let ranges = [];
+        for (let i = 0; i < tr.mapping.maps.length; i++) {
+            let map = tr.mapping.maps[i];
+            for (let j = 0; j < ranges.length; j++)
+                ranges[j] = map.map(ranges[j]);
+            map.forEach((_s, _e, from, to) => ranges.push(from, to));
+        }
+        // Figure out which joinable points exist inside those ranges,
+        // by checking all node boundaries in their parent nodes.
+        let joinable = [];
+        for (let i = 0; i < ranges.length; i += 2) {
+            let from = ranges[i], to = ranges[i + 1];
+            let $from = tr.doc.resolve(from), depth = $from.sharedDepth(to), parent = $from.node(depth);
+            for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
+                let after = parent.maybeChild(index);
+                if (!after)
+                    break;
+                if (index && joinable.indexOf(pos) == -1) {
+                    let before = parent.child(index - 1);
+                    if (before.type == after.type && isJoinable(before, after))
+                        joinable.push(pos);
+                }
+                pos += after.nodeSize;
+            }
+        }
+        // Join the joinable points
+        joinable.sort((a, b) => a - b);
+        for (let i = joinable.length - 1; i >= 0; i--) {
+            if (canJoin(tr.doc, joinable[i]))
+                tr.join(joinable[i]);
+        }
+        dispatch(tr);
+    };
+}
+/**
+Wrap a command so that, when it produces a transform that causes
+two joinable nodes to end up next to each other, those are joined.
+Nodes are considered joinable when they are of the same type and
+when the `isJoinable` predicate returns true for them or, if an
+array of strings was passed, if their node type name is in that
+array.
+*/
+function autoJoin(command, isJoinable) {
+    let canJoin = Array.isArray(isJoinable) ? (node) => isJoinable.indexOf(node.type.name) > -1
+        : isJoinable;
+    return (state, dispatch, view) => command(state, dispatch && wrapDispatchForJoin(dispatch, canJoin), view);
+}
 /**
 Combine a number of command functions into a single function (which
 calls them one by one until one returns true).
@@ -14062,6 +14725,45 @@ class KritzelText extends KritzelBaseObject {
     }
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getDefaultExportFromNamespaceIfPresent (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+}
+
+function getDefaultExportFromNamespaceIfNotNamed (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
 var cjs = {};
 
 var hasRequiredCjs;
@@ -14070,12 +14772,13 @@ function requireCjs () {
 	if (hasRequiredCjs) return cjs;
 	hasRequiredCjs = 1;
 	(function (exports) {
-		var pe=Object.defineProperty;var ge=e=>pe(e,"__esModule",{value:true});var de=(e,t)=>{ge(e);for(var s in t)pe(e,s,{get:t[s],enumerable:true});};de(exports,{default:()=>ve,getStroke:()=>ne,getStrokeOutlinePoints:()=>te,getStrokePoints:()=>re});function $(e,t,s,x=h=>h){return e*x(.5-t*(.5-s))}function ce(e){return [-e[0],-e[1]]}function l(e,t){return [e[0]+t[0],e[1]+t[1]]}function a(e,t){return [e[0]-t[0],e[1]-t[1]]}function b(e,t){return [e[0]*t,e[1]*t]}function xe(e,t){return [e[0]/t,e[1]/t]}function R(e){return [e[1],-e[0]]}function B(e,t){return e[0]*t[0]+e[1]*t[1]}function me(e,t){return e[0]===t[0]&&e[1]===t[1]}function Se(e){return Math.hypot(e[0],e[1])}function Pe(e){return e[0]*e[0]+e[1]*e[1]}function A(e,t){return Pe(a(e,t))}function G(e){return xe(e,Se(e))}function ae(e,t){return Math.hypot(e[1]-t[1],e[0]-t[0])}function L(e,t,s){let x=Math.sin(s),h=Math.cos(s),y=e[0]-t[0],n=e[1]-t[1],f=y*h-n*x,d=y*x+n*h;return [f+t[0],d+t[1]]}function K(e,t,s){return l(e,b(a(t,e),s))}function ee(e,t,s){return l(e,b(t,s))}var{min:C,PI:ke}=Math,le=.275,V=ke+1e-4;function te(e,t={}){let{size:s=16,smoothing:x=.5,thinning:h=.5,simulatePressure:y=true,easing:n=r=>r,start:f={},end:d={},last:D=false}=t,{cap:S=true,easing:j=r=>r*(2-r)}=f,{cap:q=true,easing:c=r=>--r*r*r+1}=d;if(e.length===0||s<=0)return [];let p=e[e.length-1].runningLength,g=f.taper===false?0:f.taper===true?Math.max(s,p):f.taper,T=d.taper===false?0:d.taper===true?Math.max(s,p):d.taper,oe=Math.pow(s*x,2),_=[],M=[],H=e.slice(0,10).reduce((r,i)=>{let o=i.pressure;if(y){let u=C(1,i.distance/s),W=C(1,1-u);o=C(1,r+(W-r)*(u*le));}return (r+o)/2},e[0].pressure),m=$(s,h,e[e.length-1].pressure,n),U,X=e[0].vector,z=e[0].point,F=z,O=z,E=F,J=false;for(let r=0;r<e.length;r++){let{pressure:i}=e[r],{point:o,vector:u,distance:W,runningLength:I}=e[r];if(r<e.length-1&&p-I<3)continue;if(h){if(y){let v=C(1,W/s),Z=C(1,1-v);i=C(1,H+(Z-H)*(v*le));}m=$(s,h,i,n);}else m=s/2;U===void 0&&(U=m);let fe=I<g?j(I/g):1,be=p-I<T?c((p-I)/T):1;m=Math.max(.01,m*Math.min(fe,be));let se=(r<e.length-1?e[r+1]:e[r]).vector,Y=r<e.length-1?B(u,se):1,he=B(u,X)<0&&!J,ue=Y!==null&&Y<0;if(he||ue){let v=b(R(X),m);for(let Z=1/13,w=0;w<=1;w+=Z)O=L(a(o,v),o,V*w),_.push(O),E=L(l(o,v),o,V*-w),M.push(E);z=O,F=E,ue&&(J=true);continue}if(J=false,r===e.length-1){let v=b(R(u),m);_.push(a(o,v)),M.push(l(o,v));continue}let ie=b(R(K(se,u,Y)),m);O=a(o,ie),(r<=1||A(z,O)>oe)&&(_.push(O),z=O),E=l(o,ie),(r<=1||A(F,E)>oe)&&(M.push(E),F=E),H=i,X=u;}let P=e[0].point.slice(0,2),k=e.length>1?e[e.length-1].point.slice(0,2):l(e[0].point,[1,1]),Q=[],N=[];if(e.length===1){if(!(g||T)||D){let r=ee(P,G(R(a(P,k))),-(U||m)),i=[];for(let o=1/13,u=o;u<=1;u+=o)i.push(L(r,P,V*2*u));return i}}else {if(!(g||T&&e.length===1))if(S)for(let i=1/13,o=i;o<=1;o+=i){let u=L(M[0],P,V*o);Q.push(u);}else {let i=a(_[0],M[0]),o=b(i,.5),u=b(i,.51);Q.push(a(P,o),a(P,u),l(P,u),l(P,o));}let r=R(ce(e[e.length-1].vector));if(T||g&&e.length===1)N.push(k);else if(q){let i=ee(k,r,m);for(let o=1/29,u=o;u<1;u+=o)N.push(L(i,k,V*3*u));}else N.push(l(k,b(r,m)),l(k,b(r,m*.99)),a(k,b(r,m*.99)),a(k,b(r,m)));}return _.concat(N,M.reverse(),Q)}function re(e,t={}){var q;let{streamline:s=.5,size:x=16,last:h=false}=t;if(e.length===0)return [];let y=.15+(1-s)*.85,n=Array.isArray(e[0])?e:e.map(({x:c,y:p,pressure:g=.5})=>[c,p,g]);if(n.length===2){let c=n[1];n=n.slice(0,-1);for(let p=1;p<5;p++)n.push(K(n[0],c,p/4));}n.length===1&&(n=[...n,[...l(n[0],[1,1]),...n[0].slice(2)]]);let f=[{point:[n[0][0],n[0][1]],pressure:n[0][2]>=0?n[0][2]:.25,vector:[1,1],distance:0,runningLength:0}],d=false,D=0,S=f[0],j=n.length-1;for(let c=1;c<n.length;c++){let p=h&&c===j?n[c].slice(0,2):K(S.point,n[c],y);if(me(S.point,p))continue;let g=ae(p,S.point);if(D+=g,c<j&&!d){if(D<x)continue;d=true;}S={point:p,pressure:n[c][2]>=0?n[c][2]:.5,vector:G(a(S.point,p)),distance:g,runningLength:D},f.push(S);}return f[0].vector=((q=f[1])==null?void 0:q.vector)||[0,0],f}function ne(e,t={}){return te(re(e,t),t)}var ve=ne; 
+		var pe=Object.defineProperty;var ge=e=>pe(e,"__esModule",{value:!0});var de=(e,t)=>{ge(e);for(var s in t)pe(e,s,{get:t[s],enumerable:!0});};de(exports,{default:()=>ve,getStroke:()=>ne,getStrokeOutlinePoints:()=>te,getStrokePoints:()=>re});function $(e,t,s,x=h=>h){return e*x(.5-t*(.5-s))}function ce(e){return [-e[0],-e[1]]}function l(e,t){return [e[0]+t[0],e[1]+t[1]]}function a(e,t){return [e[0]-t[0],e[1]-t[1]]}function b(e,t){return [e[0]*t,e[1]*t]}function xe(e,t){return [e[0]/t,e[1]/t]}function R(e){return [e[1],-e[0]]}function B(e,t){return e[0]*t[0]+e[1]*t[1]}function me(e,t){return e[0]===t[0]&&e[1]===t[1]}function Se(e){return Math.hypot(e[0],e[1])}function Pe(e){return e[0]*e[0]+e[1]*e[1]}function A(e,t){return Pe(a(e,t))}function G(e){return xe(e,Se(e))}function ae(e,t){return Math.hypot(e[1]-t[1],e[0]-t[0])}function L(e,t,s){let x=Math.sin(s),h=Math.cos(s),y=e[0]-t[0],n=e[1]-t[1],f=y*h-n*x,d=y*x+n*h;return [f+t[0],d+t[1]]}function K(e,t,s){return l(e,b(a(t,e),s))}function ee(e,t,s){return l(e,b(t,s))}var{min:C,PI:ke}=Math,le=.275,V=ke+1e-4;function te(e,t={}){let{size:s=16,smoothing:x=.5,thinning:h=.5,simulatePressure:y=!0,easing:n=r=>r,start:f={},end:d={},last:D=!1}=t,{cap:S=!0,easing:j=r=>r*(2-r)}=f,{cap:q=!0,easing:c=r=>--r*r*r+1}=d;if(e.length===0||s<=0)return [];let p=e[e.length-1].runningLength,g=f.taper===!1?0:f.taper===!0?Math.max(s,p):f.taper,T=d.taper===!1?0:d.taper===!0?Math.max(s,p):d.taper,oe=Math.pow(s*x,2),_=[],M=[],H=e.slice(0,10).reduce((r,i)=>{let o=i.pressure;if(y){let u=C(1,i.distance/s),W=C(1,1-u);o=C(1,r+(W-r)*(u*le));}return (r+o)/2},e[0].pressure),m=$(s,h,e[e.length-1].pressure,n),U,X=e[0].vector,z=e[0].point,F=z,O=z,E=F,J=!1;for(let r=0;r<e.length;r++){let{pressure:i}=e[r],{point:o,vector:u,distance:W,runningLength:I}=e[r];if(r<e.length-1&&p-I<3)continue;if(h){if(y){let v=C(1,W/s),Z=C(1,1-v);i=C(1,H+(Z-H)*(v*le));}m=$(s,h,i,n);}else m=s/2;U===void 0&&(U=m);let fe=I<g?j(I/g):1,be=p-I<T?c((p-I)/T):1;m=Math.max(.01,m*Math.min(fe,be));let se=(r<e.length-1?e[r+1]:e[r]).vector,Y=r<e.length-1?B(u,se):1,he=B(u,X)<0&&!J,ue=Y!==null&&Y<0;if(he||ue){let v=b(R(X),m);for(let Z=1/13,w=0;w<=1;w+=Z)O=L(a(o,v),o,V*w),_.push(O),E=L(l(o,v),o,V*-w),M.push(E);z=O,F=E,ue&&(J=!0);continue}if(J=!1,r===e.length-1){let v=b(R(u),m);_.push(a(o,v)),M.push(l(o,v));continue}let ie=b(R(K(se,u,Y)),m);O=a(o,ie),(r<=1||A(z,O)>oe)&&(_.push(O),z=O),E=l(o,ie),(r<=1||A(F,E)>oe)&&(M.push(E),F=E),H=i,X=u;}let P=e[0].point.slice(0,2),k=e.length>1?e[e.length-1].point.slice(0,2):l(e[0].point,[1,1]),Q=[],N=[];if(e.length===1){if(!(g||T)||D){let r=ee(P,G(R(a(P,k))),-(U||m)),i=[];for(let o=1/13,u=o;u<=1;u+=o)i.push(L(r,P,V*2*u));return i}}else {if(!(g||T&&e.length===1))if(S)for(let i=1/13,o=i;o<=1;o+=i){let u=L(M[0],P,V*o);Q.push(u);}else {let i=a(_[0],M[0]),o=b(i,.5),u=b(i,.51);Q.push(a(P,o),a(P,u),l(P,u),l(P,o));}let r=R(ce(e[e.length-1].vector));if(T||g&&e.length===1)N.push(k);else if(q){let i=ee(k,r,m);for(let o=1/29,u=o;u<1;u+=o)N.push(L(i,k,V*3*u));}else N.push(l(k,b(r,m)),l(k,b(r,m*.99)),a(k,b(r,m*.99)),a(k,b(r,m)));}return _.concat(N,M.reverse(),Q)}function re(e,t={}){var q;let{streamline:s=.5,size:x=16,last:h=!1}=t;if(e.length===0)return [];let y=.15+(1-s)*.85,n=Array.isArray(e[0])?e:e.map(({x:c,y:p,pressure:g=.5})=>[c,p,g]);if(n.length===2){let c=n[1];n=n.slice(0,-1);for(let p=1;p<5;p++)n.push(K(n[0],c,p/4));}n.length===1&&(n=[...n,[...l(n[0],[1,1]),...n[0].slice(2)]]);let f=[{point:[n[0][0],n[0][1]],pressure:n[0][2]>=0?n[0][2]:.25,vector:[1,1],distance:0,runningLength:0}],d=!1,D=0,S=f[0],j=n.length-1;for(let c=1;c<n.length;c++){let p=h&&c===j?n[c].slice(0,2):K(S.point,n[c],y);if(me(S.point,p))continue;let g=ae(p,S.point);if(D+=g,c<j&&!d){if(D<x)continue;d=!0;}S={point:p,pressure:n[c][2]>=0?n[c][2]:.5,vector:G(a(S.point,p)),distance:g,runningLength:D},f.push(S);}return f[0].vector=((q=f[1])==null?void 0:q.vector)||[0,0],f}function ne(e,t={}){return te(re(e,t),t)}var ve=ne; 
 	} (cjs));
 	return cjs;
 }
 
 var cjsExports = requireCjs();
+var index = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
 
 class KritzelMathHelper {
     static average(a, b) {
@@ -14419,6 +15122,7 @@ class KritzelBaseTool {
     _core;
     constructor(core) {
         this._core = core;
+        void this._core; // Avoid unused variable warning
     }
     onActivate() {
         // default implementation
@@ -14684,7 +15388,7 @@ class KritzelTextTool extends KritzelBaseTool {
     }
 }
 
-export { KritzelText as K, KritzelPath as a, KritzelBrushTool as b, KritzelTextTool as c, KritzelKeyboardHelper as d, KritzelBaseObject as e, KritzelBaseTool as f, KritzelEventHelper as g, KritzelToolRegistry as h };
-//# sourceMappingURL=p-CBYBurdY.js.map
+export { KritzelText as K, KritzelPath as a, KritzelBrushTool as b, KritzelTextTool as c, KritzelKeyboardHelper as d, commonjsGlobal as e, KritzelToolRegistry as f, getDefaultExportFromCjs as g, KritzelBaseObject as h, KritzelEventHelper as i, KritzelBaseTool as j };
+//# sourceMappingURL=text-tool.class-C0GbC5zQ.js.map
 
-//# sourceMappingURL=p-CBYBurdY.js.map
+//# sourceMappingURL=text-tool.class-C0GbC5zQ.js.map