@vscode/markdown-editor 0.0.2-113 → 0.0.2-115

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Disposable } from '@vscode/observables';
 import { IDisposable } from '@vscode/observables';
 import { IObservable } from '@vscode/observables';
 import { IObservableWithChange } from '@vscode/observables';
+import { IReader } from '@vscode/observables';
 import { ISettableObservable } from '@vscode/observables';
 import { ITransaction } from '@vscode/observables';
 import { MonarchTokenizer } from 'monaco-editor/esm/vs/editor/standalone/common/monarch/monarchLexer.js';
@@ -24,7 +25,7 @@ declare interface AnnotatedRange {
 }
 
 /** Every concrete node kind, for exhaustive consumer-side dispatch. */
-export declare type AnyAstNode = TextAstNode | MarkerAstNode | GlueAstNode | ThematicBreakAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode | HeadingAstNode | ParagraphAstNode | FrontMatterAstNode | CodeBlockAstNode | MathBlockAstNode | VideoAstNode | BlockQuoteAstNode | ListAstNode | ListItemAstNode | TableAstNode | TableRowAstNode | TableCellAstNode | DocumentAstNode | UnhandledBlockAstNode;
+export declare type AnyAstNode = TextAstNode | MarkerAstNode | GlueAstNode | ThematicBreakAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode | HeadingAstNode | ParagraphAstNode | EmptyBlockAstNode | FrontMatterAstNode | CodeBlockAstNode | MathBlockAstNode | VideoAstNode | BlockQuoteAstNode | ListAstNode | ListItemAstNode | TableAstNode | TableRowAstNode | TableCellAstNode | DocumentAstNode | UnhandledBlockAstNode;
 
 declare type AnyViewData = DocumentViewData | BlockViewData | InlineViewData | ListItemViewData | TableRowViewData | TableCellViewData | MarkerViewData | GlueViewData | DiffHunkViewData | DiffDecorationViewData;
 
