@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/plugins/footnotes/footnote-reference.js

@@ -1,17 +1,16 @@
 /**
- * The reference implementation of an inline rung: `[^label]` claims the ladder's
- * `[^`-prefix rung, consulted before the built-in `[` handler. The literal bytes stay
- * in the block's raw and the number is derived rather than stored. Recognition is gated
- * on registration: absent the plugin, `[` runs its built-in bracket handling instead.
+ * The worked example of an inline syntax handler: `[^label]` registers on the `[^` prefix, so
+ * it is tried before the built-in `[` handler. The literal bytes stay in the block's raw and
+ * the number is worked out rather than stored. Recognition starts only once the plugin
+ * registers: without it, `[` runs the built-in bracket handling instead.
  */
-import { INLINE_PRIORITIES, createScanIndex, declarePluginInlineKind, isInlineKindDeclared, registerInlineSyntax, registerInlineWidgetKind } from '../../plugin';
+import { INLINE_PRIORITIES, createScanIndex, declarePluginInlineKind, registerInlineSyntax, registerInlineWidgetKind, isWhitespaceChar } from '../../plugin';
 import FootnoteReference from './FootnoteReference.svelte';
 import { FOOTNOTE_REF_KIND } from './constants';
-const isWhitespace = (ch) => /\s/.test(ch);
 function indexLabelTerminators(raw) {
     const positions = [];
     for (let i = 0; i < raw.length; i++) {
-        if (raw[i] === ']' || isWhitespace(raw[i]))
+        if (raw[i] === ']' || isWhitespaceChar(raw[i]))
             positions.push(i);
     }
     return Int32Array.from(positions);
@@ -27,8 +26,8 @@ function recognizeFootnoteReference(raw, pos, end, kind) {
     if (raw[pos] !== '[' || raw[pos + 1] !== '^')
         return null;
     const labelStart = pos + 2;
-    // The index spans the whole block, so `end` decides the claim: a `]` past the scan
-    // range leaves the reference unterminated.
+    // The index spans the whole block, so `end` is what decides: a `]` past the scan range
+    // leaves the reference unterminated.
     const close = firstTerminatorFrom(raw, labelStart);
     if (close === -1 || close >= end)
         return null;
@@ -37,10 +36,6 @@ function recognizeFootnoteReference(raw, pos, end, kind) {
     return { kind, start: pos, end: close + 1, label: raw.slice(labelStart, close) };
 }
 export function registerFootnoteReference() {
-    // Keyed on the kind registry, not a module latch, so the platform reset that clears
-    // the inline registries also clears this guard.
-    if (isInlineKindDeclared(FOOTNOTE_REF_KIND))
-        return;
     const kind = declarePluginInlineKind(FOOTNOTE_REF_KIND);
     registerInlineSyntax('[', (raw, pos, end) => recognizeFootnoteReference(raw, pos, end, kind), {
         prefix: '[^',

package/dist/plugins/footnotes/index.js

@@ -1,6 +1,5 @@
 export { footnotesPlugin } from './footnotes-plugin';
 export { FOOTNOTE_DEF_KIND, FOOTNOTE_REF_KIND } from './constants';
-// `footnoteNumbersFor` is deliberately absent: only a mounted widget can supply its
-// content-version argument, and `InlineWidgetComponentProps.getContentVersion` is the
-// reusable half of that recipe.
+// `footnoteNumbersFor` stays unexported: only a mounted widget can supply its content version,
+// through `InlineWidgetComponentProps.getContentVersion`.
 export { assignFootnoteNumbers, collectFootnoteReferences } from './footnote-numbering';

package/dist/plugins/highlight-occurrences/highlight-occurrences-plugin.d.ts

@@ -1,15 +1,12 @@
 /**
- * The decoration-source shape on public doors only: onEditor wires a mark source to the
- * selection and edit channels, and the scan, its memo and the typing gate stay pure in
- * the sibling modules.
+ * A decoration source built on public API alone: `onEditor` wires a mark source to the
+ * selection, edit and source-swap events; the scan, its cache and the pause-while-typing rule
+ * stay pure in the sibling modules.
  */
 import { type EditorPlugin } from '../../plugin';
 export interface HighlightOccurrencesOptions {
-    /**
-     * Called when the word index is rebuilt: on a document change, not on a caret move,
-     * carrying how many leaves that rebuild had to tokenize. Public so a harness asserts
-     * the memo against this wiring rather than a copy of it.
-     */
+    /** Called when the word index is rebuilt (a document change, not a caret move) with how many
+     *  blocks it tokenized; public so a test can check this wiring's caching. */
     onScan?: (stats: {
         tokenizedLeaves: number;
     }) => void;

package/dist/plugins/highlight-occurrences/highlight-occurrences-plugin.js

@@ -1,7 +1,7 @@
 /**
- * The decoration-source shape on public doors only: onEditor wires a mark source to the
- * selection and edit channels, and the scan, its memo and the typing gate stay pure in
- * the sibling modules.
+ * A decoration source built on public API alone: `onEditor` wires a mark source to the
+ * selection, edit and source-swap events; the scan, its cache and the pause-while-typing rule
+ * stay pure in the sibling modules.
  */
 import { definePlugin } from '../../plugin';
 import { createOccurrenceSource } from './occurrence-source';
@@ -20,9 +20,14 @@ export function highlightOccurrencesPlugin(options = {}) {
                     if (occurrences.noteEdit(op))
                         handle.invalidate();
                 });
+                const offSourceSwap = editor.events.on('sourceSwap', () => {
+                    if (occurrences.noteSourceSwap())
+                        handle.invalidate();
+                });
                 return () => {
                     offSelection();
                     offEdit();
+                    offSourceSwap();
                     handle.dispose();
                 };
             });

package/dist/plugins/highlight-occurrences/occurrence-source.d.ts

@@ -1,14 +1,12 @@
 /**
- * The plugin-guide § Decorations "memoize the scan on editEpoch" recipe: the index costs a
- * document walk, so it is rebuilt only when the epoch bumps, carrying each leaf's token list
- * across the rebuild, and a caret move re-filters the cached index with one map read.
- * The marks step aside while you type: an epoch arriving under a caret with no `edit` event
- * ahead of it is a keystroke, and any edit event puts them back.
+ * The occurrence mark source: the word index is rebuilt only when `editEpoch` changes, and a caret
+ * move is one map read. The marks hide while you type: an `editEpoch` with no `edit` or
+ * `sourceSwap` event before it is a keystroke, and either event shows them again.
  */
 import type { DecorationSource, EditorSelection } from '../../plugin';
 export interface OccurrenceSourceDeps {
-    /** Fires on each real index rebuild, carrying how many leaves that rebuild had to
-     *  tokenize: the seam a memoization test asserts against. */
+    /** Fires on each real index rebuild, with how many blocks that rebuild had to tokenize:
+     *  what a caching test asserts on. */
     onScan?: (stats: {
         tokenizedLeaves: number;
     }) => void;
@@ -16,11 +14,11 @@ export interface OccurrenceSourceDeps {
 export interface OccurrenceSource {
     readonly source: DecorationSource;
     setSelection(selection: EditorSelection | null): void;
-    /**
-     * Report an `edit` op. Any of them ends the hold; only `input`, the batched flush that
-     * ends a typing burst, leaves the next epoch readable as another keystroke. Returns
-     * whether the caller must invalidate to reveal marks the hold was keeping back.
-     */
+    /** Report an `edit` op: any op shows the marks again, and only `input` (a typing burst's flush)
+     *  leaves the next `editEpoch` a keystroke. Returns whether the caller must invalidate. */
     noteEdit(op: string): boolean;
+    /** Report a `sourceSwap`: the next `editEpoch` is the new document, never a keystroke.
+     *  Returns whether the caller must invalidate, as `noteEdit` does. */
+    noteSourceSwap(): boolean;
 }
 export declare function createOccurrenceSource(deps?: OccurrenceSourceDeps): OccurrenceSource;

package/dist/plugins/highlight-occurrences/occurrence-source.js

@@ -1,9 +1,7 @@
 /**
- * The plugin-guide § Decorations "memoize the scan on editEpoch" recipe: the index costs a
- * document walk, so it is rebuilt only when the epoch bumps, carrying each leaf's token list
- * across the rebuild, and a caret move re-filters the cached index with one map read.
- * The marks step aside while you type: an epoch arriving under a caret with no `edit` event
- * ahead of it is a keystroke, and any edit event puts them back.
+ * The occurrence mark source: the word index is rebuilt only when `editEpoch` changes, and a caret
+ * move is one map read. The marks hide while you type: an `editEpoch` with no `edit` or
+ * `sourceSwap` event before it is a keystroke, and either event shows them again.
  */
 import { anchorWord, buildOccurrenceIndex } from './occurrences';
 const SOURCE_NAME = 'highlight-occurrences';
@@ -11,11 +9,11 @@ export function createOccurrenceSource(deps = {}) {
     let selection = null;
     let index = new Map();
     let tokens = new Map();
-    // Sentinel below any real epoch, so the first provide always scans.
+    // Below any real `editEpoch`, so the first call always scans.
     let indexedEpoch = -1;
     let typing = false;
-    // Nothing can have been typed into a source that has not run yet, so the first epoch it
-    // ever sees is a document arrival however the caret sits.
+    // Nothing can have been typed into a source that has not run yet, so the first `editEpoch`
+    // it ever sees is the document arriving, wherever the caret is.
     let structuralSinceScan = true;
     function provide(doc, { editEpoch }) {
         if (editEpoch !== indexedEpoch) {
@@ -24,11 +22,9 @@ export function createOccurrenceSource(deps = {}) {
             index = scan.index;
             tokens = scan.tokens;
             deps.onScan?.({ tokenizedLeaves: scan.tokenizedLeaves });
-            // A keystroke lands under a caret and says nothing on the edit channel until its
-            // burst flushes. An epoch missing either mark is some other document change: a
-            // commit that already announced itself, or a whole-document swap, which drops
-            // the caret before its epoch arrives.
-            typing = !structuralSinceScan && selection !== null;
+            // A keystroke says nothing on the edit event until its burst flushes; every other
+            // document change announced itself before its `editEpoch` arrived.
+            typing = !structuralSinceScan;
             structuralSinceScan = false;
         }
         if (typing)
@@ -36,19 +32,26 @@ export function createOccurrenceSource(deps = {}) {
         const word = anchorWord(doc, selection);
         return word ? (index.get(word) ?? []) : [];
     }
+    function showMarks() {
+        const held = typing;
+        typing = false;
+        return held;
+    }
     return {
         source: { name: SOURCE_NAME, provide },
         setSelection(next) {
             selection = next;
         },
         noteEdit(op) {
-            // Undo bumps the content version before it emits, so a structural op can reach
-            // here AFTER the epoch it moved: ending the hold here covers both orders.
+            // Undo bumps the content version before it emits, so a structural op can arrive
+            // after the `editEpoch` it caused; turning marks back on here covers both orders.
             if (op !== 'input')
                 structuralSinceScan = true;
-            const held = typing;
-            typing = false;
-            return held;
+            return showMarks();
+        },
+        noteSourceSwap() {
+            structuralSinceScan = true;
+            return showMarks();
         }
     };
 }

package/dist/plugins/highlight-occurrences/occurrences.d.ts

@@ -1,8 +1,8 @@
 /**
- * Pure occurrence scan: indexing by word is what turns the caret-driven lookup into
- * one map read rather than a fresh document walk. Offsets are per-leaf raw offsets,
- * dimmed markers included, the space mark decorations consume. `isProseKind` gates the
- * scope, so a code/HTML/raw leaf is neither scanned nor a valid anchor.
+ * Pure occurrence scan: indexing by word turns the caret-driven lookup into one map read
+ * instead of a fresh document walk. Offsets are raw offsets within a block, dimmed markers
+ * included, which is what mark decorations are measured in. Only prose blocks are scanned
+ * (`isProseKind`), so a code, HTML or raw block is neither scanned nor a word to search for.
  */
 import { type DocumentView, type EditorSelection, type MarkDecoration } from '../../plugin';
 export declare const OCCURRENCE_CLASS = "hl-occurrence";
@@ -12,22 +12,22 @@ export interface WordSpan {
     end: number;
 }
 export type OccurrenceIndex = Map<string, MarkDecoration[]>;
-/** Token lists keyed by the leaf `raw` they were scanned from, so a leaf whose bytes did
+/** Token lists keyed by the block `raw` they were scanned from, so a block whose bytes did
  *  not move costs one string compare instead of a re-tokenize. */
 export type TokenCache = Map<string, WordSpan[]>;
 export interface OccurrenceScan {
     index: OccurrenceIndex;
-    /** Carry into the next scan; a leaf gone from the document drops out of it. */
+    /** Pass into the next scan; a block gone from the document drops out of it. */
     tokens: TokenCache;
-    /** Leaves whose text had to be tokenized, the seam a memoization test asserts on. */
+    /** Blocks whose text had to be tokenized: what a caching test asserts on. */
     tokenizedLeaves: number;
 }
 /** Prefers the char at the caret, falling back to the one before it (the usual
  *  word-under-caret rule). */
 export declare function wordAt(text: string, offset: number): WordSpan | null;
-/** Null when the focus is not a leaf (a container/cell-coordinate endpoint) or the
- *  caret sits on a non-word char. */
+/** Null when the selection's focus is not a block of text (a container or a table-cell
+ *  endpoint), or the caret sits on a character that cannot start a word. */
 export declare function anchorWord(doc: DocumentView, selection: EditorSelection | null): string | null;
-/** Built once per document change by a memoizing source, not once per caret move. The
- *  marks are rebuilt every time (they carry paths), the tokens only for changed leaves. */
+/** Built once per document change by a caching source, not once per caret move. The marks
+ *  are rebuilt every time (they hold paths), the tokens only for blocks that changed. */
 export declare function buildOccurrenceIndex(doc: DocumentView, cached?: TokenCache): OccurrenceScan;

package/dist/plugins/highlight-occurrences/occurrences.js

@@ -1,13 +1,12 @@
 /**
- * Pure occurrence scan: indexing by word is what turns the caret-driven lookup into
- * one map read rather than a fresh document walk. Offsets are per-leaf raw offsets,
- * dimmed markers included, the space mark decorations consume. `isProseKind` gates the
- * scope, so a code/HTML/raw leaf is neither scanned nor a valid anchor.
+ * Pure occurrence scan: indexing by word turns the caret-driven lookup into one map read
+ * instead of a fresh document walk. Offsets are raw offsets within a block, dimmed markers
+ * included, which is what mark decorations are measured in. Only prose blocks are scanned
+ * (`isProseKind`), so a code, HTML or raw block is neither scanned nor a word to search for.
  */
-import { isProseKind } from '../../plugin';
+import { blockNodeAt, isProseKind, walkBlocks } from '../../plugin';
+import { WORD_CHAR } from './word-char';
 export const OCCURRENCE_CLASS = 'hl-occurrence';
-// Astral-plane text falls outside "word" here, which is honest enough for a reference plugin.
-const WORD_CHAR = /[\p{L}\p{N}_]/u;
 /** Prefers the char at the caret, falling back to the one before it (the usual
  *  word-under-caret rule). */
 export function wordAt(text, offset) {
@@ -28,25 +27,25 @@ export function wordAt(text, offset) {
         end++;
     return { word: text.slice(start, end), start, end };
 }
-/** Null when the focus is not a leaf (a container/cell-coordinate endpoint) or the
- *  caret sits on a non-word char. */
+/** Null when the selection's focus is not a block of text (a container or a table-cell
+ *  endpoint), or the caret sits on a character that cannot start a word. */
 export function anchorWord(doc, selection) {
     if (!selection)
         return null;
-    const leaf = leafAt(doc, selection.focus.path);
-    if (!leaf || !isProseKind(leaf.kind))
+    const leaf = blockNodeAt(doc, selection.focus.path);
+    if (!leaf || leaf.children || !isProseKind(leaf.kind))
         return null;
     const span = wordAt(leaf.raw, selection.focus.offset);
     return span ? span.word : null;
 }
-/** Built once per document change by a memoizing source, not once per caret move. The
- *  marks are rebuilt every time (they carry paths), the tokens only for changed leaves. */
+/** Built once per document change by a caching source, not once per caret move. The marks
+ *  are rebuilt every time (they hold paths), the tokens only for blocks that changed. */
 export function buildOccurrenceIndex(doc, cached) {
     const index = new Map();
     const tokens = new Map();
     let tokenizedLeaves = 0;
-    forEachLeaf(doc.children, [], (node, path) => {
-        if (!isProseKind(node.kind))
+    walkBlocks(doc, (node, path) => {
+        if (node.children || !isProseKind(node.kind))
             return;
         let spans = tokens.get(node.raw) ?? cached?.get(node.raw);
         if (!spans) {
@@ -72,27 +71,6 @@ export function buildOccurrenceIndex(doc, cached) {
     return { index, tokens, tokenizedLeaves };
 }
 // ── Internal ────────────────────────────────────────────────────────────────
-function leafAt(doc, path) {
-    let children = doc.children;
-    let node = null;
-    for (const index of path) {
-        node = children?.[index] ?? null;
-        if (!node)
-            return null;
-        children = node.children;
-    }
-    return node && !node.children ? node : null;
-}
-function forEachLeaf(children, path, visit) {
-    for (let i = 0; i < children.length; i++) {
-        const node = children[i];
-        const childPath = [...path, i];
-        if (node.children)
-            forEachLeaf(node.children, childPath, visit);
-        else
-            visit(node, childPath);
-    }
-}
 function* tokenizeWords(text) {
     let i = 0;
     while (i < text.length) {

package/dist/plugins/highlight-occurrences/word-char.d.ts

@@ -0,0 +1 @@
+export declare const WORD_CHAR: RegExp;

package/dist/plugins/highlight-occurrences/word-char.js

@@ -0,0 +1,4 @@
+// What the occurrence scan counts as part of a word. A module of its own, with no imports, so the
+// e2e specs can read it in Node without loading the plugin API.
+// Astral-plane text falls outside "word" here, which is honest enough for a reference plugin.
+export const WORD_CHAR = /[\p{L}\p{N}_]/u;