edytor 5.0.0 → 6.0.0

package/dist/crdt/doc/split-merge.js

@@ -1,179 +0,0 @@
-/**
- * Split and merge ops: `splitBlock` (one boundary item, no text copied),
- * the engine merge primitive `mergeBlocks`, and the baseline-shaped
- * `mergeBackward`/`mergeForward` (a first item lifts out of its container,
- * a layout item's first block merges across items).
- */
-import { isIncarnationId } from '../incarnations.js';
-import { sanitizeWireJson } from '../../utils/json.js';
-import { readData } from '../data.js';
-import { blockNodeOf, isSelfOrDescendant } from '../placement/model.js';
-import { ref } from './plan.js';
-/** The split-merge ops of one facade, prepared. */
-export const splitMergeOps = (c) => {
-    const { doc, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
-    /**
-     * Split `id` at content `offset` into a new sibling `newId` (one boundary
-     * item and the claims that follow it, no text copied; children follow).
-     * `tail` decides the sibling's type/data once (default: the source's —
-     * the kind it displays; an empty `tail.type` is the default too).
-     * Refused on `void` blocks and on blocks that render no content (a
-     * list, a code block: nothing to split). `ids`: the new
-     * block.
-     */
-    const splitBlock = (id, offset, newId, tail) => {
-        id = ref(id);
-        const born = ref(newId);
-        const pos = positionOf(id);
-        const rec = view().blocks.get(id);
-        if (pos === null || isVoid(id) || !rendersContent(id) || rec === undefined)
-            return REFUSED;
-        // A table's cell holds its lines as line breaks: it never splits (`table.split`).
-        if (isCellKind(blockTypeOf(id)))
-            return REFUSED;
-        if (isIncarnationId(born) || blockNodeOf(doc, born) !== null)
-            return REFUSED;
-        const [at] = clamp(id, offset, 0);
-        // An empty tail type is the one a view reads mid-retype: copy the kind.
-        const type = tail?.type ? ref(tail.type) : kindToCopy(id);
-        const t = tail
-            ? { type, data: tail.data && sanitizeWireJson(tail.data) }
-            : { type, data: readData(rec.node) };
-        const length = displayLength(id) - at;
-        const split = {
-            op: 'splitBlock',
-            id,
-            offset: at,
-            length,
-            newId: born,
-            tail: t,
-            parent: pos.parent,
-            index: pos.index + 1
-        };
-        return plan([born], [split, ...move(childrenIds(id), born, 0)]);
-    };
-    /**
-     * Engine merge primitive: `from`'s content is claimed by `into`, its
-     * children ADOPTED as `into`'s last children — an island's take
-     * `into`'s default child, like a baseline merge's — and `from` is
-     * hidden via the claim (undo restores it). The children stay under
-     * `from` and display under `into` through the claim, after `into`'s
-     * own children (the display's claim order): a concurrent delete of
-     * `into` voids the claim and `from` comes back with its children,
-     * never below them. Role rules are `canMerge`'s; a merge that would
-     * close a display cycle is refused. `ids`: `into`.
-     */
-    const mergeBlocks = (fromId, intoId) => {
-        const from = ref(fromId);
-        const into = ref(intoId);
-        const v = view();
-        if (!canMerge(from, into) || !contentTarget(into))
-            return REFUSED;
-        if (isSelfOrDescendant(v.placements, v.own, into, from))
-            return REFUSED;
-        const kids = childrenIds(from);
-        const retype = settle(from, kids, into);
-        // A list its only item leaves goes, as with every sibling op.
-        return plan([into], emptied([from], [merge(from, into), ...retype], landing(into)));
-    };
-    /**
-     * Baseline-shaped merge (both `mergeBackward` and `mergeForward`):
-     * `from`'s children unnest right after `from`'s vacated sibling slot —
-     * NOT adopted into `into` — and take the kind they show there
-     * (`settledKind`: an island's children its parent's default child, a
-     * paragraph in a list its item); then `from`'s content claims
-     * into `into`. Placed after `from`, not at it: a concurrent delete of
-     * `into` revives `from` above its former children.
-     */
-    const mergeUnnesting = (from, into) => {
-        const pos = canMerge(from, into) ? positionOf(from) : null;
-        if (pos === null || !contentTarget(into))
-            return REFUSED;
-        const kids = childrenIds(from);
-        const retype = settle(from, kids, pos.parent);
-        return plan([into], [...moveTo(kids, pos.parent, pos.index + 1, leaving(true)), ...retype, merge(from, into)]);
-    };
-    /** Remove `container`, left empty, for the key at `id` (refused if it holds text). */
-    const gone = (id, container) => {
-        const writes = emptying(container, [], []);
-        return writes.length > 0 ? plan([id], writes) : REFUSED;
-    };
-    /**
-     * Baseline `mergeBlockBackward`: merge `id` into the previous block in
-     * document order. No previous block → an empty block merges forward,
-     * else refused. The first item of a container (`isContainer`) outside
-     * any island lifts out of it instead (Notion): it takes the
-     * container's slot, as its new parent's default child, with its
-     * children (a first cell stays: nothing leaves an island; a block that
-     * would land directly in a container it is no item of stays too).
-     * The first block of a layout item merges across items
-     * instead, in reading order (`layout.merge`, Notion): into the
-     * previous item's last line, or, in the first item, the line before
-     * the layout; an item it empties goes and the layout dissolves.
-     * `ids`: the surviving block.
-     */
-    const mergeBackward = (id) => {
-        id = ref(id);
-        const prev = previous(id);
-        if (prev === null && childrenIds(id).length === 0 && displayLength(id) === 0) {
-            return mergeForward(id);
-        }
-        // A container a concurrent edit left empty shows nothing: the key removes it.
-        if (prev !== null && isContainer(prev) && childrenIds(prev).length === 0)
-            return gone(id, prev);
-        if (prev !== null && prev === positionOf(id)?.parent && isLayoutItem(prev)) {
-            const layout = positionOf(prev).parent;
-            let into = previous(prev);
-            if (into === layout)
-                into = previous(layout);
-            const merged = into === null ? REFUSED : mergeUnnesting(id, into);
-            if (!('writes' in merged) || childrenIds(id).length > 0)
-                return merged;
-            return plan(merged.ids, emptying(prev, [id], merged.writes));
-        }
-        if (prev !== null &&
-            prev === positionOf(id)?.parent &&
-            isContainer(prev) &&
-            !insideIsland(prev)) {
-            // It lands only where it fits: never directly in a container it is no item of.
-            const slot = positionOf(prev);
-            if (!fits(slot.parent, settledKind(prev, id, slot.parent)))
-                return REFUSED;
-            const lift = [
-                ...moveTo([id], slot.parent, slot.index, leaving(false)),
-                ...settle(prev, [id], slot.parent)
-            ];
-            return plan([id], emptying(prev, [id], lift, landing(slot.parent)));
-        }
-        return prev ? mergeUnnesting(id, prev) : REFUSED;
-    };
-    /**
-     * Baseline `mergeBlockForward`: pull the next block in document order
-     * into `id`. A container passes the merge to its first item (`del.merge.container`:
-     * Delete above a list pulls the item's text up and the list keeps the
-     * rest, or goes when that was its only item). A container left
-     * empty (by concurrent edits) is removed instead, by either key.
-     */
-    const mergeForward = (id) => {
-        id = ref(id);
-        let after = next(id);
-        while (after !== null && isContainer(after)) {
-            const first = childrenIds(after)[0];
-            // A container a concurrent edit left empty shows nothing: the key removes it.
-            if (first === undefined)
-                return gone(id, after);
-            after = first;
-        }
-        const out = after ? mergeUnnesting(after, id) : REFUSED;
-        const parent = after && positionOf(after)?.parent;
-        if (!('writes' in out) || !parent || childrenIds(after).length > 0)
-            return out;
-        return plan(out.ids, emptying(parent, [after], out.writes));
-    };
-    return {
-        splitBlock,
-        mergeBlocks,
-        mergeBackward,
-        mergeForward
-    };
-};

package/dist/crdt/doc/steps.d.ts

@@ -1,65 +0,0 @@
-/**
- * The step writers every prepared op composes: the plan itself, moves (a
- * move's place and side), type steps and the kind a block shows where it
- * lands (`settle`), the containers and layouts a write leaves empty
- * (`emptying`, `dissolving`), delete and merge steps, and display spans of a
- * block's content.
- */
-import { TYPE } from '../schema.js';
-import { type BlockId, type ContentItem } from '../placement/model.js';
-import type { Plan, PlanStep } from './types.js';
-import type { DocBase, DocReads } from './reads.js';
-import type { DocCapability } from './capability.js';
-/** What the step writers read: the reads and the structural capability. */
-/**
- * A record's order among the records standing at one block, for the
- * engine's sort of two records at one origin (fork patch YP22): what a split
- * of a list around a block writes there — a new head list holding the items
- * before it (`head`), new blocks placed after the items before it, which
- * stay (`kept`), a head holding those items and the block (`with`), the
- * block itself leaving (`self`), new blocks after it (`after`) — in the
- * order every serial run of the gestures gives (`del.merge.container`).
- */
-export declare const PART: {
-    readonly head: 0;
-    readonly kept: 1;
-    readonly with: 2;
-    readonly self: 3;
-    readonly after: 4;
-};
-export type StepsContext = DocBase & DocReads & DocCapability;
-/** The step writers of one facade. */
-export declare const planSteps: (c: StepsContext) => {
-    REFUSED: import("./types.js").OpResult;
-    plan: (ids: readonly BlockId[], writes: PlanStep[]) => Plan;
-    moveTo: (ids: BlockId[], parent: BlockId | null, index: number, side?: 0 | 1, at?: BlockId, part?: number) => PlanStep[];
-    move: (ids: BlockId[], parent: BlockId | null, index: number) => PlanStep[];
-    leaving: (after: boolean) => 0 | 1;
-    attr: (id: BlockId, key: typeof TYPE, value: string) => PlanStep[];
-    leavingIsland: (island: BlockId, kind: string | undefined, to: string) => string | undefined;
-    settledKind: (from: BlockId | null, kid: BlockId, parent: BlockId | null) => string | undefined;
-    settle: (from: BlockId | null, kids: readonly BlockId[], parent: BlockId | null) => PlanStep[];
-    landing: (parent: BlockId | null) => Set<BlockId | null>;
-    emptyingAll: (from: readonly (BlockId | null)[], leaving: readonly BlockId[], writes: readonly PlanStep[], kept?: ReadonlySet<BlockId | null>, removed?: readonly BlockId[]) => PlanStep[];
-    dissolving: (gone: ReadonlySet<BlockId>, leaving: readonly BlockId[], writes: readonly PlanStep[]) => PlanStep[];
-    emptying: (container: BlockId, leaving: readonly BlockId[], writes: readonly PlanStep[], kept?: ReadonlySet<BlockId | null>) => PlanStep[];
-    emptied: (leaving: readonly BlockId[], writes: PlanStep[], kept?: ReadonlySet<BlockId | null>) => PlanStep[];
-    deleting: (id: BlockId, removes: BlockId[]) => PlanStep;
-    remove: (id: BlockId, kept?: readonly BlockId[]) => PlanStep;
-    merge: (from: BlockId, into: BlockId) => PlanStep;
-    clamp: (id: BlockId, offset: number, length: number) => [number, number];
-    atomOf: (id: BlockId, atom: string) => {
-        item: ContentItem;
-        at: number;
-        end: number;
-    } | undefined;
-    textIn: (id: BlockId, at: number, end: number) => {
-        kind: "text";
-        text: string;
-        marks?: Record<string, unknown>;
-    }[];
-    writeContent: (writes: PlanStep[], id: BlockId, at: number, items?: readonly ContentItem[]) => number;
-};
-export type PlanSteps = ReturnType<typeof planSteps>;
-/** What every op family is prepared over: the reads, the capability and the step writers. */
-export type OpsContext = StepsContext & PlanSteps;

package/dist/crdt/doc/steps.js

@@ -1,311 +0,0 @@
-/**
- * The step writers every prepared op composes: the plan itself, moves (a
- * move's place and side), type steps and the kind a block shows where it
- * lands (`settle`), the containers and layouts a write leaves empty
- * (`emptying`, `dissolving`), delete and merge steps, and display spans of a
- * block's content.
- */
-import { TYPE } from '../schema.js';
-import { blockNodeOf } from '../placement/model.js';
-import { REFUSED, effectOf } from './plan.js';
-/** What the step writers read: the reads and the structural capability. */
-/**
- * A record's order among the records standing at one block, for the
- * engine's sort of two records at one origin (fork patch YP22): what a split
- * of a list around a block writes there — a new head list holding the items
- * before it (`head`), new blocks placed after the items before it, which
- * stay (`kept`), a head holding those items and the block (`with`), the
- * block itself leaving (`self`), new blocks after it (`after`) — in the
- * order every serial run of the gestures gives (`del.merge.container`).
- */
-export const PART = { head: 0, kept: 1, with: 2, self: 3, after: 4 };
-/** The step writers of one facade. */
-export const planSteps = (c) => {
-    const { doc, runsView, roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isLines, isIsland, itemKindOf, isLayout, displayLength, contentItems, live, isContainer, fitted, emptiable, defaultChild } = c;
-    // ── prepared ops ─────────────────────────────────────────────
-    // Every op is `prepare` (pure: `refused`, or a plan of named steps plus
-    // its effect summary, against the current version) then `apply(plan)`;
-    // composites compose their steps into one plan, so a hook sees the
-    // whole command before any write and a refusal refuses before one.
-    // Each prepare normalizes its inputs once, here at ingress: ids
-    // and strings as the wire would deliver them, payloads cloned.
-    const plan = (ids, writes) => ({
-        ids,
-        writes,
-        effect: effectOf(writes),
-        version: runsView.version()
-    });
-    /**
-     * Move `ids` to display index `index` among `parent`'s children (the
-     * slot hooks see). `side`: the move record's class among the items of
-     * its origin (`placement/slots.ts`) — `0`, the blocks stand after what
-     * precedes them (a move; blocks leaving a block for the gap after it:
-     * its children, a list's last items); `1`, before what follows them
-     * (blocks leaving a block for the gap before it: a list's first item
-     * lifted out). In one gap every serial order of the gestures puts a
-     * split's pieces first, then the after-records, then the before-records
-     * (`del.merge.container`), which the engine's sort gives whatever the
-     * client ids.
-     * Every planned move carries the type steps that keep what the moved
-     * blocks show: one displayed out of an island as another kind than its
-     * stored one (`displayType`) gets that kind written, so leaving the
-     * island's slot never brings the island's child kind back.
-     * `at`, `part`: the block the record stands at and its order among the
-     * records standing there, for the engine's sort of two records at one
-     * origin (`PART`; by default the first moved block, as itself).
-     */
-    const moveTo = (ids, parent, index, side = 0, at, part) => ids.length === 0
-        ? []
-        : [
-            {
-                op: 'moveBlocks',
-                ids,
-                parent,
-                index,
-                ...(side === 1 && { side }),
-                ...(at !== undefined && { at }),
-                ...(part !== undefined && { part })
-            },
-            ...ids.flatMap((id) => {
-                const shown = runsView.displayType(id);
-                return shown === undefined ? [] : attr(id, TYPE, shown);
-            })
-        ];
-    /** Move `ids` to `index` among `parent`'s children. */
-    const move = (ids, parent, index) => moveTo(ids, parent, index);
-    /** The side of blocks leaving a block for the gap right after it (`after`) or right before it. */
-    const leaving = (after) => (after ? 0 : 1);
-    /**
-     * A type step, planned only when the kind differs (the one same-value
-     * guard). A kind counts as the same only when the block is stored and
-     * shown as it: a move in the same plan pins the kind a block shows
-     * (`moveTo`), so a paragraph shown as its list's item (`itemOf`) that
-     * an outdent settles back to a paragraph is written back.
-     */
-    const attr = (id, key, value) => {
-        const same = blockNodeOf(doc, id).getAttr(key) === value;
-        if (same && (runsView.displayType(id) ?? value) === value)
-            return [];
-        return [{ op: 'setBlockType', id, type: value }];
-    };
-    /**
-     * The kind `kid` shows once it leaves `from` for a slot under `parent`
-     * — the island and container rules, one answer:
-     * - an island's child takes `parent`'s default child (it leaves the
-     *   island's kinds) — unless that renders no content while the child
-     *   does: a line then takes the document's default kind (a code line
-     *   shed into a columns layout is a paragraph), any other child
-     *   keeps its kind, as `typeOf` shows one a peer adds meanwhile;
-     * - a container's item (its default child) takes `parent`'s default
-     *   child — an item never shows outside its list — unless it
-     *   stays inside an outer container of that kind (a nested list),
-     *   or that kind renders no content (a column in a
-     *   columns layout: its text would vanish);
-     * - then a plain block that does not fit `parent` (`fits`: a paragraph
-     *   shed into a list) becomes its item, when that item renders content
-     *   (`fitted`). A block that cannot (a paragraph in a columns
-     *   layout) keeps its kind: its text never vanishes; any other kind (an
-     *   image, a code block, a heading) keeps its kind.
-     */
-    /**
-     * The kind a child of `island` (now `kind`) takes where the default
-     * child is `to`: `to` — unless `to` renders no content while the child
-     * does (its text would vanish): a line then takes the document's
-     * default kind, any other child keeps its kind (as `typeOf`).
-     */
-    const leavingIsland = (island, kind, to) => {
-        if (roles.of(to).rendersContent || (kind !== undefined && !roles.of(kind).rendersContent))
-            return to;
-        return isLines(island) ? defaultChild(null) : kind;
-    };
-    const settledKind = (from, kid, parent) => {
-        let kind = blockTypeOf(kid);
-        if (from !== null && isIsland(from))
-            kind = leavingIsland(from, kind, defaultChild(parent));
-        else if (from !== null && isContainer(from) && kind === defaultChild(from)) {
-            const within = parent === null ? [] : [parent, ...ancestorsOf(parent)];
-            const to = defaultChild(parent);
-            // An outer container of its kind keeps it an item (a nested list); a
-            // column's default child is the document's: it holds no items of its own.
-            const outer = kind !== defaultChild(null) &&
-                within.some((a) => isContainer(a) && defaultChild(a) === kind);
-            if (!outer && roles.of(to).rendersContent)
-                kind = to;
-        }
-        return fitted(parent, kind);
-    };
-    /** The kind steps for the `kids` of `from` (`null`: the root) landing under `parent` (`settledKind`). */
-    const settle = (from, kids, parent) => kids.flatMap((kid) => {
-        const kind = settledKind(from, kid, parent);
-        return kind === undefined || kind === blockTypeOf(kid) ? [] : attr(kid, TYPE, kind);
-    });
-    /** `parent` and its display ancestors: where blocks landing under `parent` keep alive. */
-    const landing = (parent) => new Set(parent === null ? [] : [parent, ...ancestorsOf(parent)]);
-    /**
-     * `writes`, then every container one of `from` (the blocks' former
-     * parents) is left with no child but `leaving` removed
-     * (`del.range.empty-container`), and so on upward — never one of
-     * `kept`, and only an `emptiable` one (a container holding text of its
-     * own stays). The containers are found together, deepest first: a
-     * list that loses its last item along with a list nested in it goes
-     * too. Then every layout the plan leaves with one
-     * item or none dissolves (`dissolving`); `removed`: blocks the plan
-     * deletes besides (a block delete's members), which only that counts.
-     */
-    const emptyingAll = (from, leaving, writes, kept = new Set(), removed = []) => {
-        const gone = new Set(leaving);
-        const tops = [];
-        const deepest = [...new Set(from)]
-            .filter((c) => c !== null)
-            .sort((a, b) => ancestorsOf(b).length - ancestorsOf(a).length);
-        for (const start of deepest) {
-            let top = null;
-            for (let c = start; c !== null && !gone.has(c) && !kept.has(c) && emptiable(c); c = positionOf(c).parent) {
-                if (!childrenIds(c).every((kid) => gone.has(kid)))
-                    break;
-                gone.add((top = c));
-            }
-            if (top !== null)
-                tops.push(top);
-        }
-        const roots = tops.filter((t) => !ancestorsOf(t).some((a) => tops.includes(a)));
-        const steps = [...writes, ...roots.map((t) => remove(t, leaving))];
-        for (const id of removed)
-            gone.add(id);
-        return [...steps, ...dissolving(gone, leaving, steps)];
-    };
-    /**
-     * `layout.dissolving`: the steps that delete each layout a plan leaves
-     * with one item or none — `gone` (blocks the plan removes) and
-     * `leaving` (blocks it moves) no longer count, an item `writes` move or
-     * insert into it does. With one left, the layout and that item are
-     * deleted and the item's children moved right after the layout, where
-     * `layout.single` shows them, as the kind they show there (`settle`);
-     * with none, the layout is deleted. One plan with the write that caused
-     * it.
-     */
-    const dissolving = (gone, leaving, writes) => {
-        const away = new Set([...gone, ...leaving]);
-        const layouts = new Set();
-        for (const id of away) {
-            const parent = positionOf(id)?.parent;
-            if (parent != null && isLayout(parent))
-                layouts.add(parent);
-        }
-        const { kids } = view();
-        const out = [];
-        for (const layout of layouts) {
-            if ([layout, ...ancestorsOf(layout)].some((a) => gone.has(a)))
-                continue;
-            const item = itemKindOf(layout);
-            const arriving = writes.reduce((n, w) => w.op === 'moveBlocks' && w.parent === layout
-                ? n + w.ids.filter((id) => blockTypeOf(id) === item).length
-                : w.op === 'insertBlocks' && w.parent === layout
-                    ? n + w.specs.filter((spec) => spec.type === item).length
-                    : n, 0);
-            const slots = kids.get(layout) ?? [];
-            const items = slots.filter((k) => !away.has(k.id) && blockTypeOf(k.id) === item);
-            if (items.length + arriving > 1)
-                continue;
-            const { parent } = positionOf(layout);
-            const last = items[0];
-            if (last === undefined) {
-                out.push(deleting(layout, [layout]));
-                continue;
-            }
-            // Its blocks keep their home slots: the read shows them in the layout's
-            // slot (`layout.single`), settled for its parent.
-            const moved = (kids.get(last.id) ?? []).filter((k) => !away.has(k.id));
-            const ids = moved.map((k) => k.id);
-            out.push(...settle(last.id, ids, parent), deleting(layout, [layout, last.id]));
-        }
-        return out;
-    };
-    /** `writes`, then `container` removed when they leave it no child but `leaving` (`emptyingAll`). */
-    const emptying = (container, leaving, writes, kept) => emptyingAll([container], leaving, writes, kept);
-    /**
-     * Delete: `removes` leave. Every one is marked with what it
-     * displays — an unmarked one would be promoted into the deleted slot
-     * (`displaySlotOf`).
-     */
-    const deleting = (id, removes) => {
-        const marks = [...new Set(removes.flatMap((b) => view().displays(b)))];
-        return { op: 'deleteBlock', id, marks, removes };
-    };
-    /** Delete `id` and its subtree, `kept` children aside. */
-    const remove = (id, kept = []) => {
-        const removes = [];
-        const skip = new Set(kept);
-        const walk = (b) => {
-            removes.push(b);
-            for (const kid of childrenIds(b))
-                if (!skip.has(kid))
-                    walk(kid);
-        };
-        walk(id);
-        return deleting(id, removes);
-    };
-    const merge = (from, into) => ({
-        op: 'mergeBlocks',
-        from,
-        into,
-        at: displayLength(into),
-        length: displayLength(from)
-    });
-    /** `[at, end)` — `[offset, offset + length)` clamped to `id`'s display. */
-    const clamp = (id, offset, length) => {
-        const total = displayLength(id);
-        const at = Math.max(0, Math.min(offset, total));
-        return [at, Math.min(total, at + Math.max(0, length))];
-    };
-    /** `id`'s display items, each with its `[at, end)` display offsets. */
-    const spans = (id) => {
-        let end = 0;
-        return contentItems(id).map((item) => {
-            const at = end;
-            end += item.kind === 'text' ? item.text.length : 1;
-            return { item, at, end };
-        });
-    };
-    /** The live inline atom `atom` in `id`'s display, or undefined. */
-    const atomOf = (id, atom) => live(id) ? spans(id).find(({ item }) => item.kind === 'inline' && item.id === atom) : undefined;
-    /** Text items overlapping `[at, end)` of `id` (inline atoms carry no marks). */
-    const textIn = (id, at, end) => spans(id).flatMap((s) => (s.item.kind === 'text' && s.at < end && s.end > at ? [s.item] : []));
-    /** Push the steps writing `items` into `id` from `at` (text runs and atoms in order); the end offset. */
-    const writeContent = (writes, id, at, items = []) => {
-        for (const item of items) {
-            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;
-            }
-        }
-        return at;
-    };
-    /** `writes`, then every container the `leaving` blocks leave with no child removed. */
-    const emptied = (leaving, writes, kept) => emptyingAll(leaving.map((id) => positionOf(id).parent), leaving, writes, kept);
-    return {
-        REFUSED,
-        plan,
-        moveTo,
-        move,
-        leaving,
-        attr,
-        leavingIsland,
-        settledKind,
-        settle,
-        landing,
-        emptyingAll,
-        dissolving,
-        emptying,
-        emptied,
-        deleting,
-        remove,
-        merge,
-        clamp,
-        atomOf,
-        textIn,
-        writeContent
-    };
-};

package/dist/crdt/text/index/cache.d.ts

@@ -1,16 +0,0 @@
-import type { BlockId } from '../../placement/model.js';
-import type { ContentRun, RunViewDebug } from '../runs.js';
-import type { IndexPlacement } from './placement.js';
-import { type Deps } from './shared.js';
-import type { IndexState } from './state.js';
-/** The run cache of one doc's index. */
-export declare const indexCache: (ix: IndexState & IndexPlacement) => {
-    intern: <T>(v: T) => T;
-    computeFresh: (b: BlockId) => {
-        fresh: ContentRun[];
-        deps: Deps;
-    };
-    computeRuns: (b: BlockId) => void;
-    debug: RunViewDebug;
-};
-export type IndexCache = ReturnType<typeof indexCache>;