@@ -82,15 +83,21 @@ declare interface AstVisualizationNode {
  * fire-and-forget. Paste must wait for the async read before inserting.
  * Handled keydowns must not reach the host, which may replay native clipboard
  * commands even when the browser's default has been prevented.
+ *
+ * Hosts can supply a paste callback to read images or other clipboard formats.
+ * It receives the original context and whether Shift requested plain text.
+ * The callback owns asynchronous errors and stale-selection checks. It does
+ * not override copy/cut or clipboard handling in nested native inputs.
  */
 export declare class AsyncClipboardStrategy implements IClipboardStrategy {
     private readonly _clipboard;
-    constructor(_clipboard?: Clipboard);
+    private readonly _paste?;
+    constructor(_clipboard?: Clipboard, _paste?: ((context: IClipboardContext, plainText: boolean) => Promise<void>) | undefined);
     writeText(text: string): Promise<void>;
     connect(context: IClipboardContext): IDisposable;
 }
 
-export declare type BlockAstNode = HeadingAstNode | ParagraphAstNode | FrontMatterAstNode | CodeBlockAstNode | MathBlockAstNode | ThematicBreakAstNode | VideoAstNode | BlockQuoteAstNode | ListAstNode | TableAstNode | UnhandledBlockAstNode;
+export declare type BlockAstNode = HeadingAstNode | ParagraphAstNode | EmptyBlockAstNode | FrontMatterAstNode | CodeBlockAstNode | MathBlockAstNode | ThematicBreakAstNode | VideoAstNode | BlockQuoteAstNode | ListAstNode | TableAstNode | UnhandledBlockAstNode;
 
 /**
  * A block-level node. Every block may carry a {@link leadingTrivia} glue — the
@@ -167,7 +174,7 @@ declare class BlockQuoteViewData {
  */
 export declare function blocksIntersecting(doc: DocumentAstNode, start: SourceOffset, endExclusive: SourceOffset): BlockAstNode[];
 
-declare type BlockViewData = HeadingViewData | ParagraphViewData | FrontMatterViewData | CodeBlockViewData | MathBlockViewData | ThematicBreakViewData | VideoViewData | BlockQuoteViewData | ListViewData | TableViewData | UnhandledBlockViewData;
+declare type BlockViewData = HeadingViewData | ParagraphViewData | EmptyBlockViewData | FrontMatterViewData | CodeBlockViewData | MathBlockViewData | ThematicBreakViewData | VideoViewData | BlockQuoteViewData | ListViewData | TableViewData | UnhandledBlockViewData;
 
 /**
  * Base view node for everything the editor renders, generic over the
@@ -219,6 +226,7 @@ export declare class BlockViewNode<T extends AnyViewData = AnyViewData> extends
 export declare interface BlockViewOptions {
     /** Writes explicit copy actions through the host clipboard; defaults to the browser API. */
     readonly writeClipboardText?: (text: string) => Promise<void>;
+    readonly preserveSourceWhitespace?: boolean;
     readonly renderCustomCodeBlock?: (language: string, content: string) => HTMLElement | undefined;
     readonly onToggleCheckbox?: (item: ListItemAstNode, newChecked: boolean) => void;
     /** Temporarily yields the host editor's text input while a nested control owns focus. */
@@ -470,11 +478,10 @@ export declare class CommentModeController extends Disposable {
     private _anchorX;
     private _pinnedRange;
     /**
-     * The range a comment was just submitted for. The box stays hidden for it
-     * until the selection changes, so submitting doesn't immediately re-summon an
-     * empty box on the still-selected text.
+     * Keep a dismissed comment hidden across layout updates until the selection
+     * changes, whether the user submitted it or pressed Escape.
      */
-    private _submittedRange;
+    private _dismissedRange;
     constructor(_model: EditorModel, _view: EditorView, _options?: CommentModeControllerOptions | undefined);
     private _update;
     private _show;
@@ -601,6 +608,7 @@ export declare interface CursorCommandContext {
     readonly document: DocumentAstNode;
     readonly activeBlock: BlockAstNode | undefined;
     readonly markerVisibleBlocks: ReadonlySet<BlockAstNode>;
+    readonly markupSelectionRange?: OffsetRange;
     readonly wordNavigationConfig: WordNavigationConfig;
     readonly cursorPosition: CursorPosition;
 }
@@ -944,6 +952,7 @@ export declare class EditorController extends Disposable {
     private _lastPointerDown;
     constructor(_model: EditorModel, _view: EditorView, options?: EditorControllerOptions);
     private readonly _handleTextUpdate;
+    insertText(text: string, selectionOverride?: Selection_2): void;
     private _insertText;
     private _remainingGeneratedIndentation;
     /** Handle typed, pasted, or command-generated text while a paragraph is pending. */
@@ -1088,17 +1097,11 @@ export declare class EditorModel {
     private _pendingEdit;
     readonly sourceText: ISettableObservable<StringValue, void>;
     readonly wordNavigationConfig: ISettableObservable<WordNavigationConfig, void>;
-    /**
-     * Read-only mode. When `true`, the editor never reveals a block's source
-     * markers (markdown special characters like `**`, `#`, list bullets, code
-     * fences, `$…$`) — every block stays in its clean rendered form regardless of
-     * where the caret/selection is — and text-editing commands are ignored.
-     * Explicit interactions with rendered controls, such as task checkboxes,
-     * remain available. Plain text selection still works everywhere (so the user
-     * can copy). The default (`false`) is the normal editing mode where the active
-     * block reveals its markers.
-     */
+    /** Disables text editing, independently of parsing, layout and markup visibility. */
     readonly readonlyMode: ISettableObservable<boolean, void>;
+    readonly presentation: ISettableObservable<EditorPresentation, void>;
+    readonly renderMarkupText: ISettableObservable<RenderMarkupText, void>;
+    readonly presentationPolicy: IObservableWithChange<PresentationPolicy, void>;
     /**
      * The current selection, or `undefined` when the editor has no caret
      * (e.g. an inactive/unfocused rendering).
@@ -1188,6 +1191,7 @@ export declare class EditorModel {
     changedBlocks: Set<BlockAstNode>;
     } | undefined, void>;
     readonly markerVisibleBlocks: IObservableWithChange<Set<BlockAstNode>, void>;
+    getMarkupSelectionRange(selectionRange: OffsetRange | undefined, reader?: IReader): OffsetRange | undefined;
     onWillApplySourceEdit(listener: (event: SourceEditEvent) => void): IDisposable;
     /** Returns a stable per-object identity without retaining the source text. */
     getSourceTextId(sourceText: StringValue): number;
@@ -1224,6 +1228,20 @@ export declare class EditorModel {
 
 export declare type EditorOverlayPosition = 'top-chrome' | 'below-selection' | 'above-decorations';
 
+export declare type EditorPresentation = 'reading' | 'editing';
+
+/** Text updates and browser attachment are separate so hosts can supply a local transport. */
+declare interface EditorTextInput {
+    readonly context: EditorTextInputContext;
+    readonly nativeContext: IObservable<EditContext | null>;
+}
+
+declare interface EditorTextInputContext extends EventTarget {
+    readonly text: string;
+    updateText(start: number, end: number, text: string): void;
+    updateSelection(start: number, end: number): void;
+}
+
 /**
  * Pure-render view of an {@link EditorModel}.
  *
@@ -1251,10 +1269,12 @@ export declare class EditorView extends Disposable {
     private readonly _model;
     private readonly _options?;
     readonly element: HTMLElement;
-    readonly editContext: EditContext;
+    readonly editContext: EditorTextInputContext;
+    private readonly _nativeEditContext;
     readonly measuredLayout: MeasuredLayoutModel;
     readonly coordinateSpace: EditorCoordinateSpace;
     readonly forcedMarkerVisibleBlocks: ISettableObservable<ReadonlySet<BlockAstNode>, void>;
+    readonly showReadonlyToggle: ISettableObservable<boolean, void>;
     /**
      * Inner container that holds the rendered document and the cursor/selection
      * overlays. The outer {@link element} spans the full width; this container
@@ -1287,6 +1307,7 @@ export declare class EditorView extends Disposable {
     private readonly _writeClipboardText;
     /** Connects explicit copy actions to the controller's host clipboard strategy. */
     setClipboardWriter(writeText: (text: string) => Promise<void>): IDisposable;
+    private _renderedSourceEditing;
     /** The current view-node tree (AST overlaid with rendered DOM), for debugging. */
     get documentViewNode(): IObservable<DocumentViewNode | undefined>;
     /** Re-resolves embedded code editors while preserving the surrounding editor view. */
@@ -1359,8 +1380,7 @@ export declare class EditorView extends Disposable {
     private _setupFocusTracking;
     private _setupCaretScrollPadding;
     /**
-     * Renders the edit/read-only mode toggle. It flips the model's
-     * {@link EditorModel.readonlyMode}: when locked (read-only) every block stays
+     * Renders the locked/rich/source editing mode toggle. When locked every block stays
      * in its clean rendered form (no markdown markers revealed) and edits are
      * ignored, while text selection still works. The control lives in a
      * zero-height *sticky* host inside the centered content container, so the
@@ -1538,6 +1558,8 @@ export declare class EditorView extends Disposable {
 }
 
 export declare interface EditorViewOptions extends BlockViewOptions {
+    readonly presentation?: EditorPresentation;
+    readonly textInput?: EditorTextInput;
     /**
      * Extra class names added to the editor root element, e.g. a theme class
      * such as `'md-theme-default'` or `'github-markdown-theme'`. Theme styles
@@ -1588,6 +1610,24 @@ declare class EmphasisViewData {
     constructor(ast: EmphasisAstNode, content: readonly AnyViewData[]);
 }
 
+/** One blank source line, or the empty final line after a terminating newline. */
+export declare class EmptyBlockAstNode extends BlockAstNodeBase {
+    readonly content: readonly GlueAstNode[];
+    readonly leadingTrivia?: GlueAstNode | undefined;
+    readonly kind = "emptyBlock";
+    constructor(content: readonly GlueAstNode[], leadingTrivia?: GlueAstNode | undefined);
+    get children(): readonly AstNode[];
+    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
+    withLeadingTrivia(trivia: GlueAstNode | undefined): EmptyBlockAstNode;
+}
+
+declare class EmptyBlockViewData {
+    readonly ast: EmptyBlockAstNode;
+    readonly content: readonly AnyViewData[];
+    readonly kind = "emptyBlock";
+    constructor(ast: EmptyBlockAstNode, content: readonly AnyViewData[]);
+}
+
 export declare function escapeFindRegex(value: string): string;
 
 export declare const FIND_MATCH_LIMIT = 19999;
@@ -1833,6 +1873,7 @@ declare class GlueViewData {
      * block children) the break is already visible, so no `↵` is drawn.
      */
     readonly decorateNewline: boolean;
+    readonly showWhitespace: boolean;
     readonly kind = "glue";
     constructor(ast: GlueAstNode, visible: boolean, 
     /**
@@ -1841,7 +1882,7 @@ declare class GlueViewData {
      * the line ending hiding there; between block-level siblings (list items,
      * block children) the break is already visible, so no `↵` is drawn.
      */
-    decorateNewline: boolean);
+    decorateNewline: boolean, showWhitespace?: boolean);
 }
 
 /**
@@ -2142,7 +2183,7 @@ export declare const insertParagraph: EditCommand;
  * 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 const insertSmartEnter: (ctx: CursorCommandContext, useSourceLineBreaks?: boolean) => SmartEnterResult;
 
 /**
  * VS Code-style Tab: insert to the next tab stop for a caret or partial
@@ -2317,10 +2358,10 @@ declare class LinkViewData {
 
 export declare class ListAstNode extends BlockAstNodeBase {
     readonly ordered: boolean;
-    readonly content: readonly (ListItemAstNode | GlueAstNode)[];
+    readonly content: readonly (ListItemAstNode | EmptyBlockAstNode | GlueAstNode)[];
     readonly leadingTrivia?: GlueAstNode | undefined;
     readonly kind = "list";
-    constructor(ordered: boolean, content: readonly (ListItemAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
+    constructor(ordered: boolean, content: readonly (ListItemAstNode | EmptyBlockAstNode | GlueAstNode)[], leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get items(): readonly ListItemAstNode[];
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
@@ -2337,6 +2378,7 @@ export declare class ListItemAstNode extends AstNode {
     constructor(marker: MarkerAstNode, content: readonly (BlockAstNode | GlueAstNode)[], checked?: boolean | undefined, leadingTrivia?: GlueAstNode | undefined);
     get children(): readonly AstNode[];
     get blocks(): readonly BlockAstNode[];
+    get isIncomplete(): boolean;
     mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
     withLeadingTrivia(trivia: GlueAstNode | undefined): ListItemAstNode;
     protected _localEquals(o: this): boolean;
@@ -2356,6 +2398,7 @@ declare class ListItemViewData {
      * reveals the literal marker instead of the progress affordance.
      */
     readonly isRunning: boolean;
+    readonly sourceIndentation: number;
     readonly kind = "listItem";
     constructor(ast: ListItemAstNode, 
     /** Whether the selection reaches this item (reveals its markers). */
@@ -2368,7 +2411,7 @@ declare class ListItemViewData {
      * Always `false` while the item is active — an active/editing task
      * reveals the literal marker instead of the progress affordance.
      */
-    isRunning?: boolean);
+    isRunning?: boolean, sourceIndentation?: number);
 }
 
 declare class ListViewData {
@@ -2404,6 +2447,15 @@ export declare class LocalHistoryStrategy implements IHistoryStrategy {
     private _clear;
 }
 
+export declare interface MarkdownParseOptions {
+    readonly explicitBlankLineBlocks?: boolean;
+    readonly explicitFinalEmptyLine?: boolean;
+    readonly preserveTrailingListContinuation?: boolean;
+    readonly allowEmptyListItemInterrupts?: boolean;
+    readonly requireListMarkerWhitespace?: boolean;
+    readonly allowEmptyTaskItems?: boolean;
+}
+
 /**
  * Parses markdown into a {@link DocumentAstNode}.
  *
@@ -2413,7 +2465,7 @@ export declare class LocalHistoryStrategy implements IHistoryStrategy {
  * blocks keep their incremental highlighting sessions.
  */
 export declare class MarkdownParser {
-    parse(text: StringValue, previous?: DocumentAstNode, edit?: StringEdit): DocumentAstNode;
+    parse(text: StringValue, previous?: DocumentAstNode, edit?: StringEdit, options?: MarkdownParseOptions): DocumentAstNode;
 }
 
 /** A semantic syntax marker (heading `#`, fences, brackets, list bullet, …). */
@@ -2609,6 +2661,11 @@ export declare const moveLinesDown: EditCommand;
 
 export declare const moveLinesUp: EditCommand;
 
+export declare interface NativeClipboardData {
+    readonly text: string;
+    readonly files: readonly File[];
+}
+
 /**
  * Default strategy: handle the browser's native `copy`/`cut`/`paste` events,
  * reading and writing the synchronous {@link ClipboardEvent.clipboardData}.
@@ -2780,6 +2837,22 @@ export declare class Point2D {
     translate(dx: number, dy: number): Point2D;
 }
 
+export declare const presentationPolicies: Readonly<Record<EditorPresentation, PresentationPolicy>>;
+
+declare interface PresentationPolicy {
+    readonly parseOptions: MarkdownParseOptions;
+    readonly preserveSourceWhitespace: boolean;
+    readonly useSourceLineBreaks: boolean;
+}
+
+/**
+ * Read native clipboard formats through an editable target. Electron can expose
+ * file clipboard entries here that navigator.clipboard.read() omits. EditContext
+ * roots themselves do not receive execCommand('paste') events.
+ * Returns undefined when the host does not support native programmatic paste.
+ */
+export declare function readNativeClipboard(focusTarget: HTMLElement, executePaste?: () => void): NativeClipboardData | undefined;
+
 /**
  * Immutable axis-aligned rectangle in a caller-defined 2D CSS-pixel coordinate
  * space. `x`/`y` is the top-left corner, growing right/down.
@@ -2815,6 +2888,89 @@ declare interface RemovedItem {
     readonly deletedLocal: readonly AnnotatedRange[];
 }
 
+export declare interface RenameAnchor {
+    readonly left: number;
+    readonly top: number;
+    readonly height: number;
+}
+
+export declare class RenameModel<TContext = undefined> {
+    private readonly _options;
+    readonly name: ISettableObservable<string, void>;
+    private readonly _session;
+    private readonly _pending;
+    private readonly _failure;
+    private _submission;
+    private _disposed;
+    readonly session: IObservable<RenameSession<TContext> | undefined>;
+    readonly pending: IObservable<boolean>;
+    readonly isOpen: IObservableWithChange<boolean, void>;
+    readonly error: IObservableWithChange<Error | undefined, void>;
+    readonly validationMessage: IObservableWithChange<string | undefined, void>;
+    readonly canSubmit: IObservableWithChange<boolean, void>;
+    private readonly _nameObserver;
+    constructor(_options: RenameModelOptions<TContext>);
+    open(session: RenameSession<TContext>): void;
+    submit(): Promise<RenameSubmitResult>;
+    cancel(): void;
+    dispose(): void;
+    private _close;
+    private _abortSubmission;
+    private _isCurrent;
+}
+
+export declare interface RenameModelOptions<TContext = undefined> {
+    readonly onSubmit: (request: RenameRequest<TContext>) => void | Promise<void>;
+    readonly onCancel?: (session: RenameSession<TContext>) => void;
+    readonly validate?: (name: string, session: RenameSession<TContext>) => string | undefined;
+}
+
+export declare interface RenameRequest<TContext = undefined> extends RenameSession<TContext> {
+    readonly name: string;
+    readonly signal: AbortSignal;
+}
+
+export declare interface RenameSession<TContext = undefined> {
+    readonly initialName: string;
+    readonly context: TContext;
+}
+
+export declare type RenameSubmitResult = {
+    readonly kind: 'submitted';
+    readonly name: string;
+} | {
+    readonly kind: 'invalid';
+    readonly message: string;
+} | {
+    readonly kind: 'error';
+    readonly error: Error;
+} | {
+    readonly kind: 'closed' | 'pending' | 'cancelled' | 'superseded';
+};
+
+export declare class RenameWidget<TContext = undefined> extends Disposable {
+    private readonly _container;
+    private readonly _model;
+    private readonly _options;
+    readonly element: HTMLDivElement;
+    readonly inputElement: HTMLInputElement;
+    private readonly _message;
+    private _anchor;
+    private _focusedSession;
+    constructor(_container: HTMLElement, _model: RenameModel<TContext>, _options?: RenameWidgetOptions);
+    focusAndSelect(): void;
+    /** Anchor coordinates are relative to the positioned container's padding box. */
+    layout(anchor?: RenameAnchor): void;
+}
+
+export declare interface RenameWidgetOptions {
+    readonly autoFocus?: boolean;
+    /** Called when a focused widget closes; the host can restore editor focus. */
+    readonly onDidHide?: () => void;
+}
+
+export declare type RenderMarkupText = 'none' | 'selection' | 'all';
+
 declare interface ReplacedItem {
     readonly kind: 'replaced';
     readonly original: AstNode;
@@ -3049,6 +3205,83 @@ declare class StrongViewData {
     constructor(ast: StrongAstNode, content: readonly AnyViewData[]);
 }
 
+export declare type SuggestAcceptance = 'enter' | 'tab' | 'pointer';
+
+export declare interface SuggestCallbacks<T extends SuggestItem> {
+    readonly onAccept: (item: T, source: SuggestAcceptance) => void;
+    readonly onCancel?: () => void;
+    readonly onSelect?: (item: T | undefined) => void;
+}
+
+export declare interface SuggestItem {
+    readonly id: string;
+    readonly label: string;
+    readonly detail?: string;
+    readonly type?: string;
+    readonly highlightLength?: number;
+}
+
+export declare class SuggestModel<T extends SuggestItem = SuggestItem> {
+    private readonly _callbacks;
+    private readonly _state;
+    readonly state: IObservable<SuggestState<T>>;
+    readonly selectedItem: IObservableWithChange<T | undefined, void>;
+    constructor(_callbacks: SuggestCallbacks<T>);
+    show(items: readonly T[], selectedId?: string | undefined): void;
+    showLoading(): void;
+    showError(message: string): void;
+    close(): void;
+    select(id: string): boolean;
+    navigate(direction: SuggestNavigation, pageSize?: number): boolean;
+    accept(source?: SuggestAcceptance): boolean;
+    cancel(): boolean;
+    private _update;
+}
+
+export declare type SuggestNavigation = 'next' | 'previous' | 'first' | 'last' | 'nextPage' | 'previousPage';
+
+export declare type SuggestState<T extends SuggestItem = SuggestItem> = {
+    readonly kind: 'closed';
+} | {
+    readonly kind: 'loading';
+} | {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'error';
+    readonly message: string;
+} | {
+    readonly kind: 'ready';
+    readonly items: readonly T[];
+    readonly selectedIndex: number;
+};
+
+export declare class SuggestWidget<T extends SuggestItem = SuggestItem> extends Disposable {
+    private readonly _options;
+    readonly element: HTMLDivElement;
+    readonly listElement: HTMLDivElement;
+    private readonly _message;
+    private readonly _savedAttributes;
+    private _items;
+    private _disposed;
+    private _pendingReveal;
+    constructor(_options: SuggestWidgetOptions<T>);
+    handleKeyDown(event: KeyboardEvent): boolean;
+    dispose(): void;
+    private _rowFromEvent;
+    private _render;
+    private _revealSelection;
+    private _createRow;
+    private _restoreAttributes;
+}
+
+export declare interface SuggestWidgetOptions<T extends SuggestItem> {
+    readonly model: SuggestModel<T>;
+    readonly focusTarget: HTMLElement;
+    readonly id: string;
+    readonly label?: string;
+    readonly listenForKeyboard?: boolean;
+}
+
 export declare type TabKeyboardAction = 'insert' | 'outdent';
 
 export declare class TableAstNode extends BlockAstNodeBase {
@@ -3113,10 +3346,10 @@ declare class TableViewData {
 }
 
 /**
- * Source range (relative to `item`) of a task list item's `[x]`/`[ ]`
+ * 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.
+ * checkbox token here.
  */
 export declare function taskCheckboxRange(item: ListItemAstNode): OffsetRange | undefined;
 
@@ -3140,6 +3373,7 @@ declare class TextViewData {
      * {@link isRunnerMarkerText} has matched this node. Zero otherwise.
      */
     readonly hiddenPrefixLength: number;
+    readonly taskLabel: boolean;
     readonly kind = "text";
     /**
      * Whether non-obvious whitespace in this text is revealed (block is active).
@@ -3155,7 +3389,7 @@ declare class TextViewData {
      * mandatory leading separator, once
      * {@link isRunnerMarkerText} has matched this node. Zero otherwise.
      */
-    hiddenPrefixLength?: number);
+    hiddenPrefixLength?: number, taskLabel?: boolean);
 }
 
 export declare class ThematicBreakAstNode extends BlockAstNodeBase {