@voithos-labs/aragonite 0.10.1

package/dist/core/lines.js

@@ -0,0 +1,91 @@
+/** Line splitting preserving endings and offsets, plus the trailing-line-ending helpers. */
+/** Length of `raw` excluding any trailing line ending (LF or CRLF). */
+export function displayLength(raw) {
+    if (raw.endsWith('\r\n'))
+        return raw.length - 2;
+    if (raw.endsWith('\n'))
+        return raw.length - 1;
+    return raw.length;
+}
+export function trimTrailingLineEnding(raw) {
+    return raw.slice(0, displayLength(raw));
+}
+/**
+ * The ending `raw` actually carries — {@link trimTrailingLineEnding}'s complement, the two
+ * partitioning `raw`. What {@link trailingLineEnding} answers instead is which ending the
+ * DOCUMENT uses, so a site reattaching a block's own bytes reads this one (G4.20).
+ */
+export function ownTrailingLineEnding(raw) {
+    return raw.slice(displayLength(raw));
+}
+/**
+ * `offset` moved off the interior of a surrogate pair, back to the pair's own start. Caret
+ * offsets are UTF-16 code units, so a cut at one can halve an astral scalar and leave a lone
+ * surrogate — bytes no UTF-8 encoder round-trips (`TextEncoder` yields U+FFFD) and no inverse
+ * gesture restores. Scalars only: a grapheme cluster is a rendering question, and answering it
+ * here would move a caret the author placed between two legitimately separate scalars.
+ */
+export function snapToScalarBoundary(raw, offset) {
+    if (offset <= 0 || offset >= raw.length)
+        return offset;
+    const splitsPair = (raw.charCodeAt(offset - 1) & 0xfc00) === 0xd800 &&
+        (raw.charCodeAt(offset) & 0xfc00) === 0xdc00;
+    return splitsPair ? offset - 1 : offset;
+}
+/**
+ * The block's authored trailing line ending. Every site that reattaches or mints one reads it
+ * here (G4.20), so a CRLF-authored block keeps its ending and an unterminated one gets `\n`.
+ */
+export function trailingLineEnding(raw) {
+    return raw.endsWith('\r\n') ? '\r\n' : '\n';
+}
+/**
+ * Keep a truncated slice line-terminated, borrowing `sourceRaw`'s own ending (G4.20). A slice
+ * whose last line stays open swallows whatever follows it once the bytes stand alone.
+ */
+export function terminateLine(text, sourceRaw) {
+    return text.endsWith('\n') ? text : text + trailingLineEnding(sourceRaw);
+}
+/** Paste entry points funnel through here so Windows CRLF does not leak into a note. */
+export function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+export function splitLines(source) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] === '\n') {
+            const raw = source.slice(start, i + 1);
+            const lineEnding = source[i - 1] === '\r' ? '\r\n' : '\n';
+            const text = raw.slice(0, raw.length - lineEnding.length);
+            lines.push({ raw, text, lineEnding, start, end: i + 1 });
+            start = i + 1;
+        }
+    }
+    if (start < source.length) {
+        const raw = source.slice(start);
+        lines.push({ raw, text: raw, lineEnding: '', start, end: source.length });
+    }
+    return lines;
+}
+/**
+ * Re-mint a `ParsedLine[]` after a per-line strip, as the container parsers do when they reparse
+ * a prefix-stripped body. Recompute, not spread: reusing an input line's offsets after shortening
+ * its text desyncs the offsets from the bytes.
+ */
+export function remapStrippedLines(lines, stripLine) {
+    let offset = 0;
+    return lines.map((line, index) => {
+        const text = stripLine(line, index);
+        const raw = text + line.lineEnding;
+        const stripped = {
+            raw,
+            text,
+            lineEnding: line.lineEnding,
+            start: offset,
+            end: offset + raw.length
+        };
+        offset += raw.length;
+        return stripped;
+    });
+}

package/dist/core/node-views.d.ts

