@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/text/edge-seat.d.ts

@@ -1,12 +1,14 @@
 /**
- * Which side of a construct's unpainted marker run a typed byte belongs to: a run painted at zero
- * width leaves one screen position naming two raw offsets. The kind's `edgeAffinity` policy answers
- * first (a link never extends), the arrival affinity second — and the painter has the last word
- * (live-mode.md § 2), since a seat that reads right can parse wrong.
+ * Which side of a construct's hidden marker run a typed byte belongs to: a run drawn at zero width
+ * leaves one screen position standing for two raw offsets. The kind's `edgeAffinity` policy answers
+ * first (a link never extends), the side the caret arrived from second, and the render has the last
+ * word (live-mode.md § 2), since a position that reads right can parse wrong.
  */
 import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
 import type { EdgeAffinity } from '../../../cursor/edge-affinity';
 import { type VisibilityContext } from '../../../core/inline/visibility';
+import type { GrammarView } from '../../../schema/block-openers';
+import type { Reading } from '../../../schema/reading';
 export interface EdgeSeat {
     /** Raw offset the byte must be written at. */
     offset: number;
@@ -14,29 +16,18 @@ export interface EdgeSeat {
      *  `offset`: a screen position reaches the runs abutting that construct's own. */
     kind: AnyInlineKind;
 }
-/**
- * Where `typed` belongs when the caret sits at `caretOffset`, or null when the offset touches no
- * construct marker run, the kind declares no policy, or no candidate earns the write. Declining is
- * the honest fallback: the byte then lands at the caret, which is what the engine writes anyway.
- */
-export declare function resolveEdgeSeat(caretOffset: number, inlines: readonly InlineNode[], affinity: EdgeAffinity | null, raw: string, screen: VisibilityContext, typed: string): EdgeSeat | null;
-/**
- * The bytes a COMPOSITION commit should have written. `insertCompositionText` beforeinput is not
- * cancelable, so the seat cannot intercept the keystroke and relocates the composed run once, on
- * the commit that lands it. Null leaves the read as-is.
- */
-export declare function relocateComposedRun(before: string, after: string, composedAt: number, inlines: readonly InlineNode[], affinity: EdgeAffinity | null, screen: VisibilityContext): {
+/** Where `typed` belongs when the caret sits at `caretOffset`, or null to let it land at the caret.
+ *  `reading` must be the one `inlines` was read with, or a reference link reads as brackets. */
+export declare function resolveEdgeSeat(caretOffset: number, inlines: readonly InlineNode[], affinity: EdgeAffinity | null, raw: string, screen: VisibilityContext, typed: string, reading: Reading): EdgeSeat | null;
+/** The bytes an IME composition's commit should have written. `insertCompositionText` cannot be
+ *  cancelled, so the composed run is moved once, on the commit that lands it. */
+export declare function relocateComposedRun(before: string, after: string, composedAt: number, inlines: readonly InlineNode[], affinity: EdgeAffinity | null, screen: VisibilityContext, reading: Reading): {
     raw: string;
     caret: number;
 } | null;
-/** The text a commit's read added at `at`, or null when the read is not a plain insertion
- *  there — a composition over a selection is a range op, and no seat claims a range. */
+/** The text a commit's reading added at `at`, or null when that reading is not a plain insertion
+ *  there: a composition over a selection is a range edit, which nothing here handles. */
 export declare function plainInsertionAt(before: string, after: string, at: number): string | null;
-/**
- * Every raw offset the caret's screen position ADMITS — the seat's whole reach, and empty where no
- * marker run touches the caret. A hidden run's hidden neighbours name the same position, so the
- * stretch of abutting runs is one position and each boundary in it is a seat; an offset inside a
- * run's own bytes is inside some construct's delimiters, which is where no byte belongs. A caret
- * strictly inside a run is one such offset, so the reach can exclude the caret it was asked about.
- */
-export declare function seatOffsetsAt(caretOffset: number, inlines: readonly InlineNode[], raw: string, screen: VisibilityContext): readonly number[];
+/** Every raw offset the caret's screen position allows: each boundary in a stretch of abutting
+ *  hidden runs, never an offset inside a run's bytes, which may exclude the caret itself. */
+export declare function seatOffsetsAt(caretOffset: number, inlines: readonly InlineNode[], raw: string, screen: VisibilityContext, grammar: GrammarView): readonly number[];

package/dist/components/blocks/text/edge-seat.js

@@ -1,20 +1,18 @@
 /**
- * Which side of a construct's unpainted marker run a typed byte belongs to: a run painted at zero
- * width leaves one screen position naming two raw offsets. The kind's `edgeAffinity` policy answers
- * first (a link never extends), the arrival affinity second — and the painter has the last word
- * (live-mode.md § 2), since a seat that reads right can parse wrong.
+ * Which side of a construct's hidden marker run a typed byte belongs to: a run drawn at zero width
+ * leaves one screen position standing for two raw offsets. The kind's `edgeAffinity` policy answers
+ * first (a link never extends), the side the caret arrived from second, and the render has the last
+ * word (live-mode.md § 2), since a position that reads right can parse wrong.
  */
-import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { constructContentRange, inlineDescendants, readInline } from '../../../core/inline';
 import { CONTENT_VISIBILITY, renderedText, visibleRuns } from '../../../core/inline/visibility';
 import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
 import { insertsExactly } from './screen-diff';
-/**
- * Where `typed` belongs when the caret sits at `caretOffset`, or null when the offset touches no
- * construct marker run, the kind declares no policy, or no candidate earns the write. Declining is
- * the honest fallback: the byte then lands at the caret, which is what the engine writes anyway.
- */
-export function resolveEdgeSeat(caretOffset, inlines, affinity, raw, screen, typed) {
-    const runs = markerRuns(inlines, raw, screen);
+/** Where `typed` belongs when the caret sits at `caretOffset`, or null to let it land at the caret.
+ *  `reading` must be the one `inlines` was read with, or a reference link reads as brackets. */
+export function resolveEdgeSeat(caretOffset, inlines, affinity, raw, screen, typed, reading) {
+    const { grammar } = reading;
+    const runs = markerRuns(inlines, raw, screen, grammar);
     const run = runAt(caretOffset, runs);
     if (!run)
         return null;
@@ -22,15 +20,18 @@ export function resolveEdgeSeat(caretOffset, inlines, affinity, raw, screen, typ
     if (!policy)
         return null;
     const content = contentBounds(inlines);
-    const before = shown(raw, content.start, content.end);
+    // What the user sees, asked of the renderer (G4.33), in the content reading: this only adds
+    // bytes, so no reading of it can license dropping one.
+    const shown = (bytes, end) => renderedText(readInline(bytes, content.start, end, reading.resolver, grammar), bytes, CONTENT_VISIBILITY, { grammar });
+    const before = shown(raw, content.end);
     const holds = (offset) => {
         const candidate = raw.slice(0, offset) + typed + raw.slice(offset);
-        const after = shown(candidate, content.start, content.end + typed.length);
+        const after = shown(candidate, content.end + typed.length);
         return insertsExactly(before, after, typed);
     };
     for (const offset of candidateOffsets(run, policy.edgeAffinity, affinity, caretOffset, runs)) {
-        // The walk's read and Chromium's insertion canonicalize the same way, so a verified
-        // `seat === caret` means native typing already lands where the seat wants it.
+        // The DOM-to-offset traversal and Chromium's insertion normalise the same way, so a
+        // verified answer equal to the caret means ordinary typing already lands there.
         if (offset === caretOffset) {
             if (holds(offset))
                 return null;
@@ -41,16 +42,13 @@ export function resolveEdgeSeat(caretOffset, inlines, affinity, raw, screen, typ
     }
     return null;
 }
-/**
- * The bytes a COMPOSITION commit should have written. `insertCompositionText` beforeinput is not
- * cancelable, so the seat cannot intercept the keystroke and relocates the composed run once, on
- * the commit that lands it. Null leaves the read as-is.
- */
-export function relocateComposedRun(before, after, composedAt, inlines, affinity, screen) {
+/** The bytes an IME composition's commit should have written. `insertCompositionText` cannot be
+ *  cancelled, so the composed run is moved once, on the commit that lands it. */
+export function relocateComposedRun(before, after, composedAt, inlines, affinity, screen, reading) {
     const composed = plainInsertionAt(before, after, composedAt);
     if (composed === null)
         return null;
-    const seat = resolveEdgeSeat(composedAt, inlines, affinity, before, screen, composed);
+    const seat = resolveEdgeSeat(composedAt, inlines, affinity, before, screen, composed, reading);
     if (!seat)
         return null;
     return {
@@ -58,8 +56,8 @@ export function relocateComposedRun(before, after, composedAt, inlines, affinity
         caret: seat.offset + composed.length
     };
 }
-/** The text a commit's read added at `at`, or null when the read is not a plain insertion
- *  there — a composition over a selection is a range op, and no seat claims a range. */
+/** The text a commit's reading added at `at`, or null when that reading is not a plain insertion
+ *  there: a composition over a selection is a range edit, which nothing here handles. */
 export function plainInsertionAt(before, after, at) {
     const length = after.length - before.length;
     if (length <= 0 || at < 0 || at > before.length)
@@ -70,15 +68,10 @@ export function plainInsertionAt(before, after, at) {
         return null;
     return after.slice(at, at + length);
 }
-/**
- * Every raw offset the caret's screen position ADMITS — the seat's whole reach, and empty where no
- * marker run touches the caret. A hidden run's hidden neighbours name the same position, so the
- * stretch of abutting runs is one position and each boundary in it is a seat; an offset inside a
- * run's own bytes is inside some construct's delimiters, which is where no byte belongs. A caret
- * strictly inside a run is one such offset, so the reach can exclude the caret it was asked about.
- */
-export function seatOffsetsAt(caretOffset, inlines, raw, screen) {
-    const runs = markerRuns(inlines, raw, screen);
+/** Every raw offset the caret's screen position allows: each boundary in a stretch of abutting
+ *  hidden runs, never an offset inside a run's bytes, which may exclude the caret itself. */
+export function seatOffsetsAt(caretOffset, inlines, raw, screen, grammar) {
+    const runs = markerRuns(inlines, raw, screen, grammar);
     const run = runAt(caretOffset, runs);
     if (!run)
         return [];
@@ -95,17 +88,11 @@ function offsetForSide(run, side) {
     return run.leading ? run.start : run.end;
 }
 const otherEnd = (run, side) => offsetForSide(run, side) === run.start ? run.end : run.start;
-/**
- * The offsets to try, best first: the policy's side, then the run's other end — the split
- * rebalancer's space-outside reading in the seat's terms, since a byte the run's inner side kills
- * is one its outer side keeps. Then the byte-literal write, verified like any other candidate: a
- * parse it rebinds is no reason to stop looking. The rest of the screen position ends the list,
- * nearest the policy's side first, for the caret whose own construct has no answer to give.
- */
+/** The offsets to try, best first: the policy's side, the run's other end, the caret itself, then
+ *  the rest of the screen position, nearest the policy's side first. */
 function candidateOffsets(run, edgeAffinity, affinity, caretOffset, runs) {
-    // Never-extend resolves like a line extreme: past the construct's delimiters, which is the
-    // run's near side at an opener and its far side at a closer. A symmetric pair follows the
-    // arrival, defaulting to the near side — the gdocs click default (live-mode.md § 4.2).
+    // `never-extend` lands past the construct's delimiters; a symmetric pair follows the side the
+    // caret arrived from, else the near side (`docs/design/live-mode.md` § 4.2).
     const side = edgeAffinity === 'never-extend' ? 'outside' : (affinity ?? 'near');
     const preferred = offsetForSide(run, side);
     const ranked = [preferred, otherEnd(run, side), caretOffset];
@@ -115,10 +102,8 @@ function candidateOffsets(run, edgeAffinity, affinity, caretOffset, runs) {
     const offsets = [...new Set([...ranked, ...rest])];
     return edgeAffinity === 'never-extend' ? offsets.filter((o) => outsideSpan(run, o)) : offsets;
 }
-/** Whether `offset` lies outside the run's own construct. A `never-extend` row admits nothing
- *  inside: half a URL is not a URL, half an escape is a literal backslash, and a destination the
- *  mode never paints is one the painter cannot check. Stated over the SPAN rather than over the
- *  run's inner end, since the screen position reaches an interior through a neighbour's run too. */
+/** Whether `offset` lies outside the run's whole construct, which is all a `never-extend` row
+ *  allows: half a URL is not a URL, and half an escape is a literal backslash. */
 const outsideSpan = (run, offset) => offset <= run.span.start || offset >= run.span.end;
 /** The stretch of abutting runs `run` belongs to, as the boundary offsets inside it. */
 function screenPositionOffsets(run, runs) {
@@ -148,19 +133,16 @@ function screenPositionOffsets(run, runs) {
     }
     return [...bounds];
 }
-/** The bytes the inline tree covers — the block's content range, read off the tree rather than
- *  taken as a second parameter that could disagree with it. */
+/** The bytes the inline tree covers, which is the block's content range, read off the tree rather
+ *  than passed in as a second parameter that could disagree with it. */
 function contentBounds(inlines) {
     return { start: inlines[0].start, end: inlines[inlines.length - 1].end };
 }
-/** What a reader sees, asked of the thing that paints it (G4.33). The content reading, not the
- *  block's own: this seam only ADDS bytes, so no reading of it licenses dropping one. */
-const shown = (raw, start, end) => renderedText(parseInline(raw, start, end), raw, CONTENT_VISIBILITY);
 /** Every construct marker run, in pre-order. */
-function markerRuns(inlines, raw, screen) {
+function markerRuns(inlines, raw, screen, grammar) {
     const runs = [];
     for (const node of inlineDescendants(inlines)) {
-        const content = constructContentRange(node) ?? paintedRange(node, raw, screen);
+        const content = constructContentRange(node) ?? paintedRange(node, raw, screen, grammar);
         if (!content)
             continue;
         const span = { start: node.start, end: node.end };
@@ -173,24 +155,15 @@ function markerRuns(inlines, raw, screen) {
     }
     return runs;
 }
-/**
- * The run `offset` sits in, its own boundaries included — the LAST in pre-order, so the innermost
- * construct at a shared boundary wins. INSIDE counts, not just the two ends: a doubled code fence
- * is a run a caret can be handed the middle of.
- */
+/** The run `offset` sits in, boundaries and interior included (a caret can be handed the middle of
+ *  a doubled code fence); the last in pre-order, so the innermost construct wins. */
 const runAt = (offset, runs) => runs.reduce((found, run) => (offset >= run.start && offset <= run.end ? run : found), null);
-/**
- * What a CHILDLESS construct paints, as a range in the block's own bytes: the outer bounds of its
- * visible runs, which such a construct has one contiguous stretch of — the precondition the two
- * marker runs below are carved out of, held by `test/core/inline/painted-contiguity.property`.
- * Asked of the render path rather than derived per kind, since which bytes a construct shows only
- * the painter answers (G4.33), and in the block's OWN reading: where its chrome paints, the whole
- * construct is on screen, no run is hidden, and the seat has nothing to relocate.
- */
-function paintedRange(node, raw, screen) {
+/** What a childless construct draws, as the outer bounds of its visible runs in the block's own
+ *  mode, asked of the render (G4.33); `painted-contiguity.property` holds it contiguous. */
+function paintedRange(node, raw, screen, grammar) {
     if (node.kind === 'text')
         return null;
-    const painted = visibleRuns([node], raw, screen).filter((run) => run.visible && run.text !== '');
+    const painted = visibleRuns([node], raw, screen, { grammar }).filter((run) => run.visible && run.text !== '');
     if (painted.length === 0)
         return null;
     return { start: painted[0].start, end: painted[painted.length - 1].end };

package/dist/components/blocks/text/link-at-point.d.ts

@@ -1,13 +1,13 @@
 /**
- * Which link construct a pointer landed in, and how to find that construct again after an edit
- * rebuilt the tree. The offset comes from the shared DOM↔raw walk and the construct from the
- * reveal chain, so the card addresses exactly what the render path drew.
+ * Which link a click landed in, and how to find that link again after an edit rebuilt the tree.
+ * The offset comes from the shared DOM-to-raw traversal and the link from the same chain used
+ * when a construct shows its source, so the card points at exactly what was drawn.
  */
 import type { InlineNode } from '../../../core/nodes';
 import type { NodeView } from '../../../core/node-views';
-import type { LinkReferenceResolverRef } from '../../../editor-keys';
+import type { Reading } from '../../../schema/reading';
 /** Both DOM shapes a bracketed link takes: `a` for an allowed scheme, `span.md-link-blocked` for a
- *  rejected one — and a blocked link is precisely the one a user opens the card to fix. */
+ *  rejected one, and a blocked link is exactly the one a user opens the card to fix. */
 export declare const LINK_ELEMENT_SELECTOR = ".md-link-content";
 /** Path plus construct start, never a node reference: every commit rebuilds the inline tree and the
  *  DOM under it, so an open card re-resolves from this identity after each edit. */
@@ -20,14 +20,14 @@ export interface LinkPointResolution {
     link: InlineNode;
 }
 export interface LinkPointQuery {
-    /** The block's content element — the walk container the raw offset is measured in. */
+    /** The block's content element, the container the raw offset is measured inside. */
     contentEl: HTMLElement;
     block: NodeView;
     path: number[];
-    linkRef?: LinkReferenceResolverRef;
+    reading: Reading;
 }
-/** The link the caret sits inside, read after the pointer has seated it. */
+/** The link the caret sits inside, read after the click has placed the caret. */
 export declare function resolveLinkAtPoint(query: LinkPointQuery): LinkPointResolution | null;
 /** The construct an open card is anchored to, re-read from the live tree; null once an edit moved
  *  or removed it. */
-export declare function linkConstructAt(block: NodeView, sourceStart: number, linkRef?: LinkReferenceResolverRef): InlineNode | null;
+export declare function linkConstructAt(block: NodeView, sourceStart: number, reading: Reading): InlineNode | null;

package/dist/components/blocks/text/link-at-point.js

@@ -1,27 +1,24 @@
 /**
- * Which link construct a pointer landed in, and how to find that construct again after an edit
- * rebuilt the tree. The offset comes from the shared DOM↔raw walk and the construct from the
- * reveal chain, so the card addresses exactly what the render path drew.
+ * Which link a click landed in, and how to find that link again after an edit rebuilt the tree.
+ * The offset comes from the shared DOM-to-raw traversal and the link from the same chain used
+ * when a construct shows its source, so the card points at exactly what was drawn.
  */
-import { ambientLengthOf } from '../../../ambient/ambient-dom';
 import { inlineDescendants } from '../../../core/inline';
 import { resolvedInlineContent } from '../../../core/inline/inline-cache';
-import { toClampedRawOffset } from '../../../cursor/coordinate-spaces';
-import { domTextOffsetAtNode } from '../../../cursor/widget-offset';
+import { rawOffsetAt } from '../../../cursor/widget-offset';
 import { isCardEditableInlineKind } from '../../../schema/inline-construct-policy';
 import { constructChainAtOffset } from './construct-reveal';
 /** Both DOM shapes a bracketed link takes: `a` for an allowed scheme, `span.md-link-blocked` for a
- *  rejected one — and a blocked link is precisely the one a user opens the card to fix. */
+ *  rejected one, and a blocked link is exactly the one a user opens the card to fix. */
 export const LINK_ELEMENT_SELECTOR = '.md-link-content';
-/** The link the caret sits inside, read after the pointer has seated it. */
+/** The link the caret sits inside, read after the click has placed the caret. */
 export function resolveLinkAtPoint(query) {
     const offset = caretRawOffset(query.contentEl);
     if (offset === null)
         return null;
-    const inlines = resolvedInlineContent(query.block, query.linkRef);
-    // Outermost-first, so the last card-editable construct in the chain is the one whose bytes
-    // enclose the pointer most tightly. The chain itself is the reveal's, which admits only
-    // revealable kinds, so an autolink never reaches this filter either way.
+    const inlines = resolvedInlineContent(query.block, query.reading);
+    // The chain is outermost first, so its last card-editable link is the one that encloses the
+    // click most tightly.
     const link = constructChainAtOffset(inlines, offset).filter(isCardEditable).at(-1);
     if (link === undefined)
         return null;
@@ -30,8 +27,8 @@ export function resolveLinkAtPoint(query) {
 const isCardEditable = (node) => isCardEditableInlineKind(node.kind);
 /** The construct an open card is anchored to, re-read from the live tree; null once an edit moved
  *  or removed it. */
-export function linkConstructAt(block, sourceStart, linkRef) {
-    for (const node of inlineDescendants(resolvedInlineContent(block, linkRef))) {
+export function linkConstructAt(block, sourceStart, reading) {
+    for (const node of inlineDescendants(resolvedInlineContent(block, reading))) {
         if (isCardEditable(node) && node.start === sourceStart)
             return node;
     }
@@ -43,5 +40,5 @@ function caretRawOffset(contentEl) {
         return null;
     if (!contentEl.contains(sel.focusNode))
         return null;
-    return toClampedRawOffset(domTextOffsetAtNode(contentEl, sel.focusNode, sel.focusOffset), ambientLengthOf(contentEl));
+    return rawOffsetAt(contentEl, sel.focusNode, sel.focusOffset);
 }

package/dist/components/blocks/text/live-join-seam.d.ts

@@ -1,15 +1,12 @@
 /**
- * The live-mode join rewrite (live-mode.md § 4.5): a literal concatenation surfaces the runs a
- * truncation left unpaired and the closer/opener pair a split's inverse abuts around nothing. Both
- * are dropped here and nowhere else, and only once the joined block re-parses to ONE prose block
- * showing what the two sides showed.
+ * The live-mode join rewrite (live-mode.md § 4.5): joining two blocks literally would show the
+ * delimiter runs a truncation left unpaired, and the closer/opener pair a split's inverse pushes
+ * together around nothing. Both are dropped here and nowhere else, and only once the joined bytes,
+ * read back where they will be stored, show what the two sides showed.
  */
 import type { InlineNode } from '../../../core/nodes';
 import { type LiveJoinSeamCleaner } from '../../../schema/inline-construct-policy';
 export declare const cleanLiveJoinSeam: LiveJoinSeamCleaner;
-/**
- * The `keep` side of `level`, rebuilt: a construct the cut crosses hands its place to its own
- * clipped children. Exported for the depth pin, which has to reach the rebuild with a tree no
- * side this deep could be rendered at.
- */
+/** The `keep` side of `level`, rebuilt: a construct the cut crosses is replaced by its clipped
+ *  children. Exported for the depth test. */
 export declare function clipNodes(level: readonly InlineNode[], cut: number, keep: 'before' | 'after'): InlineNode[];