@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/code/code-fence-boundary.js

@@ -0,0 +1,169 @@
+/**
+ * Pure decisions that keep an edit off the fence lines of a fenced code block: rewriting either
+ * fence leaves an unclosed one that absorbs the rest of the document at the next parse. Editable
+ * content is the body plus the opener's info string. Display-text coordinates throughout.
+ */
+import { metadataOf } from '../../../core/nodes';
+import { displayLength, trimTrailingLineEnding } from '../../../core/lines';
+import { sliceFencedCode } from './code-renderer';
+/**
+ * Classify a Backspace/Delete against the two body boundaries: Backspace at bodyStart
+ * would delete the opener's terminating `\n`, Delete at bodyEnd the body's — either
+ * re-parses the block in a different shape, so both become a focus-move out instead.
+ * What else a keystroke may rewrite is `crossesFenceBoundary`'s question.
+ */
+export function classifyFenceBoundary(input) {
+    const { node, offset, forward } = input;
+    const slice = sliceFencedCode(node);
+    const { start: bodyStart, end: bodyEnd } = fenceBodyBounds(slice);
+    if (!forward) {
+        if (slice.openerLine.endsWith('\n') && offset === bodyStart)
+            return { kind: 'exitPrev' };
+        return { kind: 'allow' };
+    }
+    if (slice.closerLine.length > 0 && offset === bodyEnd)
+        return { kind: 'exitNext' };
+    return { kind: 'allow' };
+}
+/**
+ * Clamp an Enter-splice out of both fence lines onto the nearest body edge — a `\n`
+ * inside the opener re-shapes the fence, one inside the closer breaks it apart. Each
+ * fence line's inner edge is left alone: splicing after the info string, or at the
+ * start of the closer line, is already safe.
+ */
+export function clampEnterOffsetToBody(node, offset) {
+    const { openerTextEnd, body, closerTextStart } = fenceRegions(node);
+    if (offset < openerTextEnd)
+        return body.start;
+    if (offset > closerTextStart)
+        return body.end;
+    return offset;
+}
+/**
+ * Clamp a whole range onto the body, unconditionally — for gestures that rewrite entire LINES (Tab
+ * indent, Shift+Tab dedent), where a tab on the closer pushes it past GFM's 3-space limit and one
+ * on the opener demotes the block. Arbitrary RANGE gestures use `fenceEditSpan` instead.
+ */
+export function clampRangeToBody(node, range) {
+    const { start: lo, end: hi } = bodyWindow(node);
+    const clamp = (offset) => Math.min(Math.max(offset, lo), hi);
+    return { start: clamp(range.start), end: clamp(range.end) };
+}
+/**
+ * Does a pending edit reach out of the editable content — the body, plus the opener's info string?
+ * Every other offset on the fence lines is one keystroke from swallowing the following blocks into
+ * the code node. An UNCLOSED fence is the exception: with no closer to orphan, its run is content
+ * too, so demoting the block is how a just-typed ` ``` ` gets undone.
+ */
+export function crossesFenceBoundary(node, range) {
+    const { openerContent, body } = fenceRegions(node);
+    const lo = Math.min(range.start, range.end);
+    const hi = Math.max(range.start, range.end);
+    if (lo >= openerContent.start && hi <= openerContent.end)
+        return false;
+    return !(lo >= body.start && hi <= body.end);
+}
+/**
+ * The span a ranged edit actually rewrites: the range itself while it stays inside
+ * one content region, its intersection with the body once it reaches structure.
+ */
+export function fenceEditSpan(node, range) {
+    const span = orderedRange(range);
+    return crossesFenceBoundary(node, span) ? clampRangeToBody(node, span) : span;
+}
+/**
+ * Where a caret LANDING may sit — every door that seats a caret on this surface goes
+ * through here. A caret parked on a fence line takes keystrokes the guard refuses:
+ * the landing looks successful and the next character disappears.
+ */
+export function clampCaretToBody(node, offset) {
+    const caret = { start: offset, end: offset };
+    if (!crossesFenceBoundary(node, caret))
+        return offset;
+    return clampRangeToBody(node, caret).start;
+}
+/**
+ * The refusal rule shared by every mutating gesture here: a range that reached structure and kept
+ * no body after the clamp is declined, not re-sited to a body edge the user never pointed at.
+ * Paste consults it directly, since it splices through the paste tree-op.
+ */
+export function isStructureOnlyRange(node, range) {
+    const ordered = orderedRange(range);
+    if (!crossesFenceBoundary(node, ordered))
+        return false;
+    const span = clampRangeToBody(node, ordered);
+    return span.start === span.end;
+}
+/**
+ * The one in-place range splice — native delete/type-over (via the beforeinput guard)
+ * and cut. Null when there is nothing to rewrite, so no undo entry is spent.
+ */
+export function computeFenceRangedEdit(node, range, insert) {
+    if (isStructureOnlyRange(node, range))
+        return null;
+    const display = trimTrailingLineEnding(node.raw);
+    const span = fenceEditSpan(node, range);
+    const newText = display.slice(0, span.start) + insert + display.slice(span.end);
+    if (newText === display)
+        return null;
+    return { newText, newCursor: span.start + insert.length };
+}
+function fenceRegions(node) {
+    const slice = sliceFencedCode(node);
+    const displayEnd = displayLength(node.raw);
+    const body = bodyWindowOf(slice, displayEnd);
+    const openerTextEnd = Math.min(displayLength(slice.openerLine), displayEnd);
+    const hasCloser = slice.closerLine.length > 0;
+    const contentStart = hasCloser
+        ? Math.min(markerRunEnd(slice.openerLine, metadataOf(node, 'fencedCode').fenceMarker), openerTextEnd)
+        : 0;
+    return {
+        openerTextEnd,
+        openerContent: { start: contentStart, end: openerTextEnd },
+        body,
+        // `slice.body` carries its own trailing ending, so its full length is where the
+        // closer line begins; an unclosed fence has no closer and collapses onto the end.
+        closerTextStart: Math.min(body.start + slice.body.length, displayEnd)
+    };
+}
+/**
+ * Past the opener's indentation and marker run — where the info string starts. The run's LENGTH is
+ * measured rather than read from `fenceLength`, so an opener a paste bumped to four markers
+ * measures as four. Past GFM's 3-space indent limit there is no info string at all.
+ */
+function markerRunEnd(openerLine, marker) {
+    const MAX_INDENT = 3;
+    let index = 0;
+    while (index < MAX_INDENT && openerLine[index] === ' ')
+        index++;
+    if (openerLine[index] !== marker)
+        return openerLine.length;
+    while (openerLine[index] === marker)
+        index++;
+    return index;
+}
+function orderedRange(range) {
+    return {
+        start: Math.min(range.start, range.end),
+        end: Math.max(range.start, range.end)
+    };
+}
+function bodyWindow(node) {
+    return bodyWindowOf(sliceFencedCode(node), displayLength(node.raw));
+}
+function bodyWindowOf(slice, displayEnd) {
+    const bounds = fenceBodyBounds(slice);
+    // A fence with no body line yet (` ``` ` plus its ending) has a body start past
+    // the display text, so the block's own end is the floor everything collapses to.
+    const start = Math.min(bounds.start, displayEnd);
+    return { start, end: Math.min(Math.max(bounds.end, start), displayEnd) };
+}
+/**
+ * The body's display-text bounds, excluding both fence lines. `end` reads the body's
+ * own trailing ending through `displayLength`, so a CRLF document's boundary does not
+ * land between the `\r` and the `\n`.
+ */
+function fenceBodyBounds(slice) {
+    const start = slice.openerLine.length;
+    return { start, end: start + displayLength(slice.body) };
+}

