@bigbinary/neeto-editor 1.47.119 → 1.47.121

package/dist/cjs/{chunk-eyfbjfPH.cjs.js → chunk-NqciyXN3.cjs.js}

@@ -148,8 +148,11 @@ function findDiffStart(a, b, pos) {
         if (!childA.sameMarkup(childB))
             return pos;
         if (childA.isText && childA.text != childB.text) {
-            for (let j = 0; childA.text[j] == childB.text[j]; j++)
+            let tA = childA.text, tB = childB.text, j = 0;
+            for (; tA[j] == tB[j]; j++)
                 pos++;
+            if (j && j < tA.length && j < tB.length && surrogateHigh(tA.charCodeAt(j - 1)) && surrogateLow(tA.charCodeAt(j)))
+                pos--;
             return pos;
         }
         if (childA.content.size || childB.content.size) {
@@ -173,12 +176,17 @@ function findDiffEnd(a, b, posA, posB) {
         if (!childA.sameMarkup(childB))
             return { a: posA, b: posB };
         if (childA.isText && childA.text != childB.text) {
-            let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
-            while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
-                same++;
+            let tA = childA.text, tB = childB.text, iA = tA.length, iB = tB.length;
+            while (iA > 0 && iB > 0 && tA[iA - 1] == tB[iB - 1]) {
+                iA--;
+                iB--;
                 posA--;
                 posB--;
             }
+            if (iA && iB && iA < tA.length && surrogateHigh(tA.charCodeAt(iA - 1)) && surrogateLow(tA.charCodeAt(iA))) {
+                posA++;
+                posB++;
+            }
             return { a: posA, b: posB };
         }
         if (childA.content.size || childB.content.size) {
@@ -190,6 +198,8 @@ function findDiffEnd(a, b, posA, posB) {
         posB -= size;
     }
 }
+function surrogateLow(ch) { return ch >= 0xDC00 && ch < 0xE000; }
+function surrogateHigh(ch) { return ch >= 0xD800 && ch < 0xDC00; }
 
 /**
 A fragment represents a node's collection of child nodes.
@@ -204,7 +214,7 @@ class Fragment {
     */
     constructor(
     /**
-    @internal
+    The child nodes in this fragment.
     */
     content, size) {
         this.content = content;
@@ -408,7 +418,7 @@ class Fragment {
     position in this fragment. The result object will be reused
     (overwritten) the next time the function is called. @internal
     */
-    findIndex(pos, round = -1) {
+    findIndex(pos) {
         if (pos == 0)
             return retIndex(0, pos);
         if (pos == this.size)
@@ -418,7 +428,7 @@ class Fragment {
         for (let i = 0, curPos = 0;; i++) {
             let cur = this.child(i), end = curPos + cur.nodeSize;
             if (end >= pos) {
-                if (end == pos || round > 0)
+                if (end == pos)
                     return retIndex(i + 1, end);
                 return retIndex(i, curPos);
             }
@@ -447,7 +457,7 @@ class Fragment {
             return Fragment.empty;
         if (!Array.isArray(value))
             throw new RangeError("Invalid input for Fragment.fromJSON");
-        return new Fragment(value.map(schema.nodeFromJSON));
+        return Fragment.fromArray(value.map(schema.nodeFromJSON));
     }
     /**
     Build a fragment from an array of nodes. Ensures that adjacent
@@ -681,17 +691,6 @@ given an invalid replacement.
 */
 class ReplaceError extends Error {
 }
-/*
-ReplaceError = function(this: any, message: string) {
-  let err = Error.call(this, message)
-  ;(err as any).__proto__ = ReplaceError.prototype
-  return err
-} as any
-
-ReplaceError.prototype = Object.create(Error.prototype)
-ReplaceError.prototype.constructor = ReplaceError
-ReplaceError.prototype.name = "ReplaceError"
-*/
 /**
 A slice represents a piece cut out of a larger document. It
 stores not only a fragment, but also the depth up to which nodes on
@@ -737,7 +736,7 @@ class Slice {
     @internal
     */
     insertAt(pos, fragment) {
-        let content = insertInto(this.content, pos + this.openStart, fragment);
+        let content = insertInto(this.content, pos + this.openStart, fragment, this.openStart + 1, this.openEnd + 1);
         return content && new Slice(content, this.openStart, this.openEnd);
     }
     /**
@@ -811,12 +810,14 @@ function removeRange(content, from, to) {
         throw new RangeError("Removing non-flat range");
     return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
 }
-function insertInto(content, dist, insert, parent) {
+function insertInto(content, dist, insert, openStart, openEnd, parent) {
     let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
     if (offset == dist || child.isText) {
+        if (parent && openStart <= 0 && openEnd <= 0 && !parent.canReplace(index, index, insert))
+            return null;
         return content.cut(0, dist).append(insert).append(content.cut(dist));
     }
-    let inner = insertInto(child.content, dist - offset - 1, insert);
+    let inner = insertInto(child.content, dist - offset - 1, insert, index == 0 ? openStart - 1 : 0, index == content.childCount - 1 ? openEnd - 1 : 0, child);
     return inner && content.replaceChild(index, child.copy(inner));
 }
 function replace($from, $to, slice) {
@@ -879,7 +880,8 @@ function addRange($start, $end, depth, target) {
         addNode($end.nodeBefore, target);
 }
 function close(node, content) {
-    node.type.checkContent(content);
+    if (!node.type.validContent(content))
+        throw new ReplaceError("Invalid content for node " + node.type.name);
     return node.copy(content);
 }
 function replaceThreeWay($from, $start, $end, $to, depth) {
@@ -1286,7 +1288,7 @@ structure between the old and new data as much as possible, which a
 tree shape like this (without back pointers) makes easy.
 
 **Do not** directly mutate the properties of a `Node` object. See
-[the guide](/docs/guide/#doc) for more information.
+[the guide](https://prosemirror.net/docs/guide/#doc) for more information.
 */
 class Node {
     /**
@@ -1316,8 +1318,12 @@ class Node {
         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](/docs/guide/#doc.indexing). For text nodes, this is the
+    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).
@@ -1342,10 +1348,11 @@ class Node {
     */
     forEach(f) { this.content.forEach(f); }
     /**
-    Invoke a callback for all descendant nodes recursively between
+    Invoke a callback for all descendant nodes recursively overlapping
     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),
+    node's content. This includes all ancestors of the nodes
+    containing the two positions. 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
@@ -1375,7 +1382,7 @@ class Node {
     `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.
+    [`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);
@@ -1982,7 +1989,7 @@ function resolveName(stream, name) {
     let result = [];
     for (let typeName in types) {
         let type = types[typeName];
-        if (type.groups.indexOf(name) > -1)
+        if (type.isInGroup(name))
             result.push(type);
     }
     if (result.length == 0)
@@ -2011,16 +2018,14 @@ function parseExprAtom(stream) {
         stream.err("Unexpected token '" + stream.next + "'");
     }
 }
-/**
-Construct an NFA from an expression as returned by the parser. The
-NFA is represented as an array of states, which are themselves
-arrays of edges, which are `{term, to}` objects. The first state is
-the entry state and the last node is the success state.
-
-Note that unlike typical NFAs, the edge ordering in this one is
-significant, in that it is used to contruct filler content when
-necessary.
-*/
+// Construct an NFA from an expression as returned by the parser. The
+// NFA is represented as an array of states, which are themselves
+// arrays of edges, which are `{term, to}` objects. The first state is
+// the entry state and the last node is the success state.
+//
+// Note that unlike typical NFAs, the edge ordering in this one is
+// significant, in that it is used to contruct filler content when
+// necessary.
 function nfa(expr) {
     let nfa = [[]];
     connect(compile(expr, 0), node());
@@ -2187,13 +2192,12 @@ function computeAttrs(attrs, value) {
     return built;
 }
 function checkAttrs(attrs, values, type, name) {
-    for (let name in values)
-        if (!(name in attrs))
-            throw new RangeError(`Unsupported attribute ${name} for ${type} of type ${name}`);
-    for (let name in attrs) {
-        let attr = attrs[name];
-        if (attr.validate)
-            attr.validate(values[name]);
+    for (let attr in values)
+        if (!(attr in attrs))
+            throw new RangeError(`Unsupported attribute ${attr} for ${type} of type ${name}`);
+    for (let attr in attrs) {
+        if (attrs[attr].validate)
+            attrs[attr].validate(values[attr]);
     }
 }
 function initAttrs(typeName, attrs) {
@@ -2261,6 +2265,13 @@ class NodeType {
     */
     get isAtom() { return this.isLeaf || !!this.spec.atom; }
     /**
+    Return true when this node type is part of the given
+    [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
+    */
+    isInGroup(group) {
+        return this.groups.indexOf(group) > -1;
+    }
+    /**
     The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
     */
     get whitespace() {
@@ -2580,8 +2591,8 @@ class Schema {
             let type = this.marks[prop], excl = type.spec.excludes;
             type.excluded = excl == null ? [type] : excl == "" ? [] : gatherMarks(this, excl.split(" "));
         }
-        this.nodeFromJSON = this.nodeFromJSON.bind(this);
-        this.markFromJSON = this.markFromJSON.bind(this);
+        this.nodeFromJSON = json => Node.fromJSON(this, json);
+        this.markFromJSON = json => Mark.fromJSON(this, json);
         this.topNodeType = this.nodes[this.spec.topNode || "doc"];
         this.cached.wrappings = Object.create(null);
     }
@@ -2617,20 +2628,6 @@ class Schema {
         return type.create(attrs);
     }
     /**
-    Deserialize a node from its JSON representation. This method is
-    bound.
-    */
-    nodeFromJSON(json) {
-        return Node.fromJSON(this, json);
-    }
-    /**
-    Deserialize a mark from its JSON representation. This method is
-    bound.
-    */
-    markFromJSON(json) {
-        return Mark.fromJSON(this, json);
-    }
-    /**
     @internal
     */
     nodeType(name) {
@@ -2812,7 +2809,7 @@ class DOMParser {
     /**
     Construct a DOM parser using the parsing rules listed in a
     schema's [node specs](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM), reordered by
-    [priority](https://prosemirror.net/docs/ref/#model.ParseRule.priority).
+    [priority](https://prosemirror.net/docs/ref/#model.GenericParseRule.priority).
     */
     static fromSchema(schema) {
         return schema.cached.domParser ||
@@ -2905,6 +2902,7 @@ class ParseContext {
         this.options = options;
         this.isOpen = isOpen;
         this.open = 0;
+        this.localPreserveWS = false;
         let topNode = options.topNode, topContext;
         let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
         if (topNode)
@@ -2931,11 +2929,13 @@ class ParseContext {
     }
     addTextNode(dom, marks) {
         let value = dom.nodeValue;
-        let top = this.top;
-        if (top.options & OPT_PRESERVE_WS_FULL ||
+        let top = this.top, preserveWS = (top.options & OPT_PRESERVE_WS_FULL) ? "full"
+            : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
+        let { schema } = this.parser;
+        if (preserveWS === "full" ||
             top.inlineContext(dom) ||
             /[^ \t\r\n\u000c]/.test(value)) {
-            if (!(top.options & OPT_PRESERVE_WS)) {
+            if (!preserveWS) {
                 value = value.replace(/[ \t\r\n\u000c]+/g, " ");
                 // If this starts with whitespace, and there is no node before it, or
                 // a hard break, or a text node that ends with whitespace, strip the
@@ -2949,14 +2949,24 @@ class ParseContext {
                         value = value.slice(1);
                 }
             }
-            else if (!(top.options & OPT_PRESERVE_WS_FULL)) {
-                value = value.replace(/\r?\n|\r/g, " ");
+            else if (preserveWS === "full") {
+                value = value.replace(/\r\n?/g, "\n");
+            }
+            else if (schema.linebreakReplacement && /[\r\n]/.test(value) && this.top.findWrapping(schema.linebreakReplacement.create())) {
+                let lines = value.split(/\r?\n|\r/);
+                for (let i = 0; i < lines.length; i++) {
+                    if (i)
+                        this.insertNode(schema.linebreakReplacement.create(), marks, true);
+                    if (lines[i])
+                        this.insertNode(schema.text(lines[i]), marks, !/\S/.test(lines[i]));
+                }
+                value = "";
             }
             else {
-                value = value.replace(/\r\n?/g, "\n");
+                value = value.replace(/\r?\n|\r/g, " ");
             }
             if (value)
-                this.insertNode(this.parser.schema.text(value), marks);
+                this.insertNode(schema.text(value), marks, !/\S/.test(value));
             this.findInText(dom);
         }
         else {
@@ -2966,12 +2976,15 @@ class ParseContext {
     // Try to find a handler for the given tag and use that to parse. If
     // none is found, the element's content nodes are added directly.
     addElement(dom, marks, matchAfter) {
+        let outerWS = this.localPreserveWS, top = this.top;
+        if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace))
+            this.localPreserveWS = true;
         let name = dom.nodeName.toLowerCase(), ruleID;
         if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
             normalizeList(dom);
         let rule = (this.options.ruleFromNode && this.options.ruleFromNode(dom)) ||
             (ruleID = this.parser.matchTag(dom, this, matchAfter));
-        if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
+        out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
             this.findInside(dom);
             this.ignoreFallback(dom, marks);
         }
@@ -2980,7 +2993,7 @@ class ParseContext {
                 this.open = Math.max(0, this.open - 1);
             else if (rule && rule.skip.nodeType)
                 dom = rule.skip;
-            let sync, top = this.top, oldNeedsBlock = this.needsBlock;
+            let sync, oldNeedsBlock = this.needsBlock;
             if (blockTags.hasOwnProperty(name)) {
                 if (top.content.length && top.content[0].isInline && this.open) {
                     this.open--;
@@ -2992,7 +3005,7 @@ class ParseContext {
             }
             else if (!dom.firstChild) {
                 this.leafFallback(dom, marks);
-                return;
+                break out;
             }
             let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
             if (innerMarks)
@@ -3006,6 +3019,7 @@ class ParseContext {
             if (innerMarks)
                 this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : undefined);
         }
+        this.localPreserveWS = outerWS;
     }
     // Called for leaf DOM nodes that would otherwise be ignored
     leafFallback(dom, marks) {
@@ -3016,7 +3030,7 @@ class ParseContext {
     ignoreFallback(dom, marks) {
         // Ignored BR nodes should at least create an inline context
         if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-            this.findPlace(this.parser.schema.text("-"), marks);
+            this.findPlace(this.parser.schema.text("-"), marks, true);
     }
     // Run any style parser associated with the node's styles. Either
     // return an updated array of marks, or null to indicate some of the
@@ -3064,7 +3078,7 @@ class ParseContext {
                     marks = inner;
                 }
             }
-            else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
+            else if (!this.insertNode(nodeType.create(rule.attrs), marks, dom.nodeName == "BR")) {
                 this.leafFallback(dom, marks);
             }
         }
@@ -3081,7 +3095,7 @@ class ParseContext {
         }
         else if (rule.getContent) {
             this.findInside(dom);
-            rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node, marks));
+            rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node, marks, false));
         }
         else {
             let contentDOM = dom;
@@ -3093,6 +3107,7 @@ class ParseContext {
                 contentDOM = rule.contentElement;
             this.findAround(dom, contentDOM, true);
             this.addAll(contentDOM, marks);
+            this.findAround(dom, contentDOM, false);
         }
         if (sync && this.sync(startIn))
             this.open--;
@@ -3111,19 +3126,22 @@ class ParseContext {
     // Try to find a way to fit the given node type into the current
     // context. May add intermediate wrappers and/or leave non-solid
     // nodes that we're in.
-    findPlace(node, marks) {
+    findPlace(node, marks, cautious) {
         let route, sync;
-        for (let depth = this.open; depth >= 0; depth--) {
+        for (let depth = this.open, penalty = 0; depth >= 0; depth--) {
             let cx = this.nodes[depth];
             let found = cx.findWrapping(node);
-            if (found && (!route || route.length > found.length)) {
+            if (found && (!route || route.length > found.length + penalty)) {
                 route = found;
                 sync = cx;
                 if (!found.length)
                     break;
             }
-            if (cx.solid)
-                break;
+            if (cx.solid) {
+                if (cautious)
+                    break;
+                penalty += 2;
+            }
         }
         if (!route)
             return null;
@@ -3133,13 +3151,13 @@ class ParseContext {
         return marks;
     }
     // Try to insert the given node, adjusting the context when needed.
-    insertNode(node, marks) {
+    insertNode(node, marks, cautious) {
         if (node.isInline && this.needsBlock && !this.top.type) {
             let block = this.textblockFromContext();
             if (block)
                 marks = this.enterInner(block, null, marks);
         }
-        let innerMarks = this.findPlace(node, marks);
+        let innerMarks = this.findPlace(node, marks, cautious);
         if (innerMarks) {
             this.closeExtra();
             let top = this.top;
@@ -3157,7 +3175,7 @@ class ParseContext {
     // Try to start a node of the given type, adjusting the context when
     // necessary.
     enter(type, attrs, marks, preserveWS) {
-        let innerMarks = this.findPlace(type.create(attrs), marks);
+        let innerMarks = this.findPlace(type.create(attrs), marks, false);
         if (innerMarks)
             innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
         return innerMarks;
@@ -3195,14 +3213,18 @@ class ParseContext {
     finish() {
         this.open = 0;
         this.closeExtra(this.isOpen);
-        return this.nodes[0].finish(this.isOpen || this.options.topOpen);
+        return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
     }
     sync(to) {
-        for (let i = this.open; i >= 0; i--)
+        for (let i = this.open; i >= 0; i--) {
             if (this.nodes[i] == to) {
                 this.open = i;
                 return true;
             }
+            else if (this.localPreserveWS) {
+                this.nodes[i].options |= OPT_PRESERVE_WS;
+            }
+        }
         return false;
     }
     get currentPos() {
@@ -3271,7 +3293,7 @@ class ParseContext {
                     let next = depth > 0 || (depth == 0 && useRoot) ? this.nodes[depth].type
                         : option && depth >= minDepth ? option.node(depth - minDepth).type
                             : null;
-                    if (!next || (next.name != part && next.groups.indexOf(part) == -1))
+                    if (!next || (next.name != part && !next.isInGroup(part)))
                         return false;
                     depth--;
                 }
@@ -3417,6 +3439,8 @@ class DOMSerializer {
     @internal
     */
     serializeNodeInner(node, options) {
+        if (node.isText)
+            return doc(options).createTextNode(node.text);
         let { dom, contentDOM } = renderSpec(doc(options), this.nodes[node.type.name](node), null, node.attrs);
         if (contentDOM) {
             if (node.isLeaf)
@@ -3451,6 +3475,9 @@ class DOMSerializer {
         return toDOM && renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
     }
     static renderSpec(doc, structure, xmlNS = null, blockArraysIn) {
+        // Kludge for backwards-compatibility with accidental original behavious
+        if (typeof structure == "string")
+            return { dom: doc.createTextNode(structure) };
         return renderSpec(doc, structure, xmlNS, blockArraysIn);
     }
     /**
@@ -3522,11 +3549,9 @@ function suspiciousAttributesInner(attrs) {
     return result;
 }
 function renderSpec(doc, structure, xmlNS, blockArraysIn) {
-    if (typeof structure == "string")
-        return { dom: doc.createTextNode(structure) };
-    if (structure.nodeType != null)
+    if (structure.nodeType == 1)
         return { dom: structure };
-    if (structure.dom && structure.dom.nodeType != null)
+    if (structure.dom && structure.dom.nodeType == 1)
         return structure;
     let tagName = structure[0], suspicious;
     if (typeof tagName != "string")
@@ -3549,6 +3574,8 @@ function renderSpec(doc, structure, xmlNS, blockArraysIn) {
                 let space = name.indexOf(" ");
                 if (space > 0)
                     dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
+                else if (name == "style" && dom.style)
+                    dom.style.cssText = attrs[name];
                 else
                     dom.setAttribute(name, attrs[name]);
             }
@@ -3560,6 +3587,9 @@ function renderSpec(doc, structure, xmlNS, blockArraysIn) {
                 throw new RangeError("Content hole must be the only child of its parent node");
             return { dom, contentDOM: dom };
         }
+        else if (typeof child == "string") {
+            dom.appendChild(doc.createTextNode(child));
+        }
         else {
             let { dom: inner, contentDOM: innerContent } = renderSpec(doc, child, xmlNS, blockArraysIn);
             dom.appendChild(inner);
@@ -3758,18 +3788,14 @@ A mapping represents a pipeline of zero or more [step
 maps](https://prosemirror.net/docs/ref/#transform.StepMap). It has special provisions for losslessly
 handling mapping positions through a series of steps in which some
 steps are inverted versions of earlier steps. (This comes up when
-‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
+‘[rebasing](https://prosemirror.net/docs/guide/#transform.rebasing)’ steps for
 collaboration or history management.)
 */
 class Mapping {
     /**
     Create a new mapping with the given position maps.
     */
-    constructor(
-    /**
-    The step maps in this mapping.
-    */
-    maps = [], 
+    constructor(maps, 
     /**
     @internal
     */
@@ -3782,23 +3808,22 @@ class Mapping {
     /**
     The end position in the `maps` array.
     */
-    to = maps.length) {
-        this.maps = maps;
+    to = maps ? maps.length : 0) {
         this.mirror = mirror;
         this.from = from;
         this.to = to;
+        this._maps = maps || [];
+        this.ownData = !(maps || mirror);
     }
     /**
-    Create a mapping that maps only through a part of this one.
+    The step maps in this mapping.
     */
-    slice(from = 0, to = this.maps.length) {
-        return new Mapping(this.maps, this.mirror, from, to);
-    }
+    get maps() { return this._maps; }
     /**
-    @internal
+    Create a mapping that maps only through a part of this one.
     */
-    copy() {
-        return new Mapping(this.maps.slice(), this.mirror && this.mirror.slice(), this.from, this.to);
+    slice(from = 0, to = this.maps.length) {
+        return new Mapping(this._maps, this.mirror, from, to);
     }
     /**
     Add a step map to the end of this mapping. If `mirrors` is
@@ -3806,18 +3831,23 @@ class Mapping {
     image of this one.
     */
     appendMap(map, mirrors) {
-        this.to = this.maps.push(map);
+        if (!this.ownData) {
+            this._maps = this._maps.slice();
+            this.mirror = this.mirror && this.mirror.slice();
+            this.ownData = true;
+        }
+        this.to = this._maps.push(map);
         if (mirrors != null)
-            this.setMirror(this.maps.length - 1, mirrors);
+            this.setMirror(this._maps.length - 1, mirrors);
     }
     /**
     Add all the step maps in a given mapping to this one (preserving
     mirroring information).
     */
     appendMapping(mapping) {
-        for (let i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
+        for (let i = 0, startSize = this._maps.length; i < mapping._maps.length; i++) {
             let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : undefined);
+            this.appendMap(mapping._maps[i], mirr != null && mirr < i ? startSize + mirr : undefined);
         }
     }
     /**
@@ -3843,9 +3873,9 @@ class Mapping {
     Append the inverse of the given mapping to this one.
     */
     appendMappingInverted(mapping) {
-        for (let i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
+        for (let i = mapping.maps.length - 1, totalSize = this._maps.length + mapping._maps.length; i >= 0; i--) {
             let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : undefined);
+            this.appendMap(mapping._maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : undefined);
         }
     }
     /**
@@ -3863,7 +3893,7 @@ class Mapping {
         if (this.mirror)
             return this._map(pos, assoc, true);
         for (let i = this.from; i < this.to; i++)
-            pos = this.maps[i].map(pos, assoc);
+            pos = this._maps[i].map(pos, assoc);
         return pos;
     }
     /**
@@ -3877,12 +3907,12 @@ class Mapping {
     _map(pos, assoc, simple) {
         let delInfo = 0;
         for (let i = this.from; i < this.to; i++) {
-            let map = this.maps[i], result = map.mapResult(pos, assoc);
+            let map = this._maps[i], result = map.mapResult(pos, assoc);
             if (result.recover != null) {
                 let corr = this.getMirror(i);
                 if (corr != null && corr > i && corr < this.to) {
                     i = corr;
-                    pos = this.maps[corr].recover(result.recover);
+                    pos = this._maps[corr].recover(result.recover);
                     continue;
                 }
             }
@@ -4284,10 +4314,11 @@ class ReplaceStep extends Step {
         return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
     }
     map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+        let to = mapping.mapResult(this.to, -1);
+        let from = this.from == this.to && ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
         if (from.deletedAcross && to.deletedAcross)
             return null;
-        return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice);
+        return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
     }
     merge(other) {
         if (!(other instanceof ReplaceStep) || other.structure || this.structure)
@@ -4323,6 +4354,15 @@ class ReplaceStep extends Step {
         return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
     }
 }
+/**
+By default, for backwards compatibility, an inserting step
+mapped over an insertion at that same position fill move after
+the inserted content. In a collaborative editing situation, that
+can make redone insertions appear in unexpected places. You can
+set this to -1 to make such mapping keep the step before the
+insertion instead.
+*/
+ReplaceStep.MAP_BIAS = 1;
 Step.jsonID("replace", ReplaceStep);
 /**
 Replace a part of the document with a slice of content, but
@@ -4397,7 +4437,8 @@ class ReplaceAroundStep extends Step {
     }
     map(mapping) {
         let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1);
+        let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+        let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
         if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
             return null;
         return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
@@ -4509,7 +4550,7 @@ function removeMark(tr, from, to, mark) {
     });
     matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
 }
-function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch) {
+function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
     let node = tr.doc.nodeAt(pos);
     let replSteps = [], cur = pos + 1;
     for (let i = 0; i < node.childCount; i++) {
@@ -4523,7 +4564,7 @@ function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch)
             for (let j = 0; j < child.marks.length; j++)
                 if (!parentType.allowsMarkType(child.marks[j].type))
                     tr.step(new RemoveMarkStep(cur, end, child.marks[j]));
-            if (child.isText && !parentType.spec.code) {
+            if (clearNewlines && child.isText && parentType.whitespace != "pre") {
                 let m, newline = /\r?\n|\r/g, slice;
                 while (m = newline.exec(child.text)) {
                     if (!slice)
@@ -4554,13 +4595,17 @@ can be lifted. Will not go across
 function liftTarget(range) {
     let parent = range.parent;
     let content = parent.content.cutByIndex(range.startIndex, range.endIndex);
-    for (let depth = range.depth;; --depth) {
+    for (let depth = range.depth, contentBefore = 0, contentAfter = 0;; --depth) {
         let node = range.$from.node(depth);
-        let index = range.$from.index(depth), endIndex = range.$to.indexAfter(depth);
+        let index = range.$from.index(depth) + contentBefore, endIndex = range.$to.indexAfter(depth) - contentAfter;
         if (depth < range.depth && node.canReplace(index, endIndex, content))
             return depth;
         if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex))
             break;
+        if (index)
+            contentBefore = 1;
+        if (endIndex < node.childCount)
+            contentAfter = 1;
     }
     return null;
 }
@@ -4647,16 +4692,49 @@ function setBlockType(tr, from, to, type, attrs) {
         throw new RangeError("Type given to setBlockType should be a textblock");
     let mapFrom = tr.steps.length;
     tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+        let attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+        if (node.isTextblock && !node.hasMarkup(type, attrsHere) &&
+            canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+            let convertNewlines = null;
+            if (type.schema.linebreakReplacement) {
+                let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
+                if (pre && !supportLinebreak)
+                    convertNewlines = false;
+                else if (!pre && supportLinebreak)
+                    convertNewlines = true;
+            }
             // Ensure all markup that isn't allowed in the new node type is cleared
-            tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type);
+            if (convertNewlines === false)
+                replaceLinebreaks(tr, node, pos, mapFrom);
+            clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, undefined, convertNewlines === null);
             let mapping = tr.mapping.slice(mapFrom);
             let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
+            if (convertNewlines === true)
+                replaceNewlines(tr, node, pos, mapFrom);
             return false;
         }
     });
 }
+function replaceNewlines(tr, node, pos, mapFrom) {
+    node.forEach((child, offset) => {
+        if (child.isText) {
+            let m, newline = /\r?\n|\r/g;
+            while (m = newline.exec(child.text)) {
+                let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset + m.index);
+                tr.replaceWith(start, start + 1, node.type.schema.linebreakReplacement.create());
+            }
+        }
+    });
+}
+function replaceLinebreaks(tr, node, pos, mapFrom) {
+    node.forEach((child, offset) => {
+        if (child.type == child.type.schema.linebreakReplacement) {
+            let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset);
+            tr.replaceWith(start, start + 1, node.type.schema.text("\n"));
+        }
+    });
+}
 function canChangeType(doc, pos, type) {
     let $pos = doc.resolve(pos), index = $pos.index();
     return $pos.parent.canReplaceWith(index, index + 1, type);
@@ -4722,8 +4800,24 @@ function canJoin(doc, pos) {
     return joinable($pos.nodeBefore, $pos.nodeAfter) &&
         $pos.parent.canReplace(index, index + 1);
 }
+function canAppendWithSubstitutedLinebreaks(a, b) {
+    if (!b.content.size)
+        a.type.compatibleContent(b.type);
+    let match = a.contentMatchAt(a.childCount);
+    let { linebreakReplacement } = a.type.schema;
+    for (let i = 0; i < b.childCount; i++) {
+        let child = b.child(i);
+        let type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type;
+        match = match.matchType(type);
+        if (!match)
+            return false;
+        if (!a.type.allowsMarks(child.marks))
+            return false;
+    }
+    return match.validEnd;
+}
 function joinable(a, b) {
-    return !!(a && b && !a.isLeaf && a.canAppend(b));
+    return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebreaks(a, b));
 }
 /**
 Find an ancestor of the given position that can be joined to the
@@ -4756,8 +4850,31 @@ function joinPoint(doc, pos, dir = -1) {
     }
 }
 function join(tr, pos, depth) {
-    let step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true);
-    tr.step(step);
+    let convertNewlines = null;
+    let { linebreakReplacement } = tr.doc.type.schema;
+    let $before = tr.doc.resolve(pos - depth), beforeType = $before.node().type;
+    if (linebreakReplacement && beforeType.inlineContent) {
+        let pre = beforeType.whitespace == "pre";
+        let supportLinebreak = !!beforeType.contentMatch.matchType(linebreakReplacement);
+        if (pre && !supportLinebreak)
+            convertNewlines = false;
+        else if (!pre && supportLinebreak)
+            convertNewlines = true;
+    }
+    let mapFrom = tr.steps.length;
+    if (convertNewlines === false) {
+        let $after = tr.doc.resolve(pos + depth);
+        replaceLinebreaks(tr, $after.node(), $after.before(), mapFrom);
+    }
+    if (beforeType.inlineContent)
+        clearIncompatible(tr, pos + depth - 1, beforeType, $before.node().contentMatchAt($before.index()), convertNewlines == null);
+    let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos - depth);
+    tr.step(new ReplaceStep(start, mapping.map(pos + depth, -1), Slice.empty, true));
+    if (convertNewlines === true) {
+        let $full = tr.doc.resolve(start);
+        replaceNewlines(tr, $full.node(), $full.before(), tr.steps.length);
+    }
+    return tr;
 }
 /**
 Try to find a point where a node of the given type can be inserted
@@ -5139,7 +5256,7 @@ function replaceRange(tr, from, to, slice) {
     let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
     if (fitsTrivially($from, $to, slice))
         return tr.step(new ReplaceStep(from, to, slice));
-    let targetDepths = coveredDepths($from, tr.doc.resolve(to));
+    let targetDepths = coveredDepths($from, $to);
     // Can't replace the whole document, so remove 0 if it's present
     if (targetDepths[targetDepths.length - 1] == 0)
         targetDepths.pop();
@@ -5232,6 +5349,26 @@ function replaceRangeWith(tr, from, to, node) {
 }
 function deleteRange(tr, from, to) {
     let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
+    // When the deleted range spans from the start of one textblock to
+    // the start of another one, move out of the start of both blocks.
+    if ($from.parent.isTextblock && $to.parent.isTextblock && $from.start() != $to.start() &&
+        $from.parentOffset == 0 && $to.parentOffset == 0) {
+        let shared = $from.sharedDepth(to), isolated = false;
+        for (let d = $from.depth; d > shared; d--)
+            if ($from.node(d).type.spec.isolating)
+                isolated = true;
+        for (let d = $to.depth; d > shared; d--)
+            if ($to.node(d).type.spec.isolating)
+                isolated = true;
+        if (!isolated) {
+            for (let d = $from.depth; d > 0 && from == $from.start(d); d--)
+                from = $from.before(d);
+            for (let d = $to.depth; d > 0 && to == $to.start(d); d--)
+                to = $to.before(d);
+            $from = tr.doc.resolve(from);
+            $to = tr.doc.resolve(to);
+        }
+    }
     let covered = coveredDepths($from, $to);
     for (let i = 0; i < covered.length; i++) {
         let depth = covered[i], last = i == covered.length - 1;
@@ -5241,7 +5378,8 @@ function deleteRange(tr, from, to) {
             return tr.delete($from.before(depth), $to.after(depth));
     }
     for (let d = 1; d <= $from.depth && d <= $to.depth; d++) {
-        if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d)
+        if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d &&
+            $from.start(d - 1) == $to.start(d - 1) && $from.node(d - 1).canReplace($from.index(d - 1), $to.index(d - 1)))
             return tr.delete($from.before(d), to);
     }
     tr.delete(from, to);
@@ -5441,6 +5579,27 @@ class Transform {
         return this.steps.length > 0;
     }
     /**
+    Return a single range, in post-transform document positions,
+    that covers all content changed by this transform. Returns null
+    if no replacements are made. Note that this will ignore changes
+    that add/remove marks without replacing the underlying content.
+    */
+    changedRange() {
+        let from = 1e9, to = -1e9;
+        for (let i = 0; i < this.mapping.maps.length; i++) {
+            let map = this.mapping.maps[i];
+            if (i) {
+                from = map.map(from, 1);
+                to = map.map(to, -1);
+            }
+            map.forEach((_f, _t, fromB, toB) => {
+                from = Math.min(from, fromB);
+                to = Math.max(to, toB);
+            });
+        }
+        return from == 1e9 ? null : { from, to };
+    }
+    /**
     @internal
     */
     addStep(step, doc) {
@@ -5590,19 +5749,26 @@ class Transform {
         return this;
     }
     /**
-    Remove a mark (or a mark of the given type) from the node at
+    Remove a mark (or all marks of the given type) from the node at
     position `pos`.
     */
     removeNodeMark(pos, mark) {
-        if (!(mark instanceof Mark)) {
-            let node = this.doc.nodeAt(pos);
-            if (!node)
-                throw new RangeError("No node at position " + pos);
-            mark = mark.isInSet(node.marks);
-            if (!mark)
-                return this;
+        let node = this.doc.nodeAt(pos);
+        if (!node)
+            throw new RangeError("No node at position " + pos);
+        if (mark instanceof Mark) {
+            if (mark.isInSet(node.marks))
+                this.step(new RemoveNodeMarkStep(pos, mark));
+        }
+        else {
+            let set = node.marks, found, steps = [];
+            while (found = mark.isInSet(set)) {
+                steps.push(new RemoveNodeMarkStep(pos, found));
+                set = found.removeFromSet(set);
+            }
+            for (let i = steps.length - 1; i >= 0; i--)
+                this.step(steps[i]);
         }
-        this.step(new RemoveNodeMarkStep(pos, mark));
         return this;
     }
     /**
@@ -5610,7 +5776,7 @@ class Transform {
     greater than one, any number of nodes above that. By default, the
     parts split off will inherit the node type of the original node.
     This can be changed by passing an array of types and attributes to
-    use after the split.
+    use after the split (with the outermost nodes coming first).
     */
     split(pos, depth = 1, typesAfter) {
         split(this, pos, depth, typesAfter);
@@ -6278,7 +6444,6 @@ class Transaction extends Transform {
         else {
             if (to == null)
                 to = from;
-            to = to == null ? from : to;
             if (!text)
                 return this.deleteRange(from, to);
             let marks = this.storedMarks;
@@ -6287,7 +6452,7 @@ class Transaction extends Transform {
                 marks = to == from ? $from.marks() : $from.marksAcross(this.doc.resolve(to));
             }
             this.replaceRangeWith(from, to, schema.text(text, marks));
-            if (!this.selection.empty)
+            if (!this.selection.empty && this.selection.to == from + text.length)
                 this.setSelection(Selection.near(this.selection.$to));
             return this;
         }
@@ -6483,7 +6648,7 @@ class EditorState {
         return newInstance;
     }
     /**
-    Start a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) from this state.
+    Accessor that constructs and returns a new [transaction](https://prosemirror.net/docs/ref/#state.Transaction) from this state.
     */
     get tr() { return new Transaction(this); }
     /**
@@ -6651,20 +6816,20 @@ exports.EditorState = EditorState;
 exports.Fragment = Fragment;
 exports.Mapping = Mapping;
 exports.Mark = Mark;
-exports.MarkType = MarkType;
 exports.Node = Node;
 exports.NodeRange = NodeRange;
 exports.NodeSelection = NodeSelection;
 exports.Plugin = Plugin;
 exports.PluginKey = PluginKey;
+exports.RemoveMarkStep = RemoveMarkStep;
 exports.ReplaceAroundStep = ReplaceAroundStep;
-exports.ReplaceError = ReplaceError;
 exports.ReplaceStep = ReplaceStep;
 exports.Schema = Schema;
 exports.Selection = Selection;
 exports.SelectionRange = SelectionRange;
 exports.Slice = Slice;
 exports.TextSelection = TextSelection;
+exports.Transform = Transform;
 exports.canJoin = canJoin;
 exports.canSplit = canSplit;
 exports.dropPoint = dropPoint;
@@ -6672,4 +6837,4 @@ exports.findWrapping = findWrapping;
 exports.joinPoint = joinPoint;
 exports.liftTarget = liftTarget;
 exports.replaceStep = replaceStep;
-//# sourceMappingURL=chunk-eyfbjfPH.cjs.js.map
+//# sourceMappingURL=chunk-NqciyXN3.cjs.js.map