edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/flow.js

@@ -1,4 +1,8 @@
+import { ref } from './doc/plan.js';
 import { id as freshId } from '../utils.js';
+import { sanitizeSpec } from '../utils/json.js';
+import { collides } from './placement/model.js';
+import { TYPE } from './schema.js';
 const lengthOf = (l) => (l.content ?? []).reduce((n, i) => n + (i.kind === 'text' ? i.text.length : 1), 0);
 /**
  * Where the caret ends a placed block: its own content's end when it shows a
@@ -22,248 +26,266 @@ export const placedEnd = (roleOf) => {
     return endOf;
 };
 /** `insertFlow`, prepared. */
-export const flowOps = (c) => ({
-    insertFlow: (target, flow, view = {}) => {
-        // Ingress: a run carries a placeholder kind through the spec sanitizer.
-        let lines = flow.lines
-            .map((l) => c.sanitize({ ...l, type: l.type ?? '' }))
-            .map((s) => ({ ...s, type: s.type || undefined }));
-        if (lines.length === 0)
-            return c.plan([], []);
-        // A cell outside a row is its text, a row outside a table its cells (`table.paste`).
-        const unbare = (l, holder) => {
-            const kind = l.type ? c.tableKind(l.type) : undefined;
-            const kids = (next) => (l.children ?? []).flatMap((kid) => unbare(kid, next));
-            if (kind === 'cell' && holder !== 'row')
-                return [{ id: l.id, content: l.content }, ...kids(null)];
-            if (kind === 'row' && holder !== 'table')
-                return kids(null);
-            if (!l.children)
-                return [l];
-            return [{ ...l, children: kids(kind === 'cell' ? null : (kind ?? null)) }];
-        };
-        lines = lines.flatMap((l) => unbare(l, null));
-        /** A line's kind under `parent`: the list's item for its flat item kind, then `fitted`. */
-        const fit = (parent, kind) => c.fitted(parent, parent !== null && kind !== undefined && kind === view.itemKind?.(parent)
-            ? c.defaultChild(parent)
-            : kind);
-        const specs = (parent, of = lines) => of.map((l) => ({ ...l, type: fit(parent, l.type) ?? c.defaultChild(parent) }));
-        const last = () => lines.at(-1);
-        /** `l` and its nested lines as runs, each line that shows its own content one run. */
-        const plain = (l) => [
-            ...(!l.type || c.roleOf(l.type).rendersContent ? [{ id: l.id, content: l.content }] : []),
-            ...(l.children ?? []).flatMap(plain)
-        ];
-        const endOf = placedEnd(c.roleOf);
-        /**
-         * A layout line, here or nested, as its items' lines in reading order, and
-         * any other child it holds (`flow.layout`): no layout lands in an item.
-         */
-        const unwrap = (l) => {
-            const item = l.type ? c.roleOf(l.type).layout : undefined;
-            if (item === undefined)
-                return [l.children ? { ...l, children: l.children.flatMap(unwrap) } : l];
-            return (l.children ?? []).flatMap((kid) => kid.type === item ? (kid.children ?? []).flatMap(unwrap) : unwrap(kid));
-        };
-        const intoItem = (parent) => {
-            if (parent !== null && c.insideItem(parent))
-                lines = lines.flatMap(unwrap);
-        };
-        /** Whole blocks at a slot, after `pre`; the caret ends the last one's shown content. */
-        const atSlot = (dest, pre) => {
-            const placed = specs(dest.parent);
-            const p = c.insertBlocks(dest, placed);
-            const at = endOf(placed.at(-1)) ?? { block: last().id, offset: lengthOf(last()) };
-            return 'writes' in p ? { ...c.plan(p.ids, [...pre, ...p.writes]), at } : p;
-        };
-        if ('replace' in target || 'slot' in target) {
-            let slot;
-            let pre = [];
-            if ('slot' in target)
-                slot = target.slot;
-            else {
-                // The lines fill the first block's slot: its parent is never emptied
-                // by the delete, so a column keeps its layout (`layout.flow-slot`).
-                const at = c.order().at;
-                const first = target.replace
-                    .filter((id) => at.has(id))
-                    .sort((a, b) => at.get(a) - at.get(b))[0];
-                const del = c.deleteBlocks(target.replace, first === undefined ? undefined : c.positionOf(first)?.parent);
-                if (!('writes' in del))
-                    return del;
-                if (first === undefined)
-                    return c.refused;
-                slot = c.positionOf(first);
-                pre = [...del.writes];
-            }
-            intoItem(slot.parent);
+export const flowOps = (c) => {
+    /** A kind's roles, as placement reads them. */
+    const roleOf = (kind) => ({
+        void: c.roles.childless(kind),
+        island: c.roles.island(kind),
+        rendersContent: c.roles.rendersContent(kind),
+        layout: c.roles.layout(kind)
+    });
+    /** What a kind is in a table: the table, its row or its cell. */
+    const tableKind = (kind) => c.roles.table(kind) !== undefined
+        ? 'table'
+        : c.isRowKind(kind)
+            ? 'row'
+            : c.isCellKind(kind)
+                ? 'cell'
+                : undefined;
+    return {
+        insertFlow: (target, flow, view = {}) => {
+            // Ingress: a run carries a placeholder kind through the spec sanitizer.
+            let lines = flow.lines
+                .map((l) => sanitizeSpec({ ...l, type: l.type ?? '' }))
+                .map((s) => ({ ...s, type: s.type || undefined }));
             if (lines.length === 0)
                 return c.plan([], []);
-            // In a code block (selected lines, a slot), the lines are plain lines too (`flow.lines`).
-            if (slot.parent !== null && c.isLines(slot.parent)) {
-                const shown = lines.flatMap(plain);
-                lines = shown.length ? shown : [{ id: lines[0].id, content: [] }];
-            }
-            return atSlot(slot, pre);
-        }
-        const B = c.ref(target.block);
-        if (!c.contentTarget(B) || !c.rendersContent(B))
-            return c.refused;
-        const len = c.displayLength(B);
-        const o = Math.max(0, Math.min(target.offset, len));
-        const { parent, index } = c.positionOf(B);
-        intoItem(B);
-        const empty = len === 0 && c.childrenIds(B).length === 0;
-        // A line of a lines island (a code line) takes plain lines: every line the flow
-        // shows, nested ones included, in order; no block lands in the island (`flow.lines`).
-        const inLines = parent !== null && c.isLines(parent);
-        if (inLines)
-            lines = lines.flatMap(plain);
-        // A table's cell is never split: the lines it shows join its text (`table.paste`).
-        const cell = c.isTableCell(B);
-        if (cell)
-            lines = lines.flatMap(plain);
-        // A line that joins no text under `under` (`flow.apart`): its kind renders
-        // none of its own (a list, a code block), or is a void or an island.
-        const apart = (l, under) => {
-            const kind = l.type && fit(under, l.type);
-            const role = kind ? c.roleOf(kind) : undefined;
-            return !!role && (!role.rendersContent || role.void || role.island);
-        };
-        // At the end of a container's header whose body shows, what follows the caret
-        // leads its children and the body stays, as Enter opens a first child
-        // (`flow.header`), unless the first line stands apart and replaces an empty
-        // one (`flow.apart`); elsewhere it follows `B` among its siblings.
-        const header = view.header?.(B);
-        // A closed header shows no children: a line it takes brings none into its hidden
-        // body; they follow it, shown (`flow.header`).
-        const shut = header === 'closed';
-        const inside = o === len && !inLines && !flow.whole && header === true && !(empty && apart(lines[0], B));
-        const home = inside ? B : parent;
-        if (lines.length === 0)
-            return { ...c.plan([B], []), at: { block: B, offset: o } };
-        if (flow.whole && !inLines && !cell)
-            return atSlot({ parent, index: index + 1 }, empty ? [c.remove(B, [])] : []);
-        // A void is never split: its caption takes the lines as one run; nor is a cell.
-        const br = { kind: 'text', text: '\n' };
-        if (c.isVoid(B) || cell) {
-            const content = lines.flatMap((l, i) => [...(i ? [br] : []), ...(l.content ?? [])]);
-            lines = [{ id: lines[0].id, content }];
-        }
-        // So a first line it joins leaves its nested lines as lines of the flow after it.
-        if (shut && lines[0].children?.length && !apart(lines[0], home))
-            lines = [{ ...lines[0], children: undefined }, ...lines[0].children, ...lines.slice(1)];
-        const first = lines[0];
-        const [joinsHead, joinsTail] = [!apart(first, home), lines.length > 1 && !apart(last(), home)];
-        const all = specs(home);
-        const placed = all.slice(joinsHead ? 1 : 0, joinsTail ? -1 : undefined);
-        const ids = placed.map((s) => s.id);
-        if (c.collides([...(joinsHead ? (first.children ?? []) : []), ...all.slice(joinsHead ? 1 : 0)]))
-            return c.refused;
-        const writes = [];
-        const text = (id, at, l) => {
-            for (const item of l.content ?? []) {
-                if (item.kind === 'inline')
-                    writes.push({ op: 'insertInline', id, offset: at++, atom: item });
-                else if (item.text !== '') {
-                    writes.push({ op: 'insertText', id, offset: at, text: item.text, marks: item.marks });
-                    at += item.text.length;
+            // A cell outside a row is its text, a row outside a table its cells (`table.paste`).
+            const unbare = (l, holder) => {
+                const kind = l.type ? tableKind(l.type) : undefined;
+                const kids = (next) => (l.children ?? []).flatMap((kid) => unbare(kid, next));
+                if (kind === 'cell' && holder !== 'row')
+                    return [{ id: l.id, content: l.content }, ...kids(null)];
+                if (kind === 'row' && holder !== 'table')
+                    return kids(null);
+                if (!l.children)
+                    return [l];
+                return [{ ...l, children: kids(kind === 'cell' ? null : (kind ?? null)) }];
+            };
+            lines = lines.flatMap((l) => unbare(l, null));
+            /** A line's kind under `parent`: the list's item for its flat item kind, then `fitted`. */
+            const fit = (parent, kind) => c.fitted(parent, parent !== null && kind !== undefined && kind === view.itemKind?.(parent)
+                ? c.defaultChild(parent)
+                : kind);
+            const specs = (parent, of = lines) => of.map((l) => ({ ...l, type: fit(parent, l.type) ?? c.defaultChild(parent) }));
+            const last = () => lines.at(-1);
+            /** `l` and its nested lines as runs, each line that shows its own content one run. */
+            const plain = (l) => [
+                ...(!l.type || roleOf(l.type).rendersContent ? [{ id: l.id, content: l.content }] : []),
+                ...(l.children ?? []).flatMap(plain)
+            ];
+            const endOf = placedEnd(roleOf);
+            /**
+             * A layout line, here or nested, as its items' lines in reading order, and
+             * any other child it holds (`flow.layout`): no layout lands in an item.
+             */
+            const unwrap = (l) => {
+                const item = l.type ? roleOf(l.type).layout : undefined;
+                if (item === undefined)
+                    return [l.children ? { ...l, children: l.children.flatMap(unwrap) } : l];
+                return (l.children ?? []).flatMap((kid) => kid.type === item ? (kid.children ?? []).flatMap(unwrap) : unwrap(kid));
+            };
+            const intoItem = (parent) => {
+                if (parent !== null && c.insideItem(parent))
+                    lines = lines.flatMap(unwrap);
+            };
+            /** Whole blocks at a slot, after `pre`; the caret ends the last one's shown content. */
+            const atSlot = (dest, pre) => {
+                const placed = specs(dest.parent);
+                const p = c.insertBlocks(dest, placed);
+                const at = endOf(placed.at(-1)) ?? { block: last().id, offset: lengthOf(last()) };
+                return 'writes' in p ? { ...c.plan(p.ids, [...pre, ...p.writes]), at } : p;
+            };
+            if ('replace' in target || 'slot' in target) {
+                let slot;
+                let pre = [];
+                if ('slot' in target)
+                    slot = target.slot;
+                else {
+                    // The lines fill the first block's slot: its parent is never emptied
+                    // by the delete, so a column keeps its layout (`layout.flow-slot`).
+                    const at = c.view().order.at;
+                    const first = target.replace
+                        .filter((id) => at.has(id))
+                        .sort((a, b) => at.get(a) - at.get(b))[0];
+                    const del = c.deleteBlocks(target.replace, false, first === undefined ? undefined : c.positionOf(first)?.parent);
+                    if (!('writes' in del))
+                        return del;
+                    if (first === undefined)
+                        return c.REFUSED;
+                    slot = c.positionOf(first);
+                    pre = [...del.writes];
+                }
+                intoItem(slot.parent);
+                if (lines.length === 0)
+                    return c.plan([], []);
+                // In a code block (selected lines, a slot), the lines are plain lines too (`flow.lines`).
+                if (slot.parent !== null && c.isLines(slot.parent)) {
+                    const shown = lines.flatMap(plain);
+                    lines = shown.length ? shown : [{ id: lines[0].id, content: [] }];
                 }
+                return atSlot(slot, pre);
             }
-            return at;
-        };
-        /** A joined line's children lead the block it joins; `moved` follow them. */
-        const kids = (to, l, moved = [], ranks = c.ranksFor(to, 0, (l?.children?.length ?? 0) + moved.length)) => {
-            const k = l?.children?.length ?? 0;
-            if (k)
-                writes.push({ op: 'insertBlocks', parent: to, index: 0, specs: l.children, ranks });
-            if (moved.length)
-                writes.push({ op: 'moveBlocks', ids: moved, parent: to, index: k, ranks: ranks.slice(k) });
-        };
-        /**
-         * `l` joins `B` at `at`: its content, its kind when `B` shows no text (a header
-         * keeps its own, as Enter does), its children first.
-         */
-        const join = (l, at, ranks) => {
-            const end = text(B, at, l);
-            const kind = l.type && fit(parent, l.type);
-            if (len === 0 && !header && kind && kind === l.type)
-                writes.push(...c.retype(B, kind), ...c.redata(B, l.data ?? {}));
-            if (!shut)
-                kids(B, l, [], ranks);
-            return end;
-        };
-        /** The placed lines at `at` under `home`, `ranks` theirs. */
-        const place = (at, ranks) => {
-            if (placed.length)
-                writes.push({ op: 'insertBlocks', parent: home, index: at, specs: placed, ranks });
-        };
-        // Under a header, the first line's children, the placed lines and the rest, in order.
-        const k = joinsHead ? (first.children?.length ?? 0) : 0;
-        const lead = inside ? c.ranksFor(B, 0, k + placed.length + 1) : [];
-        const slot = inside ? 0 : index + 1;
-        // Where the placed lines end the caret: after their last shown line (`flow.apart`).
-        const end = placed.length ? endOf(placed.at(-1)) : undefined;
-        // Nothing before the position and the first line stands apart: the lines go before `B`,
-        // which keeps its text and takes a joining last line, or goes when empty and not needed.
-        if (!joinsHead && o === 0 && !inside) {
-            place(index, c.insertRanks(parent, index, placed.length));
-            if (joinsTail) {
-                const at = join(last(), 0);
-                // A closed header's taken line's nested lines follow it, the caret ending them.
-                const after = shut ? specs(parent, last().children ?? []) : [];
-                if (after.length) {
-                    const ranks = c.insertRanks(parent, index + 1, after.length);
-                    const slot = index + placed.length + 1;
-                    writes.push({ op: 'insertBlocks', parent, index: slot, specs: after, ranks });
+            const B = ref(target.block);
+            if (!c.contentTarget(B) || !c.rendersContent(B))
+                return c.REFUSED;
+            const len = c.displayLength(B);
+            const o = Math.max(0, Math.min(target.offset, len));
+            const { parent, index } = c.positionOf(B);
+            intoItem(B);
+            const empty = len === 0 && c.childrenIds(B).length === 0;
+            // A line of a lines island (a code line) takes plain lines: every line the flow
+            // shows, nested ones included, in order; no block lands in the island (`flow.lines`).
+            const inLines = parent !== null && c.isLines(parent);
+            if (inLines)
+                lines = lines.flatMap(plain);
+            // A table's cell is never split: the lines it shows join its text (`table.paste`).
+            const cell = c.isTableCell(B);
+            if (cell)
+                lines = lines.flatMap(plain);
+            // A line that joins no text under `under` (`flow.apart`): its kind renders
+            // none of its own (a list, a code block), or is a void or an island.
+            const apart = (l, under) => {
+                const kind = l.type && fit(under, l.type);
+                const role = kind ? roleOf(kind) : undefined;
+                return !!role && (!role.rendersContent || role.void || role.island);
+            };
+            // At the end of a container's header whose body shows, what follows the caret
+            // leads its children and the body stays, as Enter opens a first child
+            // (`flow.header`), unless the first line stands apart and replaces an empty
+            // one (`flow.apart`); elsewhere it follows `B` among its siblings.
+            const header = view.header?.(B);
+            // A closed header shows no children: a line it takes brings none into its hidden
+            // body; they follow it, shown (`flow.header`).
+            const shut = header === 'closed';
+            const inside = o === len && !inLines && !flow.whole && header === true && !(empty && apart(lines[0], B));
+            const home = inside ? B : parent;
+            if (lines.length === 0)
+                return { ...c.plan([B], []), at: { block: B, offset: o } };
+            if (flow.whole && !inLines && !cell)
+                return atSlot({ parent, index: index + 1 }, empty ? [c.remove(B, [])] : []);
+            // A void is never split: its caption takes the lines as one run; nor is a cell.
+            const br = { kind: 'text', text: '\n' };
+            if (c.isVoid(B) || cell) {
+                const content = lines.flatMap((l, i) => [...(i ? [br] : []), ...(l.content ?? [])]);
+                lines = [{ id: lines[0].id, content }];
+            }
+            // So a first line it joins leaves its nested lines as lines of the flow after it.
+            if (shut && lines[0].children?.length && !apart(lines[0], home))
+                lines = [{ ...lines[0], children: undefined }, ...lines[0].children, ...lines.slice(1)];
+            const first = lines[0];
+            const [joinsHead, joinsTail] = [
+                !apart(first, home),
+                lines.length > 1 && !apart(last(), home)
+            ];
+            const all = specs(home);
+            const placed = all.slice(joinsHead ? 1 : 0, joinsTail ? -1 : undefined);
+            const ids = placed.map((s) => s.id);
+            if (collides(c.doc, [
+                ...(joinsHead ? (first.children ?? []) : []),
+                ...all.slice(joinsHead ? 1 : 0)
+            ]))
+                return c.REFUSED;
+            const writes = [];
+            /** A joined line's children lead the block it joins; `moved` follow them. */
+            const kids = (to, l, moved = [], ranks = c.ranksFor(to, 0, (l?.children?.length ?? 0) + moved.length)) => {
+                const k = l?.children?.length ?? 0;
+                if (k)
+                    writes.push({ op: 'insertBlocks', parent: to, index: 0, specs: l.children, ranks });
+                if (moved.length)
+                    writes.push({
+                        op: 'moveBlocks',
+                        ids: moved,
+                        parent: to,
+                        index: k,
+                        ranks: ranks.slice(k)
+                    });
+            };
+            /**
+             * `l` joins `B` at `at`: its content, its kind when `B` shows no text (a header
+             * keeps its own, as Enter does), its children first.
+             */
+            const join = (l, at, ranks) => {
+                const end = c.writeContent(writes, B, at, l.content);
+                const kind = l.type && fit(parent, l.type);
+                if (len === 0 && !header && kind && kind === l.type)
+                    writes.push(...c.attr(B, TYPE, kind), ...(c.dataSteps(B, c.replaceData(l.data ?? {})) ?? []));
+                if (!shut)
+                    kids(B, l, [], ranks);
+                return end;
+            };
+            /** The placed lines at `at` under `home`, `ranks` theirs. */
+            const place = (at, ranks) => {
+                if (placed.length)
+                    writes.push({ op: 'insertBlocks', parent: home, index: at, specs: placed, ranks });
+            };
+            // Under a header, the first line's children, the placed lines and the rest, in order.
+            const k = joinsHead ? (first.children?.length ?? 0) : 0;
+            const lead = inside ? c.ranksFor(B, 0, k + placed.length + 1) : [];
+            const slot = inside ? 0 : index + 1;
+            // Where the placed lines end the caret: after their last shown line (`flow.apart`).
+            const end = placed.length ? endOf(placed.at(-1)) : undefined;
+            // Nothing before the position and the first line stands apart: the lines go before `B`,
+            // which keeps its text and takes a joining last line, or goes when empty and not needed.
+            if (!joinsHead && o === 0 && !inside) {
+                place(index, c.ranksFor(parent, index, placed.length, [], true));
+                if (joinsTail) {
+                    const at = join(last(), 0);
+                    // A closed header's taken line's nested lines follow it, the caret ending them.
+                    const after = shut ? specs(parent, last().children ?? []) : [];
+                    if (after.length) {
+                        const ranks = c.ranksFor(parent, index + 1, after.length, [], true);
+                        const slot = index + placed.length + 1;
+                        writes.push({ op: 'insertBlocks', parent, index: slot, specs: after, ranks });
+                    }
+                    const caret = after.length ? endOf(after.at(-1)) : undefined;
+                    const touched = [...ids, B, ...after.map((s) => s.id)];
+                    return { ...c.plan(touched, writes), at: caret ?? { block: B, offset: at } };
                 }
-                const caret = after.length ? endOf(after.at(-1)) : undefined;
-                const touched = [...ids, B, ...after.map((s) => s.id)];
-                return { ...c.plan(touched, writes), at: caret ?? { block: B, offset: at } };
+                if (empty && end)
+                    return { ...c.plan(ids, [...writes, c.remove(B, [])]), at: end };
+                return { ...c.plan([...ids, B], writes), at: end ?? { block: B, offset: 0 } };
             }
-            if (empty && end)
-                return { ...c.plan(ids, [...writes, c.remove(B, [])]), at: end };
-            return { ...c.plan([...ids, B], writes), at: end ?? { block: B, offset: 0 } };
-        }
-        const head = joinsHead ? join(first, o, inside ? lead.slice(0, k) : undefined) : o;
-        if (lines.length === 1 && joinsHead)
-            return { ...c.plan([B], writes), at: { block: B, offset: head } };
-        const moved = inside ? [] : c.childrenIds(B).filter((id) => !view.hidden?.(id));
-        // Nothing after the position to keep, and the caret has a line: no split.
-        if (!joinsTail && o === len && moved.length === 0 && end) {
-            place(slot, inside ? lead.slice(k, -1) : c.pieceRanks(B, o, placed.length));
-            return { ...c.plan([B, ...ids], writes), at: end };
+            const head = joinsHead ? join(first, o, inside ? lead.slice(0, k) : undefined) : o;
+            if (lines.length === 1 && joinsHead)
+                return { ...c.plan([B], writes), at: { block: B, offset: head } };
+            const moved = inside ? [] : c.childrenIds(B).filter((id) => !view.hidden?.(id));
+            // Nothing after the position to keep, and the caret has a line: no split.
+            if (!joinsTail && o === len && moved.length === 0 && end) {
+                place(slot, inside ? lead.slice(k, -1) : c.pieceRanks(B, o, placed.length));
+                return { ...c.plan([B, ...ids], writes), at: end };
+            }
+            // The rest of `B` stays in a shown line: the last line's block when it joins, else
+            // a line of `B`'s kind, as Enter makes; one made only for the caret (after a
+            // divider at the end) or under a header is a fresh line of its parent's default kind.
+            const T = joinsTail ? last().id : freshId('b');
+            const lastType = joinsTail && last().type && fit(home, last().type);
+            const bare = !joinsTail && o === len && moved.length === 0;
+            const tail = lastType
+                ? { type: lastType, data: last().data }
+                : bare || inside
+                    ? { type: c.defaultChild(home), data: {} }
+                    : { type: c.kindToCopy(B), data: c.blockDataOf(B) };
+            // By the offset the paste splits `B` at (SW12-crdt-4), as Enter's split.
+            const ranks = inside ? lead.slice(k) : c.pieceRanks(B, o, placed.length + 1);
+            const rank = ranks.pop();
+            const length = len - o;
+            writes.push({
+                op: 'splitBlock',
+                id: B,
+                offset: head,
+                length,
+                newId: T,
+                tail,
+                parent: home,
+                rank
+            });
+            kids(T, joinsTail ? last() : undefined, moved);
+            place(slot, ranks);
+            const at = joinsTail
+                ? { block: T, offset: c.writeContent(writes, T, 0, last().content) }
+                : (end ?? { block: T, offset: 0 });
+            return { ...c.plan([B, ...ids, T], writes), at };
         }
-        // The rest of `B` stays in a shown line: the last line's block when it joins, else
-        // a line of `B`'s kind, as Enter makes; one made only for the caret (after a
-        // divider at the end) or under a header is a fresh line of its parent's default kind.
-        const T = joinsTail ? last().id : freshId('b');
-        const lastType = joinsTail && last().type && fit(home, last().type);
-        const bare = !joinsTail && o === len && moved.length === 0;
-        const tail = lastType
-            ? { type: lastType, data: last().data }
-            : bare || inside
-                ? { type: c.defaultChild(home), data: {} }
-                : c.tailOf(B);
-        // By the offset the paste splits `B` at (SW12-crdt-4), as Enter's split.
-        const ranks = inside ? lead.slice(k) : c.pieceRanks(B, o, placed.length + 1);
-        const rank = ranks.pop();
-        const length = len - o;
-        writes.push({
-            op: 'splitBlock',
-            id: B,
-            offset: head,
-            length,
-            newId: T,
-            tail,
-            parent: home,
-            rank
-        });
-        kids(T, joinsTail ? last() : undefined, moved);
-        place(slot, ranks);
-        const at = joinsTail
-            ? { block: T, offset: text(T, 0, last()) }
-            : (end ?? { block: T, offset: 0 });
-        return { ...c.plan([B, ...ids, T], writes), at };
-    }
-});
+    };
+};