package/dist/components/blocks/code/code-fence-exit.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pure decision for "does pressing Enter exit a fenced code block?". An unclosed
+ * fence exits by MINTING its own closer: the gesture authors a block below, and
+ * without a closer a reload's lazy continuation absorbs that block back in.
+ * `none` means Enter falls through to in-block edit handling.
+ */
+import type { FencedCodeMetadata } from '../../../core/nodes';
+export interface FenceExitInput {
+    text: string;
+    offset: number;
+    meta: FencedCodeMetadata;
+}
+export type FenceExitResult = {
+    kind: 'exit';
+} | {
+    kind: 'exitWithEdit';
+    newText: string;
+} | {
+    kind: 'closeAndExit';
+    newText: string;
+} | {
+    kind: 'none';
+};
+export declare function computeFenceExit(input: FenceExitInput): FenceExitResult;

package/dist/components/blocks/code/code-fence-exit.js

@@ -0,0 +1,36 @@
+/**
+ * Pure decision for "does pressing Enter exit a fenced code block?". An unclosed
+ * fence exits by MINTING its own closer: the gesture authors a block below, and
+ * without a closer a reload's lazy continuation absorbs that block back in.
+ * `none` means Enter falls through to in-block edit handling.
+ */
+import { trailingLineEnding } from '../../../core/lines';
+import { matchFenceClose } from '../../../core/parsers/fence-syntax';
+// ── Public API ──────────────────────────────────────────────────────────────
+export function computeFenceExit(input) {
+    const { text, offset, meta } = input;
+    if (meta.closed) {
+        if (offset === text.length)
+            return { kind: 'exit' };
+        const onEmptyLineBeforeCloser = offset >= 1 &&
+            text[offset - 1] === '\n' &&
+            text[offset] === '\n' &&
+            matchFenceClose(lineAt(text, offset + 1), meta.fenceMarker, meta.fenceLength);
+        if (onEmptyLineBeforeCloser) {
+            return { kind: 'exitWithEdit', newText: text.slice(0, offset) + text.slice(offset + 1) };
+        }
+        return { kind: 'none' };
+    }
+    if (offset === text.length && text.endsWith('\n')) {
+        const ending = trailingLineEnding(text);
+        const body = text.slice(0, text.length - ending.length);
+        const closer = meta.fenceMarker.repeat(meta.fenceLength);
+        return { kind: 'closeAndExit', newText: body + ending + closer };
+    }
+    return { kind: 'none' };
+}
+// The one physical line beginning at `start`, without its trailing newline.
+function lineAt(text, start) {
+    const end = text.indexOf('\n', start);
+    return end === -1 ? text.slice(start) : text.slice(start, end);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Pure tab-indent / tab-dedent for code-block text. Dedent removes one tab OR up to
+ * four leading spaces per line, preferring tab.
+ */
+export interface Selection {
+    start: number;
+    end: number;
+}
+export interface IndentResult {
+    text: string;
+    selection: Selection;
+}
+export declare function indentLines(text: string, selection: Selection): IndentResult;
+export declare function dedentLines(text: string, selection: Selection): IndentResult;

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

@@ -0,0 +1,87 @@
+/**
+ * Pure tab-indent / tab-dedent for code-block text. Dedent removes one tab OR up to
+ * four leading spaces per line, preferring tab.
+ */
+// ── Public API ──────────────────────────────────────────────────────────────
+export function indentLines(text, selection) {
+    if (selection.start === selection.end) {
+        const at = selection.start;
+        return {
+            text: text.slice(0, at) + '\t' + text.slice(at),
+            selection: { start: at + 1, end: at + 1 }
+        };
+    }
+    const lineStarts = collectLineStarts(text, selection);
+    let newText = text;
+    for (let i = lineStarts.length - 1; i >= 0; i--) {
+        const idx = lineStarts[i];
+        newText = newText.slice(0, idx) + '\t' + newText.slice(idx);
+    }
+    return {
+        text: newText,
+        selection: {
+            start: selection.start + 1,
+            end: selection.end + lineStarts.length
+        }
+    };
+}
+export function dedentLines(text, selection) {
+    if (selection.start === selection.end) {
+        const lineStart = text.lastIndexOf('\n', selection.start - 1) + 1;
+        const removed = computeDedentCount(text, lineStart);
+        if (removed === 0)
+            return { text, selection };
+        const newText = text.slice(0, lineStart) + text.slice(lineStart + removed);
+        const newCursor = Math.max(lineStart, selection.start - removed);
+        return { text: newText, selection: { start: newCursor, end: newCursor } };
+    }
+    const lineStarts = collectLineStarts(text, selection);
+    let newText = text;
+    let removedTotal = 0;
+    let removedOnFirstLine = 0;
+    for (let i = lineStarts.length - 1; i >= 0; i--) {
+        const idx = lineStarts[i];
+        const removed = computeDedentCount(newText, idx);
+        if (removed === 0)
+            continue;
+        newText = newText.slice(0, idx) + newText.slice(idx + removed);
+        if (i === 0)
+            removedOnFirstLine = removed;
+        removedTotal += removed;
+    }
+    const firstLineStart = lineStarts[0];
+    return {
+        text: newText,
+        selection: {
+            start: Math.max(firstLineStart, selection.start - removedOnFirstLine),
+            end: selection.end - removedTotal
+        }
+    };
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+/**
+ * Line-start offsets for every line the selection touches. A selection ending
+ * at or before a line's terminating newline stays on that line; one ending at
+ * the next line's start pulls that line in.
+ */
+function collectLineStarts(text, selection) {
+    const first = text.lastIndexOf('\n', selection.start - 1) + 1;
+    const starts = [first];
+    let pos = first;
+    while (pos < selection.end) {
+        const next = text.indexOf('\n', pos);
+        if (next === -1 || next >= selection.end)
+            break;
+        starts.push(next + 1);
+        pos = next + 1;
+    }
+    return starts;
+}
+function computeDedentCount(text, lineStart) {
+    if (text[lineStart] === '\t')
+        return 1;
+    let spaces = 0;
+    while (spaces < 4 && text[lineStart + spaces] === ' ')
+        spaces++;
+    return spaces;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Language registry for code-block tokenization. Nothing outside this directory
+ * imports highlight.js directly; static vs. dynamic loading is a policy on top.
+ */
+import type { LanguageFn } from 'highlight.js';
+export interface LanguageGrammar {
+    readonly name: string;
+    readonly definition: LanguageFn;
+}
+/** Idempotent — repeat calls with the same name are no-ops. */
+export declare function registerLanguage(name: string, definition: LanguageFn, aliasList?: readonly string[]): void;
+/** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
+export declare function getLanguageGrammar(infoString: string): LanguageGrammar | null;
+/** Test-only: clear all registered languages. */
+export declare function __resetRegistryForTests(): void;

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

@@ -0,0 +1,30 @@
+/**
+ * Language registry for code-block tokenization. Nothing outside this directory
+ * imports highlight.js directly; static vs. dynamic loading is a policy on top.
+ */
+const grammars = new Map();
+const aliases = new Map();
+/** Idempotent — repeat calls with the same name are no-ops. */
+export function registerLanguage(name, definition, aliasList = []) {
+    const key = name.toLowerCase();
+    if (grammars.has(key))
+        return;
+    grammars.set(key, { name: key, definition });
+    for (const alias of aliasList) {
+        aliases.set(alias.toLowerCase(), key);
+    }
+}
+/** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
+export function getLanguageGrammar(infoString) {
+    const trimmed = infoString.trim();
+    if (trimmed.length === 0)
+        return null;
+    const firstToken = trimmed.split(/\s+/)[0].toLowerCase();
+    const resolvedName = aliases.get(firstToken) ?? firstToken;
+    return grammars.get(resolvedName) ?? null;
+}
+/** Test-only: clear all registered languages. */
+export function __resetRegistryForTests() {
+    grammars.clear();
+    aliases.clear();
+}

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

@@ -0,0 +1,6 @@
+/**
+ * PasteSurface for fenced code blocks. Paste is always literal text, so the structural
+ * hook is omitted and pasteDispatch falls through to the inline path.
+ */
+import type { PasteSurface } from '../../../tree-operations/paste-surfaces';
+export declare const codePasteSurface: PasteSurface;

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

@@ -0,0 +1,29 @@
+/**
+ * PasteSurface for fenced code blocks. Paste is always literal text, so the structural
+ * hook is omitted and pasteDispatch falls through to the inline path.
+ */
+import { metadataOf } from '../../../core/nodes';
+import { trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
+import { computeCodePaste } from './code-paste';
+export const codePasteSurface = {
+    kind: 'fencedCode',
+    onInlinePaste(node, offset, text, preDelete) {
+        const meta = metadataOf(node, 'fencedCode');
+        const lineEnding = trailingLineEnding(node.raw);
+        const display = trimTrailingLineEnding(node.raw);
+        const start = preDelete?.start ?? offset;
+        const end = preDelete?.end ?? offset;
+        const result = computeCodePaste({
+            display,
+            selection: { start, end },
+            pasted: text,
+            fenceMarker: meta.fenceMarker,
+            fenceLength: meta.fenceLength,
+            closed: meta.closed
+        });
+        return {
+            newRaw: result.text + lineEnding,
+            caretOffset: result.cursor
+        };
+    }
+};

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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,21 @@
+/**
+ * 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/code/code-renderer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Code-block renderer. Produces a DocumentFragment with dimmed marker spans
+ * for fences and tokenized spans for the body. Invariant (G1.28):
+ *   fragment.textContent === trimTrailingLineEnding(node.raw)
+ */
+import type { NodeView } from '../../../core/node-views';
+export interface FencedCodeSlice {
+    openerLine: string;
+    body: string;
+    closerLine: string;
+    infoString: string;
+}
+export declare function sliceFencedCode(node: NodeView): FencedCodeSlice;
+export declare function mapHljsClass(hljsClass: string): string;
+export declare function walkHljsNodes(source: Node, target: DocumentFragment | HTMLElement): void;
+/** `ignoreIllegals` is set so mid-typing invalid syntax doesn't throw. */
+export declare function tokenizeBody(body: string, infoString: string): DocumentFragment;
+export declare function renderCodeBlock(node: NodeView): DocumentFragment;