@vscode/markdown-editor 0.0.2-1 → 0.0.2-11

package/dist/index.d.ts

@@ -31,7 +31,7 @@ export declare abstract class AstNode {
      * instances — keeping this O(children), not O(subtree). Leaves have no
      * children, so {@link _localEquals} is their whole comparison.
      */
-    structurallyEqual(other: AstNode): boolean;
+    equalsShallow(other: AstNode): boolean;
     /** Compares only this node's own scalar fields (kind/length already match). */
     protected _localEquals(_other: this): boolean;
     /**
@@ -54,8 +54,41 @@ declare interface AstVisualizationNode {
     children?: AstVisualizationNode[];
 }
 
+/**
+ * Strategy for hosts that never deliver native clipboard events to the editor
+ * — most importantly VS Code webviews, whose preload calls `preventDefault()`
+ * on the Ctrl/Cmd+C/X/V keydowns, so no `copy`/`cut`/`paste` event is ever
+ * dispatched. Here the keystrokes are the only signal, so this strategy
+ * listens for them directly and drives the async {@link Clipboard} API
+ * (`navigator.clipboard`), which webviews are granted.
+ *
+ * Cut deletes synchronously once the text is captured; the clipboard write is
+ * fire-and-forget. Paste must wait for the async read before inserting.
+ */
+export declare class AsyncClipboardStrategy implements IClipboardStrategy {
+    private readonly _clipboard;
+    constructor(_clipboard?: Clipboard);
+    connect(context: IClipboardContext): IDisposable;
+}
+
 export declare type BlockAstNode = HeadingAstNode | ParagraphAstNode | CodeBlockAstNode | MathBlockAstNode | ThematicBreakAstNode | BlockQuoteAstNode | ListAstNode | TableAstNode;
 
+/**
+ * A block-level node. Every block may carry a {@link leadingTrivia} glue — the
+ * whitespace that precedes it on its own line (a nested list's indentation, the
+ * leading space of a continued paragraph). It is owned by the block it precedes
+ * (not the one it trails), so the view reveals it exactly when *this* block is
+ * active, and it tiles at the block's front: {@link children} prepends it to the
+ * block's own content while `content` stays the block's real payload.
+ */
+declare abstract class BlockAstNodeBase extends AstNode {
+    abstract readonly leadingTrivia?: GlueAstNode;
+    /** This block with its leading trivia replaced — re-homes a leading glue onto it. */
+    abstract withLeadingTrivia(trivia: GlueAstNode | undefined): BlockAstNode;
+    /** Prepends {@link leadingTrivia}, if any, ahead of the block's own children. */
+    protected _withLeading(own: readonly AstNode[]): readonly AstNode[];
+}
+
 /**
  * One block's place in the rendered document.
  *
@@ -79,13 +112,15 @@ export declare interface BlockMeasurement {
     readonly viewNode: ViewNode | undefined;
 }
 
-export declare class BlockQuoteAstNode extends AstNode {
+export declare class BlockQuoteAstNode extends BlockAstNodeBase {
     readonly content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "blockQuote";
-    constructor(content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[]);
+    constructor(content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get blocks(): readonly BlockAstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): BlockQuoteAstNode;
 }
 
 declare class BlockQuoteViewData {
@@ -163,13 +198,14 @@ export declare interface BlockViewOptions {
     readonly renderMath?: (request: MathRenderRequest) => MathRendering | undefined;
 }
 
-export declare class CodeBlockAstNode extends AstNode {
+export declare class CodeBlockAstNode extends BlockAstNodeBase {
     readonly language: string;
     readonly content: readonly (MarkerAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "codeBlock";
     private _previous?;
     private _contentEdit?;
-    constructor(language: string, content: readonly (MarkerAstNode | GlueAstNode)[]);
+    constructor(language: string, content: readonly (MarkerAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get openFence(): MarkerAstNode | undefined;
     get closeFence(): MarkerAstNode | undefined;
@@ -177,6 +213,7 @@ export declare class CodeBlockAstNode extends AstNode {
     /** Relative start offset of the {@link code} marker within this block. */
     get codeOffset(): number;
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): CodeBlockAstNode;
     protected _localEquals(o: this): boolean;
     /**
      * A copy of this block carrying an incremental link to `previous`:
@@ -301,6 +338,13 @@ export declare class CursorView extends Disposable {
 export declare interface CursorViewOptions {
     readonly offset: IObservable<SourceOffset | undefined>;
     readonly visualLineMap: IObservable<VisualLineMap>;
+    /**
+     * When set, the caret is drawn over the transient empty paragraph instead
+     * of at {@link offset} — its rect (in client coordinates) comes straight
+     * from that synthetic element's geometry, since it has no visual-line-map
+     * entry. Takes priority over the normal offset-based placement.
+     */
+    readonly pendingCaretRect?: IObservable<Rect2D | undefined>;
 }
 
 export declare class CursorViewRendering {
@@ -346,13 +390,14 @@ declare interface DocumentBlockViewData {
     readonly view: BlockViewData;
 }
 
-/** A mounted document child: a block or a run of inter-block glue. */
+/** A mounted document child: a block, a run of inter-block glue, or the
+ * transient empty paragraph (see {@link PendingParagraphViewData}). */
 declare interface DocumentChildViewData {
     readonly absoluteStart: number;
-    /** For a block: selection reaches it. For glue: a neighbouring block is active. */
+    /** For a block: selection reaches it. For glue: always false (unowned, hidden). */
     readonly isActive: boolean;
-    readonly view: BlockViewData | GlueViewData;
-    readonly kind: 'block' | 'glue';
+    readonly view: BlockViewData | GlueViewData | PendingParagraphViewData;
+    readonly kind: 'block' | 'glue' | 'pendingParagraph';
 }
 
 /**
@@ -408,6 +453,8 @@ declare class DocumentViewData {
  */
 export declare class DocumentViewNode extends ViewNode {
     readonly blocks: readonly DocumentBlock[];
+    /** The transient empty-paragraph element, when one is armed. */
+    readonly pendingElement?: HTMLElement | undefined;
     static create(viewData: DocumentViewData, options: BlockViewOptions | undefined, previous: DocumentViewNode | undefined): DocumentViewNode;
     private constructor();
     /** The stable content element this document mounts its children into. */
@@ -442,7 +489,7 @@ export declare class EditorController extends Disposable {
     private readonly _model;
     private readonly _view;
     private _desiredColumn;
-    constructor(_model: EditorModel, _view: EditorView);
+    constructor(_model: EditorModel, _view: EditorView, options?: EditorControllerOptions);
     private readonly _handleTextUpdate;
     private readonly _handleMouseDown;
     private _makeCursorContext;
@@ -454,11 +501,25 @@ export declare class EditorController extends Disposable {
     cursorDown(extend?: boolean): void;
     /** Move the cursor up one visual line (Arrow Up). */
     cursorUp(extend?: boolean): void;
-    private readonly _handleCopy;
-    private readonly _handleCut;
-    private readonly _handlePaste;
     private _selectedText;
+    private readonly _updateModifierState;
+    private readonly _clearModifierState;
     private readonly _handleKeyDown;
+    /**
+     * Context-aware Enter: splits / line-breaks via {@link insertSmartEnter}, or
+     * arms a transient empty paragraph when at the end of a paragraph.
+     */
+    private _smartEnter;
+}
+
+/** Options for an {@link EditorController}. */
+export declare interface EditorControllerOptions {
+    /**
+     * How copy/cut/paste is handled. Defaults to {@link NativeClipboardStrategy},
+     * which reads the browser's native clipboard events — pass a different
+     * strategy (e.g. `AsyncClipboardStrategy`) in hosts that swallow them.
+     */
+    readonly clipboardStrategy?: IClipboardStrategy;
 }
 
 export declare class EditorModel {
@@ -476,6 +537,20 @@ export declare class EditorModel {
      * (e.g. an inactive/unfocused rendering).
      */
     readonly selection: ISettableObservable<Selection_2 | undefined, void>;
+    /**
+     * Whether a Ctrl/Cmd modifier is currently held. Set by the controller from
+     * live keyboard state; the view reads it to show the link-open affordance
+     * (underline + pointer cursor) only while a Ctrl/Cmd+click would open a link
+     * whose block is active.
+     */
+    readonly ctrlOrMetaDown: ISettableObservable<boolean, void>;
+    /**
+     * Gutter markers (source-control style change indicators) painted in the
+     * left gutter. Each entry maps a source {@link OffsetRange} to a change kind
+     * — see {@link GutterMarker}. Purely decorative: markers never affect the
+     * parsed {@link document}, selection, or layout. Empty by default.
+     */
+    readonly gutterMarkers: ISettableObservable<readonly GutterMarker[], void>;
     /**
      * Forces the rendered active-block set. `undefined` (the default)
      * derives the set from the current selection range (see
@@ -484,6 +559,13 @@ export declare class EditorModel {
      * collapsed/inactive rendering.
      */
     readonly activeBlocksOverride: ISettableObservable<readonly BlockAstNode[] | typeof NO_ACTIVE_BLOCKS | undefined, void>;
+    /**
+     * The transient empty-paragraph editing state, or `undefined` when none is
+     * armed. See {@link PendingParagraph}. This is *not* document data — it is
+     * cleared by any source edit and lives only between the Enter that armed it
+     * and the next keystroke.
+     */
+    readonly pendingParagraph: ISettableObservable<PendingParagraph | undefined, void>;
     readonly cursorOffset: IObservableWithChange<number | undefined, void>;
     /**
      * The parsed document. Threads the previous document into the parser so
@@ -507,6 +589,24 @@ export declare class EditorModel {
      * collapsed this is a one-element set holding {@link activeBlock}.
      */
     readonly activeBlocks: IObservableWithChange<Set<BlockAstNode>, void>;
+    /**
+     * Arm a {@link PendingParagraph} at the given gap, minting a fresh synthetic
+     * AST node for it, and park the caret at the gap start. No source edit is
+     * applied — the blank line exists only in the view until it is materialized.
+     */
+    armPendingParagraph(req: {
+        anchorBlock: BlockAstNode;
+        replaceRange: OffsetRange;
+        atEof: boolean;
+    }): void;
+    /** Discard the pending paragraph (if any) without touching the source. */
+    cancelPendingParagraph(): void;
+    /**
+     * Turn the pending paragraph into real source: rewrite its gap so the typed
+     * `text` becomes its own paragraph, separated from its neighbours by blank
+     * lines, and place the caret after the inserted text.
+     */
+    materializePendingParagraph(text: string): void;
     applyEdit(edit: StringEdit): void;
     applyEditForSelection(edit: StringEdit): void;
 }
@@ -540,8 +640,16 @@ export declare class EditorView extends Disposable {
     readonly element: HTMLElement;
     readonly editContext: EditContext;
     readonly measuredLayout: MeasuredLayoutModel;
+    /**
+     * Inner container that holds the rendered document and the cursor/selection
+     * overlays. The outer {@link element} spans the full width; this container
+     * is what limited-width mode caps and centers, so the overlays (which anchor
+     * to their parent's box) stay aligned with the content.
+     */
+    private readonly _contentContainer;
     private readonly _cursorView;
     private readonly _selectionView;
+    private readonly _gutterMarkersView;
     /**
      * The mounted block sequence, in source order. Rebuilt (not mutated) each
      * frame by {@link DocumentViewNode.create}; the view just swaps one
@@ -561,6 +669,13 @@ export declare class EditorView extends Disposable {
     /** The current view-data tree (AST overlaid with selection flags), for debugging. */
     private readonly _viewData;
     get viewData(): IObservable<DocumentViewData | undefined>;
+    /**
+     * Caret rect (client coords) for the transient empty paragraph, or
+     * `undefined` when none is armed. Set each frame from the synthetic
+     * paragraph element's geometry and fed to the {@link CursorView}, which has
+     * no visual-line-map entry to place the caret from otherwise.
+     */
+    private readonly _pendingCaretRect;
     /**
      * The block cache projected for views (selection painting) that need to
      * react to mount/unmount. Derived from {@link _document}, so it stays in
@@ -568,6 +683,13 @@ export declare class EditorView extends Disposable {
      */
     private readonly _selectionBlocksObs;
     constructor(_model: EditorModel, _options?: EditorViewOptions | undefined);
+    /**
+     * Mirrors the model's live Ctrl/Cmd state onto the editor root as
+     * `.md-mod-down` so CSS can show the link-open underline and pointer cursor
+     * only while a click would actually open the link: an inactive link opens on
+     * a plain click, but an active link only opens with the modifier held.
+     */
+    private _setupModifierTracking;
     focus(): void;
     /**
      * Client coordinates → absolute source offset (any block). Used during
@@ -603,6 +725,16 @@ export declare interface EditorViewOptions extends BlockViewOptions {
      * only) unless a theme class is supplied.
      */
     readonly classNames?: readonly string[];
+    /**
+     * Controls "limited width mode". The observable yields the maximum content
+     * width in pixels, or `undefined` to let the content fill the available
+     * width. When the option is omitted, the width is capped at
+     * {@link DEFAULT_LIMITED_WIDTH}px (limited mode is on by default).
+     *
+     * The cap and centering apply to an inner content container; the editor
+     * root ({@link element}) always spans the full available width.
+     */
+    readonly limitedWidth?: IObservable<number | undefined>;
 }
 
 export declare class EmphasisAstNode extends AstNode {
@@ -670,14 +802,39 @@ declare class GlueViewData {
     decorateNewline: boolean);
 }
 
-export declare class HeadingAstNode extends AstNode {
+/**
+ * A single gutter marker: a source {@link OffsetRange} tagged with a
+ * {@link GutterMarkerType}. The view resolves the range to the visual lines it
+ * covers and paints a bar (or, for `deleted`, a wedge at the range position) in
+ * the left gutter.
+ *
+ * A `deleted` marker is normally an empty range (`range.isEmpty`) sitting at the
+ * boundary where the removed text used to be — there is nothing left to span,
+ * so it is drawn as a caret between lines rather than a bar.
+ */
+export declare interface GutterMarker {
+    readonly range: OffsetRange;
+    readonly type: GutterMarkerType;
+}
+
+/**
+ * The kind of change a gutter marker represents, mirroring the three states a
+ * source-control diff distinguishes (the git change markers in the editor
+ * gutter): a freshly inserted region, an edited region, and a point where
+ * content was removed.
+ */
+export declare type GutterMarkerType = 'added' | 'modified' | 'deleted';
+
+export declare class HeadingAstNode extends BlockAstNodeBase {
     readonly level: 1 | 2 | 3 | 4 | 5 | 6;
     readonly marker: MarkerAstNode;
     readonly content: readonly (InlineAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "heading";
-    constructor(level: 1 | 2 | 3 | 4 | 5 | 6, marker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[]);
+    constructor(level: 1 | 2 | 3 | 4 | 5 | 6, marker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): HeadingAstNode;
     protected _localEquals(o: this): boolean;
 }
 
@@ -688,6 +845,42 @@ declare class HeadingViewData {
     constructor(ast: HeadingAstNode, content: readonly AnyViewData[]);
 }
 
+/**
+ * The editor operations a clipboard strategy drives. The strategy never
+ * touches the model or the DOM directly — it asks through this seam, so the
+ * same strategy works regardless of how the editor is wired up.
+ */
+export declare interface IClipboardContext {
+    /** The element that owns focus and receives clipboard/keyboard events. */
+    readonly element: HTMLElement;
+    /** The selected source text, or `undefined` when the selection is empty. */
+    getSelectedText(): string | undefined;
+    /** Delete the current selection (the cut half of cut). */
+    deleteSelection(): void;
+    /** Insert text at the caret, replacing any selection (the paste action). */
+    insertText(text: string): void;
+}
+
+/**
+ * How copy/cut/paste intent reaches the editor. Host environments deliver it
+ * differently, so the controller owns no clipboard logic itself — it
+ * {@link connect}s a strategy and lets it install whatever listeners it needs.
+ *
+ * Two implementations ship:
+ * - {@link NativeClipboardStrategy} (default) reads the browser's native
+ *   `copy`/`cut`/`paste` events and their synchronous `clipboardData`.
+ * - {@link AsyncClipboardStrategy} drives the async `navigator.clipboard` API
+ *   from Ctrl/Cmd+C/X/V keystrokes, for hosts (e.g. VS Code webviews) that
+ *   swallow the native clipboard events before they reach the editor.
+ */
+export declare interface IClipboardStrategy {
+    /**
+     * Wire up clipboard handling against `context`. The returned disposable
+     * tears down every listener the strategy installed.
+     */
+    connect(context: IClipboardContext): IDisposable;
+}
+
 /** The Monarch language definitions the default highlighter wires up. */
 export declare interface IDefaultMonarchGrammars {
     typescript: unknown;
@@ -782,6 +975,21 @@ export declare const insertLineBreak: EditCommand;
 
 export declare const insertParagraph: EditCommand;
 
+/**
+ * Context-aware Enter. The behaviour is chosen from the active block:
+ *  - paragraph / heading / thematic break — the "rich text" thing: at the
+ *    block's end arm a transient empty paragraph (see {@link SmartEnterResult});
+ *    elsewhere split into two paragraphs (`\n\n`).
+ *  - code block — insert a newline that preserves the current line's indentation,
+ *    staying inside the fence.
+ *  - block quote — continue the quote (`\n> `); an empty quote line exits it.
+ *  - list — continue the list with the next marker (incrementing ordered
+ *    numbers, re-emitting task checkboxes); an empty item exits the list.
+ * A non-collapsed selection, or any other block, falls back to a plain soft line
+ * break, preserving today's behaviour.
+ */
+export declare const insertSmartEnter: (ctx: CursorCommandContext) => SmartEnterResult;
+
 export declare function insertText(text: string): EditCommand;
 
 /**
@@ -886,14 +1094,16 @@ declare class LinkViewData {
     constructor(ast: LinkAstNode, content: readonly AnyViewData[]);
 }
 
-export declare class ListAstNode extends AstNode {
+export declare class ListAstNode extends BlockAstNodeBase {
     readonly ordered: boolean;
     readonly content: readonly (ListItemAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "list";
-    constructor(ordered: boolean, content: readonly (ListItemAstNode | GlueAstNode)[]);
+    constructor(ordered: boolean, content: readonly (ListItemAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get items(): readonly ListItemAstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): ListAstNode;
     protected _localEquals(o: this): boolean;
 }
 
@@ -907,6 +1117,7 @@ export declare class ListItemAstNode extends AstNode {
     get children(): readonly AstNode[];
     get blocks(): readonly BlockAstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): ListItemAstNode;
     protected _localEquals(o: this): boolean;
 }
 
@@ -960,13 +1171,15 @@ declare class MarkerViewData {
     constructor(ast: MarkerAstNode, visible: boolean);
 }
 
-export declare class MathBlockAstNode extends AstNode {
+export declare class MathBlockAstNode extends BlockAstNodeBase {
     readonly content: readonly (MarkerAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "mathBlock";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
+    constructor(content: readonly (MarkerAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get code(): MarkerAstNode | undefined;
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): MathBlockAstNode;
 }
 
 declare class MathBlockViewData {
@@ -1129,6 +1342,17 @@ export declare class MonacoSyntaxHighlighter implements ISyntaxHighlighter {
     private _tokenizerFor;
 }
 
+/**
+ * Default strategy: handle the browser's native `copy`/`cut`/`paste` events,
+ * reading and writing the synchronous {@link ClipboardEvent.clipboardData}.
+ * This is the standard rich-editor approach and works wherever the browser
+ * actually dispatches those events to the focused element (e.g. a standalone
+ * web page).
+ */
+export declare class NativeClipboardStrategy implements IClipboardStrategy {
+    connect(context: IClipboardContext): IDisposable;
+}
+
 /**
  * Move the cursor one position left or right, skipping over hidden marker
  * ranges in inactive blocks (and inactive items of an active list).
@@ -1164,12 +1388,14 @@ export declare class OffsetRange {
     toString(): string;
 }
 
-export declare class ParagraphAstNode extends AstNode {
+export declare class ParagraphAstNode extends BlockAstNodeBase {
     readonly content: readonly (InlineAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "paragraph";
-    constructor(content: readonly (InlineAstNode | GlueAstNode)[]);
+    constructor(content: readonly (InlineAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): ParagraphAstNode;
 }
 
 declare class ParagraphViewData {
@@ -1179,6 +1405,45 @@ declare class ParagraphViewData {
     constructor(ast: ParagraphAstNode, content: readonly AnyViewData[]);
 }
 
+/**
+ * A *transient* editing state: the empty paragraph the user conjured by
+ * pressing Enter at the end of a paragraph. Markdown has no empty-paragraph
+ * node, so this never lives in {@link EditorModel.sourceText} or the parsed
+ * {@link EditorModel.document} — it is pure edit intent that the view renders
+ * as a synthetic blank line and that the controller either *materializes* (the
+ * user types) or *cancels* (the user navigates away / backspaces).
+ */
+declare interface PendingParagraph {
+    /** The paragraph the blank line is rendered directly after. */
+    readonly anchorBlock: BlockAstNode;
+    /**
+     * Source region rewritten when the pending paragraph is materialized — the
+     * gap between {@link anchorBlock}'s text and whatever follows it.
+     */
+    readonly replaceRange: OffsetRange;
+    /** Whether {@link replaceRange} ends at the end of the document. */
+    readonly atEof: boolean;
+    /**
+     * A throwaway AST node that exists only to give the synthetic view child a
+     * stable identity across render frames (the view pairs nodes by `ast.id`).
+     * It is never part of {@link document}.
+     */
+    readonly syntheticAst: ParagraphAstNode;
+}
+
+/**
+ * View-data for the transient empty paragraph (see `PendingParagraph` in the
+ * model). It carries only the throwaway {@link ParagraphAstNode} that gives the
+ * rendered blank line a stable identity across frames; it has no content and is
+ * never measured or part of the selection geometry — the caret is positioned
+ * over it via a dedicated rect, not via the visual-line map.
+ */
+declare class PendingParagraphViewData {
+    readonly ast: ParagraphAstNode;
+    readonly kind = "pendingParagraph";
+    constructor(ast: ParagraphAstNode);
+}
+
 /**
  * Immutable point in 2D space, in CSS-pixel client coordinates.
  */
@@ -1296,6 +1561,25 @@ export declare class SelectionViewRendering {
 
 export declare const selectWord: SelectionCommand;
 
+/**
+ * The outcome of {@link insertSmartEnter}: either a concrete source edit (the
+ * ordinary cases), or a request to arm a transient empty paragraph (Enter at
+ * the very end of a paragraph), which the controller turns into
+ * {@link EditorModel.armPendingParagraph} rather than a source edit. Modelling
+ * the empty paragraph as state instead of source keeps the document valid
+ * Markdown — which has no empty-paragraph node — until the user actually types.
+ */
+export declare type SmartEnterResult = {
+    readonly kind: 'edit';
+    readonly edit: StringEdit;
+    readonly selection: Selection_2;
+} | {
+    readonly kind: 'pending';
+    readonly anchorBlock: BlockAstNode;
+    readonly replaceRange: OffsetRange;
+    readonly atEof: boolean;
+};
+
 /**
  * A run of {@link Token}s together with the exact {@link OffsetRange} they
  * cover.
@@ -1381,16 +1665,18 @@ declare class StrongViewData {
     constructor(ast: StrongAstNode, content: readonly AnyViewData[]);
 }
 
-export declare class TableAstNode extends AstNode {
+export declare class TableAstNode extends BlockAstNodeBase {
     readonly content: readonly (TableRowAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "table";
-    constructor(content: readonly (TableRowAstNode | GlueAstNode)[]);
+    constructor(content: readonly (TableRowAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     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;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): TableAstNode;
 }
 
 export declare class TableCellAstNode extends AstNode {
@@ -1472,13 +1758,15 @@ declare class TextViewData {
     constructor(ast: TextAstNode, showWhitespace: boolean, leftWordBoundary?: boolean, rightWordBoundary?: boolean);
 }
 
-export declare class ThematicBreakAstNode extends AstNode {
+export declare class ThematicBreakAstNode extends BlockAstNodeBase {
     readonly content: readonly (MarkerAstNode | GlueAstNode)[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "thematicBreak";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
+    constructor(content: readonly (MarkerAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get marker(): MarkerAstNode | undefined;
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): ThematicBreakAstNode;
 }
 
 declare class ThematicBreakViewData {