@vscode/markdown-editor 0.0.2-0 → 0.0.2-2

package/dist/parser/ast.d.ts

@@ -1,274 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { StringEdit } from '../core/stringEdit.js';
-export declare function _resetNodeIds(): void;
-export declare abstract class AstNode {
-    abstract readonly kind: string;
-    abstract get children(): readonly AstNode[];
-    /**
-     * A stable identity. Every node has one: it is minted on construction and
-     * carried across edits by reconciliation, so a node that survives an edit
-     * (even with changed content) keeps the same id.
-     */
-    readonly id: number;
-    /** Rebuild this node with each child replaced by `map.get(child) ?? child`. */
-    abstract mapChildren(map: ReadonlyMap<AstNode, AstNode>): AstNode;
-    private _length;
-    get length(): number;
-    /**
-     * True when `other` has the same content. Containers compare children *by
-     * identity* (`===`): bottom-up reconciliation substitutes reused old
-     * instances into the fresh tree first, so equal children already share
-     * instances — keeping this O(children), not O(subtree). Leaves have no
-     * children, so {@link _localEquals} is their whole comparison.
-     */
-    structurallyEqual(other: AstNode): boolean;
-    /** Compares only this node's own scalar fields (kind/length already match). */
-    protected _localEquals(_other: this): boolean;
-    /**
-     * A copy of this node that adopts `id`. Reconciliation uses this to carry an
-     * old identity onto a node whose content changed. Nodes are immutable value
-     * holders, so a shallow prototype copy with `id` overridden is sound.
-     */
-    cloneWithId(id: number): this;
-}
-declare abstract class LeafAstNode extends AstNode {
-    abstract readonly content: string;
-    get children(): readonly AstNode[];
-    get length(): number;
-    mapChildren(): AstNode;
-}
-/** Real document text (an {@link InlineAstNode}). */
-export declare class TextAstNode extends LeafAstNode {
-    readonly content: string;
-    readonly kind = "text";
-    constructor(content: string);
-    protected _localEquals(o: this): boolean;
-}
-/** A semantic syntax marker (heading `#`, fences, brackets, list bullet, …). */
-export declare class MarkerAstNode extends LeafAstNode {
-    readonly markerKind: string;
-    readonly content: string;
-    readonly kind = "marker";
-    constructor(markerKind: string, content: string);
-    protected _localEquals(o: this): boolean;
-}
-/** Non-semantic syntactic glue: whitespace, padding, table pipes. */
-export declare class GlueAstNode extends LeafAstNode {
-    readonly content: string;
-    readonly glueKind?: string | undefined;
-    readonly kind = "glue";
-    constructor(content: string, glueKind?: string | undefined);
-    protected _localEquals(o: this): boolean;
-}
-export declare class ThematicBreakAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "thematicBreak";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get marker(): MarkerAstNode | undefined;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export type InlineAstNode = TextAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode;
-export declare class StrongAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "strong";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class EmphasisAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "emphasis";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class StrikethroughAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "strikethrough";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class InlineCodeAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "inlineCode";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class InlineMathAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "inlineMath";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class LinkAstNode extends AstNode {
-    readonly url: string;
-    readonly content: readonly (MarkerAstNode | InlineAstNode | GlueAstNode)[];
-    readonly kind = "link";
-    constructor(url: string, content: readonly (MarkerAstNode | InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ImageAstNode extends AstNode {
-    readonly alt: string;
-    readonly url: string;
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "image";
-    constructor(alt: string, url: string, content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export type BlockAstNode = HeadingAstNode | ParagraphAstNode | CodeBlockAstNode | MathBlockAstNode | ThematicBreakAstNode | BlockQuoteAstNode | ListAstNode | TableAstNode;
-export declare class HeadingAstNode extends AstNode {
-    readonly level: 1 | 2 | 3 | 4 | 5 | 6;
-    readonly marker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly kind = "heading";
-    constructor(level: 1 | 2 | 3 | 4 | 5 | 6, marker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ParagraphAstNode extends AstNode {
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly kind = "paragraph";
-    constructor(content: readonly (InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class CodeBlockAstNode extends AstNode {
-    readonly language: string;
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "codeBlock";
-    private _previous?;
-    private _contentEdit?;
-    constructor(language: string, content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get openFence(): MarkerAstNode | undefined;
-    get closeFence(): MarkerAstNode | undefined;
-    get code(): MarkerAstNode | undefined;
-    /** Relative start offset of the {@link code} marker within this block. */
-    get codeOffset(): number;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-    /**
-     * A copy of this block carrying an incremental link to `previous`:
-     * `contentEdit` (in the block's *content* coordinates) turns `previous`'s
-     * content into this one. Uses a weak reference so the previous tree can be
-     * garbage-collected.
-     */
-    withCodeDiff(previous: CodeBlockAstNode, contentEdit: StringEdit): CodeBlockAstNode;
-    /**
-     * When this block was incrementally derived from `previous` (same
-     * fences/language, edit entirely within the content), returns the
-     * content-coordinate edit; otherwise `undefined`.
-     */
-    getDiff(previous: CodeBlockAstNode): CodeBlockDiff | undefined;
-}
-/**
- * Describes how a {@link CodeBlockAstNode} was incrementally derived from a previous
- * one: {@link stringEdit} (in the block's *content* coordinates) turns the
- * previous content into this one.
- */
-export interface CodeBlockDiff {
-    readonly stringEdit: StringEdit;
-}
-export declare class MathBlockAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "mathBlock";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get code(): MarkerAstNode | undefined;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class BlockQuoteAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[];
-    readonly kind = "blockQuote";
-    constructor(content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class ListAstNode extends AstNode {
-    readonly ordered: boolean;
-    readonly content: readonly (ListItemAstNode | GlueAstNode)[];
-    readonly kind = "list";
-    constructor(ordered: boolean, content: readonly (ListItemAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get items(): readonly ListItemAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ListItemAstNode extends AstNode {
-    readonly marker: MarkerAstNode;
-    readonly content: readonly (BlockAstNode | GlueAstNode)[];
-    readonly checked?: boolean | undefined;
-    readonly leadingTrivia?: GlueAstNode | undefined;
-    readonly kind = "listItem";
-    constructor(marker: MarkerAstNode, content: readonly (BlockAstNode | GlueAstNode)[], checked?: boolean | undefined, leadingTrivia?: GlueAstNode | undefined);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class TableAstNode extends AstNode {
-    readonly content: readonly (TableRowAstNode | GlueAstNode)[];
-    readonly kind = "table";
-    constructor(content: readonly (TableRowAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    private get _rows();
-    get headerRow(): TableRowAstNode | undefined;
-    get delimiterRow(): TableRowAstNode | undefined;
-    get bodyRows(): readonly TableRowAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class TableRowAstNode extends AstNode {
-    readonly content: readonly (TableCellAstNode | GlueAstNode)[];
-    readonly kind = "tableRow";
-    constructor(content: readonly (TableCellAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get cells(): readonly TableCellAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class TableCellAstNode extends AstNode {
-    readonly content: readonly (InlineAstNode | MarkerAstNode | GlueAstNode)[];
-    readonly kind = "tableCell";
-    constructor(content: readonly (InlineAstNode | MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class DocumentAstNode extends AstNode {
-    readonly content: readonly (BlockAstNode | GlueAstNode)[];
-    readonly kind = "document";
-    constructor(content: readonly (BlockAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-/** Every concrete node kind, for exhaustive consumer-side dispatch. */
-export type AnyAstNode = TextAstNode | MarkerAstNode | GlueAstNode | ThematicBreakAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode | HeadingAstNode | ParagraphAstNode | CodeBlockAstNode | MathBlockAstNode | BlockQuoteAstNode | ListAstNode | ListItemAstNode | TableAstNode | TableRowAstNode | TableCellAstNode | DocumentAstNode;
-/**
- * Source offset (relative to `root`) of the node with `target`'s id, or
- * `undefined` when it is not in the tree. Ids are stable across edits, so this
- * locates a node even after reconciliation has rebuilt the tree around it.
- */
-export declare function findNodeOffsetById(root: AstNode, target: AstNode): number | undefined;
-/**
- * Source range (relative to `item`) of a task list item's `[x]`/`[ ]`
- * checkbox, or `undefined` when the item is not a task item. The checkbox is
- * plain glue in the AST, so a host that wants to toggle it locates the literal
- * `[x]`/`[ ]` token here.
- */
-export declare function taskCheckboxRange(item: ListItemAstNode): OffsetRange | undefined;
-export {};

package/dist/parser/index.d.ts

@@ -1,4 +0,0 @@
-export { MarkdownParser } from './parser.js';
-export { getAnnotatedSource } from './test/getAnnotatedSource.js';
-export { visualizeAst, type AstVisualization } from './visualizeAst.js';
-export { BlockQuoteAstNode, CodeBlockAstNode, DocumentAstNode, EmphasisAstNode, GlueAstNode, HeadingAstNode, ImageAstNode, InlineCodeAstNode, InlineMathAstNode, LinkAstNode, ListAstNode, ListItemAstNode, MarkerAstNode, MathBlockAstNode, AstNode, findNodeOffsetById, taskCheckboxRange, ParagraphAstNode, StrikethroughAstNode, StrongAstNode, TableAstNode, TableCellAstNode, TableRowAstNode, TextAstNode, ThematicBreakAstNode, type AnyAstNode, type BlockAstNode, type InlineAstNode, } from './ast.js';

package/dist/parser/parse.d.ts

@@ -1,2 +0,0 @@
-import { DocumentAstNode } from './ast.js';
-export declare function parse(source: string): DocumentAstNode;

package/dist/parser/parser.d.ts

@@ -1,14 +0,0 @@
-import { StringValue } from '../core/stringValue.js';
-import { StringEdit } from '../core/stringEdit.js';
-import { DocumentAstNode } from './ast.js';
-/**
- * Parses markdown into a {@link DocumentAstNode}.
- *
- * When given the `previous` document and the `edit` that produced the new
- * text, it reuses unchanged subtrees and carries node identities across the
- * edit (see {@link parseIncremental}), so views can diff cheaply and code
- * blocks keep their incremental highlighting sessions.
- */
-export declare class MarkdownParser {
-    parse(text: StringValue, previous?: DocumentAstNode, edit?: StringEdit): DocumentAstNode;
-}

package/dist/parser/reconcile.d.ts

@@ -1,33 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { StringEdit } from '../core/stringEdit.js';
-import { DocumentAstNode, AstNode } from './ast.js';
-/** Maps offsets/ranges from modified (new) coordinates back to original (previous). */
-export declare class EditMapper {
-    private readonly _edit;
-    constructor(_edit: StringEdit);
-    /**
-     * The original range corresponding to `mod`, or `undefined` if `mod`
-     * overlaps any replaced/inserted text (i.e. is not provably unchanged).
-     */
-    getOriginalRange(mod: OffsetRange): OffsetRange | undefined;
-    /** The original offset for `mod`, or `undefined` if it falls inside inserted text. */
-    getOriginalOffset(mod: number): number | undefined;
-}
-/** Indexes the previous tree for O(1) lookup by exact range or by stable id. */
-export declare class OldTreeIndex {
-    private readonly _byRange;
-    private readonly _byId;
-    constructor(root: AstNode);
-    private _walk;
-    /** The old node spanning exactly `range` with the given `kind`, if any. */
-    lookupExact(range: OffsetRange, kind: string): AstNode | undefined;
-    /** The old node that began at `originalStart` with the given `kind`. */
-    lookupId(originalStart: number, kind: string): AstNode | undefined;
-}
-export declare function reconcile(fresh: AstNode, previous: AstNode, edit: StringEdit): AstNode;
-/**
- * Parses `text`; when `previous` and `edit` are given, reconciles the fresh
- * tree against `previous` so unchanged subtrees keep their old instances and
- * edited id-bearing nodes keep their old ids.
- */
-export declare function parseIncremental(text: string, previous?: DocumentAstNode, edit?: StringEdit): DocumentAstNode;

package/dist/parser/test/getAnnotatedSource.d.ts

@@ -1,2 +0,0 @@
-import { AstNode } from '../ast.js';
-export declare function getAnnotatedSource(node: AstNode, source: string, offset?: number): string;

package/dist/parser/test/snapshot.d.ts

@@ -1,9 +0,0 @@
-import { DocumentAstNode, AstNode } from '../ast.js';
-/** Assigns a small stable number to each distinct object instance, in first-seen order. */
-export declare class InstanceIds {
-    private readonly _map;
-    private _next;
-    get(n: AstNode): number;
-}
-export declare function snapshot(root: AstNode, ids: InstanceIds): string;
-export declare function snapshotDoc(doc: DocumentAstNode, ids: InstanceIds): string;

package/dist/parser/visualizeAst.d.ts

@@ -1,33 +0,0 @@
-import { AstNode } from './ast.js';
-export interface AstVisualizationNode {
-    label: string;
-    range: [start: number, endExclusive: number];
-    children?: AstVisualizationNode[];
-}
-export interface AstVisualization {
-    $fileExtension: 'ast.w';
-    source: string;
-    root: AstVisualizationNode;
-}
-/**
- * Globally-stable per-object-instance id, assigned in first-seen order across
- * every visualization (AST, view-data, view-node). A single registry — not one
- * per tree — is the whole point: the same object always renders the same `#N`,
- * so you can correlate instances across the different trees and across edits.
- */
-export declare function objectInstanceId(n: object): number;
-export declare function visualizeAst(root: AstNode, source: string): AstVisualization;
-/**
- * Adapts the raw micromark token stream into the same `ast.w` visualization
- * payload, as a flat list (no nesting): one child per event, in document order.
- * This is the input the {@link visualizeAst} tree is built from, so showing both
- * side by side makes the parser's tokens → AST step inspectable.
- *
- * Both `enter` and `exit` events are emitted — the open/close structure is the
- * one piece of micromark's information that is NOT derivable from a flat list of
- * ranges (tokens can share a range, and ranges alone don't disambiguate nesting
- * order). Everything else a token carries is here too: its type, its
- * `[start, end)` range, and the source slice that range covers (so the length,
- * which the AST view derives, is visible directly).
- */
-export declare function visualizeTokens(source: string): AstVisualization;

package/dist/test/random.d.ts

@@ -1,16 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { StringEdit } from '../core/stringEdit.js';
-/**
- * Seeded RNG for deterministic fuzz tests. A small port of the `Random` helper
- * used by VS Code's editor tests (`src/vs/editor/test/common/core/random.ts`),
- * backed by a Mersenne Twister so a given seed always replays the same run.
- */
-export declare abstract class Random {
-    static readonly basicAlphabetMultiline = "      \n\nabcdefghijklmnopqrstuvwxyz0123456789";
-    static create(seed: number): Random;
-    abstract nextIntRange(start: number, endExclusive: number): number;
-    nextString(length: number, alphabet?: string): string;
-    nextMultiLineString(lineCount: number, lineLength: OffsetRange, alphabet?: string): string;
-    /** A single random replacement over `target` (insert, delete or replace). */
-    nextSingleStringEdit(target: string, newTextAlphabet?: string): StringEdit;
-}

package/dist/view/content/blockView.d.ts

@@ -1,179 +0,0 @@
-import { BlockAstNode, ListItemAstNode } from '../../parser/ast.js';
-import { AnyViewData, CodeBlockViewData } from '../viewData.js';
-import { ISyntaxHighlighter } from '../../highlighter/syntaxHighlighter.js';
-import { ViewNode } from './viewNode.js';
-export interface BlockViewOptions {
-    readonly renderCustomCodeBlock?: (language: string, content: string) => HTMLElement | undefined;
-    readonly onToggleCheckbox?: (item: ListItemAstNode, newChecked: boolean) => void;
-    /**
-     * Opens a link's URL. Called when the user activates a link: a plain click
-     * while the link's block is inactive (rendered), or a Ctrl/Cmd+click while it
-     * is active (source shown). Defaults to `window.open(url, '_blank')`.
-     */
-    readonly onOpenLink?: (url: string, event: MouseEvent) => void;
-    /**
-     * Colours fenced code blocks. When set, a code block's content is rendered
-     * as a sequence of token spans instead of one plain text node. This is the
-     * non-incremental path: the snapshot is read once at render time.
-     */
-    readonly syntaxHighlighter?: ISyntaxHighlighter;
-    /**
-     * Pluggable renderer for the *inactive* (rendered) form of a math node —
-     * both `$$…$$` blocks and inline `$…$`. When set and it returns a result,
-     * its {@link MathRendering.dom} replaces the default opaque `katex.render`
-     * output, and its {@link MathRendering.segments} let parts of the rendered
-     * math (e.g. individual identifier glyphs) map back to source ranges so the
-     * caret can land inside them. Returning `undefined` falls back to the
-     * default whole-node KaTeX leaf. The active (source) form is unaffected.
-     *
-     * This is the seam used to explore in-place editing of rendered math (see
-     * `katexEditableIdentifiers.ts`).
-     */
-    readonly renderMath?: (request: MathRenderRequest) => MathRendering | undefined;
-}
-/** Input to a {@link BlockViewOptions.renderMath} renderer. */
-export interface MathRenderRequest {
-    /** The LaTeX source of the math content (without the `$$`/`$` fences). */
-    readonly latex: string;
-    /** `true` for a `$$…$$` block, `false` for inline `$…$`. */
-    readonly displayMode: boolean;
-    /** CSS class the host element must carry (editor styling/measurement hooks). */
-    readonly className: string;
-    /** Full source length of the math node (fences/`$` included). */
-    readonly nodeLength: number;
-    /** Offset of {@link latex} within the node (i.e. after the opening fence/`$`). */
-    readonly contentStart: number;
-}
-/**
- * A span of the rendered math output that maps to a slice of source. The
- * renderer reports these for the parts it can map (e.g. identifier glyphs);
- * the editor tiles the gaps between them so the whole math node stays mapped.
- */
-export interface MathSourceSegment {
-    /** A DOM node (ideally a Text node) within the rendered output. */
-    readonly dom: globalThis.Node;
-    /** Start offset of the mapped slice, relative to the math node's start. */
-    readonly start: number;
-    /** Source length of the mapped slice. */
-    readonly length: number;
-}
-/** Result of a {@link BlockViewOptions.renderMath} renderer. */
-export interface MathRendering {
-    /** Host element to mount (the rendered math output). */
-    readonly dom: HTMLElement;
-    /** Source-mapped spans within {@link dom} (need not tile the whole node). */
-    readonly segments: readonly MathSourceSegment[];
-}
-/**
- * Base view node for everything the editor renders, generic over the
- * {@link AnyViewData view-data} it renders so subclasses get a precisely-typed
- * {@link data} (e.g. `BlockViewNode<HeadingViewData>`). Every view-data kind has
- * a subclass whose constructor builds the node's DOM and, recursively,
- * constructs its child view nodes — so *constructing a node is rendering it*.
- * There is no separate render pass: the view tree is the result of construction,
- * and {@link createViewNode} is the single entry point that turns a `ViewData`
- * into a node (reusing a `previous` node untouched when it still matches).
- *
- * The name is historical — it is the base for inline and leaf nodes too — but
- * top-level blocks are always instances of it, and {@link element}/{@link block}
- * are the conveniences {@link EditorView} uses for those.
- */
-export declare class BlockViewNode<T extends AnyViewData = AnyViewData> extends ViewNode {
-    readonly data: T;
-    constructor(data: T, dom: globalThis.Node, children: readonly ViewNode[]);
-    get block(): BlockAstNode;
-    get element(): HTMLElement;
-    /**
-     * Whether this already-built node can stand in for `data` unchanged. The
-     * builder preserves view-data identity for any subtree whose ast and
-     * selection-derived flags are unchanged (see `buildDocumentViewData`), so a
-     * single identity check captures "nothing in my subtree changed" — and its
-     * whole subtree, and any session it owns, are kept as-is.
-     */
-    canReuse(data: AnyViewData): boolean;
-    /**
-     * Called by the view after this block is mounted and measured, with the
-     * block's rendered height in px. The default is a no-op; subclasses whose
-     * active/inactive renderings have different intrinsic heights (e.g. a math
-     * block) override this to remember a height to reserve across the toggle.
-     */
-    recordMeasuredHeight(_height: number): void;
-}
-/**
- * Turn a {@link AnyViewData view-data} node into its view node, reusing
- * `previous` when it still renders the very same view-data object (see
- * {@link BlockViewNode.canReuse}). Otherwise the matching subclass is
- * constructed, which renders it and recursively constructs its children —
- * threading `previous` down so an edited node can adopt its predecessor's DOM
- * (and, for an edited {@link CodeBlockAstNode}, the highlighting session of the
- * node it was derived from).
- *
- * On a rebuild `previous` is the view node {@link pairNodes} paired by stable id:
- * identity-matched nodes (same view-data) short-circuit above, an edited node is
- * paired with the node carrying its previous id, and any previous node whose id
- * is gone is dropped (disposed by its container's reconcile) so its replacement
- * is built with `previous === undefined`.
- */
-export declare function createViewNode(data: AnyViewData, options: BlockViewOptions | undefined, previous?: ViewNode): ViewNode;
-/**
- * Build the view children for `childData` and patch `parentDom`'s child DOM in
- * place to match, in one step. Each new child-data is paired with the previous
- * view child that should render it ({@link pairNodes}) — by stable node id, which
- * covers both unchanged subtrees and edited nodes — so DOM and session adoption
- * carry over; the
- * `build` callback turns `(childData, prev)` into its view node (usually via
- * {@link createViewNode}). Previous children left unpaired are disposed, then
- * {@link _patchDomChildren} reorders/inserts/removes `parentDom`'s children so
- * the DOM matches the new view nodes — moving reused child DOM into place
- * rather than re-creating it. The returned array mirrors `childData` 1:1,
- * preserving the source ↔ DOM mapping invariant.
- */
-export declare function reconcileDomChildren(parentDom: globalThis.Node, childData: readonly AnyViewData[], previousChildren: readonly ViewNode[] | undefined, build: (childData: AnyViewData, prev: ViewNode | undefined) => ViewNode): ViewNode[];
-/**
- * Like {@link _patchDomChildren} but over raw mount nodes, so a caller can mount
- * a mix of view-node DOM and synthetic wrappers (e.g. a list item's gutter
- * span) in place without detaching the nodes that stay put.
- */
-export declare function _patchDomNodes(parent: globalThis.Node, nodes: readonly globalThis.Node[]): void;
-/**
- * A fenced code block. It owns its incremental
- * {@link ISyntaxHighlighterDocument} session: constructing the node creates (or
- * adopts from `previous`) the session, and disposing the node disposes it, so
- * colouring stays incremental across edits — the session is reused and
- * `update`d rather than rebuilt. A node at any depth owns a session; the only
- * difference today is that the parser links `getDiff` for top-level code blocks
- * only, so a nested block currently builds a fresh session on each rebuild.
- */
-export declare class CodeBlockViewNode extends BlockViewNode<CodeBlockViewData> {
-    private _session;
-    /**
-     * Subscription that re-tokenises the rendered `<code>` in place whenever the
-     * session advances its {@link ISyntaxHighlighterDocument.snapshot} *without*
-     * a source edit (an async grammar finishing, a live recolour). It is tied to
-     * this node's lifetime, but like {@link _session} it must be disposed
-     * manually: a node reused as `previous` for a rebuild is never `dispose`d
-     * (see {@link reconcileDomChildren}), so the rebuilding constructor disposes
-     * its predecessor's subscription explicitly.
-     */
-    private _snapshotSub;
-    constructor(data: CodeBlockViewData, options: BlockViewOptions | undefined, previous: ViewNode | undefined);
-    dispose(): void;
-}
-/**
- * Pair each new node with the previous view node that should render it, then
- * report the previous nodes left over. Pairing is by {@link AstNode.id} — the
- * stable identity the parser mints on construction and carries across edits (see
- * `reconcile`). One key covers both reuse cases uniformly: an unchanged subtree
- * keeps its node object (so, trivially, its id), and an edited node — e.g. a
- * code block whose content changed — is rebuilt as a fresh object cloned with
- * its previous id. So the previous view node (which owns any DOM and, for a code
- * block, the highlighting session) is paired with the new view-data derived from
- * it, and that DOM/session is adopted rather than rebuilt.
- *
- * Previous nodes whose id no longer appears are returned in `unused`; the caller
- * disposes them (freeing any session they still own).
- */
-export declare function pairNodes(newData: readonly AnyViewData[], prevNodes: readonly ViewNode[]): {
-    paired: Map<AnyViewData, ViewNode>;
-    unused: ViewNode[];
-};

package/dist/view/content/documentView.d.ts

@@ -1,41 +0,0 @@
-import { DocumentViewData } from '../viewData.js';
-import { BlockViewNode, BlockViewOptions } from './blockView.js';
-import { ViewNode } from './viewNode.js';
-/** A mounted block: its view node paired with where it starts in the source. */
-export interface DocumentBlock {
-    readonly node: BlockViewNode;
-    readonly absoluteStart: number;
-}
-/**
- * Immutable view of the document's block sequence — the document-level
- * analogue of {@link BlockViewNode}. Each {@link create} maps the
- * {@link DocumentViewData} (the AST overlaid with selection-derived flags) to
- * the block sequence, reusing the previous node's blocks by view-data identity,
- * rebuilding only what changed, and patching its {@link contentDomNode}'s
- * children to match.
- *
- * Like a {@link BlockViewNode}, it owns its DOM: the first `create` allocates
- * the content element, and every later `create` keeps the previous node's
- * element rather than making a new one. The element is therefore stable
- * across rebuilds:
- *
- *     create(viewData, …, old).contentDomNode === old.contentDomNode
- *
- * so a parent can mount it once and never re-parent it.
- *
- * Because it is rebuilt rather than mutated, {@link EditorView} can hold the
- * whole block cache as one value and simply swap it each frame, instead of
- * carrying a mutable entry array and the reconcile bookkeeping itself.
- *
- * It is itself a {@link ViewNode} (the root of the view-node tree), so DOM ↔
- * source mapping such as {@link ViewNode.resolveSource} is inherited: a hit on
- * any descendant lifts up the parent chain to here, yielding an absolute
- * document offset.
- */
-export declare class DocumentViewNode extends ViewNode {
-    readonly blocks: readonly DocumentBlock[];
-    static create(viewData: DocumentViewData, options: BlockViewOptions | undefined, previous: DocumentViewNode | undefined): DocumentViewNode;
-    private constructor();
-    /** The stable content element this document mounts its children into. */
-    get contentDomNode(): HTMLElement;
-}

package/dist/view/content/dom.d.ts

@@ -1,16 +0,0 @@
-import { Point2D } from '../../core/geometry.js';
-/**
- * A DOM node paired with a caret offset inside it. The node is an arbitrary
- * {@link globalThis.Node} (a Text node for a caret inside text, an Element for
- * a hit on element-only content), and `offset` is the caret offset within it.
- */
-export interface DomPosition {
-    readonly node: globalThis.Node;
-    readonly offset: number;
-}
-/**
- * Client-coordinate point → the DOM caret position under it, using the
- * platform hit-test API (`caretPositionFromPoint`, with a `caretRangeFromPoint`
- * fallback). Returns `undefined` when the point hits nothing.
- */
-export declare function caretDomPositionFromPoint(point: Point2D): DomPosition | undefined;