@@ -0,0 +1,22 @@
+/**
+ * G1.9 in the type system (G3.8): a snapshot-shared node is read-only on its serialized bytes,
+ * so a view freezes every byte-carrying field. `childIds`, `childSpans` and `ownerEpoch` are
+ * editor bookkeeping, not round-trip bytes, and stay writable through a view. The ONE sanctioned
+ * view-to-mutable door is the unshare seam (`tree-operations/unshare.ts`) plus the commit
+ * ceremony's owned scope views (G4.13); everywhere else the source-scan lint holds the perimeter.
+ */
+import type { CstNode, Document } from './nodes';
+type BytesWritableKey = 'childIds' | 'childSpans' | 'ownerEpoch';
+/** Primitives pass through untouched, so branded string kinds keep their brands. */
+export type BytesView<T> = T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends readonly (infer E)[] ? readonly BytesView<E>[] : {
+    readonly [K in keyof T as K extends BytesWritableKey ? never : K]: BytesView<T[K]>;
+} & {
+    [K in keyof T as K extends BytesWritableKey ? K : never]: T[K];
+};
+export type NodeView = BytesView<CstNode>;
+export type DocumentView = BytesView<Document>;
+/** A spine root the unshare seam accepts: the live document or a caller-owned children wrapper. */
+export type NodeParentView = {
+    readonly children: readonly NodeView[];
+};
+export {};

package/dist/core/node-views.js

@@ -0,0 +1,8 @@
+/**
+ * G1.9 in the type system (G3.8): a snapshot-shared node is read-only on its serialized bytes,
+ * so a view freezes every byte-carrying field. `childIds`, `childSpans` and `ownerEpoch` are
+ * editor bookkeeping, not round-trip bytes, and stay writable through a view. The ONE sanctioned
+ * view-to-mutable door is the unshare seam (`tree-operations/unshare.ts`) plus the commit
+ * ceremony's owned scope views (G4.13); everywhere else the source-scan lint holds the perimeter.
+ */
+export {};

package/dist/core/nodes.d.ts

