@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/ambient/ambient-cursor.js

@@ -1,120 +0,0 @@
-/**
- * Ambient-aware cursor I/O for prose contenteditable surfaces: raw ↔ DOM offset
- * translation that respects the leading ambient marker span a container block contributes
- * to its first prose child. Zero-ambient surfaces are first-class consumers —
- * `getAmbientLength: () => 0` reduces this to plain widget-aware translation.
- */
-import { asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
-import { domTextOffsetAtNode, findDomTextOffsetTarget } from '../cursor/widget-offset';
-import { ambientSpanOf, placeCaretAfterAmbientSpan } from './ambient-dom';
-export function createAmbientCursorIO(deps) {
-    function snapTargetRaw() {
-        const target = deps.getSnapTarget?.() ?? null;
-        return target === null ? null : asRawOffset(target);
-    }
-    function readLiveRange() {
-        const el = deps.getEl();
-        if (!el || document.activeElement !== el)
-            return { state: 'inactive' };
-        const sel = window.getSelection();
-        if (!sel || sel.rangeCount === 0)
-            return { state: 'dropped' };
-        const ambient = ambientSpanOf(el);
-        return {
-            state: 'live',
-            el,
-            range: sel.getRangeAt(0),
-            collapsed: sel.isCollapsed,
-            inAmbient: (node) => ambient !== null && ambient.contains(node)
-        };
-    }
-    function getRaw() {
-        const live = readLiveRange();
-        if (live.state === 'inactive')
-            return null;
-        // Dropped (Chromium loses element-level carets past atomic widgets) or rebounded
-        // into a contenteditable=false island: the snap target carries the user's intent.
-        if (live.state === 'dropped')
-            return snapTargetRaw();
-        if (live.inAmbient(live.range.startContainer))
-            return snapTargetRaw();
-        const content = domTextOffsetAtNode(live.el, live.range.startContainer, live.range.startOffset);
-        return toClampedRawOffset(content, deps.getAmbientLength());
-    }
-    function setToAmbientBoundary() {
-        const el = deps.getEl();
-        if (el)
-            placeCaretAfterAmbientSpan(el);
-    }
-    function setRaw(offset) {
-        const el = deps.getEl();
-        if (!el)
-            return;
-        const ambientLength = deps.getAmbientLength();
-        // Walking to position ambientLength lands inside the marker island, where Chromium
-        // bounces the caret out in front of the span. Use a sibling boundary instead.
-        if (ambientLength > 0 && offset <= 0) {
-            setToAmbientBoundary();
-            return;
-        }
-        const target = toDomTextOffset(offset, ambientLength);
-        const pos = findDomTextOffsetTarget(el, target);
-        if (!pos)
-            return;
-        // The walker's last-text-node fallback can land inside the marker text, where the
-        // contenteditable="false" island traps the caret.
-        const ambient = ambientSpanOf(el);
-        if (ambient && ambient.contains(pos.node)) {
-            setToAmbientBoundary();
-            return;
-        }
-        const range = document.createRange();
-        try {
-            range.setStart(pos.node, pos.offset);
-        }
-        catch {
-            return;
-        }
-        range.collapse(true);
-        const sel = window.getSelection();
-        sel?.removeAllRanges();
-        sel?.addRange(range);
-    }
-    function clampOutOfAmbient() {
-        // Liveness before the ambient read, as every other method here does it: the length is an
-        // owner-bound derived at the call site, and a surface unmounted mid-dispatch is a dead owner.
-        const live = readLiveRange();
-        if (live.state !== 'live' || !live.collapsed)
-            return;
-        const ambientLength = deps.getAmbientLength();
-        if (ambientLength === 0)
-            return;
-        const content = domTextOffsetAtNode(live.el, live.range.startContainer, live.range.startOffset);
-        if (content >= ambientLength)
-            return;
-        setToAmbientBoundary();
-    }
-    function getRawSelection() {
-        const live = readLiveRange();
-        if (live.state !== 'live' || live.collapsed)
-            return null;
-        // No snap-target fallback here, unlike `getRaw`: a single caret intent cannot stand
-        // in for one end of a pair, and the clamp below already maps the marker interior to
-        // raw 0 — the right boundary for a drag that began inside the marker.
-        return rawEndpointsOf(live.el, live.range, deps.getAmbientLength());
-    }
-    function rawRangeOf(range) {
-        const el = deps.getEl();
-        if (!el || !el.contains(range.startContainer) || !el.contains(range.endContainer))
-            return null;
-        return rawEndpointsOf(el, range, deps.getAmbientLength());
-    }
-    return { getRaw, setRaw, getRawSelection, rawRangeOf, clampOutOfAmbient, setToAmbientBoundary };
-}
-// ── Internal ────────────────────────────────────────────────────────────────
-function rawEndpointsOf(el, range, ambientLength) {
-    return {
-        start: toClampedRawOffset(domTextOffsetAtNode(el, range.startContainer, range.startOffset), ambientLength),
-        end: toClampedRawOffset(domTextOffsetAtNode(el, range.endContainer, range.endOffset), ambientLength)
-    };
-}

package/dist/components/blocks/code/code-paste.d.ts

@@ -1,24 +0,0 @@
-/**
- * Pure paste pipeline for fenced code blocks: splice the text in, then hand the
- * result to the write seam every route shares (`schema/fenced-code-raw.ts`).
- */
-export interface CodePasteInput {
-    display: string;
-    selection: {
-        start: number;
-        end: number;
-    };
-    pasted: string;
-    fenceMarker: '`' | '~';
-    fenceLength: number;
-    closed: boolean;
-}
-export interface CodePasteResult {
-    text: string;
-    cursor: number;
-}
-/**
- * A paste is literal content, so a run it lands — or forms against the bytes already
- * there — grows the fence instead of terminating the block.
- */
-export declare function computeCodePaste(input: CodePasteInput): CodePasteResult;

package/dist/components/blocks/code/code-paste.js

@@ -1,21 +0,0 @@
-/**
- * Pure paste pipeline for fenced code blocks: splice the text in, then hand the
- * result to the write seam every route shares (`schema/fenced-code-raw.ts`).
- */
-import { reconcileFenceWrite } from '../../../schema/fenced-code-raw';
-// ── Public API ──────────────────────────────────────────────────────────────
-/**
- * A paste is literal content, so a run it lands — or forms against the bytes already
- * there — grows the fence instead of terminating the block.
- */
-export function computeCodePaste(input) {
-    const { display, selection, pasted, fenceMarker, fenceLength, closed } = input;
-    const { start, end } = selection;
-    const written = reconcileFenceWrite({
-        display: display.slice(0, start) + pasted + display.slice(end),
-        caret: start + pasted.length,
-        fence: { marker: fenceMarker, length: fenceLength, closed },
-        mode: 'literal'
-    });
-    return { text: written.display, cursor: written.caret };
-}

package/dist/components/blocks/table/cell-clipboard.d.ts

@@ -1,33 +0,0 @@
-/**
- * Pure clipboard payload for an intra-table multi-cell rectangle; the component
- * owns the live ClipboardEvent wiring.
- */
-import type { DocumentGetter } from '../../../editor-keys';
-import type { SelectionState } from '../../../selection/selection-state.svelte';
-export interface CellClipboardDeps {
-    selection: SelectionState;
-    getDoc: DocumentGetter;
-}
-export interface IntraTableRect {
-    tablePath: number[];
-    anchorCellIdx: number;
-    focusCellIdx: number;
-}
-/**
- * Both endpoints share the table path, so each `offset` is a row-major cell index
- * (unflagged — see `selection/primitives` on context-established cell offsets). Callers
- * compare `tablePath` against their own; the rectangle belongs to at most one table.
- */
-export declare function intraTableRect(selection: SelectionState): IntraTableRect | null;
-/** The GFM sub-table for the current selection, or null when it isn't a rectangle. */
-export declare function intraTableRectPayload(deps: CellClipboardDeps): string | null;
-/** The rectangle's bounds in row/column terms, or null when the selection isn't one. */
-export declare function intraTableRectBounds(deps: CellClipboardDeps): {
-    tablePath: number[];
-    top: number;
-    left: number;
-    rows: number;
-    cols: number;
-} | null;
-/** The rectangle's cell texts as a grid (pipes unescaped), for the spreadsheet formats. */
-export declare function intraTableRectGrid(deps: CellClipboardDeps): string[][] | null;

package/dist/components/blocks/table/cell-clipboard.js

@@ -1,67 +0,0 @@
-/**
- * Pure clipboard payload for an intra-table multi-cell rectangle; the component
- * owns the live ClipboardEvent wiring.
- */
-import { metadataOf } from '../../../core/nodes';
-import { isBlockNode, nodeAt } from '../../../tree-operations/node-primitives';
-import { pathsEqual } from '../../../selection/path-math';
-import { cellRowCol } from '../../../cursor/coordinate-spaces';
-import { copyRectangleAsSubTable } from '../../../tree-operations/sub-table-copy';
-import { rectangleGrid } from '../../../tree-operations/table-grid-clipboard';
-/**
- * Both endpoints share the table path, so each `offset` is a row-major cell index
- * (unflagged — see `selection/primitives` on context-established cell offsets). Callers
- * compare `tablePath` against their own; the rectangle belongs to at most one table.
- */
-export function intraTableRect(selection) {
-    const { anchor, focus } = selection;
-    if (!selection.isCustomRendered || !anchor || !focus || !pathsEqual(anchor.path, focus.path)) {
-        return null;
-    }
-    return { tablePath: anchor.path, anchorCellIdx: anchor.offset, focusCellIdx: focus.offset };
-}
-/** The GFM sub-table for the current selection, or null when it isn't a rectangle. */
-export function intraTableRectPayload(deps) {
-    const rect = intraTableRect(deps.selection);
-    if (!rect)
-        return null;
-    const tableNode = nodeAt(deps.getDoc(), rect.tablePath);
-    if (!tableNode || !isBlockNode(tableNode) || tableNode.kind !== 'table')
-        return null;
-    const colCount = metadataOf(tableNode, 'table').columnCount;
-    const a = cellRowCol(rect.anchorCellIdx, colCount);
-    const b = cellRowCol(rect.focusCellIdx, colCount);
-    return copyRectangleAsSubTable(tableNode, { rowIdx: a.row, colIdx: a.col }, { rowIdx: b.row, colIdx: b.col });
-}
-/** The rectangle's bounds in row/column terms, or null when the selection isn't one. */
-export function intraTableRectBounds(deps) {
-    const rect = intraTableRect(deps.selection);
-    if (!rect)
-        return null;
-    const tableNode = nodeAt(deps.getDoc(), rect.tablePath);
-    if (!tableNode || !isBlockNode(tableNode) || tableNode.kind !== 'table')
-        return null;
-    const colCount = metadataOf(tableNode, 'table').columnCount;
-    const a = cellRowCol(rect.anchorCellIdx, colCount);
-    const b = cellRowCol(rect.focusCellIdx, colCount);
-    const top = Math.min(a.row, b.row);
-    const left = Math.min(a.col, b.col);
-    return {
-        tablePath: rect.tablePath,
-        top,
-        left,
-        rows: Math.max(a.row, b.row) - top + 1,
-        cols: Math.max(a.col, b.col) - left + 1
-    };
-}
-/** The rectangle's cell texts as a grid (pipes unescaped), for the spreadsheet formats. */
-export function intraTableRectGrid(deps) {
-    const bounds = intraTableRectBounds(deps);
-    if (!bounds)
-        return null;
-    const tableNode = nodeAt(deps.getDoc(), bounds.tablePath);
-    if (!tableNode || !isBlockNode(tableNode))
-        return null;
-    const { top, left, rows, cols } = bounds;
-    return rectangleGrid(tableNode, { rowIdx: top, colIdx: left }, { rowIdx: top + rows - 1, colIdx: left + cols - 1 });
-}

package/dist/components/blocks/text/hidden-suffix.d.ts

@@ -1,10 +0,0 @@
-/**
- * Whether a block keeps structure PAST its content that the surface paints nothing for — today the
- * setext underline. A merge past it concatenates it into view (`Title\n===` + `next` reparses to a
- * paragraph showing `===next`), so the keydown dispatch consumes the press and the command arm
- * declines it — one home, since the two ask from different coordinate sources (live-mode.md § 4.5).
- */
-import type { NodeView } from '../../../core/node-views';
-/** `displayLength` is the caller's, not this module's: the component reads the DOM while a widget
- *  reveal is open, where `node.raw` is stale by construction. */
-export declare function hidesStructuralSuffix(el: HTMLElement | null, node: NodeView, displayLength: number): boolean;

package/dist/components/blocks/text/hidden-suffix.js

@@ -1,15 +0,0 @@
-/**
- * Whether a block keeps structure PAST its content that the surface paints nothing for — today the
- * setext underline. A merge past it concatenates it into view (`Title\n===` + `next` reparses to a
- * paragraph showing `===next`), so the keydown dispatch consumes the press and the command arm
- * declines it — one home, since the two ask from different coordinate sources (live-mode.md § 4.5).
- */
-import { getContentRange } from '../../../core/inline';
-import { revealsNoMarkers } from '../../../cursor/widget-offset';
-/** `displayLength` is the caller's, not this module's: the component reads the DOM while a widget
- *  reveal is open, where `node.raw` is stale by construction. */
-export function hidesStructuralSuffix(el, node, displayLength) {
-    if (!el || !revealsNoMarkers(el))
-        return false;
-    return getContentRange(node).end < displayLength;
-}

package/dist/components/blocks/text/link-source-bytes.d.ts

@@ -1,37 +0,0 @@
-/**
- * Where a link edit becomes bytes: the seam every link write path calls (G4.34), and under it the
- * GFM branch. A candidate is written only once the RENDER PATH says the reader sees exactly what
- * they saw before — a destination that breaks its own construct surfaces as literal source, which
- * a private walk over the parse cannot see.
- */
-import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
-import type { InlineNode } from '../../../core/nodes';
-export interface LinkFields {
-    /** RAW inner bytes of the link text. Never re-escaped: the text holds whole nested constructs,
-     *  and re-emitting them from the parse would rewrite bytes the user never touched. */
-    text: string;
-    url: string;
-    title?: string;
-    /** Reference forms only: the raw tail after the text's `]` (`[ref]`, `[]`, or empty for the
-     *  shortcut form). Present preserves the reference; absent inlines the destination. */
-    reference?: string;
-}
-/**
- * Bytes to splice over `link`'s range, or `null` when the edit must be declined. **Every link
- * write path goes through here** (G4.34): a node an inline rung claimed carries no `rewriteLink`
- * hook, so emitting built-in grammar over its bytes would destroy the author's syntax.
- */
-export declare function buildLinkEditBytes(link: InlineNode, display: string, fields: LinkFields, resolver?: LinkReferenceResolver): string | null;
-/** Bytes that unwrap `link` to the text the reader already sees — remove-link. An autolink has no
- *  brackets to drop, so its removal is the same escape rewrite a re-linking text needs. */
-export declare function buildLinkUnwrapBytes(link: InlineNode, display: string, resolver?: LinkReferenceResolver): string | null;
-/** Bytes that mint `[text](url)` over `[start, end)` — the card's create half. Declines an empty
- *  destination, a range crossing another construct's bytes, and any candidate the render check
- *  refuses (a neighbouring `!` would turn the wrap into an image). */
-export declare function buildLinkWrapBytes(display: string, start: number, end: number, url: string, resolver?: LinkReferenceResolver): string | null;
-/** True when `[start, end)` holds only bytes safe to become link text. Wrapping inside or across
- *  another construct is a policy question create does not answer — it declines. */
-export declare function canWrapRangeAsLink(display: string, start: number, end: number, resolver?: LinkReferenceResolver): boolean;
-/** The fields the card edits, read off the source bytes: `url`/`title` are decoded on the node,
- *  but the text and the reference tail must survive as the author wrote them. */
-export declare function linkFieldsFromInline(link: InlineNode, display: string): LinkFields;

package/dist/components/image/image-source-bytes.d.ts

@@ -1,15 +0,0 @@
-import type { ImageFields, InlineNode } from '../../core/nodes';
-/**
- * Bytes to splice over `image`'s range, or `null` when the edit must be declined. **Every image
- * write path goes through here** (G4.21): a node an inline rung claimed re-serializes through that
- * rung's `rewriteImage` hook, since built-in grammar over another syntax's bytes destroys them.
- * Plugin-side contract: docs/design/plugin-contract.md § Inline authoring.
- */
-export declare function buildImageEditBytes(image: InlineNode, blockRaw: string, fields: ImageFields): string | null;
-/** Omits optional keys the node doesn't carry, so a rebuild writes back only what the
- *  source held. Byte-exactness is not the claim (the GFM serializer canonicalizes);
- *  idempotence on the alt is, so repeated resizes never grow the escapes. */
-export declare function imageFieldsFromInline(image: InlineNode): ImageFields;
-/** The built-in grammar's inverse. Reach it through `buildImageEditBytes`, the only
- *  caller entitled to decide these bytes are GFM's to write. */
-export declare function buildImageSourceBytes(fields: ImageFields): string;

package/dist/components/image/image-source-bytes.js

@@ -1,80 +0,0 @@
-// Where an image edit becomes bytes: the claim dispatcher every write path calls, and
-// under it the GFM branch. The two live together because G4.21 requires the image
-// serializer to be named in exactly one module.
-import { encodeDestination, escapeTitle } from '../../core/inline/destination-bytes';
-import { devWarn } from '../../dev-warn';
-// ── The write seam ──────────────────────────────────────────────────────────
-/**
- * Bytes to splice over `image`'s range, or `null` when the edit must be declined. **Every image
- * write path goes through here** (G4.21): a node an inline rung claimed re-serializes through that
- * rung's `rewriteImage` hook, since built-in grammar over another syntax's bytes destroys them.
- * Plugin-side contract: docs/design/plugin-contract.md § Inline authoring.
- */
-export function buildImageEditBytes(image, blockRaw, fields) {
-    const claim = image.syntaxClaim;
-    if (!claim)
-        return buildImageSourceBytes(fields);
-    const bytes = claim.rewriteImage?.(blockRaw.slice(image.start, image.end), fields) ?? null;
-    if (bytes === null) {
-        devWarn('image-edit', `declined: the "${claim.prefix}" inline rung owns these bytes and ` +
-            `${claim.rewriteImage ? 'its rewriteImage hook cannot represent this edit' : 'registered no rewriteImage hook'}`, fields);
-    }
-    return bytes;
-}
-/** Omits optional keys the node doesn't carry, so a rebuild writes back only what the
- *  source held. Byte-exactness is not the claim (the GFM serializer canonicalizes);
- *  idempotence on the alt is, so repeated resizes never grow the escapes. */
-export function imageFieldsFromInline(image) {
-    return {
-        alt: image.alt ?? '',
-        url: image.url ?? '',
-        ...(image.title !== undefined ? { title: image.title } : {}),
-        ...(image.width !== undefined ? { width: image.width } : {}),
-        ...(image.height !== undefined ? { height: image.height } : {}),
-        ...(image.crop !== undefined ? { crop: image.crop } : {}),
-        ...(image.label !== undefined ? { label: image.label } : {})
-    };
-}
-// ── The GFM serializer ──────────────────────────────────────────────────────
-/** The built-in grammar's inverse. Reach it through `buildImageEditBytes`, the only
- *  caller entitled to decide these bytes are GFM's to write. */
-export function buildImageSourceBytes(fields) {
-    const dimSuffix = buildDimSuffix(fields.width, fields.height, fields.crop);
-    const altSegment = escapeAlt(fields.alt) + dimSuffix;
-    // Reference form: the dimension hint rides in the alt, and url/title are not
-    // written — they belong to the LRD.
-    if (fields.label !== undefined) {
-        return `![${altSegment}][${fields.label}]`;
-    }
-    const titleSegment = fields.title !== undefined ? ` "${escapeTitle(fields.title)}"` : '';
-    return `![${altSegment}](${encodeDestination(fields.url)}${titleSegment})`;
-}
-function buildDimSuffix(width, height, crop) {
-    if (width === undefined)
-        return '';
-    if (height === undefined)
-        return `|${width}`;
-    return `|${width}x${height}${crop ? buildCropTail(crop) : ''}`;
-}
-/** Whole percents; the zoom only when it is one worth writing, trimmed to what it needs. */
-function buildCropTail(crop) {
-    const z = Math.round(crop.z * 100) / 100;
-    const zoom = z === 1 ? '' : `,${String(z)}`;
-    return `@${Math.round(crop.x)},${Math.round(crop.y)}${zoom}`;
-}
-// Alt sits inside `[...]`, where an unescaped bracket closes the scan early. Unlike
-// `title` and `url` it carries RAW label bytes, so a blanket escape doubles every
-// backslash per commit; passing any backslash PAIR through untouched keeps it idempotent.
-function escapeAlt(alt) {
-    let out = '';
-    for (let i = 0; i < alt.length; i++) {
-        const ch = alt[i];
-        if (ch === '\\' && i + 1 < alt.length) {
-            out += ch + alt[i + 1];
-            i++;
-            continue;
-        }
-        out += ch === '[' || ch === ']' || ch === '\\' ? '\\' + ch : ch;
-    }
-    return out;
-}

package/dist/cursor/content-offsets.d.ts

@@ -1,29 +0,0 @@
-/**
- * Cursor / range / selection helpers for contenteditable text surfaces. Offsets count DOM
- * text characters ambient-inclusively (`Range.toString()` does not skip
- * contenteditable=false islands), so they are `DomTextOffset`. An offset inside a span the
- * cursor may not enter — an atomic inline widget, or marker text the mode hides — snaps to
- * that span's leading or trailing edge.
- */
-import { type DomTextOffset } from './coordinate-spaces';
-export declare function createRangeFromOffsets(container: HTMLElement, start: DomTextOffset, end: DomTextOffset): Range | null;
-export declare function setCursorOffset(container: HTMLElement, offset: DomTextOffset): void;
-/** The range START (anchor for forward selections); the moving endpoint during Shift+Arrow
- *  extension is `getSelectionFocusOffset`. */
-export declare function getCursorOffset(container: HTMLElement): DomTextOffset | null;
-/** The moving endpoint of the selection, distinct from the anchor once extended. */
-export declare function getSelectionFocusOffset(container: HTMLElement): DomTextOffset | null;
-export declare function getSelectionOffsets(container: HTMLElement): {
-    start: DomTextOffset;
-    end: DomTextOffset;
-} | null;
-/**
- * Offsets for an arbitrary range inside `container` — an InputEvent's `getTargetRanges()`
- * pending-edit range is not the live selection (a word delete at a collapsed caret reports
- * the whole word). Null when either endpoint sits outside the container.
- */
-export declare function getRangeOffsets(container: HTMLElement, range: AbstractRange): {
-    start: DomTextOffset;
-    end: DomTextOffset;
-} | null;
-export declare function hasSelection(): boolean;

package/dist/cursor/content-offsets.js

@@ -1,151 +0,0 @@
-/**
- * Cursor / range / selection helpers for contenteditable text surfaces. Offsets count DOM
- * text characters ambient-inclusively (`Range.toString()` does not skip
- * contenteditable=false islands), so they are `DomTextOffset`. An offset inside a span the
- * cursor may not enter — an atomic inline widget, or marker text the mode hides — snaps to
- * that span's leading or trailing edge.
- */
-import { asDomTextOffset } from './coordinate-spaces';
-import { domDescendants } from './dom-walk';
-import { isAtomicInlineWidget, isHiddenMarkerRoot } from './widget-offset';
-/**
- * Length of a span the cursor may not enter, or null when it is transparent. Atomic widgets
- * and marker text the mode paints nothing for are both opaque: an offset inside either has
- * no position to seat, and hiding is classified at its one home, never re-derived here.
- */
-function opaqueSpanLength(node, container) {
-    if (node.nodeType !== Node.ELEMENT_NODE)
-        return null;
-    const el = node;
-    if (!isAtomicInlineWidget(el) && !isHiddenMarkerRoot(el, container))
-        return null;
-    return el.textContent?.length ?? 0;
-}
-export function createRangeFromOffsets(container, start, end) {
-    const range = document.createRange();
-    let charCount = 0;
-    let startSet = false;
-    let endFound = false;
-    // One classification per node, though the walk and the body below both ask: the read is a
-    // `contains` plus a `closest` per element, and a caret seat spends this walk on every step.
-    const opaque = new Map();
-    const opaqueLengthOf = (node) => {
-        if (!opaque.has(node))
-            opaque.set(node, opaqueSpanLength(node, container));
-        return opaque.get(node) ?? null;
-    };
-    for (const node of domDescendants(container, (node) => opaqueLengthOf(node) === null)) {
-        // The cursor never lands inside an opaque span: snap to the nearer edge.
-        const opaqueLen = opaqueLengthOf(node);
-        if (opaqueLen !== null) {
-            if (!startSet && start <= charCount + opaqueLen) {
-                if (start <= charCount)
-                    range.setStartBefore(node);
-                else
-                    range.setStartAfter(node);
-                startSet = true;
-            }
-            if (startSet && end <= charCount + opaqueLen) {
-                if (end <= charCount)
-                    range.setEndBefore(node);
-                else
-                    range.setEndAfter(node);
-                endFound = true;
-                break;
-            }
-            charCount += opaqueLen;
-            continue;
-        }
-        if (node.nodeType === Node.TEXT_NODE) {
-            const len = node.textContent?.length ?? 0;
-            if (!startSet && charCount + len >= start) {
-                range.setStart(node, start - charCount);
-                startSet = true;
-            }
-            if (startSet && charCount + len >= end) {
-                range.setEnd(node, end - charCount);
-                endFound = true;
-                break;
-            }
-            charCount += len;
-        }
-    }
-    if (!startSet) {
-        range.selectNodeContents(container);
-        range.collapse(false);
-    }
-    else if (!endFound) {
-        range.setEndAfter(container);
-    }
-    return range;
-}
-export function setCursorOffset(container, offset) {
-    const range = createRangeFromOffsets(container, offset, offset);
-    if (!range)
-        return;
-    const sel = window.getSelection();
-    sel?.removeAllRanges();
-    sel?.addRange(range);
-}
-/**
- * The one "DOM (node, offset) → content-offset" read here. `Selection.toString()` skips
- * text inside contenteditable=false islands and is unreliable across them; `Range.toString()`
- * on a prefix range does not skip, so all readers funnel through this.
- */
-function nodeOffsetToContent(container, node, offset) {
-    const preRange = document.createRange();
-    preRange.selectNodeContents(container);
-    try {
-        preRange.setEnd(node, offset);
-    }
-    catch {
-        return asDomTextOffset(0);
-    }
-    return asDomTextOffset(preRange.toString().length);
-}
-/** The range START (anchor for forward selections); the moving endpoint during Shift+Arrow
- *  extension is `getSelectionFocusOffset`. */
-export function getCursorOffset(container) {
-    if (document.activeElement !== container)
-        return null;
-    const sel = window.getSelection();
-    if (!sel || sel.rangeCount === 0)
-        return null;
-    const range = sel.getRangeAt(0);
-    return nodeOffsetToContent(container, range.startContainer, range.startOffset);
-}
-/** The moving endpoint of the selection, distinct from the anchor once extended. */
-export function getSelectionFocusOffset(container) {
-    if (document.activeElement !== container)
-        return null;
-    const sel = window.getSelection();
-    if (!sel || sel.focusNode === null)
-        return null;
-    if (!container.contains(sel.focusNode))
-        return null;
-    return nodeOffsetToContent(container, sel.focusNode, sel.focusOffset);
-}
-export function getSelectionOffsets(container) {
-    const sel = window.getSelection();
-    if (!sel || sel.isCollapsed)
-        return null;
-    return getRangeOffsets(container, sel.getRangeAt(0));
-}
-/**
- * Offsets for an arbitrary range inside `container` — an InputEvent's `getTargetRanges()`
- * pending-edit range is not the live selection (a word delete at a collapsed caret reports
- * the whole word). Null when either endpoint sits outside the container.
- */
-export function getRangeOffsets(container, range) {
-    if (!container.contains(range.startContainer) || !container.contains(range.endContainer)) {
-        return null;
-    }
-    return {
-        start: nodeOffsetToContent(container, range.startContainer, range.startOffset),
-        end: nodeOffsetToContent(container, range.endContainer, range.endOffset)
-    };
-}
-export function hasSelection() {
-    const sel = window.getSelection();
-    return Boolean(sel && !sel.isCollapsed);
-}

package/dist/cursor/reveal-anchor.d.ts

@@ -1,30 +0,0 @@
-/**
- * Reveal-target anchor. While a reveal is in flight the top-level windowing scope's
- * `correctAnchor` re-asserts the target's screen position at its requested `block`
- * placement instead of anchoring the top-of-viewport block, so image-decode churn
- * above it can't shrink the document and clamp the scroll off it. One slot with
- * per-call ownership; a plain closed-over value, never reactive `$state`.
- */
-export type RevealBlock = 'nearest' | 'center';
-export interface RevealTarget {
-    /** The full path the reveal was asked for, not a top-level narrowing. */
-    path: number[];
-    block: RevealBlock;
-}
-/** One `scrollTo`'s hold on the slot. */
-export interface RevealClaim {
-    /** Drop the pin, iff this claim still holds it — a superseded claimant's release is a no-op. */
-    release(): void;
-    /** True once a LATER claim was minted — the only signal that another reveal owns the
-     *  viewport. An empty slot (a user or self release) is not one, and is no reason for a
-     *  reveal in flight to abandon what it was asked to do. */
-    isSuperseded(): boolean;
-}
-export interface RevealAnchorState {
-    get(): RevealTarget | null;
-    /** Take the slot, superseding whoever held it. */
-    claim(path: readonly number[], block?: RevealBlock): RevealClaim;
-    /** Drop the pin whoever holds it — the user-intent release. */
-    releaseAll(): void;
-}
-export declare function createRevealAnchorState(): RevealAnchorState;