@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/core/parsers/fence-syntax.d.ts

@@ -1,6 +1,7 @@
 /**
- * The fence grammar's line predicates, split from the block parser so the write-side rule
- * (`schema/fenced-code-raw.ts`) can read them without pulling `core/parser` into schema.
+ * The fence grammar: the line predicates, the closer search and a fenced block's anatomy, apart
+ * from the block parser so the write rule (`schema/fenced-code-raw.ts`) and plugins read the one
+ * definition without pulling `core/parser` in.
  */
 /**
  * The fence-open shape, re-exported on `@voithos-labs/aragonite/plugin` for fence-claiming openers:
@@ -15,10 +16,38 @@ export interface FenceOpen {
 }
 export declare function matchFenceOpen(text: string): FenceOpen | null;
 export declare function matchFenceClose(text: string, marker: '`' | '~', minLength: number): boolean;
+/** The fence length needed to wrap `body`: one past every body line that would close this block,
+ *  never below `minimum`, so no body line ejects the rest on reparse. */
+export declare function escalatedFenceLength(body: string, marker: '`' | '~', minimum: number): number;
+export declare function fenceRunLength(text: string, marker: '`' | '~'): number;
+/** A fence's marker and run length: what its closer has to repeat, at that length or longer. */
+export interface FenceRun {
+    marker: '`' | '~';
+    length: number;
+}
+/** The first line in `[from, end)` that closes `fence`, or -1: the closer the parser takes. */
+export declare function findFenceCloser(lines: readonly {
+    text: string;
+}[], from: number, end: number, fence: FenceRun): number;
 /**
- * The fence length needed to wrap `body`: one past every body line the parser would read
- * as this block's closer, never below `minimum`. Without it a body line reproducing the
- * terminator closes the block early and ejects everything below it on reparse. A floor,
- * not a target: it never shortens an existing fence.
+ * Where a fenced block's parts sit in its bytes: the opener's indent, marker run and info string,
+ * the body, and the closer line. Offsets are into the bytes as given, trailing ending included.
  */
-export declare function escalatedFenceLength(body: string, marker: '`' | '~', minimum: number): number;
+export interface FenceAnatomy extends FenceRun {
+    /** End of the opener's indent; its marker run ends at `runEnd`, its info string at `openerEnd`. */
+    indentEnd: number;
+    runEnd: number;
+    openerEnd: number;
+    /** Past the opener's line ending, where the body starts. */
+    bodyStart: number;
+    /** Where the closer line starts, or the end of the bytes for a fence nothing closes. */
+    closerStart: number;
+    closed: boolean;
+}
+/** Reads `raw` as a fenced block whose line 0 opens a run of `fence`'s marker at least as long (any
+ *  fence when omitted), closed when its last line closes that run. Null when line 0 opens none. */
+export declare function fenceAnatomy(raw: string, fence?: FenceRun): FenceAnatomy | null;
+/** A fence opener whose info string's first word is `token`: how a plugin claims its fences. */
+export declare function matchFenceInfo(token: string): (text: string) => FenceOpen | null;
+/** An info string's first word, which names the fence's language; empty when there is none. */
+export declare function fenceLanguage(info: string): string;

package/dist/core/parsers/fence-syntax.js

@@ -1,8 +1,10 @@
 /**
- * The fence grammar's line predicates, split from the block parser so the write-side rule
- * (`schema/fenced-code-raw.ts`) can read them without pulling `core/parser` into schema.
+ * The fence grammar: the line predicates, the closer search and a fenced block's anatomy, apart
+ * from the block parser so the write rule (`schema/fenced-code-raw.ts`) and plugins read the one
+ * definition without pulling `core/parser` in.
  */
 import { escalateTerminatorRun } from '../terminator-escalation';
+import { OPTIONAL_LINE_ENDING, splitLines, trimWhitespace, WHITESPACE_RUN } from '../lines';
 // Backtick info may not contain backticks (CommonMark §4.5); tilde info may.
 const BACKTICK_OPEN = /^( {0,3})(`{3,})([^`]*)$/;
 const TILDE_OPEN = /^( {0,3})(~{3,})(.*)$/;
@@ -14,26 +16,25 @@ export function matchFenceOpen(text) {
     return {
         marker: fence[0],
         length: fence.length,
-        info: infoRaw.trim(),
+        info: trimWhitespace(infoRaw),
         indent,
         infoRaw
     };
 }