@@ -0,0 +1,297 @@
+/** CST node types for the GFM parser: mutable plain objects. Spec: docs/design/syntax-tree.md. */
+import type { BytesView, NodeView } from './node-views';
+export type LeafBlockKind = 'heading' | 'setextHeading' | 'paragraph' | 'fencedCode' | 'thematicBreak' | 'indentedCode' | 'htmlBlock' | 'linkReferenceDefinition' | 'tableCell' | 'unrecognized';
+export type ContainerBlockKind = 'blockquote' | 'list' | 'listItem' | 'table' | 'tableRow';
+export type BlockKind = LeafBlockKind | ContainerBlockKind;
+/**
+ * The single union-derived source for "iterate over all kinds": `Record<BlockKind, true>` makes
+ * the compiler flag a missing or stray member, where a hand-kept list passes vacuously.
+ */
+export declare const BLOCK_KIND_TABLE: Record<BlockKind, true>;
+export declare const ALL_BLOCK_KINDS: BlockKind[];
+declare const PluginKindBrand: unique symbol;
+/**
+ * A plugin-declared block kind, a plain string at runtime. The brand keeps `BlockKind` switches
+ * exhaustive over built-ins while the registries key plugin kinds. Create via `declarePluginKind`.
+ */
+export type PluginBlockKind = string & {
+    readonly [PluginKindBrand]: true;
+};
+export type AnyBlockKind = BlockKind | PluginBlockKind;
+export declare function isBuiltinBlockKind(kind: AnyBlockKind): kind is BlockKind;
+export interface HeadingMetadata {
+    level: number;
+}
+export interface SetextHeadingMetadata {
+    level: 1 | 2;
+}
+export interface FencedCodeMetadata {
+    fenceMarker: '`' | '~';
+    fenceLength: number;
+    info: string;
+    closed: boolean;
+}
+export interface ThematicBreakMetadata {
+    marker: string;
+}
+export interface LinkReferenceDefinitionMetadata {
+    label: string;
+    url?: string;
+    title?: string;
+}
+export type TableAlignment = 'none' | 'left' | 'center' | 'right';
+export interface TableMetadata {
+    columnCount: number;
+    alignments: TableAlignment[];
+}
+export interface TableRowMetadata {
+    isHeader: boolean;
+}
+export interface BlockquoteMetadata {
+    quoteDepth: number;
+}
+export interface ListMetadata {
+    ordered: boolean;
+}
+export interface ListItemMetadata {
+    marker: string;
+    taskItem: boolean;
+    taskChecked: boolean;
+    taskMarker: string | null;
+}
+export type BlockMetadata = HeadingMetadata | SetextHeadingMetadata | FencedCodeMetadata | ThematicBreakMetadata | LinkReferenceDefinitionMetadata | TableMetadata | TableRowMetadata | BlockquoteMetadata | ListMetadata | ListItemMetadata;
+/** Metadata-less kinds are intentionally absent, so `metadataOf` rejects them. */
+export interface BlockMetadataByKind {
+    heading: HeadingMetadata;
+    setextHeading: SetextHeadingMetadata;
+    fencedCode: FencedCodeMetadata;
+    thematicBreak: ThematicBreakMetadata;
+    linkReferenceDefinition: LinkReferenceDefinitionMetadata;
+    table: TableMetadata;
+    tableRow: TableRowMetadata;
+    blockquote: BlockquoteMetadata;
+    list: ListMetadata;
+    listItem: ListItemMetadata;
+}
+/**
+ * The one sanctioned metadata cast, for contexts a narrowed `BuiltinCstNode` arm cannot reach:
+ * a generic `K`, or a full `CstNode` whose branded plugin arm blocks `kind` narrowing. Prefer
+ * reading `node.metadata` off a narrowed arm. Pass the kind you have already established.
+ */
+export declare function metadataOf<K extends keyof BlockMetadataByKind>(node: CstNode, kind: K): BlockMetadataByKind[K];
+export declare function metadataOf<K extends keyof BlockMetadataByKind>(node: NodeView, kind: K): BytesView<BlockMetadataByKind[K]>;
+/**
+ * `BlockMetadata` is closed over the built-ins, so bridging a plugin's shape needs a cast and
+ * this pair is the one place it lives. Keep the stored shape primitive-valued: the one-level
+ * undo clone (G1.6) shallow-copies metadata.
+ */
+export declare function setPluginMetadata<T>(node: CstNode, data: T): void;
+export declare function getPluginMetadata<T>(node: NodeView): T | undefined;
+/**
+ * Null for any non-heading node. The one heading-metadata read on the authoring barrel:
+ * `metadata.level` narrows only past `isBuiltinBlockNode`, which the barrel does not export.
+ */
+export declare function headingLevel(node: NodeView): number | null;
+/** `ownerEpoch` is structural-sharing bookkeeping, not round-trip bytes. */
+interface BlockNodeBase {
+    leadingTrivia: string;
+    raw: string;
+    ownerEpoch?: number;
+}
+/**
+ * G1.5 forbids `children` and the container structural fields on non-containers, so the arms pin
+ * them `undefined` and the union rejects a leaf that grew a child at the type level.
+ */
+interface LeafBlockNodeBase extends BlockNodeBase {
+    children?: undefined;
+    innerPrefix?: undefined;
+    innerSuffix?: undefined;
+    childIds?: undefined;
+    childSpans?: undefined;
+}
+/**
+ * G1.5 is one-directional (a container may be transiently childless mid-edit), so every
+ * structural field stays optional. `childIds` mirrors `children` for keyed rendering;
+ * `childSpans` records where each child's bytes sit in `raw` (`schema/child-spans.ts`).
+ */
+interface ContainerBlockNodeBase extends BlockNodeBase {
+    children?: CstNode[];
+    innerPrefix?: string;
+    innerSuffix?: string;
+    childIds?: string[];
+    childSpans?: Uint32Array;
+}
+export interface ParagraphNode extends LeafBlockNodeBase {
+    kind: 'paragraph';
+    metadata?: undefined;
+}
+export interface HeadingNode extends LeafBlockNodeBase {
+    kind: 'heading';
+    metadata: HeadingMetadata;
+}
+export interface SetextHeadingNode extends LeafBlockNodeBase {
+    kind: 'setextHeading';
+    metadata: SetextHeadingMetadata;
+}
+export interface FencedCodeNode extends LeafBlockNodeBase {
+    kind: 'fencedCode';
+    metadata: FencedCodeMetadata;
+}
+export interface ThematicBreakNode extends LeafBlockNodeBase {
+    kind: 'thematicBreak';
+    metadata: ThematicBreakMetadata;
+}
+export interface IndentedCodeNode extends LeafBlockNodeBase {
+    kind: 'indentedCode';
+    metadata?: undefined;
+}
+export interface HtmlBlockNode extends LeafBlockNodeBase {
+    kind: 'htmlBlock';
+    metadata?: undefined;
+}
+export interface LinkReferenceDefinitionNode extends LeafBlockNodeBase {
+    kind: 'linkReferenceDefinition';
+    metadata: LinkReferenceDefinitionMetadata;
+}
+export interface TableCellNode extends LeafBlockNodeBase {
+    kind: 'tableCell';
+    metadata?: undefined;
+}
+export interface UnrecognizedNode extends LeafBlockNodeBase {
+    kind: 'unrecognized';
+    metadata?: undefined;
+}
+export interface BlockquoteNode extends ContainerBlockNodeBase {
+    kind: 'blockquote';
+    metadata: BlockquoteMetadata;
+}
+export interface ListNode extends ContainerBlockNodeBase {
+    kind: 'list';
+    metadata: ListMetadata;
+}
+export interface ListItemNode extends ContainerBlockNodeBase {
+    kind: 'listItem';
+    metadata: ListItemMetadata;
+}
+export interface TableNode extends ContainerBlockNodeBase {
+    kind: 'table';
+    metadata: TableMetadata;
+}
+export interface TableRowNode extends ContainerBlockNodeBase {
+    kind: 'tableRow';
+    metadata: TableRowMetadata;
+}
+/**
+ * A branded-string kind, so this arm is NOT discriminable by `switch (node.kind)`: narrow past
+ * it with `isBuiltinBlockNode` first. A plugin block may be a leaf or a container, so the
+ * structural fields stay optional.
+ */
+export interface PluginBlockNode extends BlockNodeBase {
+    kind: PluginBlockKind;
+    metadata?: BlockMetadata;
+    children?: CstNode[];
+    innerPrefix?: string;
+    innerSuffix?: string;
+    childIds?: string[];
+    childSpans?: Uint32Array;
+}
+/** A genuine discriminated union: `switch (node.kind)` narrows `node.metadata` with no cast. */
+export type BuiltinCstNode = ParagraphNode | HeadingNode | SetextHeadingNode | FencedCodeNode | ThematicBreakNode | IndentedCodeNode | HtmlBlockNode | LinkReferenceDefinitionNode | TableCellNode | UnrecognizedNode | BlockquoteNode | ListNode | ListItemNode | TableNode | TableRowNode;
+/**
+ * The open `PluginBlockNode` arm does not discriminate, so full-union `kind` checks do not
+ * narrow: reach the discriminated world through `isBuiltinBlockNode`. Common fields (`raw`,
+ * `leadingTrivia`, `kind`) project across every arm and read without narrowing.
+ */
+export type CstNode = BuiltinCstNode | PluginBlockNode;
+/**
+ * The door to the `switch (node.kind)` narrowing the branded plugin arm blocks. Mirrored for
+ * views, so a reader that narrows a `NodeView` reads each arm's metadata with no `metadataOf`.
+ */
+export declare function isBuiltinBlockNode(node: CstNode): node is BuiltinCstNode;
+export declare function isBuiltinBlockNode(node: NodeView): node is BytesView<BuiltinCstNode>;
+/**
+ * The ONE place the runtime-kind construction cast lives. A construction door, not the
+ * view-to-mutable strip door: the spread returns a FRESH object, so passing a view mints a copy
+ * instead of stripping its readonly-ness, which is why G4.13 sanctions this file. Fields are not
+ * checked against the arm, so a metadata-less node of a metadata-carrying kind is mintable (a
+ * transient re-parse probe does this) and its `metadata` must not be read before re-parse.
+ */
+export declare function makeBlockNode(fields: {
+    kind: AnyBlockKind;
+    leadingTrivia: string;
+    raw: string;
+    metadata?: BlockMetadata;
+    children?: CstNode[];
+    innerPrefix?: string;
+    innerSuffix?: string;
+    childIds?: string[];
+    ownerEpoch?: number;
+}): CstNode;
+export interface Document {
+    kind: 'document';
+    prefix: string;
+    children: CstNode[];
+    suffix: string;
+    /** The root's parallel id array while a caller keeps one here — the editor's own live ids
+     *  are editor state, but the splice doors maintain whatever array the parent carries. */
+    childIds?: string[];
+}
+export type InlineNodeKind = 'text' | 'emphasis' | 'strong' | 'strikethrough' | 'inlineCode' | 'link' | 'image' | 'autolink' | 'hardLineBreak' | 'escape' | 'entityReference' | 'unresolvedReference' | 'rawHtml';
+declare const InlineKindBrand: unique symbol;
+/** The inline sibling of `PluginBlockKind`; create via `declarePluginInlineKind`. */
+export type PluginInlineKind = string & {
+    readonly [InlineKindBrand]: true;
+};
+export type AnyInlineKind = InlineNodeKind | PluginInlineKind;
+export declare const INLINE_KIND_TABLE: Record<InlineNodeKind, true>;
+export declare function isBuiltinInlineKind(kind: AnyInlineKind): kind is InlineNodeKind;
+/** start/end are byte offsets into the parent block's raw, including markers. */
+export interface InlineNode {
+    kind: AnyInlineKind;
+    start: number;
+    end: number;
+    text?: string;
+    children?: InlineNode[];
+    url?: string;
+    title?: string;
+    label?: string;
+    alt?: string;
+    decoded?: string;
+    width?: number;
+    height?: number;
+    /** Discriminator for `unresolvedReference` nodes: which form they would have been. */
+    refKind?: 'link' | 'image';
+    /**
+     * Stamped by the scan when a plugin rung claimed these bytes, derived per scan and never
+     * persisted. Write paths read it to re-serialize in the claiming syntax, not built-in GFM.
+     */
+    syntaxClaim?: InlineSyntaxClaim;
+}
+/**
+ * Optional keys are omitted rather than set to `undefined`, so a serializer can tell "no title"
+ * from "empty title" and reproduce a node that never carried one.
+ */
+export interface ImageFields {
+    alt: string;
+    url: string;
+    title?: string;
+    width?: number;
+    height?: number;
+    /**
+     * Reference-style images only (`![alt][label]`). When set, the serializer emits the reference
+     * form and writes no url/title: those live in the LRD, and inlining them would orphan it.
+     */
+    label?: string;
+}
+/**
+ * Re-serializes an image an inline rung minted over its own bytes: `source` in, its replacement
+ * in the rung's syntax out, or `null` to decline the edit rather than rewrite the bytes as GFM.
+ */
+export type ImageSyntaxRewriter = (source: string, fields: ImageFields) => string | null;
+/** What the scan records on a node an inline rung claimed. */
+export interface InlineSyntaxClaim {
+    /** The claiming rung's prefix: its bare trigger, or its multi-char prefix. */
+    prefix: string;
+    rewriteImage?: ImageSyntaxRewriter;
+}
+export {};

