edytor 5.0.0 → 7.0.0

package/dist/surface/projector.svelte.js

@@ -44,6 +44,7 @@ import { getMarkEdgeSide, getYIndex, isTextBoundSelectionPoint } from '../select
 import { project, sameEnds } from '../session/selection.js';
 import { isAndroidChromeBrowser } from '../events/events.utils.js';
 import { isKindControl, isOwnPoint } from '../events/nativeInteractiveControl.js';
+import { textLeaves } from '../events/domTextOffset.js';
 /**
  * Named rule: Android Chrome mutates the DOM after a
  * canceled `deleteContentBackward` and reports the caret one position right
@@ -54,9 +55,8 @@ const ANDROID_SNAP_BACK_MS = 250;
 const IME_POST_COMMIT_JUMP_MS = 100;
 /** The DOM point of a text-segment offset: its text leaf, else the element itself. */
 export const domPointOf = (element, offset) => {
-    const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
     let at = 0;
-    for (let leaf = walker.nextNode(); leaf; leaf = walker.nextNode()) {
+    for (const leaf of textLeaves(element)) {
         const end = at + leaf.length;
         if (offset <= end)
             return [leaf, offset - at];

package/dist/utils.d.ts

@@ -1,4 +1,9 @@
 export declare const id: (prefix: "t" | "b" | "i" | "v" | "s" | "c") => string;
+/** `key`'s value in `map`, made (`make`) and stored when it holds none. */
+export declare const getOr: <K, V>(map: {
+    get(key: K): V | undefined;
+    set(key: K, value: V): unknown;
+}, key: K, make: () => V) => V;
 /**
  * A hook's veto as the dispatcher carries it: what `prevent(cb?)` recorded,
  * and the extension that recorded it. Hooks never see one thrown at them:

package/dist/utils.js

@@ -6,6 +6,13 @@ export const id = (prefix) => {
         t += alphabet[61 & r[n]];
     return `${prefix}_${t}`;
 };
+/** `key`'s value in `map`, made (`make`) and stored when it holds none. */
+export const getOr = (map, key, make) => {
+    let value = map.get(key);
+    if (value === undefined)
+        map.set(key, (value = make()));
+    return value;
+};
 /**
  * A hook's veto as the dispatcher carries it: what `prevent(cb?)` recorded,
  * and the extension that recorded it. Hooks never see one thrown at them:

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "edytor",
 	"license": "MIT",
-	"version": "5.0.0",
+	"version": "7.0.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/beynar/edytor.git"

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

@@ -1,56 +0,0 @@
-/**
- * Structural capability: one answer in advance and at execution.
- *
- * ── Island/void enforcement (operation-layer, not stored) ──────────────
- *
- * Roles are resolved operation-time via `config.roleOf(type)`, through one
- * role table (`DisplayRoles`) that the index's display and every guard
- * below ask of a block's shown kind — the editor derives them from plugin
- * block definitions, exactly like the baseline's
- * `block.definition.island/void`. They are deliberately NOT replicated block
- * data: the schema stays policy-free, and a replica with different plugins
- * reads the same document. Enforced rules (baseline semantics, see
- * `plugins.ts` + `block.utils.ts`):
- *
- * - `void`: cannot accept children (insert/move/nest into void rejected),
- *   cannot merge either direction, cannot be split. Content edits ARE
- *   allowed — void rendered content (captions) stays editable per the
- *   baseline contract. Deletion is allowed (delete is not editing).
- * - `island`: editable content, but its subtree is structurally sealed —
- *   a block inside an island (`insideIsland`) cannot be moved, nested,
- *   unnested, or merged across the island boundary. Merges INSIDE one
- *   island are allowed; merging an island child into the island itself is
- *   allowed when the island renders its content. Moving or merging
- *   INTO an island subtree is rejected. An island declared `lines` (code)
- *   holds only lines of its `defaultChild` kind, and a line holds no
- *   children (the display enforces it against undo,
- *   `insertBlocks` refuses a line parent); any other island keeps its
- *   structure. `canPlace` and `canMerge` are the one answer, asked in
- *   advance or by the ops.
- * - Island merge: when an island block itself is merged (backward or
- *   forward), its children are unnested to the vacated sibling slot and
- *   reset to the default child of that slot's parent (`defaultChild`).
- * - Baseline merges NEVER adopt the merged block's children — they unnest
- *   to the vacated slot. The facade exposes both: `mergeBlocks` is the
- *   engine primitive (children adopt into the target
- *   by staying under the source, which the target's claim displays),
- *   `mergeBackward`/`mergeForward` reproduce the baseline command shape.
- *
- */
-import { type BlockId } from '../placement/model.js';
-import type { DocBase, DocReads } from './reads.js';
-/** The capability of the facade over its reads. */
-export declare const docCapability: (c: DocBase & DocReads) => {
-    canPlace: (ids: readonly BlockId[], parent?: BlockId | null, kindOf?: (id: BlockId) => string | undefined) => boolean;
-    isContainer: (id: BlockId) => boolean;
-    fits: (parent: BlockId | null, kind: string | undefined) => boolean;
-    fitsIn: (parentType: string, kind: string | undefined) => boolean;
-    fitted: (parent: BlockId | null, kind: string | undefined) => string | undefined;
-    emptiable: (id: BlockId) => boolean;
-    nestParent: (ids: readonly BlockId[], parent: BlockId) => BlockId;
-    canMerge: (fromId: BlockId, intoId: BlockId) => boolean;
-    rendersContent: (id: BlockId) => boolean;
-    defaultChild: (parent: BlockId | null) => string;
-    kindToCopy: (id: BlockId) => string;
-};
-export type DocCapability = ReturnType<typeof docCapability>;

package/dist/crdt/doc/capability.js

@@ -1,207 +0,0 @@
-/**
- * Structural capability: one answer in advance and at execution.
- *
- * ── Island/void enforcement (operation-layer, not stored) ──────────────
- *
- * Roles are resolved operation-time via `config.roleOf(type)`, through one
- * role table (`DisplayRoles`) that the index's display and every guard
- * below ask of a block's shown kind — the editor derives them from plugin
- * block definitions, exactly like the baseline's
- * `block.definition.island/void`. They are deliberately NOT replicated block
- * data: the schema stays policy-free, and a replica with different plugins
- * reads the same document. Enforced rules (baseline semantics, see
- * `plugins.ts` + `block.utils.ts`):
- *
- * - `void`: cannot accept children (insert/move/nest into void rejected),
- *   cannot merge either direction, cannot be split. Content edits ARE
- *   allowed — void rendered content (captions) stays editable per the
- *   baseline contract. Deletion is allowed (delete is not editing).
- * - `island`: editable content, but its subtree is structurally sealed —
- *   a block inside an island (`insideIsland`) cannot be moved, nested,
- *   unnested, or merged across the island boundary. Merges INSIDE one
- *   island are allowed; merging an island child into the island itself is
- *   allowed when the island renders its content. Moving or merging
- *   INTO an island subtree is rejected. An island declared `lines` (code)
- *   holds only lines of its `defaultChild` kind, and a line holds no
- *   children (the display enforces it against undo,
- *   `insertBlocks` refuses a line parent); any other island keeps its
- *   structure. `canPlace` and `canMerge` are the one answer, asked in
- *   advance or by the ops.
- * - Island merge: when an island block itself is merged (backward or
- *   forward), its children are unnested to the vacated sibling slot and
- *   reset to the default child of that slot's parent (`defaultChild`).
- * - Baseline merges NEVER adopt the merged block's children — they unnest
- *   to the vacated slot. The facade exposes both: `mergeBlocks` is the
- *   engine primitive (children adopt into the target
- *   by staying under the source, which the target's claim displays),
- *   `mergeBackward`/`mergeForward` reproduce the baseline command shape.
- *
- */
-import { isLiveIn } from '../placement/model.js';
-/** The capability of the facade over its reads. */
-export const docCapability = (c) => {
-    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isVoid, isIsland, islandOf, insideIsland, holdsLayout, insideItem, isRowKind, isCellKind, displayLength } = c;
-    // ── structural capability: one answer in advance and at execution ──
-    /**
-     * May `ids` be placed under `parent` (`null` = the root)? Every id is
-     * live, distinct and outside any island interior (island subtrees are
-     * sealed); the destination is live, neither void nor an island nor
-     * inside one, and not inside any moved block's own subtree; and every
-     * block fits it as the kind `kindOf` gives (`fits`; a move keeps its
-     * kind) or already sits in it (a reorder changes nothing a list holds:
-     * an image shed into a list still moves among its items); and
-     * no layout, nor a block holding one, lands inside a layout item
-     * (`layout.nest`). A table's cell never moves, and its row only
-     * within its table (`table.fits`).
-     * Without a `parent`: may these blocks move at all (the drag
-     * affordance). The move ops refuse exactly when this answers `false`.
-     * (`insertBlock` is looser — island interiors are built by inserting
-     * into them.)
-     */
-    const canPlace = (ids, parent, kindOf = blockTypeOf) => {
-        const v = view();
-        if (ids.length === 0 || new Set(ids).size !== ids.length)
-            return false;
-        if (ids.some((id) => !isLiveIn(v, id) || insideIsland(id, v)))
-            return false;
-        // A cell moves only with its column, never as a block (`table.fits`).
-        if (ids.some((id) => isCellKind(blockTypeOf(id))))
-            return false;
-        // A row moves only within its table: a table's rows are reordered, never re-homed.
-        const rows = ids.filter((id) => isRowKind(blockTypeOf(id)));
-        if (rows.length > 0 && parent !== undefined)
-            if (parent === null || rows.some((id) => positionOf(id)?.parent !== parent))
-                return false;
-        if (parent === undefined || parent === null)
-            return true;
-        if (!isLiveIn(v, parent) || isVoid(parent))
-            return false;
-        const stays = (id) => positionOf(id)?.parent === parent;
-        if (!ids.every((id) => stays(id) || fits(parent, kindOf(id))))
-            return false;
-        if (insideItem(parent, v) && ids.some(holdsLayout))
-            return false;
-        return ![parent, ...ancestorsOf(parent, v)].some((a) => isIsland(a) || ids.includes(a));
-    };
-    /**
-     * A container: a block that shows only its children — no content of
-     * its own, neither void nor an island (a list, a table row, a column).
-     */
-    const isContainer = (id) => roles.of(blockTypeOf(id) ?? '').container;
-    /**
-     * THE container rule: may a block of `kind` sit directly
-     * under `parent` (`null` = the root)? A container whose default child is
-     * a kind of its own — its item (a list's `list-item`, a columns
-     * layout's `column`) — holds only its items, and containers of them
-     * when the item renders content (a list directly in a list, from JSON
-     * or the API; a layout holds no layout, `layout.fits`); one whose
-     * default child is the document's (a column) holds any block. Every
-     * structural placement asks it: a move is refused where its blocks do
-     * not fit (`canPlace`), Tab nests under a container's last item
-     * (`nestParent`), an outdent or a lift is refused where the block would
-     * not fit, and a block a merge, delete or range sheds into a container
-     * takes its item kind when it is a plain block (`fitted`). Explicit kind
-     * writes (`insertBlocks`, a retype) place what they are told (the
-     * view's Turn into places the kind where it fits first, `liftOut`); a
-     * plain block stored directly in a list still shows as its item (the
-     * index's `typeOf`), whatever write or race put it there.
-     */
-    const fits = (parent, kind) => parent === null || fitsIn(blockTypeOf(parent) ?? '', kind);
-    /** `fits`, by the parent's kind (a block not written yet: `placeBeside`'s new item). */
-    const fitsIn = (parentType, kind) => {
-        const { container, child: item } = roles.of(parentType);
-        if (!container || item === defaultChild(null) || kind === item)
-            return true;
-        const k = kind === undefined ? undefined : roles.of(kind);
-        return k?.container === true && k.child === item && roles.of(item).rendersContent;
-    };
-    /**
-     * `kind`, or — where a plain block (the document's default kind, or
-     * none: a pasted run) does not fit `parent` — `parent`'s item, when
-     * that renders content (a paragraph landing in a list is its item; one
-     * in a columns layout keeps its kind: its text never vanishes). Any
-     * other kind keeps its kind and data wherever a merge, a delete or a
-     * paste sheds it — an image under a bullet stays an image, a heading a
-     * heading, a to-do keeps its check — as a peer's
-     * concurrent promotion shows it (`typeOf` resets only the default
-     * kind); an outdent or a move that would place one directly in a list
-     * is refused (`fits`).
-     */
-    const fitted = (parent, kind) => {
-        if (fits(parent, kind) || (kind !== undefined && kind !== defaultChild(null)))
-            return kind;
-        const item = defaultChild(parent);
-        return roles.of(item).rendersContent ? item : kind;
-    };
-    /** A container that goes once it loses every child: it holds no text of its own (a peer's retype can leave some, hidden: it renders none). */
-    const emptiable = (id) => isContainer(id) && displayLength(id) === 0;
-    /**
-     * Where `ids` nest when nested into `parent` (Tab, a drop inside it):
-     * `parent`, or — a container they are no items of — its last child,
-     * and so on down. Tab after a list nests under its last item (Notion);
-     * a last child that holds no children (an image, a code block) is
-     * answered as it is, and `canPlace` refuses it, as Tab right under
-     * that block is refused.
-     */
-    const nestParent = (ids, parent) => {
-        let at = parent;
-        while (!ids.every((id) => fits(at, blockTypeOf(id)))) {
-            const last = childrenIds(at).at(-1);
-            if (last === undefined)
-                break;
-            at = last;
-        }
-        return at;
-    };
-    /**
-     * May `fromId`'s content merge into `intoId`? Both live and distinct,
-     * neither void, `intoId` renders its content (a list, a table row or a
-     * code block shows none, so a first item, cell or line never merges
-     * into it), `fromId` renders its own unless it is
-     * an island (a list or a row never merges as a whole: its items would
-     * leave it, `del.merge.container`), and the merge stays on one side of an island
-     * boundary (a block may merge into its own island root — that stays
-     * inside — but nothing from outside merges into an island).
-     */
-    const canMerge = (fromId, intoId) => {
-        const v = view();
-        if (fromId === intoId || !isLiveIn(v, fromId) || !isLiveIn(v, intoId))
-            return false;
-        if (isVoid(fromId) || isVoid(intoId))
-            return false;
-        // Nothing merges into or out of a table's cell (`table.merge`).
-        if (isCellKind(blockTypeOf(fromId)) || isCellKind(blockTypeOf(intoId)))
-            return false;
-        if (!rendersContent(intoId) || !(rendersContent(fromId) || isIsland(fromId)))
-            return false;
-        const islandFrom = islandOf(fromId, v);
-        if (intoId === islandFrom)
-            return true;
-        return islandFrom === islandOf(intoId, v) && !isIsland(intoId);
-    };
-    /** `id`'s shown kind renders its content. */
-    const rendersContent = (id) => roles.of(blockTypeOf(id) ?? '').rendersContent;
-    /** The adopted default child type under `parent` (`null` = the root). */
-    const defaultChild = (parent) => roles.of(parent === null ? null : (blockTypeOf(parent) ?? null)).child;
-    /**
-     * The kind a new block copies from `id` (a split tail, a flow's tail,
-     * a duplicate and each of its descendants). A type a peer's retype is
-     * replacing can be missing while its new value is pending: the copy
-     * then takes its parent's default child, never a missing type
-     * (it showed as `unknown` everywhere, for good).
-     */
-    const kindToCopy = (id) => blockTypeOf(id) ?? defaultChild(positionOf(id)?.parent ?? null);
-    return {
-        canPlace,
-        isContainer,
-        fits,
-        fitsIn,
-        fitted,
-        emptiable,
-        nestParent,
-        canMerge,
-        rendersContent,
-        defaultChild,
-        kindToCopy
-    };
-};

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

@@ -1,16 +0,0 @@
-import type { BlockId, InlineSpec } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** An inline atom to insert: its id is minted when it names none. */
-export type NewInline = Omit<InlineSpec, 'id'> & {
-    id?: string;
-};
-/** The content ops of one facade, prepared. */
-export declare const contentOps: (c: OpsContext) => {
-    insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
-    deleteText: (id: BlockId, offset: number, length: number) => Prepared;
-    formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
-    clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-    insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
-    removeInline: (id: BlockId, inlineId: string) => Prepared;
-};

package/dist/crdt/doc/content.js

@@ -1,77 +0,0 @@
-/**
- * Content ops: text and inline atoms in a block's display (allowed
- * inside voids — the caption contract), and marks over a range.
- */
-import { sanitizeWireJson, jsonEquals } from '../../utils/json.js';
-import { id as newId } from '../../utils.js';
-import { ref, sanitizeInline } from './plan.js';
-/** The content ops of one facade, prepared. */
-export const contentOps = (c) => {
-    const { contentTarget, REFUSED, plan, clamp, atomOf, textIn } = c;
-    // content ops (allowed inside voids — caption contract)
-    const insertText = (id, offset, text, marks) => {
-        id = ref(id);
-        const clean = ref(text);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at] = clamp(id, offset, 0);
-        const m = marks && sanitizeWireJson(marks);
-        return plan([id], clean === '' ? [] : [{ op: 'insertText', id, offset: at, text: clean, marks: m }]);
-    };
-    const deleteText = (id, offset, length) => {
-        id = ref(id);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        return plan([id], end > at ? [{ op: 'deleteText', id, offset: at, length: end - at }] : []);
-    };
-    /**
-     * Multi-mark format over a range (values may be null = unset); planned
-     * only when some text atom in the range carries a different value.
-     */
-    const formatRange = (id, offset, length, marks) => {
-        id = ref(id);
-        const clean = sanitizeWireJson(marks);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        // Planned only when some text atom carries another value (the same-value guard).
-        const differs = textIn(id, at, end).some((item) => Object.keys(clean).some((k) => !jsonEquals(item.marks?.[k] ?? null, clean[k] ?? null)));
-        return plan([id], differs ? [{ op: 'formatRange', id, offset: at, length: end - at, marks: clean }] : []);
-    };
-    /**
-     * Baseline `removeMarksFromText`: every mark present anywhere in the
-     * range is unset over the range. Names are discovered from the content.
-     */
-    const clearMarks = (id, offset, length) => {
-        const clears = {};
-        for (const item of textIn(ref(id), offset, offset + length)) {
-            for (const k of Object.keys(item.marks ?? {}))
-                clears[k] = null;
-        }
-        return formatRange(id, offset, length, clears);
-    };
-    /** An atom without an id gets a fresh one. */
-    const insertInline = (id, offset, atom) => {
-        id = ref(id);
-        const clean = sanitizeInline({ ...atom, id: atom.id ?? newId('i') });
-        if (!contentTarget(id))
-            return REFUSED;
-        return plan([id], [{ op: 'insertInline', id, offset: clamp(id, offset, 0)[0], atom: clean }]);
-    };
-    const removeInline = (id, inlineId) => {
-        id = ref(id);
-        const atom = atomOf(id, ref(inlineId));
-        if (atom === undefined)
-            return REFUSED;
-        return plan([id], [{ op: 'removeInline', id, offset: atom.at, inlineId: ref(inlineId) }]);
-    };
-    return {
-        insertText,
-        deleteText,
-        formatRange,
-        clearMarks,
-        insertInline,
-        removeInline
-    };
-};

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

@@ -1,15 +0,0 @@
-/**
- * Block deletion (`del.blocks.promote`): only the members leave, the
- * unselected children of a deleted block take its slot.
- */
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The delete ops of one facade, prepared. */
-export declare const deleteOps: (c: OpsContext) => {
-    deleteBlocks: (ids: readonly BlockId[], subtree?: boolean, filled?: BlockId | null) => Prepared;
-    deleteBlock: (id: BlockId, opts?: {
-        keepChildren?: boolean;
-    }) => Prepared;
-};
-export type DeleteOps = ReturnType<typeof deleteOps>;

package/dist/crdt/doc/delete.js

@@ -1,84 +0,0 @@
-import { ref } from './plan.js';
-/** The delete ops of one facade, prepared. */
-export const deleteOps = (c) => {
-    const { view, blockTypeOf, childrenIds, positionOf, ancestorsOf, itemKindOf, isLayout, isLayoutItem, isTable, isTableRow, live, REFUSED, plan, settle, emptyingAll, emptied, deleting, remove } = c;
-    /**
-     * Delete a set of blocks (`del.blocks.promote`): this writer's mark on
-     * every member and on what it displays through merge claims (wins over
-     * concurrent moves). Only the members leave: the unselected children of a
-     * deleted block take its slot, in order, with their subtrees, as the
-     * kind they show there (`settledKind`: a deleted island's children take
-     * the slot parent's default child, a deleted list's items leave its
-     * kind, a block promoted into a list is its item). A container the delete leaves with no child goes too
-     * (`del.range.empty-container`). `subtree` is the explicit whole-subtree
-     * delete. `filled`: a parent the same plan fills again (a flow placed in
-     * the deleted blocks' slot, `flow.slot`), which is never emptied, so its
-     * layout never dissolves (`layout.flow-slot`).
-     */
-    const deleteBlocks = (ids, subtree = false, filled) => {
-        const set = new Set(ids.map(ref));
-        if ([...set].some((id) => !live(id)))
-            return REFUSED;
-        // A layout goes with its items: their blocks take its slot (`layout.dissolving`).
-        for (const id of [...set])
-            if (isLayout(id))
-                for (const kid of childrenIds(id))
-                    if (isLayoutItem(kid))
-                        set.add(kid);
-        // A table goes with its rows and cells, a row with its cells: none shows outside them (`table.delete-row`).
-        const whole = (id) => {
-            for (const kid of childrenIds(id)) {
-                set.add(kid);
-                whole(kid);
-            }
-        };
-        for (const id of [...set])
-            if (isTable(id) || isTableRow(id))
-                whole(id);
-        if (subtree) {
-            const roots = [...set].filter((id) => !ancestorsOf(id).some((a) => set.has(a)));
-            return plan(roots, emptied(roots, roots.map((id) => remove(id))));
-        }
-        const roots = [...set].filter((id) => !set.has(positionOf(id).parent));
-        const { kids } = view();
-        const promoting = new Set();
-        const members = [];
-        const writes = roots.flatMap((root) => {
-            const pos = positionOf(root);
-            const chunk = [];
-            const kept = [];
-            // The kept children keep their home slots: the read shows them in the
-            // root's slot, in its order (a block a peer puts under a member
-            // meanwhile takes the slot in that order too); only their kinds are
-            // written, as the slot's parent settles them.
-            const walk = (b) => {
-                chunk.push(b);
-                for (const kid of kids.get(b) ?? []) {
-                    if (set.has(kid.id))
-                        walk(kid.id);
-                    else
-                        kept.push({ id: kid.id, from: b });
-                }
-            };
-            walk(root);
-            members.push(...chunk);
-            if (kept.length > 0)
-                promoting.add(root);
-            // A layout shows only its items: a deleted item's blocks show right
-            // after the layout (`layout.only-items`), settled for its parent.
-            const item = pos.parent === null ? undefined : itemKindOf(pos.parent);
-            const out = (k) => item !== undefined && blockTypeOf(k.id) !== item;
-            return [
-                ...kept.flatMap((k) => settle(k.from, [k.id], out(k) ? positionOf(pos.parent).parent : pos.parent)),
-                deleting(root, chunk)
-            ];
-        });
-        return plan(roots, emptyingAll(roots.filter((r) => !promoting.has(r)).map((id) => positionOf(id).parent), roots.filter((r) => !promoting.has(r)), writes, filled === undefined ? undefined : new Set([filled]), members));
-    };
-    /** Delete `id` — its children take its slot (`keepChildren: false`: the whole subtree). */
-    const deleteBlock = (id, opts = {}) => deleteBlocks([id], opts.keepChildren === false);
-    return {
-        deleteBlocks,
-        deleteBlock
-    };
-};

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

@@ -1,9 +0,0 @@
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The layout ops of one facade, prepared. */
-export declare const layoutOps: (c: OpsContext) => {
-    besideAt: (target: BlockId, kind?: string) => BlockId;
-    placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
-    wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
-};