+// GFM §4.5: only spaces or tabs follow a closer. The line ending is for a caller that passes one.
+const BACKTICK_CLOSE = new RegExp(`^ {0,3}(\`{3,})[ \\t]*${OPTIONAL_LINE_ENDING}$`);
+const TILDE_CLOSE = new RegExp(`^ {0,3}(~{3,})[ \\t]*${OPTIONAL_LINE_ENDING}$`);
 export function matchFenceClose(text, marker, minLength) {
-    const pattern = marker === '`' ? /^ {0,3}(`{3,})\s*$/ : /^ {0,3}(~{3,})\s*$/;
+    const pattern = marker === '`' ? BACKTICK_CLOSE : TILDE_CLOSE;
     const m = text.match(pattern);
     return Boolean(m && m[1].length >= minLength);
 }
-/**
- * The fence length needed to wrap `body`: one past every body line the parser would read
- * as this block's closer, never below `minimum`. Without it a body line reproducing the
- * terminator closes the block early and ejects everything below it on reparse. A floor,
- * not a target: it never shortens an existing fence.
- */
+/** The fence length needed to wrap `body`: one past every body line that would close this block,
+ *  never below `minimum`, so no body line ejects the rest on reparse. */
 export function escalatedFenceLength(body, marker, minimum) {
     return escalateTerminatorRun(body, minimum, (text, required) => matchFenceClose(text, marker, required) ? fenceRunLength(text, marker) : null);
 }
-function fenceRunLength(text, marker) {
+export function fenceRunLength(text, marker) {
     let index = 0;
     while (text[index] === ' ')
         index++;
@@ -42,3 +43,52 @@ function fenceRunLength(text, marker) {
         run++;
     return run;
 }
+/** The first line in `[from, end)` that closes `fence`, or -1: the closer the parser takes. */
+export function findFenceCloser(lines, from, end, fence) {
+    for (let i = from; i < end; i++) {
+        if (matchFenceClose(lines[i].text, fence.marker, fence.length))
+            return i;
+    }
+    return -1;
+}
+/** Reads `raw` as a fenced block whose line 0 opens a run of `fence`'s marker at least as long (any
+ *  fence when omitted), closed when its last line closes that run. Null when line 0 opens none. */
+export function fenceAnatomy(raw, fence) {
+    const lines = splitLines(raw);
+    if (lines.length === 0)
+        return null;
+    const opener = lines[0];
+    const indentEnd = /^ {0,3}/.exec(opener.text)[0].length;
+    const marker = fence?.marker ?? opener.text[indentEnd];
+    if (marker !== '`' && marker !== '~')
+        return null;
+    let runEnd = indentEnd;
+    while (opener.text[runEnd] === marker)
+        runEnd++;
+    const length = runEnd - indentEnd;
+    if (length < Math.max(3, fence?.length ?? 3))
+        return null;
+    const last = lines[lines.length - 1];
+    const closed = lines.length > 1 && matchFenceClose(last.text, marker, length);
+    return {
+        marker,
+        length,
+        indentEnd,
+        runEnd,
+        openerEnd: opener.text.length,
+        bodyStart: opener.end,
+        closerStart: closed ? last.start : raw.length,
+        closed
+    };
+}
+/** A fence opener whose info string's first word is `token`: how a plugin claims its fences. */
+export function matchFenceInfo(token) {
+    return (text) => {
+        const fence = matchFenceOpen(text);
+        return fence && fenceLanguage(fence.info) === token ? fence : null;
+    };
+}
+/** An info string's first word, which names the fence's language; empty when there is none. */
+export function fenceLanguage(info) {
+    return trimWhitespace(info).split(WHITESPACE_RUN)[0];
+}

package/dist/core/parsers/fenced-code.d.ts

@@ -1,5 +1,21 @@
 import type { ParsedLine } from '../lines';
 import type { BlockOpenerResult } from '../../schema/block-openers';
+import { type FenceRun } from './fence-syntax';
+/** A fence's extent from its opener line: `closer` is the line that closes it, or -1. */
+export interface FenceScan {
+    closer: number;
+    /** Lines taken, the opener and closer included; to the end of the range when nothing closes. */
+    consumed: number;
+    raw: string;
+    /** The lines between the fence lines, verbatim. */
+    body: string;
+}
+/** Scans the fence opened at `ctx.index` the way the parser does: it closes on its first closer. */
+export declare function scanFence(ctx: {
+    lines: ParsedLine[];
+    index: number;
+    end: number;
+}, fence: FenceRun): FenceScan;
 export declare function parseFencedCode(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, fence: {
     marker: '`' | '~';
     length: number;

package/dist/core/parsers/fenced-code.js

@@ -1,29 +1,30 @@
 import { joinRaw } from '../parser';
-import { matchFenceClose } from './fence-syntax';
+import { findFenceCloser } from './fence-syntax';
+/** Scans the fence opened at `ctx.index` the way the parser does: it closes on its first closer. */
+export function scanFence(ctx, fence) {
+    const closer = findFenceCloser(ctx.lines, ctx.index + 1, ctx.end, fence);
+    const stop = closer === -1 ? ctx.end : closer + 1;
+    return {
+        closer,
+        consumed: stop - ctx.index,
+        raw: joinRaw(ctx.lines, ctx.index, stop),
+        body: joinRaw(ctx.lines, ctx.index + 1, closer === -1 ? ctx.end : closer)
+    };
+}
 export function parseFencedCode(lines, startIndex, endIndex, leadingTrivia, fence) {
-    let i = startIndex + 1;
-    let closed = false;
-    while (i < endIndex) {
-        if (matchFenceClose(lines[i].text, fence.marker, fence.length)) {
-            i++;
-            closed = true;
-            break;
-        }
-        i++;
-    }
-    const raw = joinRaw(lines, startIndex, i);
+    const scan = scanFence({ lines, index: startIndex, end: endIndex }, fence);
     return {
         node: {
             kind: 'fencedCode',
             leadingTrivia,
-            raw,
+            raw: scan.raw,
             metadata: {
                 fenceMarker: fence.marker,
                 fenceLength: fence.length,
                 info: fence.info,
-                closed
+                closed: scan.closer !== -1
             }
         },
-        consumed: i - startIndex
+        consumed: scan.consumed
     };
 }

package/dist/core/parsers/heading.d.ts

@@ -1,3 +1,20 @@
-export declare function matchHeading(text: string): {
+import type { AnyBlockKind } from '../nodes';
+export interface AtxHeadingMatch {
     level: number;
-} | null;
+    /** The editable text's range in the line: past the hashes and one space or tab, and short of
+     *  the closing run with the one space or tab before it (GFM §4.2). */
+    contentStart: number;
+    contentEnd: number;
+}
+/** The ATX heading `text` opens, read once for every caller: the parser, the content range and
+ *  the keys that rewrite a heading's marker. `text` may carry its line ending. */
+export declare function matchHeading(text: string): AtxHeadingMatch | null;
+/** A heading whose bytes are its hashes alone, the state a line passes through on the way to `#tag`.
+ *  The parse keeps it a heading; {@link shownKind} decides what it shows as. */
+export declare function isBareHeadingOpener(raw: string): boolean;
+/** The kind a block shows as: a bare `#` keeps the paragraph's type until the space lands, so a line
+ *  on its way to `#tag` never flashes to heading size. */
+export declare function shownKind(node: {
+    kind: AnyBlockKind;
+    raw: string;
+}): AnyBlockKind;

package/dist/core/parsers/heading.js

@@ -1,6 +1,54 @@
 // ATX headings only. Setext (`===` / `---` underline) lives in paragraph.ts
 // because it emerges from paragraph continuation.
+import { OPTIONAL_LINE_ENDING, displayLength, trimTrailingLineEnding } from '../lines';
+// GFM §4.2: the hashes end at a space, a tab or the line's end.
+const OPENING = /^ {0,3}(#{1,6})(?:[ \t]|$)/;
+const MAY_OPEN = /^ {0,3}#/;
+const LINE_ENDING = new RegExp(`${OPTIONAL_LINE_ENDING}$`);
+/** The ATX heading `text` opens, read once for every caller: the parser, the content range and
+ *  the keys that rewrite a heading's marker. `text` may carry its line ending. */
 export function matchHeading(text) {
-    const m = text.match(/^ {0,3}(#{1,6})(?:\s|$)/);
-    return m ? { level: m[1].length } : null;
+    // Every parsed line comes through here, so a line that opens no heading costs no copy.
+    if (!MAY_OPEN.test(text))
+        return null;
+    // A document's last line may end in a lone `\r`, which a heading's own raw keeps as text.
+    const line = text.replace(LINE_ENDING, '');
+    const m = OPENING.exec(line);
+    if (!m)
+        return null;
+    const contentStart = m[0].length;
+    const contentEnd = closingRunStart(line, contentStart) ?? displayLength(text);
+    return { level: m[1].length, contentStart, contentEnd };
+}
+/** Where the optional closing `#` run starts, with the space or tab before it, or null. Trailing
+ *  whitespace with no run after it stays content, so a space typed at the end is kept. */
+function closingRunStart(line, contentStart) {
+    let end = line.length;
+    while (end > contentStart && isSpaceOrTab(line[end - 1]))
+        end--;
+    let run = end;
+    while (run > contentStart && line[run - 1] === '#')
+        run--;
+    if (run === end)
+        return null;
+    if (run === contentStart)
+        return contentStart;
+    return isSpaceOrTab(line[run - 1]) ? run - 1 : null;
+}
+function isSpaceOrTab(ch) {
+    return ch === ' ' || ch === '\t';
+}
+/** A heading whose bytes are its hashes alone, the state a line passes through on the way to `#tag`.
+ *  The parse keeps it a heading; {@link shownKind} decides what it shows as. */
+export function isBareHeadingOpener(raw) {
+    const heading = matchHeading(raw);
+    if (!heading)
+        return false;
+    const line = trimTrailingLineEnding(raw);
+    return heading.contentStart === line.length && line.endsWith('#');
+}
+/** The kind a block shows as: a bare `#` keeps the paragraph's type until the space lands, so a line
+ *  on its way to `#tag` never flashes to heading size. */
+export function shownKind(node) {
+    return node.kind === 'heading' && isBareHeadingOpener(node.raw) ? 'paragraph' : node.kind;
 }

package/dist/core/parsers/html-block.d.ts

@@ -2,14 +2,11 @@
  * HTML block parser, CommonMark §4.6: seven block types, each with its own close
  * condition. Types 1-5 close on a per-type pattern; types 6-7 close on a blank line.
  */
-import type { ParsedLine } from '../lines';
+import { type ParsedLine } from '../lines';
 import type { BlockOpenerResult } from '../../schema/block-openers';
 export type HtmlBlockType = 1 | 2 | 3 | 4 | 5 | 6 | 7;
-/**
- * Recognize a type-6 tag line for ONE listed tag name, open or close. Built from the same
- * shape as the type-6 union so a container whose terminator is an html tag line tests the
- * spec's looseness (`   </details>`, `</DETAILS>`, `<details >`) rather than a copy of it.
- */
+/** Recognize a type-6 tag line, open or close, for one tag name, built from the type-6 union so a
+ *  terminator tests the spec's looseness (`</DETAILS>`, `<details >`) rather than a copy of it. */
 export declare function htmlBlockTagLineMatcher(tagName: string): (text: string) => 'open' | 'close' | null;
 export declare function matchHtmlBlock(text: string): HtmlBlockType | null;
 /** Types 1-6 interrupt a paragraph; type 7 (catch-all complete tags) cannot, per §4.6. */

package/dist/core/parsers/html-block.js

@@ -2,26 +2,26 @@
  * HTML block parser, CommonMark §4.6: seven block types, each with its own close
  * condition. Types 1-5 close on a per-type pattern; types 6-7 close on a blank line.
  */
+import { WHITESPACE_CLASS } from '../lines';
 import { joinRaw, isBlankLine } from '../parser';
 import { OPEN_TAG_SOURCE, CLOSE_TAG_SOURCE } from '../inline/html-tag-grammar';
 // ── Per-type opener patterns ────────────────────────────────────────────────
 // Priority 1 → 7, first match wins. script/pre/style/textarea must stay out of type 6's
 // tag union: they close on their end tag, not on a blank line.
-const TYPE_1_OPEN = /^ {0,3}<(?:script|pre|style|textarea)(?:[\s/>]|$)/i;
+// A tag name ends at GFM whitespace (§2.1), `/`, `>` or the line's end.
+const TAG_NAME_END = `(?:${WHITESPACE_CLASS}|[/>]|$)`;
+const TYPE_1_OPEN = new RegExp(`^ {0,3}<(?:script|pre|style|textarea)${TAG_NAME_END}`, 'i');
 const TYPE_2_OPEN = /^ {0,3}<!--/;
 const TYPE_3_OPEN = /^ {0,3}<\?/;
 const TYPE_4_OPEN = /^ {0,3}<![A-Za-z]/;
 const TYPE_5_OPEN = /^ {0,3}<!\[CDATA\[/;
 const TYPE_6_TAGS = 'address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|template|tfoot|th|thead|title|tr|track|ul';
 function type6Shape(names) {
-    return `^ {0,3}<(/?)(?:${names})(?:[\\s/>]|$)`;
+    return `^ {0,3}<(/?)(?:${names})${TAG_NAME_END}`;
 }
 const TYPE_6_OPEN = new RegExp(type6Shape(TYPE_6_TAGS), 'i');
-/**
- * Recognize a type-6 tag line for ONE listed tag name, open or close. Built from the same
- * shape as the type-6 union so a container whose terminator is an html tag line tests the
- * spec's looseness (`   </details>`, `</DETAILS>`, `<details >`) rather than a copy of it.
- */
+/** Recognize a type-6 tag line, open or close, for one tag name, built from the type-6 union so a
+ *  terminator tests the spec's looseness (`</DETAILS>`, `<details >`) rather than a copy of it. */
 export function htmlBlockTagLineMatcher(tagName) {
     const pattern = new RegExp(type6Shape(tagName), 'i');
     return (text) => {
@@ -29,10 +29,9 @@ export function htmlBlockTagLineMatcher(tagName) {
         return m === null ? null : m[1] === '/' ? 'close' : 'open';
     };
 }
-// CommonMark §6.6 complete-tag grammar at line scope, reusing the inline raw-HTML sources
-// (core/inline/html-tag-grammar.ts). Priority LAST: types 1 and 6 claim their names first,
-// which is what implements the spec's exclusion of the type-1 tag names.
-const TYPE_7_OPEN = new RegExp(`^ {0,3}(?:${OPEN_TAG_SOURCE}|${CLOSE_TAG_SOURCE})\\s*$`);
+// CommonMark §6.6's complete-tag grammar at line scope, from the inline raw-HTML sources. Last in
+// priority, so types 1 and 6 take their tag names first, as the spec requires.
+const TYPE_7_OPEN = new RegExp(`^ {0,3}(?:${OPEN_TAG_SOURCE}|${CLOSE_TAG_SOURCE})${WHITESPACE_CLASS}*$`);
 export function matchHtmlBlock(text) {
     if (TYPE_1_OPEN.test(text))
         return 1;

package/dist/core/parsers/indented-code.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedLine } from '../lines';
+import { type ParsedLine } from '../lines';
 import type { BlockOpenerResult } from '../../schema/block-openers';
 export declare function matchIndentedCode(text: string): boolean;
 export declare function parseIndentedCode(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string): BlockOpenerResult;

package/dist/core/parsers/indented-code.js

@@ -1,15 +1,9 @@
 // The paragraph-interruption guard is dispatch context, not a line-level match, so it lives
 // with the opener registration rather than the matcher.
+import { indentColumns } from '../lines';
 import { joinRaw, isBlankLine } from '../parser';
 export function matchIndentedCode(text) {
-    // GFM §2.2: a tab advances to the next 4-column stop, so `  \t` is four columns of indent.
-    let col = 0;
-    for (let i = 0; i < text.length && (text[i] === ' ' || text[i] === '\t'); i++) {
-        col += text[i] === '\t' ? 4 - (col % 4) : 1;
-        if (col >= 4)
-            return true;
-    }
-    return false;
+    return indentColumns(text) >= 4;
 }
 export function parseIndentedCode(lines, startIndex, endIndex, leadingTrivia) {
     let i = startIndex;

package/dist/core/parsers/link-reference.d.ts

@@ -1,7 +1,9 @@
 /**
- * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`, URL and title
- * allowed on continuation lines). Footnote labels (`[^...]:`) are excluded; they stay paragraphs.
+ * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`). The label,
+ * destination and title are read by the link grammar in `inline/link-destination.ts`, and may
+ * continue on the lines after the first that a paragraph would absorb. Footnote labels
+ * (`[^...]:`) stay paragraphs.
  */
-import type { ParsedLine } from '../lines';
+import { type ParsedLine } from '../lines';
 import { type BlockOpenerResult } from '../../schema/block-openers';
 export declare function parseLinkReferenceDefinition(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string): BlockOpenerResult | null;