package/dist/core/nodes.js

@@ -0,0 +1,83 @@
+/** CST node types for the GFM parser: mutable plain objects. Spec: docs/design/syntax-tree.md. */
+/**
+ * The single union-derived source for "iterate over all kinds": `Record<BlockKind, true>` makes
+ * the compiler flag a missing or stray member, where a hand-kept list passes vacuously.
+ */
+export const BLOCK_KIND_TABLE = {
+    heading: true,
+    setextHeading: true,
+    paragraph: true,
+    fencedCode: true,
+    thematicBreak: true,
+    indentedCode: true,
+    htmlBlock: true,
+    linkReferenceDefinition: true,
+    tableCell: true,
+    unrecognized: true,
+    blockquote: true,
+    list: true,
+    listItem: true,
+    table: true,
+    tableRow: true
+};
+export const ALL_BLOCK_KINDS = Object.keys(BLOCK_KIND_TABLE);
+export function isBuiltinBlockKind(kind) {
+    return kind in BLOCK_KIND_TABLE;
+}
+export function metadataOf(node, kind) {
+    void kind;
+    return node.metadata;
+}
+/**
+ * `BlockMetadata` is closed over the built-ins, so bridging a plugin's shape needs a cast and
+ * this pair is the one place it lives. Keep the stored shape primitive-valued: the one-level
+ * undo clone (G1.6) shallow-copies metadata.
+ */
+export function setPluginMetadata(node, data) {
+    node.metadata = data;
+}
+export function getPluginMetadata(node) {
+    return node.metadata;
+}
+/**
+ * Null for any non-heading node. The one heading-metadata read on the authoring barrel:
+ * `metadata.level` narrows only past `isBuiltinBlockNode`, which the barrel does not export.
+ */
+export function headingLevel(node) {
+    if (node.kind === 'heading')
+        return metadataOf(node, 'heading').level;
+    if (node.kind === 'setextHeading')
+        return metadataOf(node, 'setextHeading').level;
+    return null;
+}
+export function isBuiltinBlockNode(node) {
+    return isBuiltinBlockKind(node.kind);
+}
+/**
+ * The ONE place the runtime-kind construction cast lives. A construction door, not the
+ * view-to-mutable strip door: the spread returns a FRESH object, so passing a view mints a copy
+ * instead of stripping its readonly-ness, which is why G4.13 sanctions this file. Fields are not
+ * checked against the arm, so a metadata-less node of a metadata-carrying kind is mintable (a
+ * transient re-parse probe does this) and its `metadata` must not be read before re-parse.
+ */
+export function makeBlockNode(fields) {
+    return { ...fields };
+}
+export const INLINE_KIND_TABLE = {
+    text: true,
+    emphasis: true,
+    strong: true,
+    strikethrough: true,
+    inlineCode: true,
+    link: true,
+    image: true,
+    autolink: true,
+    hardLineBreak: true,
+    escape: true,
+    entityReference: true,
+    unresolvedReference: true,
+    rawHtml: true
+};
+export function isBuiltinInlineKind(kind) {
+    return kind in INLINE_KIND_TABLE;
+}

