smartrte-core 0.2.1 → 1.0.0-beta.1

package/dist/foundation/scope/resolveScope.js

@@ -0,0 +1,860 @@
+import { isTextNode } from "../identity.js";
+import { occupancyGridFor } from "../table/index.js";
+const pathKey = (path) => path.join("/");
+const copyPos = (pos) => ({ path: [...pos.path], offset: pos.offset });
+const copyRange = (range) => ({ from: copyPos(range.from), to: copyPos(range.to) });
+const typeKey = (type) => type.toLowerCase().replace(/-/g, "_");
+const fallbackRole = (type) => {
+    const key = typeKey(type);
+    if (key === "list")
+        return "list";
+    if (key === "list_item" || key === "listitem")
+        return "list-item";
+    if (key === "table")
+        return "table";
+    if (key === "table_row" || key === "tablerow")
+        return "table-row";
+    if (["table_cell", "table_header", "table_header_cell", "tablecell"].includes(key))
+        return "table-cell";
+    return null;
+};
+/** The single semantic-role resolution boundary: explicit role, then legacy type fallback. */
+const roleOf = (node, schema) => schema.nodes[node.type]?.semanticRole ?? fallbackRole(node.type);
+const isList = (entry) => entry.role === "list";
+const isListItem = (entry) => entry.role === "list-item";
+const isTable = (entry) => entry.role === "table";
+const isTableRow = (entry) => entry.role === "table-row";
+const isTableCell = (entry) => entry.role === "table-cell";
+const schemaGroup = (node, schema) => {
+    if (node.type === "unknown") {
+        return node.attrs?.originalGroup === "inline" ? "inline" : "block";
+    }
+    return schema.nodes[node.type]?.group ?? "block";
+};
+const contentAcceptsInline = (node, schema) => {
+    const expression = schema.nodes[node.type]?.content;
+    return Boolean(expression && /(^|[^A-Za-z0-9_-])(?:inline|text)([^A-Za-z0-9_-]|$)/.test(expression));
+};
+const buildIndex = (document, schema) => {
+    const entries = [];
+    const byId = new Map();
+    const byPath = new Map();
+    let cursor = 0;
+    let preorder = 0;
+    const visit = (node, path, parent, index) => {
+        if (node.attrs?.["data-smart-ui"] === true) {
+            throw new Error("Editor UI nodes may not appear in the canonical model.");
+        }
+        if (byId.has(node.id))
+            throw new Error(`Duplicate node id "${node.id}".`);
+        const spec = schema.nodes[node.type];
+        const group = schemaGroup(node, schema);
+        const atomic = Boolean(spec?.atomic || node.type === "unknown");
+        const entry = {
+            node,
+            path: [...path],
+            parent,
+            children: [],
+            index,
+            depth: path.length,
+            preorder: preorder++,
+            open: cursor++,
+            contentStart: cursor,
+            contentEnd: cursor,
+            end: cursor,
+            inlineOwner: !atomic && contentAcceptsInline(node, schema),
+            group,
+            atomic,
+            isolating: Boolean(spec?.isolating),
+            role: roleOf(node, schema),
+            inlineChildren: [],
+        };
+        entries.push(entry);
+        byId.set(node.id, entry);
+        byPath.set(pathKey(path), entry);
+        if (entry.inlineOwner) {
+            let inlineOffset = 0;
+            for (const child of node.children || []) {
+                const width = isTextNode(child) ? child.text.length : 1;
+                entry.inlineChildren.push({ node: child, from: inlineOffset, to: inlineOffset + width });
+                if (isTextNode(child)) {
+                    cursor += width;
+                }
+                else {
+                    if (!schema.nodes[child.type]?.atomic && child.type !== "unknown") {
+                        throw new Error(`Inline child "${child.type}" must be atomic.`);
+                    }
+                    const atomStart = cursor;
+                    const atom = visit(child, [...path, entry.inlineChildren.length - 1], entry, entry.inlineChildren.length - 1);
+                    atom.open = atomStart;
+                    atom.contentStart = atomStart;
+                    atom.contentEnd = atomStart + 1;
+                    atom.end = atomStart + 1;
+                    cursor = atomStart + 1;
+                }
+                inlineOffset += width;
+            }
+        }
+        else if (!atomic) {
+            (node.children || []).forEach((child, childIndex) => {
+                if (!isTextNode(child))
+                    entry.children.push(visit(child, [...path, childIndex], entry, childIndex));
+                else
+                    cursor += child.text.length;
+            });
+        }
+        entry.contentEnd = cursor;
+        entry.end = cursor++;
+        return entry;
+    };
+    const root = visit(document, [], null, 0);
+    const hasBlockDescendant = (entry) => entry.children.some((child) => (child.group === "block" && !isListItem(child) && !isTableRow(child) && !isTableCell(child)) || hasBlockDescendant(child));
+    const blocks = entries.filter((entry) => entry.group === "block"
+        && !isListItem(entry)
+        && !isTableRow(entry)
+        && !isTableCell(entry)
+        && (entry.atomic || !hasBlockDescendant(entry)));
+    const atoms = entries.filter((entry) => entry.atomic);
+    return { root, entries, byId, byPath, blocks, blockSet: new Set(blocks), atoms };
+};
+/** Reuses every cached entry/map when node identity says topology is unchanged. */
+const refreshIndex = (index, document, schema) => {
+    const update = (entry, node) => {
+        if (entry.node === node)
+            return true;
+        if (entry.node.id !== node.id || entry.node.type !== node.type)
+            return false;
+        entry.node = node;
+        entry.isolating = Boolean(schema.nodes[node.type]?.isolating);
+        entry.role = roleOf(node, schema);
+        if (entry.inlineOwner) {
+            const beforeAtoms = entry.inlineChildren.filter((child) => !isTextNode(child.node)).map((child) => child.node.id);
+            const afterAtoms = (node.children || []).filter((child) => !isTextNode(child)).map((child) => child.id);
+            if (beforeAtoms.length !== afterAtoms.length || beforeAtoms.some((id, position) => id !== afterAtoms[position]))
+                return false;
+            let offset = 0;
+            entry.inlineChildren = (node.children || []).map((child) => {
+                const from = offset;
+                offset += isTextNode(child) ? child.text.length : 1;
+                if (!isTextNode(child)) {
+                    const atom = index.byId.get(child.id);
+                    if (!atom || !update(atom, child))
+                        return { node: child, from, to: offset };
+                }
+                return { node: child, from, to: offset };
+            });
+            return true;
+        }
+        const children = (node.children || []).filter((child) => !isTextNode(child));
+        if (children.length !== entry.children.length)
+            return false;
+        for (let position = 0; position < children.length; position += 1) {
+            if (children[position].id !== entry.children[position].node.id || !update(entry.children[position], children[position]))
+                return false;
+        }
+        return true;
+    };
+    if (!update(index.root, document))
+        return false;
+    let cursor = 0;
+    const reflow = (entry) => {
+        entry.open = cursor++;
+        entry.contentStart = cursor;
+        if (entry.inlineOwner) {
+            entry.inlineChildren.forEach((child) => {
+                if (isTextNode(child.node))
+                    cursor += child.node.text.length;
+                else {
+                    const atom = index.byId.get(child.node.id);
+                    if (atom) {
+                        atom.open = cursor;
+                        atom.contentStart = cursor;
+                        atom.contentEnd = cursor + 1;
+                        atom.end = cursor + 1;
+                    }
+                    cursor += 1;
+                }
+            });
+        }
+        else if (!entry.atomic)
+            entry.children.forEach(reflow);
+        entry.contentEnd = cursor;
+        entry.end = cursor++;
+    };
+    reflow(index.root);
+    return true;
+};
+const limitFor = (entry) => entry.inlineOwner
+    ? entry.inlineChildren.reduce((size, child) => Math.max(size, child.to), 0)
+    : entry.children.length;
+const nodeAroundInlineOffset = (entry, offset, before) => {
+    const children = entry.inlineChildren;
+    if (before) {
+        for (let index = children.length - 1; index >= 0; index -= 1)
+            if (children[index].to <= offset)
+                return children[index].node;
+    }
+    else {
+        for (const child of children)
+            if (child.from >= offset)
+                return child.node;
+    }
+    return null;
+};
+/** The only place in the scope runtime that interprets stored SmartPos fields. */
+const resolveEndpoint = (index, pos) => {
+    const entry = index.byPath.get(pathKey(pos.path));
+    if (!entry)
+        throw new Error("A SmartPos path must resolve to an owning non-text node.");
+    if (entry.atomic)
+        throw new Error("A position cannot resolve inside an atomic node; address its owning container boundary.");
+    const limit = limitFor(entry);
+    if (!Number.isInteger(pos.offset) || pos.offset < 0 || pos.offset > limit) {
+        throw new Error(`Position offset ${pos.offset} is outside 0..${limit}.`);
+    }
+    const ancestors = [];
+    let cursor = entry;
+    while (cursor) {
+        ancestors.unshift(cursor.node);
+        cursor = cursor.parent;
+    }
+    const rank = entry.inlineOwner
+        ? entry.contentStart + pos.offset
+        : pos.offset < entry.children.length ? entry.children[pos.offset].open : entry.contentEnd;
+    const resolved = {
+        pos: copyPos(pos),
+        kind: entry.inlineOwner ? "inline" : "structural",
+        nodeId: entry.node.id,
+        parent: entry.node,
+        depth: entry.depth,
+        affinity: "backward",
+        ancestors,
+        nodeBefore: entry.inlineOwner
+            ? nodeAroundInlineOffset(entry, pos.offset, true)
+            : pos.offset > 0 ? entry.node.children?.[pos.offset - 1] ?? null : null,
+        nodeAfter: entry.inlineOwner
+            ? nodeAroundInlineOffset(entry, pos.offset, false)
+            : pos.offset < limit ? entry.node.children?.[pos.offset] ?? null : null,
+        atStart: pos.offset === 0,
+        atEnd: pos.offset === limit,
+        indexAt(depth) {
+            if (!Number.isInteger(depth) || depth < 0 || depth >= pos.path.length)
+                throw new Error("Position depth is out of range.");
+            return pos.path[depth];
+        },
+    };
+    cursor = entry;
+    let isolation = null;
+    while (cursor) {
+        if (cursor.isolating) {
+            isolation = cursor;
+            break;
+        }
+        cursor = cursor.parent;
+    }
+    return { resolved, entry, rank, isolation };
+};
+const stablePosKey = (pos) => `${pos.path.map((part) => String(part).padStart(8, "0")).join(".")}:${String(pos.offset).padStart(12, "0")}`;
+const normalizeSelection = (index, selection) => {
+    const anchor = resolveEndpoint(index, selection.anchor);
+    const head = resolveEndpoint(index, selection.head);
+    const anchorFirst = anchor.rank < head.rank || (anchor.rank === head.rank && stablePosKey(anchor.resolved.pos) <= stablePosKey(head.resolved.pos));
+    return anchorFirst
+        ? { from: anchor, to: head, range: { from: copyPos(anchor.resolved.pos), to: copyPos(head.resolved.pos) } }
+        : { from: head, to: anchor, range: { from: copyPos(head.resolved.pos), to: copyPos(anchor.resolved.pos) } };
+};
+const atomicParentSpan = (entry) => {
+    if (!entry.atomic || !entry.parent)
+        return null;
+    if (entry.parent.inlineOwner) {
+        const span = entry.parent.inlineChildren.find((child) => !isTextNode(child.node) && child.node.id === entry.node.id);
+        return span ? { parent: entry.parent, from: span.from, to: span.to } : null;
+    }
+    return { parent: entry.parent, from: entry.index, to: entry.index + 1 };
+};
+const entryStartPos = (entry) => {
+    const atom = atomicParentSpan(entry);
+    return atom ? { path: [...atom.parent.path], offset: atom.from } : { path: [...entry.path], offset: 0 };
+};
+const entryEndPos = (entry) => {
+    const atom = atomicParentSpan(entry);
+    return atom ? { path: [...atom.parent.path], offset: atom.to } : { path: [...entry.path], offset: limitFor(entry) };
+};
+const afterEntryPos = (entry) => entry.parent
+    ? { path: [...entry.parent.path], offset: entry.index + 1 }
+    : entryEndPos(entry);
+const isAncestor = (ancestor, descendant) => {
+    let cursor = descendant;
+    while (cursor) {
+        if (cursor === ancestor)
+            return true;
+        cursor = cursor.parent;
+    }
+    return false;
+};
+const outermostIsolation = (entry) => {
+    let result = entry;
+    let cursor = entry.parent;
+    while (cursor) {
+        if (cursor.isolating)
+            result = cursor;
+        cursor = cursor.parent;
+    }
+    return result;
+};
+const spansIsolating = (index, from, to) => {
+    if (from.isolation?.node.id !== to.isolation?.node.id)
+        return true;
+    return index.entries.some((entry) => entry.isolating
+        && entry.open > from.rank
+        && entry.end < to.rank
+        && entry !== from.isolation);
+};
+/**
+ * Shared isolation clamp. To preserve the stronger reverse-selection invariant,
+ * the active side is the normalized document-order end rather than the mutable
+ * anchor/head direction. Table-grid may cross sibling cells in the same table.
+ */
+const clampToIsolating = (index, from, to, request) => {
+    const crossCellGrid = request.want === "table-grid"
+        && from.isolation && to.isolation
+        && isTableCell(from.isolation) && isTableCell(to.isolation)
+        && nearestAncestor(from.entry, isTable) === nearestAncestor(to.entry, isTable);
+    if (!spansIsolating(index, from, to) || crossCellGrid) {
+        return { from, to, range: { from: copyPos(from.resolved.pos), to: copyPos(to.resolved.pos) }, clamped: false };
+    }
+    if (to.isolation) {
+        const start = resolveEndpoint(index, entryStartPos(to.isolation));
+        const end = resolveEndpoint(index, entryEndPos(to.isolation));
+        const clampedFrom = from.rank < start.rank ? start : from;
+        const clampedTo = to.rank > end.rank ? end : to;
+        return {
+            from: clampedFrom,
+            to: clampedTo,
+            range: { from: copyPos(clampedFrom.resolved.pos), to: copyPos(clampedTo.resolved.pos) },
+            clamped: true,
+        };
+    }
+    const crossed = index.entries
+        .filter((entry) => entry.isolating && entry.end > from.rank && entry.open < to.rank)
+        .map(outermostIsolation)
+        .filter((entry, position, all) => all.indexOf(entry) === position)
+        .sort((left, right) => right.end - left.end)[0];
+    if (!crossed)
+        return { from, to, range: { from: copyPos(from.resolved.pos), to: copyPos(to.resolved.pos) }, clamped: false };
+    const clampedFrom = resolveEndpoint(index, afterEntryPos(crossed));
+    return {
+        from: clampedFrom,
+        to,
+        range: { from: copyPos(clampedFrom.resolved.pos), to: copyPos(to.resolved.pos) },
+        clamped: true,
+    };
+};
+const nearestAncestor = (entry, predicate) => {
+    let cursor = entry;
+    while (cursor) {
+        if (predicate(cursor))
+            return cursor;
+        cursor = cursor.parent;
+    }
+    return null;
+};
+const commonAncestor = (entries) => {
+    if (!entries.length)
+        return null;
+    let cursor = entries[0];
+    while (cursor) {
+        if (entries.every((entry) => isAncestor(cursor, entry)))
+            return cursor;
+        cursor = cursor.parent;
+    }
+    return null;
+};
+const baseFor = (context, isolation) => ({
+    range: copyRange(context.range),
+    isolatingAncestorId: (isolation === undefined ? commonIsolation(context) : isolation)?.node.id ?? null,
+    clamped: context.clamped,
+    ...(context.clampReason ? { clampReason: context.clampReason } : {}),
+});
+const commonIsolation = (context) => {
+    const left = context.from.isolation;
+    const right = context.to.isolation;
+    return left && left === right ? left : null;
+};
+const emptyScope = (context) => ({ kind: "empty", ...baseFor(context) });
+const overlaps = (entry, from, to) => entry.contentStart < to && entry.contentEnd >= from;
+const containingBlock = (context, endpoint) => nearestAncestor(endpoint.entry, (entry) => context.index.blockSet.has(entry));
+const touchedBlocks = (context) => {
+    if (context.from.rank === context.to.rank) {
+        const block = containingBlock(context, context.to);
+        return block ? [block] : [];
+    }
+    const first = containingBlock(context, context.from);
+    const last = containingBlock(context, context.to);
+    if (first && first === last)
+        return [first];
+    return context.index.blocks.filter((entry) => {
+        if (entry.contentStart === entry.contentEnd)
+            return entry.contentStart > context.from.rank && entry.contentStart <= context.to.rank;
+        return entry.contentStart < context.to.rank && entry.contentEnd >= context.from.rank;
+    });
+};
+const blockPart = (context, blocks) => {
+    const first = blocks[0];
+    const last = blocks[blocks.length - 1];
+    const parents = new Set(blocks.map((entry) => entry.parent?.node.id ?? null));
+    return {
+        kind: "block-range",
+        ...baseFor(context),
+        blockIds: blocks.map((entry) => entry.node.id),
+        promotedFromPartial: context.from.rank > first.contentStart || context.to.rank < last.contentEnd,
+        commonParentId: parents.size === 1 ? [...parents][0] : null,
+    };
+};
+const ownerSlice = (entry, fromRank, toRank) => ({
+    from: Math.max(0, Math.min(limitFor(entry), fromRank - entry.contentStart)),
+    to: Math.max(0, Math.min(limitFor(entry), toRank - entry.contentStart)),
+});
+const resolveInlineRange = (context) => {
+    const owners = context.from.entry === context.to.entry && context.from.entry.inlineOwner
+        ? [context.from.entry]
+        : context.index.entries.filter((entry) => entry.inlineOwner && (context.from.rank === context.to.rank
+            ? context.from.entry === entry
+            : entry.contentStart < context.to.rank && entry.contentEnd >= context.from.rank));
+    if (!owners.length)
+        return emptyScope(context);
+    const runs = owners.map((owner) => {
+        const slice = ownerSlice(owner, context.from.rank, context.to.rank);
+        return {
+            ownerNodeId: owner.node.id,
+            from: slice.from,
+            to: slice.to,
+            containsAtoms: owner.inlineChildren.some((child) => !isTextNode(child.node) && child.from < slice.to && child.to > slice.from),
+        };
+    });
+    const collapsed = context.from.rank === context.to.rank;
+    return {
+        kind: "inline-range",
+        ...baseFor(context),
+        runs,
+        collapsed,
+        ...(collapsed ? { storedMarkAnchor: context.from.resolved } : {}),
+    };
+};
+const resolveBlockRange = (context) => {
+    const blocks = touchedBlocks(context);
+    if (!blocks.length)
+        return emptyScope(context);
+    return blockPart(context, blocks);
+};
+const subtreeIds = (root) => {
+    const result = [];
+    const visit = (entry) => {
+        result.push(entry.node.id);
+        entry.children.forEach(visit);
+        entry.inlineChildren.forEach((child) => {
+            if (!isTextNode(child.node))
+                result.push(child.node.id);
+        });
+    };
+    visit(root);
+    return result;
+};
+const resolveContainerTree = (context, stopAt) => {
+    const blocks = touchedBlocks(context);
+    if (!blocks.length)
+        return emptyScope(context);
+    let root = commonAncestor(blocks) ?? blocks[0];
+    if (stopAt) {
+        const stops = blocks.map((block) => nearestAncestor(block, (entry) => stopAt(entry.node))).filter((entry) => Boolean(entry));
+        if (stops.length === blocks.length && stops.every((entry) => entry === stops[0]))
+            root = stops[0];
+    }
+    const first = blocks[0];
+    const last = blocks[blocks.length - 1];
+    return {
+        kind: "container-tree",
+        ...baseFor(context),
+        rootId: root.node.id,
+        nodeIds: subtreeIds(root),
+        promotedFromPartial: context.from.rank > first.contentStart || context.to.rank < last.contentEnd,
+    };
+};
+const atomSelectedExactly = (context, atom) => {
+    if (atom.group === "inline") {
+        const owner = atom.parent;
+        const span = owner?.inlineChildren.find((child) => !isTextNode(child.node) && child.node.id === atom.node.id);
+        return Boolean(owner && span
+            && context.from.entry === owner && context.to.entry === owner
+            && context.from.resolved.pos.offset === span.from && context.to.resolved.pos.offset === span.to);
+    }
+    const parent = atom.parent;
+    return Boolean(parent
+        && context.from.entry === parent && context.to.entry === parent
+        && context.from.resolved.pos.offset === atom.index
+        && context.to.resolved.pos.offset === atom.index + 1);
+};
+const atomsTouched = (context) => context.from.rank === context.to.rank ? [] : context.index.atoms.filter((atom) => {
+    if (atomSelectedExactly(context, atom))
+        return true;
+    if (context.from.rank === context.to.rank)
+        return false;
+    if (atom.group === "inline") {
+        const owner = atom.parent;
+        const span = owner?.inlineChildren.find((child) => !isTextNode(child.node) && child.node.id === atom.node.id);
+        if (!owner || !span)
+            return false;
+        const slice = ownerSlice(owner, context.from.rank, context.to.rank);
+        return context.from.entry === owner || context.to.entry === owner || overlaps(owner, context.from.rank, context.to.rank)
+            ? span.from < slice.to && span.to > slice.from
+            : false;
+    }
+    return atom.open < context.to.rank && atom.end > context.from.rank;
+});
+const atomScope = (context, atom) => ({
+    kind: "atomic-node",
+    ...baseFor(context, nearestAncestor(atom, (entry) => entry.isolating)),
+    nodeId: atom.node.id,
+    inline: atom.group === "inline",
+});
+const resolveAtomicNode = (context) => {
+    const atoms = atomsTouched(context).filter((atom) => atomSelectedExactly(context, atom));
+    if (!atoms.length)
+        return emptyScope(context);
+    if (atoms.length === 1)
+        return atomScope(context, atoms[0]);
+    return { kind: "mixed", ...baseFor(context), parts: atoms.map((atom) => atomScope(context, atom)) };
+};
+const touchedListItems = (context) => {
+    if (context.from.rank === context.to.rank) {
+        const item = nearestAncestor(context.to.entry, isListItem);
+        return item ? [item] : [];
+    }
+    // A ranged selection wholly inside one nested list must resolve to that
+    // list, not to every ancestor list item whose content interval contains the
+    // descendant.  Ancestor intervals intentionally include nested content for
+    // block promotion, but list-type commands act on the nearest list whose
+    // items the user actually selected.  When the endpoints belong to
+    // different list levels we retain the broader traversal below so a range
+    // that genuinely crosses a parent/child boundary still promotes to the
+    // containing list.
+    const fromItem = nearestAncestor(context.from.entry, isListItem);
+    const toItem = nearestAncestor(context.to.entry, isListItem);
+    const fromList = fromItem ? nearestAncestor(fromItem.parent ?? fromItem, isList) : null;
+    const toList = toItem ? nearestAncestor(toItem.parent ?? toItem, isList) : null;
+    if (fromList && fromList === toList) {
+        return context.index.entries.filter((entry) => isListItem(entry)
+            && isAncestor(fromList, entry)
+            && overlaps(entry, context.from.rank, context.to.rank)
+            && !(entry === toItem && endpointAtContentStart(context.to, entry)));
+    }
+    return context.index.entries.filter((entry) => isListItem(entry) && overlaps(entry, context.from.rank, context.to.rank));
+};
+const listDepth = (item, list) => {
+    let depth = 0;
+    let cursor = item.parent;
+    while (cursor && cursor !== list) {
+        if (isList(cursor))
+            depth += 1;
+        cursor = cursor.parent;
+    }
+    return depth;
+};
+/**
+ * A range ending at the first editable position of a list item has not
+ * entered that item yet. Entry content ranges include the item's wrapper and
+ * first block, so a raw rank overlap would otherwise promote the endpoint
+ * item as well (and can turn a one-item deletion into a whole-list deletion).
+ */
+const firstContentEntry = (entry) => {
+    if (entry.inlineOwner || entry.atomic || !entry.children.length)
+        return entry;
+    return firstContentEntry(entry.children[0]);
+};
+const endpointAtContentStart = (endpoint, entry) => {
+    const first = firstContentEntry(entry);
+    return endpoint.entry === first && endpoint.resolved.pos.offset === 0;
+};
+const listPart = (context, list, items) => {
+    const selected = new Set(items);
+    const hasChildList = (item) => context.index.entries.some((entry) => isList(entry) && entry !== list && isAncestor(item, entry));
+    const partialSubtree = items.some((item) => hasChildList(item)
+        && context.index.entries.some((entry) => isListItem(entry) && isAncestor(item, entry) && entry !== item && !selected.has(entry)));
+    return {
+        kind: "list-selection",
+        ...baseFor(context),
+        listId: list.node.id,
+        items: items.map((item) => ({ itemId: item.node.id, depth: listDepth(item, list), hasChildList: hasChildList(item) })),
+        partialSubtree,
+        promotedFromPartial: context.from.rank > items[0].contentStart || context.to.rank < items[items.length - 1].contentEnd,
+    };
+};
+const selectedListRoot = (item, selected) => {
+    let list = nearestAncestor(item.parent ?? item, isList);
+    if (!list)
+        return null;
+    while (true) {
+        const ownerItem = nearestAncestor(list.parent ?? list, isListItem);
+        if (!ownerItem || !selected.has(ownerItem))
+            return list;
+        const outer = nearestAncestor(ownerItem.parent ?? ownerItem, isList);
+        if (!outer)
+            return list;
+        list = outer;
+    }
+};
+const resolveListSelection = (context) => {
+    const items = touchedListItems(context);
+    const selected = new Set(items);
+    const groups = new Map();
+    items.forEach((item) => {
+        const list = selectedListRoot(item, selected);
+        if (list)
+            groups.set(list, [...(groups.get(list) || []), item]);
+    });
+    const parts = [...groups].map(([list, listItems]) => ({
+        order: list.preorder,
+        scope: listPart(context, list, listItems),
+    }));
+    const plainBlocks = touchedBlocks(context).filter((block) => !nearestAncestor(block, isListItem));
+    if (plainBlocks.length)
+        parts.push({ order: plainBlocks[0].preorder, scope: blockPart(context, plainBlocks) });
+    parts.sort((left, right) => left.order - right.order);
+    if (!parts.length)
+        return emptyScope(context);
+    if (parts.length === 1)
+        return parts[0].scope;
+    return { kind: "mixed", ...baseFor(context), parts: parts.map((part) => part.scope) };
+};
+const endpointCell = (endpoint) => nearestAncestor(endpoint.entry, isTableCell);
+const touchedCells = (context, table) => {
+    if (context.from.rank === context.to.rank) {
+        const cell = endpointCell(context.to);
+        return cell && isAncestor(table, cell) ? [cell] : [];
+    }
+    return context.index.entries.filter((entry) => isTableCell(entry) && isAncestor(table, entry) && overlaps(entry, context.from.rank, context.to.rank));
+};
+const tablePart = (context, table) => {
+    const grid = occupancyGridFor(table.node);
+    const fromCell = endpointCell(context.from);
+    const toCell = endpointCell(context.to);
+    let selected;
+    if (fromCell && toCell && context.from.resolved.pos && context.to.resolved.pos) {
+        const first = grid.anchors.find((cell) => cell.cellId === fromCell.node.id);
+        const last = grid.anchors.find((cell) => cell.cellId === toCell.node.id);
+        if (first && last && context.from.resolved.pos && context.to.resolved.pos && fromCell !== toCell) {
+            const bounds = {
+                top: Math.min(first.top, last.top), left: Math.min(first.left, last.left),
+                bottom: Math.max(first.bottom, last.bottom), right: Math.max(first.right, last.right),
+            };
+            selected = grid.anchors.filter((cell) => cell.top >= bounds.top && cell.left >= bounds.left && cell.top < bounds.bottom && cell.left < bounds.right);
+        }
+        else {
+            const touched = new Set(touchedCells(context, table).map((entry) => entry.node.id));
+            selected = grid.anchors.filter((cell) => touched.has(cell.cellId));
+        }
+    }
+    else {
+        const touched = new Set(touchedCells(context, table).map((entry) => entry.node.id));
+        selected = grid.anchors.filter((cell) => touched.has(cell.cellId));
+    }
+    if (!selected.length)
+        return emptyScope(context);
+    const rect = {
+        top: Math.min(...selected.map((cell) => cell.top)),
+        left: Math.min(...selected.map((cell) => cell.left)),
+        bottom: Math.max(...selected.map((cell) => cell.bottom)) - 1,
+        right: Math.max(...selected.map((cell) => cell.right)) - 1,
+    };
+    const selectedSet = new Set(selected.map((cell) => cell.cellId));
+    const covered = new Set();
+    let rectangular = true;
+    for (let row = rect.top; row <= rect.bottom; row += 1) {
+        for (let column = rect.left; column <= rect.right; column += 1) {
+            const occupant = grid.at(row, column);
+            if (!occupant || !selectedSet.has(occupant.cellId))
+                rectangular = false;
+            if (occupant && (occupant.top < rect.top || occupant.left < rect.left))
+                covered.add(occupant.cellId);
+        }
+    }
+    if (selected.some((cell) => cell.bottom - 1 > rect.bottom || cell.right - 1 > rect.right))
+        rectangular = false;
+    return {
+        kind: "table-grid",
+        ...baseFor(context, nearestAncestor(table, (entry) => entry.isolating)),
+        tableId: table.node.id,
+        rect,
+        cellIds: selected.map((cell) => cell.cellId),
+        coveredCellIds: [...covered],
+        rectangular,
+    };
+};
+const resolveTableGrid = (context) => {
+    const tables = new Set();
+    const fromTable = nearestAncestor(context.from.entry, isTable);
+    const toTable = nearestAncestor(context.to.entry, isTable);
+    if (fromTable)
+        tables.add(fromTable);
+    if (toTable)
+        tables.add(toTable);
+    if (fromTable !== toTable || !fromTable)
+        context.index.entries.forEach((entry) => {
+            if (isTable(entry) && overlaps(entry, context.from.rank, context.to.rank))
+                tables.add(entry);
+        });
+    const parts = [...tables].sort((a, b) => a.preorder - b.preorder).map((table) => tablePart(context, table)).filter((part) => part.kind === "table-grid");
+    if (!parts.length)
+        return emptyScope(context);
+    if (parts.length === 1)
+        return parts[0];
+    return { kind: "mixed", ...baseFor(context), parts };
+};
+const markKey = (mark) => JSON.stringify([mark.type, mark.attrs ?? null]);
+const marksForRange = (context) => {
+    if (context.from.rank === context.to.rank && context.from.entry.inlineOwner) {
+        const offset = context.from.resolved.pos.offset;
+        // A collapsed caret strictly inside a run (not at any run boundary) has
+        // exactly one containing run - `from <= offset <= to` - regardless of
+        // how many other runs the owner has. At an exact boundary between two
+        // runs, both the preceding and following run satisfy that inequality;
+        // prefer the preceding one (`to === offset`), matching this function's
+        // original tie-break (continuing the run just typed/edited, not the
+        // one about to be entered). The previous version only ever found a run
+        // via that boundary tie-break, which by construction never matches a
+        // caret that isn't at some run's edge - a collapsed caret anywhere in
+        // the interior of a run (the overwhelmingly common case) silently
+        // returned no marks at all.
+        const touching = context.from.entry.inlineChildren.filter((candidate) => candidate.from <= offset && offset <= candidate.to);
+        const child = touching.find((candidate) => candidate.to === offset) ?? touching[0];
+        return child && isTextNode(child.node)
+            ? child.node.marks?.map((mark) => ({ mark, coverage: "all" })) || []
+            : [];
+    }
+    const occurrences = new Map();
+    let total = 0;
+    context.index.entries.filter((entry) => entry.inlineOwner).forEach((owner) => {
+        const slice = ownerSlice(owner, context.from.rank, context.to.rank);
+        owner.inlineChildren.forEach((child) => {
+            if (!isTextNode(child.node))
+                return;
+            const width = Math.max(0, Math.min(child.to, slice.to) - Math.max(child.from, slice.from));
+            if (!width)
+                return;
+            total += width;
+            (child.node.marks || []).forEach((mark) => {
+                const key = markKey(mark);
+                const current = occurrences.get(key);
+                occurrences.set(key, { mark, covered: (current?.covered || 0) + width });
+            });
+        });
+    });
+    return [...occurrences.values()].map(({ mark, covered }) => ({ mark, coverage: covered === total ? "all" : "partial" }));
+};
+const describeSelection = (unclamped) => {
+    const blocks = touchedBlocks(unclamped);
+    const canonical = unclamped.to;
+    const item = nearestAncestor(canonical.entry, isListItem);
+    const list = item ? nearestAncestor(item.parent ?? item, isList) : null;
+    const cell = endpointCell(canonical);
+    const table = cell ? nearestAncestor(cell.parent ?? cell, isTable) : null;
+    return {
+        blockTypes: [...new Set(blocks.map((entry) => entry.node.type))],
+        marks: marksForRange(unclamped),
+        inList: list && item ? { listId: list.node.id, depth: listDepth(item, list) } : null,
+        inTable: table && cell ? { tableId: table.node.id, cellId: cell.node.id } : null,
+        isolatingAncestorId: canonical.isolation?.node.id ?? null,
+        atoms: atomsTouched(unclamped).map((entry) => entry.node.id),
+        collapsed: unclamped.from.rank === unclamped.to.rank,
+        spansIsolatingBoundary: spansIsolating(unclamped.index, unclamped.from, unclamped.to),
+    };
+};
+const contextFor = (index, schema, original, from, to, range, clamped) => ({
+    index,
+    schema,
+    original: copyRange(original),
+    from,
+    to,
+    range: copyRange(range),
+    clamped,
+    ...(clamped ? { clampReason: "isolating" } : {}),
+});
+const resolveWithIndex = (index, selection, request, schema) => {
+    const normalized = normalizeSelection(index, selection);
+    const unclamped = contextFor(index, schema, normalized.range, normalized.from, normalized.to, normalized.range, false);
+    if (request.want === "describe")
+        return describeSelection(unclamped);
+    const clamped = clampToIsolating(index, normalized.from, normalized.to, request);
+    const context = contextFor(index, schema, normalized.range, clamped.from, clamped.to, clamped.range, clamped.clamped);
+    switch (request.want) {
+        case "inline-range": return resolveInlineRange(context);
+        case "block-range": return resolveBlockRange(context);
+        case "container-tree": return resolveContainerTree(context, request.stopAt);
+        case "list-selection": return resolveListSelection(context);
+        case "table-grid": return resolveTableGrid(context);
+        case "atomic-node": return resolveAtomicNode(context);
+    }
+};
+const outerRange = (entry) => {
+    if (!entry.parent)
+        return { from: entryStartPos(entry), to: entryEndPos(entry) };
+    const atom = atomicParentSpan(entry);
+    if (atom)
+        return {
+            from: { path: [...atom.parent.path], offset: atom.from },
+            to: { path: [...atom.parent.path], offset: atom.to },
+        };
+    return {
+        from: { path: [...entry.parent.path], offset: entry.index },
+        to: { path: [...entry.parent.path], offset: entry.index + 1 },
+    };
+};
+const lookupFor = (index) => ({
+    positionOf(nodeId) {
+        const entry = index.byId.get(nodeId);
+        if (!entry)
+            return null;
+        return resolveEndpoint(index, outerRange(entry).from).resolved;
+    },
+    rangeOf(nodeId) {
+        const entry = index.byId.get(nodeId);
+        return entry ? copyRange(outerRange(entry)) : null;
+    },
+    contentRangeOf(nodeId) {
+        const entry = index.byId.get(nodeId);
+        if (!entry)
+            return null;
+        if (entry.atomic)
+            return copyRange(outerRange(entry));
+        return { from: entryStartPos(entry), to: entryEndPos(entry) };
+    },
+    exists(nodeId) { return index.byId.has(nodeId); },
+});
+export class FoundationScopeIndex {
+    constructor() {
+        this.document = null;
+        this.schema = null;
+        this.index = null;
+    }
+    update(document, schema) {
+        if (this.document === document && this.schema === schema && this.index)
+            return this.index;
+        if (this.schema === schema && this.index && refreshIndex(this.index, document, schema)) {
+            this.document = document;
+            return this.index;
+        }
+        this.document = document;
+        this.schema = schema;
+        this.index = buildIndex(document, schema);
+        return this.index;
+    }
+    resolve(document, selection, request, schema) {
+        return resolveWithIndex(this.update(document, schema), selection, request, schema);
+    }
+    positions(document, schema) {
+        return lookupFor(this.update(document, schema));
+    }
+    get liveNodeCount() { return this.index?.entries.length ?? 0; }
+}
+export const createScopeIndex = () => new FoundationScopeIndex();
+export const resolveScope = (document, selection, request, schema) => resolveWithIndex(buildIndex(document, schema), selection, request, schema);