edytor 1.0.0-rc.2 → 1.0.0

package/dist/events/beforeInputDeleteCommands.js

@@ -1,14 +1,10 @@
 import { Text } from '../text/text.svelte.js';
-import { dispatchPlan } from '../block/block.utils.js';
-import { prepareDeleteContent } from '../edytor.utils.js';
+import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { deleteSelectedBlocks, deleteSelectedRange } from '../selection/replaceSelection.js';
-import { shown } from '../selection/visibility.js';
-import { caretAt } from '../session/attempt.js';
-import { getNextWordEndOffset, getPreviousWordStartOffset } from '../text/wordBoundary.js';
-/** A forward delete at a live composition's region keeps the preview (the IME owns it). */
-const isForwardDeleteInsideActiveComposition = (edytor, snapshot) => snapshot.inputType === 'deleteContentForward' &&
-    snapshot.isCollapsed &&
-    Boolean(snapshot.startText && edytor.composition.covers(snapshot.startText, snapshot.yStart));
+import { shown, viewOf } from '../selection/visibility.js';
+import { blockSelection } from '../session/selection.js';
+import { INTENTS, caretAt } from '../session/attempt.js';
+import { getNextGraphemeEnd, getNextWordEndOffset, getPreviousGraphemeStart, getPreviousWordStartOffset } from '../text/wordBoundary.js';
 /**
  * Merge `from` into a collapsed toggle's header `into`, as the key's merge:
  * one plan that deletes the seam from the header's end to `from`'s start,
@@ -17,165 +13,134 @@ const isForwardDeleteInsideActiveComposition = (edytor, snapshot) => snapshot.in
  * refuses all of it. Nothing when the document refuses the merge (an island).
  */
 const mergeIntoHeader = (edytor, from, into, backward) => {
+    const { facade, dispatcher } = edytor;
     const [end, start] = [into.lastText, from.firstText];
-    if (!end || !start || !('writes' in edytor.facade.prepare.mergeBlocks(from.id, into.id)))
+    if (!end || !start || !('writes' in facade.prepare.mergeBlocks(from.id, into.id)))
         return;
-    const seam = { startText: end, yStart: end.length, endText: start, yEnd: 0 };
-    const plan = () => prepareDeleteContent.call(edytor, { replace: true, selection: seam });
+    const seam = () => facade.prepare.replaceRange({ block: into.id, offset: end.segStart + end.length }, { block: from.id, offset: start.segStart }, viewOf(edytor));
     if (backward)
-        dispatchPlan(from, 'mergeBlockBackward', {}, plan, [from.parent]);
+        dispatcher.plan('mergeBackward', [from.id], seam, from);
     else
-        dispatchPlan(into, 'mergeBlockForward', {}, plan, [from.parent]);
+        dispatcher.plan('mergeForward', [into.id], seam, into);
 };
 /**
- * The line a forward merge into a collapsed toggle's header joins: `block`,
- * or for a container (a list) its first item's, descending as the
- * document's `mergeForward` does; the seam range then removes a container
- * left with no item.
+ * Delete at the caret's text edge, one character inside it: the inline
+ * atom beside the edge, else the character, the caret staying at its side.
  */
