@nerd-bible/wordgard 0.5.3-beta7 → 0.6.2-beta10

package/dist/doc.js

@@ -42,40 +42,63 @@ const Token = /*@__PURE__*/(function (Token) {
     })(Token.Type || (Token.Type = {}));
     Token.End = {
         tokenType: Token.Type.Close,
-        toString() { return "[end]"; }
+        toString() { return "[end]"; },
+        toJSON() { return "."; }
     };
+    function fromJSON(schema, value) {
+        if (value === ".")
+            return Token.End;
+        if (!value || typeof value.type != "string")
+            throw new ValidationError("Invalid slice JSON");
+        let type = schema.getNode(value.type);
+        return type?.isLeaf || ("content" in value) ? schema.nodeFromJSON(value) : schema.tagFromJSON(value);
+    }
+    Token.fromJSON = fromJSON;
 ;return Token})({});
 class Slice {
     content;
+    context;
     length;
-    constructor(content) {
+    constructor(
+    content, 
+    context) {
         this.content = content;
+        this.context = context;
         this.length = content.reduce((l, e) => l + (e.tokenType == Token.Type.Node ? e.length : 1), 0);
     }
-    static of(content) { return new Slice(content); }
-    eq(other) {
-        if (other.content.length != this.content.length)
-            return false;
-        for (let i = 0; i < this.content.length; i++) {
-            let a = this.content[i], b = other.content[i];
-            if (a == Token.End) {
-                if (b != Token.End)
-                    return false;
-            }
-            else if (a.tokenType == Token.Type.Node) {
-                if (!((b.tokenType == Token.Type.Node) && a.eq(b)))
-                    return false;
+    static of(content, context) {
+        return content.length || context && context.length ? new Slice(content, context || Slice.empty.context) : Slice.empty;
+    }
+    concat(other) {
+        return new Slice(Slice.concat(this.content, other.content), this.context);
+    }
+    textContent(options = {}) {
+        let { blockSeparator = "\n", leafText } = options;
+        let out = new TextOutput(blockSeparator, leafText == null ? undefined : typeof leafText == "string" ? () => leafText : leafText);
+        for (let tok of this.content) {
+            if (tok.tokenType == Token.Type.Open) {
+                if (tok.isTextblock)
+                    out.openBlock();
             }
-            else if (a.tokenType == Token.Type.Open) {
-                if (!((b.tokenType == Token.Type.Open) && a.eq(b)))
-                    return false;
+            else if (tok.tokenType == Token.Type.Node) {
+                if (tok.isLeaf)
+                    out.serialize(tok);
+                else
+                    tok.iterate(node => !out.serialize(node));
             }
         }
-        return true;
+        return out.text;
+    }
+    static empty = /*@__PURE__*/(() => new Slice([], []))();
+    toString() {
+        return `<${this.content.join()}>`;
+    }
+    static get(doc, from, to) {
+        return new Slice(doc.slice(from, to), doc.contextAt(from));
     }
-    run(track, startPos = 0) {
+    static run(tokens, track, startPos = 0) {
         let pos = startPos;
-        for (let elt of this.content) {
+        for (let elt of tokens) {
             if (elt.tokenType == Token.Type.Open)
                 track.open(elt, pos++);
             else if (elt.tokenType == Token.Type.Node) {
@@ -86,18 +109,30 @@ class Slice {
                 track.close(pos++);
         }
     }
-    slice(from, to = this.length) {
+    static concat(a, b) {
+        let tokens = a.slice();
+        let i = 0;
+        if (a.length && b.length && b[0].tokenType == Token.Type.Node &&
+            a[a.length - 1].tokenType == Token.Type.Node) {
+            b[0].pushTo(tokens);
+            i = 1;
+        }
+        for (; i < b.length; i++)
+            tokens.push(b[i]);
+        return tokens;
+    }
+    static slice(tokens, from, to = 1e9) {
         if (from == to)
-            return Slice.empty;
+            return Slice.empty.content;
         let result = [], off = 0;
-        for (let elt of this.content) {
+        for (let elt of tokens) {
             let start = off;
             off += elt.tokenType == Token.Type.Node ? elt.length : 1;
             if (off <= from)
                 continue;
             if (start < from || off > to) {
                 let inner = elt.sliceInner(Math.max(0, from - start), Math.min(elt.length, to - start));
-                for (let elt of inner.content)
+                for (let elt of inner)
                     result.push(elt);
             }
             else {
@@ -106,55 +141,17 @@ class Slice {
             if (off >= to)
                 break;
         }
-        return new Slice(result);
-    }
-    concat(other) {
-        let content = this.content.slice();
-        let i = 0;
-        if (content.length && other.content.length && other.content[0].tokenType == Token.Type.Node &&
-            content[content.length - 1].tokenType == Token.Type.Node) {
-            other.content[0].pushTo(content);
-            i = 1;
-        }
-        for (; i < other.content.length; i++)
-            content.push(other.content[i]);
-        return new Slice(content);
+        return result;
     }
-    textContent(options = {}) {
-        let { blockSeparator = "\n", leafText } = options;
-        let out = new TextOutput(blockSeparator, leafText == null ? undefined : typeof leafText == "string" ? () => leafText : leafText);
-        for (let tok of this.content) {
-            if (tok.tokenType == Token.Type.Open) {
-                if (tok.isTextblock)
-                    out.openBlock();
-            }
-            else if (tok.tokenType == Token.Type.Node) {
-                if (tok.isLeaf)
-                    out.serialize(tok);
-                else
-                    tok.iterate(node => !out.serialize(node));
-            }
+    static eq(a, b) {
+        if (a.length != b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            let tA = a[i], tB = b[i];
+            if (tA.tokenType != tB.tokenType || (tA.tokenType != Token.Type.Close && !tA.eq(tB)))
+                return false;
         }
-        return out.text;
-    }
-    static empty = /*@__PURE__*/(() => new Slice([]))();
-    toString() {
-        return `<${this.content.join()}>`;
-    }
-    toJSON() {
-        return this.content.map(e => e.tokenType == Token.Type.Close ? "." : e.toJSON());
-    }
-    static fromJSON(schema, json) {
-        if (!Array.isArray(json))
-            throw new ValidationError("Invalid slice JSON");
-        return new Slice(json.map(value => {
-            if (value === ".")
-                return Token.End;
-            if (!value || typeof value.type != "string")
-                throw new ValidationError("Invalid slice JSON");
-            let type = schema.getNode(value.type);
-            return type?.isLeaf || ("content" in value) ? schema.nodeFromJSON(value) : schema.tagFromJSON(value);
-        }));
+        return true;
     }
 }
 
@@ -415,7 +412,7 @@ const Attributes = /*@__PURE__*/(function (Attributes) {
                 score--;
                 iA += 2;
             }
-            else if (iB < b.length && iA == a.length) {
+            else if (iB < b.length) {
                 score--;
                 iB += 2;
             }
@@ -870,8 +867,8 @@ class Pos {
         let d = this.depth;
         if (depth > d)
             throw new RangeError("Asking for parent deeper than position depth");
-        for (let d = this.depth, p = this.parent;; p = p.parent)
-            if (d == depth)
+        for (let p = this.parent;; p = p.parent)
+            if (d-- == depth)
                 return p;
     }
     isAtStart(parent) {
@@ -1096,6 +1093,7 @@ class BaseType {
     get isBlock() { return (this.flags & 1) == 0; }
     get isAtom() { return (this.flags & 4) > 0; }
     get isSelectable() { return (this.flags & 32) > 0; }
+    toString() { return this.name; }
 }
 class BaseTag {
     param;
@@ -1134,29 +1132,48 @@ const Node = /*@__PURE__*/(function (Node) {
     })(Node.Type || (Node.Type = {}));
     class Group {
         parent;
+        name;
         constructor(
-        parent) {
+        parent, 
+        name) {
             this.parent = parent;
+            this.name = name;
         }
-        static define(parent) { return new Group(parent); }
-        static All = Group.define();
-        static Inline = Group.define();
-        static Block = Group.define();
-        static Leaf = Group.define();
-        static Plot = Group.define();
-        static Textblock = Group.define();
-        static Content = Group.define();
-        static TableCell = Group.define();
-        static ListItem = Group.define();
+        static define(spec = {}) {
+            return new Group(spec.parent, spec.name || null);
+        }
+        static All = Group.define({ name: "All" });
+        static Inline = Group.define({ name: "Inline" });
+        static Block = Group.define({ name: "Block" });
+        static Leaf = Group.define({ name: "Leaf" });
+        static Plot = Group.define({ name: "Plot" });
+        static Textblock = Group.define({ name: "Textblock" });
+        static Content = Group.define({ name: "Content" });
+        static TableCell = Group.define({ name: "TableCell" });
+        static ListItem = Group.define({ name: "ListItem" });
         static builtin = [Group.All, Group.Inline, Group.Block, Group.Leaf, Group.Plot, Group.Textblock];
+        toString() { return "Node.Group" + (this.name ? ":" + this.name : ""); }
     }
     Node.Group = Group;
+    function queryToString(q) {
+        if ("and" in q)
+            return `and(${q.and.map(queryToString)})`;
+        if (Array.isArray(q))
+            return `or(q.map(queryToString))`;
+        return String(q);
+    }
+    Node.queryToString = queryToString;
     class Role {
-        constructor() { }
-        static define() { return new Role; }
-        static Code = Role.define();
-        static List = Role.define();
-        static LineBreak = Role.define();
+        name;
+        constructor(
+        name) {
+            this.name = name;
+        }
+        static define(name) { return new Role(name || null); }
+        static Code = Role.define("Code");
+        static List = Role.define("List");
+        static LineBreak = Role.define("LineBreak");
+        toString() { return "Node.Role" + (this.name ? ":" + this.name : ""); }
     }
     Node.Role = Role;
 ;return Node})({});
@@ -1198,7 +1215,7 @@ class Leaf extends BaseTag {
         nodes.push(this);
     }
     sliceInner(from, to) {
-        return from == to ? Slice.empty : Slice.of([this.is(Leaf.Text) ? this.sliceText(from, to) : this]);
+        return from == to ? Slice.empty.content : [this.is(Leaf.Text) ? this.sliceText(from, to) : this];
     }
     sliceText(from, to) {
         if (!this.is(Leaf.Text))
@@ -1210,6 +1227,8 @@ class Leaf extends BaseTag {
         return Leaf.Text.of(this.param.slice(Math.max(from, 0), Math.max(0, to)), this.marks);
     }
     static text(text, marks = Mark.none) {
+        if (!text)
+            throw new Error("Cannot create empty text nodes");
         return Leaf.Text.of(text, marks);
     }
     toString() {
@@ -1270,10 +1289,10 @@ class Plot {
     }
     sliceInner(from, to) {
         if (from == to)
-            return Slice.empty;
+            return Slice.empty.content;
         let content = [];
         this.slicePlot(content, from, to);
-        return Slice.of(content);
+        return content;
     }
     slicePlot(out, from, to) {
         if (from <= 0) {
@@ -1393,6 +1412,8 @@ class Plot {
         constructor(type, param, marks) {
             super(param, marks);
             this.type = type;
+            if (this.type.isDoc && marks.length)
+                throw new Error("Document nodes cannot have marks");
         }
         static new(type, param, marks) {
             return new Tag(type, param, marks);
@@ -1953,6 +1974,7 @@ class BuildContext {
         this.parent = parent;
     }
 }
+const noTokens = /*@__PURE__*/(() => Slice.empty.content)();
 class Builder {
     stack;
     modifications = null;
@@ -1997,11 +2019,9 @@ class Builder {
         return this.schema.doc(this.stack.children);
     }
 }
-function isAdd(m) { return !!m.add; }
-function isRemove(m) { return !!m.remove; }
 function applyModifications(modifications, marks, type) {
     for (const m of modifications) {
-        if (isAdd(m)) {
+        if ("add" in m) {
             marks = m.add.addToSet(marks);
         }
         else {
@@ -2011,7 +2031,7 @@ function applyModifications(modifications, marks, type) {
     return marks;
 }
 function modificationToJSON(m) {
-    return isAdd(m) ? { add: m.add.name, value: m.add.value } : { remove: m.remove.name, value: m.remove.value };
+    return "add" in m ? { add: m.add.name, value: m.add.value } : { remove: m.remove.name, value: m.remove.value };
 }
 function modificationFromJSON(schema, json) {
     let { add, remove } = json;
@@ -2036,7 +2056,7 @@ function compareModifications(a, b) {
     return true;
 }
 function compareModification(a, b) {
-    return isAdd(a) ? isAdd(b) && a.add.eq(b.add) : isRemove(b) && a.remove.eq(b.remove);
+    return "add" in a ? "add" in b && a.add.eq(b.add) : "remove" in b && a.remove.eq(b.remove);
 }
 function isNatNum(value) {
     return typeof value == "number" && Math.floor(value) == value && value >= 0;
@@ -2081,7 +2101,7 @@ class ChangeSet {
                 return false;
         for (let i = 0; i < this.data.length; i++) {
             let a = this.data[i], b = other.data[i];
-            if (a && !(this.sections[(i << 1) + 1] < 0 ? compareModifications(a, b) : a.eq(b)))
+            if (a && !(this.sections[(i << 1) + 1] < 0 ? compareModifications(a, b) : Slice.eq(a, b)))
                 return false;
         }
         return true;
@@ -2105,7 +2125,7 @@ class ChangeSet {
             }
             else {
                 cursor = cursor.advance(lenA);
-                this.data[i].run(builder);
+                Slice.run(this.data[i], builder);
             }
         }
         if (cursor.pos != doc.length)
@@ -2123,7 +2143,7 @@ class ChangeSet {
             else if (ins == -2)
                 result.push([len, this.data[i].map(modificationToJSON)]);
             else
-                result.push([len, this.data[i].toJSON()]);
+                result.push([len, this.data[i].map(t => t.toJSON())]);
         }
         return result;
     }
@@ -2145,9 +2165,11 @@ class ChangeSet {
                     data.push(val.map(m => modificationFromJSON(schema, m)));
                 }
                 else {
-                    let slice = Slice.fromJSON(schema, val);
-                    sections.push(len, slice.length);
-                    data.push(slice);
+                    if (!Array.isArray(val))
+                        throw new ValidationError("Invalid ChangeSet JSON");
+                    let tokens = val.map(v => Token.fromJSON(schema, v));
+                    sections.push(len, sliceLen(tokens));
+                    data.push(tokens);
                 }
             }
         }
@@ -2232,7 +2254,7 @@ class ChangeSet {
         this.iterChanges((_f, _t, pos, _to, inserted) => {
             if (found != null)
                 return;
-            for (let tok of inserted.content) {
+            for (let tok of inserted) {
                 if (tok.tokenType == Token.Type.Node) {
                     if (pred(tok.tag))
                         return found = pos;
@@ -2371,7 +2393,7 @@ class ChangeSet {
             }
             else if (data) {
                 text += `[${data.map(mod => {
-                    return `${isAdd(mod) ? "+" + mod.add : "-" + mod.remove}`;
+                    return `${"add" in mod ? "+" + mod.add : "-" + mod.remove}`;
                 })}]`;
             }
             if (text)
@@ -2397,6 +2419,39 @@ class ChangeSetBuilder {
     sections = [];
     data = [];
     pos = 0;
+    addSection(from, to, ins, value) {
+        if (from >= this.pos) {
+            addSection(this.sections, this.data, from - this.pos, -1, null);
+            addSection(this.sections, this.data, to - from, ins, value);
+            this.pos = to;
+            return true;
+        }
+        if (this.sections.length && this.sections[0] > to && this.sections[1] == -1) {
+            this.spliceSection(0, from, to, ins, value);
+            return true;
+        }
+        for (let pos = this.pos, i = this.sections.length; i > 2 && pos > to;) {
+            let nextIns = this.sections[--i], nextLen = this.sections[--i];
+            let start = pos - nextLen;
+            if (nextIns == -1 && start < from) {
+                this.spliceSection(i, from - start, to - start, ins, value);
+                return true;
+            }
+            pos = start;
+        }
+        return false;
+    }
+    spliceSection(i, from, to, ins, value) {
+        let sections = [], data = [];
+        addSection(sections, data, from, -1, null);
+        addSection(sections, data, to - from, ins, value);
+        addSection(sections, data, this.sections[i] - to, -1, null);
+        this.sections.splice(i, 2, ...sections);
+        this.data.splice(i >> 1, 1, ...data);
+    }
+}
+function sliceLen(tokens) {
+    return tokens.reduce((l, e) => l + (e.tokenType == Token.Type.Node ? e.length : 1), 0);
 }
 function createChangeSet(doc, spec, mayCorrect = true) {
     let cur = null;
@@ -2414,14 +2469,11 @@ function createChangeSet(doc, spec, mayCorrect = true) {
         accum = accum ? accum.compose(transform(set, accum, doc, false, false).set) : set;
     };
     let section = (from, to, ins, value) => {
-        if (!cur || from < cur.pos) {
+        if (!cur?.addSection(from, to, ins, value)) {
             flush();
             cur = new ChangeSetBuilder(doc.length);
+            cur.addSection(from, to, ins, value);
         }
-        if (from > cur.pos)
-            addSection(cur.sections, cur.data, from - cur.pos, -1, null);
-        addSection(cur.sections, cur.data, to - from, ins, value);
-        cur.pos = to;
     };
     let build = (spec) => {
         if (Array.isArray(spec)) {
@@ -2471,17 +2523,20 @@ function createChangeSet(doc, spec, mayCorrect = true) {
                 if (remove) {
                     let mods = [{ remove }];
                     markableSections(doc, from, to, remove.type.spanning, (node, from, to) => {
-                        const has = remove.isInSet(node.tag.marks);
-                        if (!has || !doc.schema.markAllowed(remove.type, node.type))
-                            return false;
-                        let modsHere = mods;
                         if (remove.type.set) {
-                            let left = subtractSet(remove.value, has.value, remove.type.set);
+                            let has = remove.type.isInSet(node.tag.marks);
+                            if (!has)
+                                return false;
+                            let left = remove.value.filter(a => has.value.some(b => remove.type.set(a, b) == 0));
                             if (!left.length)
                                 return false;
-                            modsHere = [{ remove: remove.type.of(left) }];
+                            section(from, to, -2, left.length == remove.value.length ? mods : [{ remove: remove.type.of(left) }]);
+                        }
+                        else {
+                            if (!remove.isInSet(node.tag.marks))
+                                return false;
+                            section(from, to, -2, mods);
                         }
-                        section(from, to, -2, modsHere);
                         return true;
                     });
                 }
@@ -2489,16 +2544,17 @@ function createChangeSet(doc, spec, mayCorrect = true) {
             else {
                 if (to == null)
                     to = from;
-                insert = (!insert ? Slice.empty : Array.isArray(insert) ? Slice.of(insert) : insert);
+                let context = insert instanceof Slice ? insert.context : Slice.empty.context;
+                insert = !insert ? noTokens : insert instanceof Slice ? insert.content : insert;
                 if (to <= from)
                     to = from;
                 if (fit) {
                     doCorrect = true;
-                    ({ from, to, slice: insert } =
-                        fitReplacement(doc, doc.resolve(from), doc.resolve(to), insert, fit === true ? [] : fit));
+                    ({ from, to, tokens: insert } =
+                        fitReplacement(doc, doc.resolve(from), doc.resolve(to), insert, context));
                 }
                 if (insert.length || to != from)
-                    section(from, to, insert.length, insert);
+                    section(from, to, sliceLen(insert), insert);
             }
         }
     };
@@ -2527,15 +2583,15 @@ function transform(setA, setB, doc, before, fit) {
             let end = pos + b.len;
             addSection(sections, data, b.ins, -1, null);
             if (fitter)
-                fitter.replaced(b.slice, pos, end, true);
+                fitter.replaced(b.tokens, pos, end, true);
             while (pos < end) {
                 if (a.done)
                     throw new ValidationError("Mismatched change sets");
                 let piece = Math.min(a.len, end - pos);
                 if (a.ins >= 0 && inserted < a.i && a.len <= piece) {
-                    addSection(sections, data, 0, a.ins, a.slice);
+                    addSection(sections, data, 0, a.ins, a.tokens);
                     if (fitter)
-                        fitter.replaced(a.slice, pos - a.off, pos + a.len);
+                        fitter.replaced(a.tokens, pos - a.off, pos + a.len);
                     inserted = a.i;
                 }
                 a.forward(piece);
@@ -2554,7 +2610,7 @@ function transform(setA, setB, doc, before, fit) {
                 }
                 else if (b.ins == 0 && pos + b.len < end) {
                     if (fitter)
-                        fitter.replaced(b.slice, pos, pos + b.len, true);
+                        fitter.replaced(b.tokens, pos, pos + b.len, true);
                     pos += b.len;
                     b.next();
                 }
@@ -2563,13 +2619,13 @@ function transform(setA, setB, doc, before, fit) {
                 }
             }
             if (inserted < a.i) {
-                addSection(sections, data, len, a.ins, a.slice);
+                addSection(sections, data, len, a.ins, a.tokens);
                 if (fitter)
-                    fitter.replaced(a.slice, start - a.off, start + a.len);
+                    fitter.replaced(a.tokens, start - a.off, start + a.len);
                 inserted = a.i;
             }
             else {
-                addSection(sections, data, len, 0, Slice.empty);
+                addSection(sections, data, len, 0, noTokens);
             }
             a.forward(pos - start);
         }
@@ -2588,10 +2644,10 @@ function compose(sectionsA, sectionsB, dataA, dataB) {
         if (a.done && b.done) {
             return { sections, data };
         }
-        else if (a.ins == 0) {            addSection(sections, data, a.len, 0, a.slice, open);
+        else if (a.ins == 0) {            addSection(sections, data, a.len, 0, a.tokens, open);
             a.next();
         }
-        else if (b.len == 0 && !b.done) {            addSection(sections, data, 0, b.ins, b.slice, open);
+        else if (b.len == 0 && !b.done) {            addSection(sections, data, 0, b.ins, b.tokens, open);
             b.next();
         }
         else if (a.done || b.done) {
@@ -2604,13 +2660,13 @@ function compose(sectionsA, sectionsB, dataA, dataB) {
                 addSection(sections, data, len, (data ? mods : a.ins == -2 || b.ins == -2) ? -2 : -1, mods, open);
             }
             else if (a.keep) {
-                addSection(sections, data, len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
+                addSection(sections, data, len, b.off ? 0 : b.ins, b.off ? noTokens : b.tokens, open);
             }
             else if (b.keep) {
                 addSection(sections, data, a.off ? 0 : a.len, len, data ? applyModsToSlice(a.slicePart(len), b.mods) : null, open);
             }
             else {
-                addSection(sections, data, a.off ? 0 : a.len, b.off ? 0 : b.ins, b.off ? Slice.empty : b.slice, open);
+                addSection(sections, data, a.off ? 0 : a.len, b.off ? 0 : b.ins, b.off ? noTokens : b.tokens, open);
             }
             open = (a.ins > len || b.ins >= 0 && b.len > len) && (open || sections.length > sectionLen);
             a.forward2(len);
@@ -2627,16 +2683,16 @@ function filterMods(mods, against) {
     return mods.filter(m => !against.some(a => modCancels(a, m)));
 }
 function modCancels(mod, other) {
-    if (isAdd(other)) {
-        return isAdd(mod) ? mod.add.type == other.add.type && !mod.add.type.set : mod.remove.eq(other.add);
+    if ("add" in other) {
+        return "add" in mod ? mod.add.type == other.add.type && !mod.add.type.set : mod.remove.eq(other.add);
     }
     else {
-        return isAdd(mod) && mod.add.eq(isAdd(other) ? other.add : other.remove);
+        return "add" in mod && mod.add.eq(other.remove);
     }
 }
 function invertMods(mods, target) {
     return mods.map(mod => {
-        if (isRemove(mod))
+        if ("remove" in mod)
             return { add: mod.remove };
         if (!mod.add.type.set) {
             let existed = mod.add.type.isInSet(target.marks);
@@ -2646,11 +2702,11 @@ function invertMods(mods, target) {
         return { remove: mod.add };
     });
 }
-function applyModsToSlice(slice, mods) {
+function applyModsToSlice(tokens, mods) {
     if (!mods)
-        return slice;
+        return tokens;
     let content = [];
-    for (let tok of slice.content) {
+    for (let tok of tokens) {
         if (tok.tokenType == Token.Type.Open) {
             content.push(tok.withMarks(applyModifications(mods, tok.marks, tok.type)));
         }
@@ -2665,7 +2721,7 @@ function applyModsToSlice(slice, mods) {
             content.push(tok);
         }
     }
-    return Slice.of(content);
+    return content;
 }
 class FitLevel {
     tag;
@@ -2740,13 +2796,13 @@ class ChangeFitter {
     lastCoverFrom = -1;
     lastCoverTo = -1;
     doubleDeleteDelta = 0;
-    replaced(slice, from, to, covering = false) {
+    replaced(tokens, from, to, covering = false) {
         this.doubleDeleteDelta = 0;
         if (covering) {
             this.lastCoverFrom = from;
             this.lastCoverTo = to;
         }
-        else if (slice.length) {
+        else if (tokens.length) {
             let overlapFrom = Math.max(from, this.lastCoverFrom);
             let overlapTo = Math.min(to, this.lastCoverTo);
             if (overlapFrom < overlapTo) {
@@ -2759,7 +2815,7 @@ class ChangeFitter {
             this.inputDelta -= counter.count;
         }
         this.inserting = true;
-        slice.run(this, this.pos);
+        Slice.run(tokens, this, this.pos);
         this.inserting = false;
         if (this.local)
             this.nextSync = Math.max(this.nextSync, localSyncPosAfter(this.inputPos = this.getPos(to)));
@@ -2922,8 +2978,7 @@ class ChangeFitter {
         let sections = [], data = [], pos = 0;
         for (let { from, to, insert } of this.patches) {
             addSection(sections, data, from - pos, -1, null);
-            let slice = Slice.of(insert);
-            addSection(sections, data, to - from, slice.length, slice);
+            addSection(sections, data, to - from, sliceLen(insert), insert);
             pos = to;
         }
         addSection(sections, data, this.pos - pos, -1, null);
@@ -2979,11 +3034,11 @@ class SectionIter {
     get mods() {
         return this.data ? this.data[(this.i - 2) >> 1] : null;
     }
-    get slice() {
-        return this.data ? this.data[(this.i - 2) >> 1] : Slice.empty;
+    get tokens() {
+        return this.data ? this.data[(this.i - 2) >> 1] : noTokens;
     }
     slicePart(len) {
-        return this.slice.slice(this.off, len == null ? undefined : this.off + len);
+        return Slice.slice(this.tokens, this.off, len == null ? undefined : this.off + len);
     }
     forward(len) {
         if (len == this.len)
@@ -3022,7 +3077,7 @@ function addSection(sections, data, len, ins, value, forceJoin = false) {
         sections[last] += len;
         sections[last + 1] += ins;
         if (data)
-            data[data.length - 1] = data[data.length - 1].concat(value);
+            data[data.length - 1] = Slice.concat(data[data.length - 1], value);
     }
     else {
         sections.push(len, ins);
@@ -3034,11 +3089,11 @@ function finishCx(cx, schema) {
     return cx.tag.create(cx.children.length || cx.tag.type.canBeEmpty ? cx.children
         : [schema.createDefault(cx.tag.type)]);
 }
-function closeSlice(schema, slice, context, depth, closeEnd = false) {
+function closeSlice(schema, tokens, context, depth, closeEnd = false) {
     let top = [], stack = null;
     for (let i = depth - 1; i >= 0; i--)
         stack = new BuildContext(context[i], stack);
-    for (let token of slice.content) {
+    for (let token of tokens) {
         if (token.tokenType == Token.Type.Close) {
             if (stack) {
                 let node = finishCx(stack, schema);
@@ -3064,7 +3119,7 @@ function closeSlice(schema, slice, context, depth, closeEnd = false) {
         }
     if (stack)
         splatContext(top, stack);
-    return Slice.of(top);
+    return top;
 }
 function splatContext(top, cx) {
     if (cx.parent)
@@ -3076,8 +3131,8 @@ function splatContext(top, cx) {
 function isFitBarrier(plot) {
     return plot.isolating || plot.isInline;
 }
-function fitReplacement(doc, from, to, slice, context) {
-    if (!slice.length)
+function fitReplacement(doc, from, to, tokens, context) {
+    if (!tokens.length)
         return fitDeletion(doc, from, to);
     let preferredContext = -1;
     for (let i = 0; i < context.length; i++) {
@@ -3088,8 +3143,8 @@ function fitReplacement(doc, from, to, slice, context) {
             break;
     }
     let firstType = null, closeCount = 0;
-    for (let i = 0, opened = 0; i < slice.content.length; i++) {
-        let tok = slice.content[i];
+    for (let i = 0, opened = 0; i < tokens.length; i++) {
+        let tok = tokens[i];
         if (tok.tokenType == Token.Type.Close) {
             if (opened)
                 opened--;
@@ -3134,7 +3189,7 @@ function fitReplacement(doc, from, to, slice, context) {
                     let cost = (neutral ? 0 : 2) + (i < preferredContext ? context.length - i : i - preferredContext) + (toEnd ? 0 : 1e7);
                     if (foundCost > cost) {
                         found = { from: cxFrom.before, to: toEnd ? cxTo.after : to.pos,
-                            slice: i >= 0 ? closeSlice(doc.schema, slice, context, i + 1, toEnd) : slice };
+                            tokens: i >= 0 ? closeSlice(doc.schema, tokens, context, i + 1, toEnd) : tokens };
                         foundCost = cost;
                     }
                 }
@@ -3151,7 +3206,7 @@ function fitReplacement(doc, from, to, slice, context) {
                     continue;
                 if (doc.schema.canContain(cx.node.type, type)) {
                     let pos = before > -1 ? before : after;
-                    return { from: pos, to: pos, slice: i >= 0 ? closeSlice(doc.schema, slice, context, i + 1, true) : slice };
+                    return { from: pos, to: pos, tokens: i >= 0 ? closeSlice(doc.schema, tokens, context, i + 1, true) : tokens };
                 }
             }
             if (isFitBarrier(cx.node.type) || !cx.parent)
@@ -3166,11 +3221,11 @@ function fitReplacement(doc, from, to, slice, context) {
             continue;
         let depth = i < 0 ? preferredContext : i;
         if (doc.schema.canContain(from.parent.node.type, context[depth].type)) {
-            slice = closeSlice(doc.schema, slice, context, depth + 1, true);
+            tokens = closeSlice(doc.schema, tokens, context, depth + 1, true);
             break;
         }
     }
-    return { from: from.pos, to: to.pos, slice };
+    return { from: from.pos, to: to.pos, tokens };
 }
 function fitDeletion(doc, from, to) {
     let toDepth = to.depth;
@@ -3184,12 +3239,12 @@ function fitDeletion(doc, from, to) {
             end++;
         }
         let toAtEnd = toDepth == depth && cxTo.end == end;        if (cx.end < to.pos && cx.parent.end > to.pos && !toAtEnd)
-            return { from: cx.before, to: to.pos, slice: Slice.empty };
+            return { from: cx.before, to: to.pos, tokens: noTokens };
         if (!cx.node.inlineContent && toAtEnd && cx.parent.start == cxTo.parent.start &&
             !(from.parent.start == to.parent.start && from.parent.node.inlineContent))
-            covered = { from: cx.before, to: cxTo.after, slice: Slice.empty };
+            covered = { from: cx.before, to: cxTo.after, tokens: noTokens };
     }
-    return covered || { from: from.pos, to: to.pos, slice: Slice.empty };
+    return covered || { from: from.pos, to: to.pos, tokens: noTokens };
 }
 
 function parse(schema, doc, options = {}) {
@@ -3229,7 +3284,7 @@ function parse(schema, doc, options = {}) {
             }
         };
         emitTokens(top.children, true, true);
-        return { slice: Slice.of(tokens), context };
+        return Slice.of(tokens, context);
     }
     parse.slice = slice;
     (function (Rule) {
@@ -3675,12 +3730,12 @@ function serialize(doc, options = {}) {
     return Elt.Fragment.create(serializeChildren(doc.content, new SerializeContext(options)));
 }
 ;serialize = /*@__PURE__*/(function (serialize) {
-    function node(node, options) {
+    function node(node, options = {}) {
         return serializeChildren([node], new SerializeContext(options))[0];
     }
     serialize.node = node;
-    function slice(slice, options) {
-        return Elt.Fragment.create(serializeChildren(flattenSlice(slice.content, options.context || [], options.includeContext || 0, !!options.openAttr), new SerializeContext(options, options.openAttr)));
+    function slice(slice, options = {}) {
+        return Elt.Fragment.create(serializeChildren(flattenSlice(slice.content, slice.context, options.includeContext || 0, !!options.openAttr), new SerializeContext(options, options.openAttr)));
     }
     serialize.slice = slice;
 ;return serialize})(serialize);