package/dist/core/parser.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Single-pass GFM block parser, producing a CST where serialize(parse(source)) === source.
+ * Per-kind parsers live in parsers/; this file holds dispatch and shared utilities only.
+ */
+import type { CstNode, Document } from './nodes';
+import { type ParsedLine } from './lines';
+import { type GrammarView } from '../schema/block-openers';
+/**
+ * Container-nesting cap: past it the remaining prefix parses as paragraph content instead of
+ * recursing, so pathological input degrades rather than overflowing the stack. Sits well under
+ * the empirical crash point, with headroom for the tree walks that recurse to the same depth.
+ * Byte-preserving, since only a top-level node's `raw` serializes and that is fixed first.
+ */
+export declare const MAX_NESTING_DEPTH = 512;
+/** Whether `source` is a whole document or one block's bytes read standalone. */
+export type ParseScope = 'document' | 'fragment';
+/**
+ * Parse GFM to a lossless CST. `opts.grammar` is the per-instance grammar view, defaulting to
+ * the global openers. It filters only the TOP-LEVEL opener dispatch: nested container reparses
+ * and the paragraph-interrupt scan read the global grammar, the documented enablement boundary,
+ * so a top-level disabled kind is skipped and a nested one is not. `opts.scope` reaches openers
+ * as `ctx.isDocumentParse`; it defaults to `'document'`, so whole-source callers need nothing.
+ */
+export declare function parse(source: string, opts?: {
+    grammar?: GrammarView;
+    scope?: ParseScope;
+}): Document;
+interface ParseBlocksResult {
+    children: CstNode[];
+    suffix: string;
+}
+/**
+ * The seam block-incremental parsing re-parses ranges through: a block-aligned window parses
+ * identically to a full parse of the window's text. A window is a FRAGMENT unless its caller
+ * says otherwise, so `parse` alone defaults to document scope. Blank-line rule
+ * (`design/syntax-tree.md`): the first blank line of a run separates and folds into trivia;
+ * every later one is an empty paragraph carrying its own bytes.
+ */
+export declare function parseBlocks(lines: ParsedLine[], start: number, end: number, grammar?: GrammarView, depth?: number, isDocumentParse?: boolean): ParseBlocksResult;
+export interface ContainerBodyWrap {
+    /** A chrome line of the container's own sits above the body (`:::note`, `<summary>`). */
+    afterOpenerLine?: boolean;
+    /** A chrome line of the container's own sits below the body (`:::`, `</details>`). */
+    beforeCloserLine?: boolean;
+}
+/**
+ * Parse a container body between the container's own chrome lines; a body starting at the
+ * container's own first line (blockquote, list item) has no wrap and uses `parse`. A blank line
+ * against a chrome line separates as it does between blocks, landing in `prefix`/`suffix` while
+ * the rest of its run materializes as body content; one with no body on its far side separated
+ * nothing and stays content. `opts.scope` is required: a new entry cannot recover it (G4.27).
+ */
+export declare function parseContainerBody(bodyText: string, wrap: ContainerBodyWrap, opts: {
+    scope: ParseScope;
+    depth?: number;
+}): Document;
+export declare function isBlankLine(text: string): boolean;
+/**
+ * Nothing but blank lines — what the blank-line rule mints a block from. Blankness is the
+ * parser's (GFM §2.1), never `String.trim()`: a non-breaking space is content.
+ */
+export declare function isBlankSource(source: string): boolean;
+export declare function isBlankParagraph(node: {
+    kind: string;
+    raw: string;
+}): boolean;
+export declare function joinRaw(lines: ParsedLine[], startIndex: number, endIndex: number): string;
+export {};