-const firstLine = (block) => {
-    while (block.isContainer && block.children[0])
-        block = block.children[0];
-    return block;
+export const deleteInText = (edytor, text, yStart, back, atEdge) => {
+    const { content } = text.parent;
+    if (!atEdge) {
+        // One character is one grapheme, at the caret as it is now (anchored: a
+        // peer's edit since the occurrence moved it).
+        const value = text.stringContent;
+        const at = edytor.selection.textRange().yStart;
+        const [start, end] = back
+            ? [getPreviousGraphemeStart(value, at), at]
+            : [at, getNextGraphemeEnd(value, at)];
+        if (end > start)
+            edytor.deleteText(text.parent.id, text.segStart + start, end - start);
+        return edytor.selection.selectText(text, back ? start : yStart);
+    }
+    const index = content.indexOf(text) + (back ? -1 : 1);
+    const before = back ? content.at(index - 1) : text;
+    // Read before the removal joins the texts beside the atom.
+    const offset = back && before instanceof Text ? before.length : yStart;
+    const atom = content.at(index);
+    if (atom instanceof InlineBlock)
+        edytor.removeInline(text.parent.id, atom.id);
+    if (before instanceof Text)
+        edytor.selection.selectText(before, offset);
 };
 const deleteContentForward = (edytor, snapshot) => {
     const { startText, yStart } = snapshot;
-    if (!startText) {
-        return;
-    }
-    if (isForwardDeleteInsideActiveComposition(edytor, snapshot)) {
-        edytor.selection.setAtTextOffset(startText, yStart);
-        return;
-    }
-    if (snapshot.isAtEndOfBlock) {
-        const currentBlock = startText.parent;
-        if (currentBlock.definition.void) {
-            edytor.selection.setAtTextOffset(startText, yStart);
-            return;
-        }
-        const nextBlock = shown(currentBlock, 'blockAfter');
-        if (nextBlock?.definition.void) {
-            edytor.selection.selectBlocks(nextBlock);
-            return;
-        }
-        if (nextBlock === currentBlock.closestNextBlock)
-            currentBlock.mergeBlockForward();
-        else if (nextBlock)
-            mergeIntoHeader(edytor, firstLine(nextBlock), currentBlock, false);
-        caretAt(edytor, startText, yStart);
-        return;
-    }
-    if (snapshot.isAtEndOfText) {
-        const index = startText.parent.content.indexOf(startText) + 1;
-        startText.parent.removeInlineBlock({ index });
-        edytor.selection.setAtTextOffset(startText, yStart);
+    if (!startText)
         return;
+    const current = startText.parent;
+    // At a live composition's region the preview stays (the IME owns it).
+    const keep = edytor.composition.covers(startText, yStart) ||
+        (snapshot.projection.isAtEndOfBlock && current.definition.void);
+    if (keep || !snapshot.projection.isAtEndOfBlock)
+        return keep
+            ? edytor.selection.selectText(startText, yStart)
+            : deleteInText(edytor, startText, yStart, false, snapshot.projection.isAtEndOfText);
+    const next = shown(current, 'blockAfter');
+    if (next?.definition.void)
+        return edytor.selection.select(blockSelection([next.id]));
+    if (next === current.closestNextBlock)
+        edytor.mergeForward(current.id);
+    else if (next) {
+        // A forward merge into a collapsed toggle's header joins its first line:
+        // a container's (a list's) first item, as the document's `mergeForward`.
+        let line = next;
+        while (line.isContainer && line.children[0])
+            line = line.children[0];
+        mergeIntoHeader(edytor, line, current, false);
     }
-    startText.deleteText({ direction: 'FORWARD', length: 1 });
-    edytor.selection.setAtTextOffset(startText, yStart);
-};
-/**
- * Backspace at the start of a catalogue kind other than its parent's default
- * (a bullet, a to-do, a heading) turns it into that default first, keeping
- * its content and children (`del.start.kind`, Notion); the next Backspace
- * merges or unnests. Structural kinds outside the catalogue (a `list-item`,
- * a `codeLine`) keep the structural path.
- */
-const resetKindAtStart = (edytor, snapshot) => {
-    const block = snapshot.startText?.parent;
-    if (!snapshot.isAtStartOfBlock || !block?.convertible || !block.parent)
-        return false;
-    const type = edytor.defaultChild(block.parent);
-    if (block.type === type || !edytor.kinds.some((row) => row.value.type === block.type)) {
-        return false;
-    }
-    block.setBlock({ value: { type, data: {} } });
-    caretAt(edytor, block.firstText, 0);
-    return true;
+    caretAt(edytor, startText, yStart);
 };
 const deleteContentBackward = (edytor, snapshot) => {
     const { startText, yStart } = snapshot;
-    if (resetKindAtStart(edytor, snapshot))
-        return;
-    // A table's cell keeps its caret at its start: nothing merges into or out of
-    // a cell, and it never outdents (`table.merge`).
-    const cell = startText?.parent;
-    if (snapshot.isAtStartOfBlock && cell && edytor.facade.isTableCell(cell.id)) {
-        edytor.selection.setAtTextOffset(startText, 0);
+    const block = startText?.parent;
+    if (!block)
         return;
+    if (!snapshot.projection.isAtStartOfBlock)
+        return deleteInText(edytor, startText, yStart, true, snapshot.projection.isAtStartOfText);
+    const { facade, root } = edytor;
+    const parent = block.parent;
+    // At the start of a catalogue kind other than its parent's default (a
+    // bullet, a to-do, a heading), it turns into that default first, keeping
+    // its content and children (`del.start.kind`, Notion); structural kinds
+    // outside the catalogue (a `list-item`, a `codeLine`) keep the structural path.
+    const type = parent && edytor.defaultChild(parent);
+    if (block.convertible &&
+        type &&
+        block.type !== type &&
+        edytor.kinds.some((row) => row.value.type === block.type)) {
+        edytor.setBlock(block.id, { type, data: {} });
+        return caretAt(edytor, block.firstText, 0);
     }
-    if (snapshot.isAtStartOfBlock && snapshot.isFirstChildOfDocument && startText?.parent.isEmpty) {
-        edytor.selection.setAtTextOffset(startText, 0);
+    const at = facade.positionOf(block.id);
+    // A table's cell keeps its caret at its start: nothing merges into or out
+    // of a cell, and it never outdents (`table.merge`); nor does the
+    // document's first block, empty.
+    if (facade.isTableCell(block.id) || (block.isEmpty && at?.parent === null && at.index === 0))
+        return edytor.selection.selectText(startText, 0);
+    const island = edytor.idToBlock.get(edytor.selection.projection.islandRoot ?? '');
+    // A column's block never outdents (nothing but a column sits in a layout):
+    // it merges, across columns in reading order (`layout.merge`).
+    const inColumn = !!parent && !parent.isRoot && facade.isLayoutItem(parent.id);
+    const last = !!at && at.index === facade.childrenIds(at.parent).length - 1;
+    if (parent !== root && last && !island && !inColumn) {
+        if (edytor.unNestBlock(block.id).status === 'applied')
+            edytor.selection.selectText(block.firstText, 0);
         return;
     }
-    if (!startText) {
+    if (island && island.children.length === 1)
+        return edytor.selection.select(blockSelection([island.id]));
+    if (island && block.index === 0)
         return;
-    }
-    if (snapshot.isAtStartOfBlock) {
-        const { facade } = edytor;
-        const column = startText.parent.parent;
-        // A column's block never outdents (nothing but a column sits in a layout):
-        // it merges, across columns in reading order (`layout.merge`).
-        const inColumn = !!column && !column.isRoot && facade.isLayoutItem(column.id);
-        if (snapshot.isNested && snapshot.isLastChild && !snapshot.islandRoot && !inColumn) {
-            const newBlock = startText.parent.unNestBlock();
-            if (newBlock) {
-                edytor.selection.setAtTextOffset(newBlock.firstText, 0);
-            }
-            return;
-        }
-        if (snapshot.islandRoot && snapshot.islandRoot.children.length === 1) {
-            edytor.selection.selectBlocks(snapshot.islandRoot);
-            return;
-        }
-        if (snapshot.islandRoot &&
-            snapshot.islandRoot.children.length > 1 &&
-            startText.parent.index === 0) {
-            return;
-        }
-        const block = startText.parent;
-        // A column's first block joins the line before its column (and, in the first,
-        // before its layout), as the document's merge does (`layout.merge`).
-        const structure = (at) => inColumn &&
-            block.index === 0 &&
-            !!at &&
-            (facade.isLayout(at.id) || facade.isLayoutItem(at.id));
-        let previousBlock = shown(block, 'blockBefore');
-        let closest = block.closestPreviousBlock;
-        while (structure(previousBlock))
-            previousBlock = shown(previousBlock, 'blockBefore');
-        while (structure(closest))
-            closest = closest.closestPreviousBlock;
-        if (previousBlock?.definition.void) {
-            edytor.selection.selectBlocks(previousBlock);
-            return;
-        }
-        const previousText = previousBlock?.lastText;
-        const offset = previousText?.length;
-        if (previousBlock === closest)
-            block.mergeBlockBackward();
-        else if (previousBlock)
-            mergeIntoHeader(edytor, block, previousBlock, true);
-        if (typeof offset === 'number')
-            caretAt(edytor, previousText, offset);
-        // A list's first item lifts out of it: the caret stays at its start.
-        else if (previousBlock === block.parent)
-            caretAt(edytor, block.firstText, 0);
-        return;
-    }
-    if (snapshot.isAtStartOfText) {
-        const index = startText.parent.content.indexOf(startText) - 1;
-        const previousText = startText.parent.content.at(index - 1);
-        const hasPreviousText = previousText && previousText instanceof Text;
-        const offset = hasPreviousText ? previousText.length : 0;
-        startText.parent.removeInlineBlock({ index });
-        if (hasPreviousText) {
-            edytor.selection.setAtTextOffset(previousText, offset);
-        }
-        return;
-    }
-    const deletion = startText.deleteText({ direction: 'BACKWARD', length: 1 });
-    edytor.selection.setAtTextOffset(startText, deletion?.start ?? yStart - 1);
+    // A column's first block joins the line before its column (and, in the first,
+    // before its layout), as the document's merge does (`layout.merge`).
+    const structure = (b) => inColumn && block.index === 0 && !!b && (facade.isLayout(b.id) || facade.isLayoutItem(b.id));
+    let previous = shown(block, 'blockBefore');
+    let closest = block.closestPreviousBlock;
+    while (structure(previous))
+        previous = shown(previous, 'blockBefore');
+    while (structure(closest))
+        closest = closest.closestPreviousBlock;
+    if (previous?.definition.void)
+        return edytor.selection.select(blockSelection([previous.id]));
+    const previousText = previous?.lastText;
+    const offset = previousText?.length;
+    if (previous === closest)
+        edytor.mergeBackward(block.id);
+    else if (previous)
+        mergeIntoHeader(edytor, block, previous, true);
+    if (offset !== undefined)
+        caretAt(edytor, previousText, offset);
+    // A list's first item lifts out of it: the caret stays at its start.
+    else if (previous === parent)
+        caretAt(edytor, block.firstText, 0);
 };
 /**
  * The caret's line edge in one direction (`del.unit.soft-line`): a soft line
@@ -200,69 +165,53 @@ const lineEdge = (text, at, backward, soft) => {
     }
 };
 /**
- * A collapsed unit delete (`del.unit.*`): the model owns the extent — a word
- * run from the caret's own text, the caret's line to either side, or the
- * whole block — deleted as one range; the caret lands at its start.
+ * The model command of a delete intent. A block selection: every delete key
+ * (a word or line chord too) deletes the blocks as Backspace does —
+ * `onDeleteSelectedBlocks` first, children promoted (a drag or composition
+ * fragment is not a key). A range: the document's range deletion (a forward
+ * one needs its text). A collapsed caret: the intent's unit (`del.unit.*`),
+ * whose extent the model owns — a character; a word run from the caret's own
+ * text, the caret's line to either side, or the whole block, deleted as one
+ * range, the caret at its start; a cut, drag or composition fragment deletes
+ * nothing. A unit with nothing of the caret's own text in its direction
+ * (next to an inline atom, at the block's edge) is the neighbour, deleted
+ * like a character (atom, merge, unnest).
  */
-const deleteCollapsedUnit = (edytor, snapshot) => {
-    const { startText: text, yStart, inputType } = snapshot;
-    if (!text)
-        return;
-    const [first, last] = [text.parent.firstText, text.parent.lastText];
-    const soft = inputType.startsWith('deleteSoftLine');
-    const [from, to] = inputType === 'deleteWordBackward'
-        ? [
-            [text, getPreviousWordStartOffset(text.stringContent, yStart)],
-            [text, yStart]
-        ]
-        : inputType === 'deleteWordForward'
-            ? [
-                [text, yStart],
-                [text, getNextWordEndOffset(text.stringContent, yStart)]
-            ]
-            : inputType === 'deleteEntireSoftLine'
-                ? [
-                    [first, 0],
-                    [last, last.length]
-                ]
-                : inputType.endsWith('Backward')
-                    ? [lineEdge(text, yStart, true, soft), [text, yStart]]
-                    : [[text, yStart], lineEdge(text, yStart, false, soft)];
-    // Nothing of the caret's own text lies in the delete direction (the caret
-    // is at the text's edge: next to an inline atom, or at the block's edge):
-    // the unit is the neighbour, deleted like a character (atom, merge, unnest).
-    if (from[0] === to[0] && from[1] === to[1] && inputType !== 'deleteEntireSoftLine') {
-        return inputType.endsWith('Backward')
-            ? deleteContentBackward(edytor, snapshot)
-            : deleteContentForward(edytor, snapshot);
-    }
-    text.parent.deleteContentAtRange({ start: [from[0].index, from[1]], end: [to[0].index, to[1]] });
-    edytor.selection.setAtTextOffset(...from);
-};
 export const runBeforeInputDeleteCommand = (edytor, snapshot) => {
     // The Android post-delete snap-back's evidence (a named projector rule):
     // only an actual delete arms it, never a navigational jump.
     edytor.projector.deleted(snapshot);
-    const { inputType } = snapshot;
-    const forward = /Forward$|^deleteContent$|^deleteEntireSoftLine$/.test(inputType);
-    // A block selection: every delete key (a word or line chord too) deletes
-    // the blocks as Backspace does — `onDeleteSelectedBlocks` first, children
-    // promoted (a drag or composition fragment is not a key).
-    if (edytor.selection.selectedBlocks.size && !/^delete(ByDrag|ByComposition)$/.test(inputType)) {
-        deleteSelectedBlocks(edytor);
-        return;
-    }
-    // A selection: the document's range deletion (a forward one needs its text).
+    const { inputType, startText: text, yStart } = snapshot;
+    const { dir, unit } = INTENTS[inputType] ?? {};
+    const back = !unit || dir === 'back';
+    if (edytor.selection.selectedBlocks.size && !/^delete(ByDrag|ByComposition)$/.test(inputType))
+        return deleteSelectedBlocks(edytor);
     if (!snapshot.isCollapsed) {
-        if (!forward || snapshot.startText)
+        if (back || text)
             deleteSelectedRange(edytor, { selection: snapshot });
         return;
     }
-    if (inputType === 'deleteContentBackward')
-        return deleteContentBackward(edytor, snapshot);
-    if (inputType === 'deleteContentForward' || inputType === 'deleteContent')
-        return deleteContentForward(edytor, snapshot);
-    // A collapsed cut, drag or composition fragment deletes nothing.
-    if (!/^delete(ByCut|ByDrag|ByComposition)$/.test(inputType))
-        return deleteCollapsedUnit(edytor, snapshot);
+    if (!unit || !text)
+        return;
+    const byChar = () => back ? deleteContentBackward(edytor, snapshot) : deleteContentForward(edytor, snapshot);
+    if (unit === 'char')
+        return byChar();
+    const [first, last] = [text.parent.firstText, text.parent.lastText];
+    const word = back
+        ? getPreviousWordStartOffset(text.stringContent, yStart)
+        : getNextWordEndOffset(text.stringContent, yStart);
+    const edge = unit === 'word' ? [text, word] : lineEdge(text, yStart, back, unit === 'soft');
+    const [from, to] = unit === 'line'
+        ? [
+            [first, 0],
+            [last, last.length]
+        ]
+        : back
+            ? [edge, [text, yStart]]
+            : [[text, yStart], edge];
+    if (unit !== 'line' && from[0] === to[0] && from[1] === to[1])
+        return byChar();
+    const at = from[0].segStart + from[1];
+    edytor.deleteText(text.parent.id, at, to[0].segStart + to[1] - at);
+    edytor.selection.selectText(...from);
 };

package/dist/events/domTextOffset.d.ts

@@ -1,12 +1,12 @@
 /**
- * Character offset of the DOM point `(node, offset)` inside `textNode`,
- * counting text content in document order — the one DOM→model point
- * mapper (`getYIndex` adds the editor's marker, boundary and filler rules
- * on top; `domPointOf` is its inverse). Two point shapes exist: a
- * text-node anchor carries a character offset; an element anchor
- * (Firefox's node-bound caret shape) carries a CHILD INDEX, so the text
- * content of the children before that index is counted instead. Points
- * outside `textNode` clamp to the nearest edge by document position —
- * an ancestor anchor resolves through the child-index boundary.
+ * Character offset of the DOM point `(node, offset)` inside `textNode`: the
+ * text of the text nodes before it, in document order (Svelte's anchors
+ * are comments and carry none) — the one DOM→model point mapper
+ * (`getYIndex` adds the editor's marker, boundary and filler rules on top;
+ * `domPointOf` is its inverse). A text-node point carries a character
+ * offset, an element point (Firefox's node-bound caret) a child index;
+ * either past its node's end clamps to it. A point outside `textNode` clamps
+ * to the nearest edge by document position (an ancestor's point resolves
+ * through its child index); a disconnected one keeps its offset.
  */
 export declare const getTextContentOffsetAtPoint: (textNode: Node, node: Node, offset: number) => number;

package/dist/events/domTextOffset.js

@@ -1,52 +1,24 @@
-const getChildTextLengthBeforeOffset = (element, offset) => {
-    let length = 0;
-    const end = Math.min(offset, element.childNodes.length);
-    for (let index = 0; index < end; index++) {
-        // Svelte's hydration comments carry data, never text.
-        const child = element.childNodes[index];
-        if (child.nodeType !== Node.COMMENT_NODE)
-            length += child.textContent?.length ?? 0;
-    }
-    return length;
-};
 /**
- * Character offset of the DOM point `(node, offset)` inside `textNode`,
- * counting text content in document order — the one DOM→model point
- * mapper (`getYIndex` adds the editor's marker, boundary and filler rules
- * on top; `domPointOf` is its inverse). Two point shapes exist: a
- * text-node anchor carries a character offset; an element anchor
- * (Firefox's node-bound caret shape) carries a CHILD INDEX, so the text
- * content of the children before that index is counted instead. Points
- * outside `textNode` clamp to the nearest edge by document position —
- * an ancestor anchor resolves through the child-index boundary.
+ * Character offset of the DOM point `(node, offset)` inside `textNode`: the
+ * text of the text nodes before it, in document order (Svelte's anchors
+ * are comments and carry none) — the one DOM→model point mapper
+ * (`getYIndex` adds the editor's marker, boundary and filler rules on top;
+ * `domPointOf` is its inverse). A text-node point carries a character
+ * offset, an element point (Firefox's node-bound caret) a child index;
+ * either past its node's end clamps to it. A point outside `textNode` clamps
+ * to the nearest edge by document position (an ancestor's point resolves
+ * through its child index); a disconnected one keeps its offset.
  */
 export const getTextContentOffsetAtPoint = (textNode, node, offset) => {
-    if (textNode !== node && !textNode.contains(node)) {
-        const position = textNode.compareDocumentPosition(node);
-        if (position & Node.DOCUMENT_POSITION_DISCONNECTED) {
-            return offset;
-        }
-        if (position & Node.DOCUMENT_POSITION_CONTAINS) {
-            // `node` is an ancestor of `textNode` — `offset` indexes its
-            // children, so the whole text sits on one side of the boundary.
-            let child = textNode;
-            while (child.parentNode && child.parentNode !== node) {
-                child = child.parentNode;
-            }
-            const index = child.parentNode === node ? Array.prototype.indexOf.call(node.childNodes, child) : -1;
-            return index !== -1 && index < offset ? (textNode.textContent?.length ?? 0) : 0;
-        }
-        return position & Node.DOCUMENT_POSITION_FOLLOWING ? (textNode.textContent?.length ?? 0) : 0;
-    }
-    const pointOffset = node.nodeType === Node.TEXT_NODE
-        ? Math.min(offset, node.textContent?.length ?? 0)
-        : getChildTextLengthBeforeOffset(node, offset);
-    let total = pointOffset;
-    const treeWalker = (textNode.ownerDocument ?? document).createTreeWalker(textNode, NodeFilter.SHOW_TEXT, (child) => child.compareDocumentPosition(node) === Node.DOCUMENT_POSITION_FOLLOWING
-        ? NodeFilter.FILTER_ACCEPT
-        : NodeFilter.FILTER_SKIP);
-    while (treeWalker.nextNode()) {
-        total += treeWalker.currentNode.textContent?.length ?? 0;
-    }
-    return total;
+    if (textNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_DISCONNECTED)
+        return offset;
+    const range = (textNode.ownerDocument ?? document).createRange();
+    range.selectNodeContents(textNode);
+    const at = Math.min(offset, node.nodeType === Node.TEXT_NODE ? node.length : node.childNodes.length);
+    const side = range.comparePoint(node, at);
+    if (side < 0)
+        return 0;
+    if (side === 0)
+        range.setEnd(node, at);
+    return range.toString().length;
 };

package/dist/events/events.utils.d.ts

@@ -1,3 +1 @@
-import type { Text } from '../text/text.svelte.js';
 export declare const isAndroidChromeBrowser: () => boolean;
-export declare const getTextPath: (text: Text) => number[];

package/dist/events/events.utils.js

@@ -7,7 +7,3 @@ export const isAndroidChromeBrowser = () => {
         /\bChrome\//i.test(userAgent) &&
         !/(Edg|OPR|SamsungBrowser)/i.test(userAgent));
 };
-export const getTextPath = (text) => {
-    const index = text.parent.content.findIndex((part) => part === text);
-    return [...text.parent.path, index === -1 ? text.index : index];
-};

package/dist/events/nativeInteractiveControl.d.ts

@@ -1,22 +1,15 @@
 export declare const isNativeInteractiveControl: (target: EventTarget | null) => boolean;
-export declare const isNativeFormControl: (target: EventTarget | null) => boolean;
 export declare const isNativeInteractiveEvent: (event: Event) => boolean;
 export declare const isNativeTextControl: (target: EventTarget | null) => boolean;
 export declare const isNativeTextControlEvent: (event: Event) => boolean;
-/**
- * The event target sits inside a nested `contenteditable` island that is
- * neither the editor root nor a managed text element (text elements
- * carry their own `contentEditable="true"`). Such islands — a plugin
- * chrome editor, an embedded code field — own their input/composition
- * lifecycle; the outer editor must not snapshot them against the model
- * selection or commit their composition text.
- */
-export declare const isNestedForeignEditableTarget: (editorRoot: Element | null | undefined, target: EventTarget | null) => boolean;
 /**
  * A kind's own control: a form control (`input` of any type, `textarea`,
- * `select`, `button`) or a nested editable island inside the host, never the
- * root nor the editor's own text elements. It owns its focus, selection and
- * events; the projector never writes the editor's caret over it.
+ * `select`, `button`) or a nested editable island inside the host (a plugin
+ * chrome editor, an embedded code field: it owns its input and composition
+ * lifecycle), never the root nor the editor's own text elements (they carry
+ * their own `contentEditable="true"`). It owns its focus, selection and
+ * events; the projector never writes the editor's caret over it, and the
+ * editor never snapshots it nor commits its composition text.
  */
 export declare const isKindControl: (editorRoot: Element | null | undefined, target: EventTarget | null) => boolean;
 /**
@@ -29,3 +22,10 @@ export declare const isKindControl: (editorRoot: Element | null | undefined, tar
  * `onDrop` all ask this.
  */
 export declare const ownsEvent: (editorRoot: Element | null | undefined, event: Event) => boolean;
+/**
+ * An event of a native control anywhere (a link, the chrome's buttons beside
+ * the host) or of a kind's own: never the view's own composition or input.
+ */
+export declare const isControlEvent: (editorRoot: Element | null | undefined, event: Event) => boolean;
+/** A DOM point of the view's own: inside the host and in no kind's own control. */
+export declare const isOwnPoint: (editorRoot: Element | null | undefined, node: Node | null | undefined) => boolean;