@vscode/markdown-editor 0.0.2-117 → 0.0.2-119

package/README.md

@@ -75,11 +75,20 @@ character is typed. These narrow recognition deviations avoid structural jumps
 while typing or deleting, without depending on editing history. The reading
 preset leaves these extensions off.
 
+Editing presentation recognizes empty task checkboxes (`[ ]`, `[x]`, and `[]`)
+at end-of-file as well as before whitespace or a newline. Enter exits an empty
+task just like an empty list item; a nested empty task first outdents.
+
 In editing presentation, Enter continues complete list items and exits/outdents
 empty ones. Elsewhere it inserts a single newline without creating a virtual
 paragraph. Arrow Down also stays within
 the existing source instead of creating a virtual paragraph.
 
+At a soft wrap, the end of one visual line and start of the next share a source
+offset. Mouse placement and visual-line navigation retain upstream caret
+affinity when targeting the preceding line, without changing source offsets.
+Explicit newlines and programmatic selections keep their existing behavior.
+
 See [Editing property tests](docs/editing-properties.md) for the interactive
 assertion fixtures, CI contracts, deterministic editing corpus, and the
 red/green/visual evidence required for layout fixes.
@@ -93,6 +102,12 @@ GitHub issue URLs can receive VS Code rich presentations without `[label](url)`
 syntax. Active links retain their exact editable source. Code spans and fenced
 code do not auto-link; trailing punctuation is excluded from link targets.
 
+Pasting a single HTTP(S) URL over selected inline text turns that selection into
+a Markdown link, preserving inline formatting. Pasting without a selection,
+inside code or an existing link, or across block boundaries keeps ordinary text
+replacement. Ctrl/Cmd+Shift+V bypasses link creation with the async clipboard
+strategy (including VS Code). Typed URLs do not wrap selections.
+
 ### Fixture reference rendering
 
 The real-editor examples expose **Interactive mode** in the fixture toolbar.
@@ -101,7 +116,11 @@ editor, selection, or recording; it defaults off for deterministic screenshots.
 
 In the sidebar, **showEditModeToggle** restores the editor's lock button.
 **readonly**, **presentation** (`reading` / `editing`), and **renderMarkupText**
-(`none` / `selection` / `all`) control the three independent policies. These controls are
+(`none` / `selection` / `all`) control permission, presentation, and markup policy.
+In read-only mode, `selection` keeps Markdown rendered even when text is selected;
+unlocking restores selection-driven source markers. Explicit `all` still exposes
+source for inspection, and diff/find diagnostics retain their explicit source reveals.
+These controls are
 live in the examples, main demos, content/selection fixtures, and Mermaid
 fixtures: edits and selection survive changes. The dropdown follows the editor
 button and replayed state. Legacy recordings with `sourceEditing` and
@@ -181,9 +200,10 @@ source markers. The source-selection status uses a fixed-height, ellipsized row.
 
 These are coverage seeds, not a claim that every combination is complete.
 Concrete feedback must receive a named fixture plus behavioral/geometry
-assertions; screenshot review alone does not close a regression. Production
-margin optimization and removal of alternative hit-testing remain separate
-follow-ups after reviewing these fixtures.
+assertions; screenshot review alone does not close a regression.
+Point-to-source resolution always uses the editor's geometric hit test. The
+demo's `caretDomPosArea` visualization samples that same path; the browser
+caret hit-test alternative and its `caretDomPos`/`ownHitTest` switches are removed.
 
 The list-marker review deliberately distinguishes presentation policies.
 Editing presentation treats a bare `*`, `-`, `+`, or ordered marker as paragraph
@@ -213,21 +233,83 @@ normal font sidebearing; the selection spans those exact caret endpoints.
 Source-only spaces that do not create a nested item extend
 leftward into the gutter instead of moving the logical bullet or text column.
 Their display width uses the parsed marker prefix, not a fixed two-space rule.
-Reading layout is unchanged.
+Native bullet typography is unchanged.
+Nested task prefixes use half-width indentation cells to bring their first
+source-space dot closer to ordinary siblings without moving bullets, checkboxes,
+or labels. Unordered-list continuation indentation reuses the source prefix's
+indentation, marker, and separator cells, including an indented blank line
+following a list. `lists/mixed-prefix-spaces`, `lists/blank-continuation-spaces`,
+and `lists/nested-continuation-spaces` isolate these cases; browser tests verify
+each cell's geometry, clicking, arrow movement, and typing at four font sizes.
 The `lists/indent-depth-2`, `lists/indent-depth-uneven`, and `lists/indent-prefix-3`
 fixtures reconstruct the nested-spacing feedback with minimal sources.
 Browser geometry assertions also cover wider ordered prefixes, tabs,
 markup visibility, typing, and undo.
 
+Typing the third backtick of a new opening fence inserts a closing fence on the
+next line, leaving the caret on the opener for a language name. Container
+indentation is retained; pasted, inline, already-paired, and closing fences are
+not completed. `formatting/fence-completion` captures the typing states. Enter
+inside a fenced block preserves its indentation in editing presentation.
+`lists/fenced-continuation-spaces` covers list-contained fences: opening, code,
+and closing-line spaces reuse the list's source prefix cells, including with
+syntax highlighting, without changing reading presentation.
+
+The mode toggle is a sticky overlay in the right margin when there is room,
+and may overlap content in narrow editors. It never changes text flow or reserves
+an asymmetric rail. Left and right padding use two fixed sizes, without
+intermediate scaling: 8px through 600px editor width, then 48px.
+Once the document reaches its configured maximum width (900px by default),
+it stays that width and additional space goes equally to the outer margins.
+Disabling the width limit keeps the 48px margins on wide editors.
+Top-level headings retain
+symmetric 2em minimum clearance for their hanging markers, independent of heading
+level. Long prefixes scale to fit that gutter instead of moving the document.
+Top padding stays at 32px regardless of editor width, document content, or
+scrollbar gutters. The VS Code webview uses thin scrollbars with transparent
+tracks. First and later headings use identical font line boxes, preserving the
+same text-to-underline spacing. Only the first block's top margin is removed;
+the fixed top padding provides the optical spacing adjustment.
+The `editor/readonly-toggle/` fixtures include wide, narrow, and scrolling documents.
+The first block has no additional top margin in either presentation. The first
+block inside a blockquote also has no top margin, preventing it from collapsing
+outward and shifting the quote when a marker-only line gains content. The
+paired `HeadingReading` and `HeadingEditing` fixtures and lock-toggle browser
+tests guard its text position. VS Code themes map whitespace indicators to
+`editorWhitespace.foreground`, including its dark-theme opacity.
+The `HeadingSpacingH1` and `HeadingSpacingH2` fixtures compare first and later
+headings; browser tests cover their underline spacing across themes, widths,
+wrapped text, presentation modes, and active or inactive selections.
+
+Set `EditorViewOptions.highlightActiveBlock` to `false` to disable the active
+block's background and glow, or update the live `view.highlightActiveBlock`
+observable. This does not change active source markers, selection, or editing
+behavior. Highlighting is enabled by default.
+
+Empty ATX headings keep their separator whitespace in the same source marker
+as populated headings. A zero-source-length line anchor preserves the heading
+caret's column and line box when typing or removing its first character.
+The existing `headings/atx-*` empty-prefix states and `headings/prefix-caret-*`
+populated states cover this transition.
+
+Rich-link pills at the end of a rendered line may use the remaining content
+width before truncating their title. Short titles retain their natural width;
+pills followed by prose retain their compact title limit. The width is updated
+with editor layout and metadata changes, respecting list indentation and the
+mode toggle's local exclusion rectangle. `Links/Rich links/Static/Trailing titles`
+provides long, short, mid-line, formatted, and session-link examples.
+
 `task-lists/nested-task-ownership` prevents a child checkbox from turning its
 parent into a task. `task-lists/mixed-task-labels` aligns labels of task and
 ordinary sibling items while preserving nested indentation. The ordinary
 item's real separator spaces expand to fill the extra label-column width.
 `task-lists/nested-task-empty-sibling-*` and `task-lists/mixed-task-separated-lists-*`
 isolate populated/empty nested tasks and mixed lists separated by a thematic break.
-In editing presentation, checkboxes and ordinary bullets share a gutter column;
+In both presentations, checkboxes and ordinary bullets share a gutter column;
 the task's extra source bullet hangs farther left. Labels keep their position
 when markup visibility changes, except for extra source-only separator padding.
+`lists/mixed-label-column` compares the same nested labels in reading and editing;
+both use one shared marker/label layout rather than separate task indentation.
 The expanded ordinary separator has a visible
 whitespace dot. Browser tests click task-label characters with markup hidden,
 selection-revealed, and fully revealed, then verify exact insertion offsets.
@@ -235,6 +317,15 @@ selection-revealed, and fully revealed, then verify exact insertion offsets.
 before label text is typed in editing presentation. Reading retains standard GFM
 parsing. Typing or deleting the label must not change checkbox ownership or move
 the empty caret's text column.
+The `task-lists/checkbox-separator-*` fixtures cover the caret immediately
+after `]`, after its first separator, and after an extra space. In editing
+presentation, the first separator reaches the label column and each additional
+space advances normally. The checkbox and separator participate in inline layout,
+so native text ranges, clicks, and the painted caret agree.
+The `lists/extra-separator-continuation-spaces` and
+`lists/extra-separator-blank-line` fixtures protect `-   test` followed by a blank
+line and `    test`: the four prefix cells align and the blank-line caret sits
+at the active label column.
 Editing also treats `- [] test` as unchecked, preserving task layout through
 `[x]` -> `[]` -> `[ ]` edits without inserting a space into the source.
 Reading keeps `[]` as literal text. The normal separator requirement remains;

package/dist/index.d.ts

@@ -637,16 +637,13 @@ export declare interface CursorMoveResult {
 export declare const cursorMoveRight: CursorCommand;
 
 /** The cursor's position in either source text or a source-less visual line. */
-export declare type CursorPosition = {
-    readonly kind: 'source';
-    readonly offset: SourceOffset;
-} | {
+export declare type CursorPosition = SourceCursorPosition | {
     readonly kind: 'virtual';
     readonly line: VirtualCursorLine;
 };
 
 export declare namespace CursorPosition {
-    export function source(offset: SourceOffset): CursorPosition;
+    export function source(offset: SourceOffset, affinity?: SourceCursorPosition['affinity']): SourceCursorPosition;
     export function virtual(line: VirtualCursorLine): CursorPosition;
 }
 
@@ -1275,6 +1272,7 @@ export declare class EditorView extends Disposable {
     readonly coordinateSpace: EditorCoordinateSpace;
     readonly forcedMarkerVisibleBlocks: ISettableObservable<ReadonlySet<BlockAstNode>, void>;
     readonly showReadonlyToggle: ISettableObservable<boolean, void>;
+    readonly highlightActiveBlock: 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
@@ -1383,9 +1381,9 @@ export declare class EditorView extends Disposable {
      * 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
-     * lock follows the content's right edge and remains pinned as the document
-     * scrolls. The current mode is also mirrored onto the root as `.md-readonly`
+     * zero-height sticky host, using the right margin when it fits and
+     * overlapping content when narrow, without changing the document's geometry.
+     * The current mode is also mirrored onto the root as `.md-readonly`
      * for any CSS hooks.
      */
     private _setupReadonlyToggle;
@@ -1458,31 +1456,19 @@ export declare class EditorView extends Disposable {
      * re-check still respects any target the user has claimed in the meantime.
      */
     autoFocusOnOpen(): void;
-    /**
-     * Own point→offset resolution. When `true` (the default),
-     * {@link resolveOffsetFromPoint} ignores the platform DOM hit-test
-     * (`caretPositionFromPoint`) and snaps the point to the nearest offset purely
-     * from the rendered {@link VisualLineMap} geometry — picking the nearest
-     * visual line by `y`, then the nearest offset on it by `x`. Because a table
-     * row's cells share one horizontal line band, this makes the whole width of a
-     * row resolve into that row (rather than only the cell boxes), with no visible
-     * layout change. It also lets a drag keep extending toward off-viewport points
-     * (e.g. the pointer leaving the window), which the platform hit-test cannot
-     * resolve. Set to `false` to fall back to the platform DOM hit-test.
-     */
-    readonly geometricHitTest: ISettableObservable<boolean, void>;
     /**
      * Client coordinates → absolute source offset (any block). Used during
      * drag to keep extending the selection even when the pointer leaves the
-     * original block. Honours {@link geometricHitTest}.
+     * original block. Snaps to the nearest visual line and source offset.
      */
     resolveOffsetFromPoint(point: Point2D): SourceOffset | undefined;
+    resolveCursorPositionFromPoint(point: Point2D): SourceCursorPosition | undefined;
     private _resolveControlFreeVideoOffset;
     /**
      * Resolve table-cell hits that have no measurable text run. Empty cells map
      * from their own box instead of snapping to a neighboring cell; element-only
      * content (for example an inactive image) maps through the hit element's view
-     * node. Text-bearing cells keep the normal pixel-precise line-map/DOM path.
+     * node. Text-bearing cells keep the normal pixel-precise line-map path.
      */
     private _resolveTableCellOffset;
     /**
@@ -1568,11 +1554,13 @@ export declare interface EditorViewOptions extends BlockViewOptions {
      */
     readonly classNames?: readonly string[];
     /**
-     * Whether to render the sticky edit/read-only toggle at the top-right edge
+     * Whether to render the edit/read-only toggle at the top-right edge
      * of the content. Defaults to `true`; set to `false` to omit it (e.g. in
      * fixtures that focus on selection rendering).
      */
     readonly showReadonlyToggle?: boolean;
+    /** Whether to paint the active block's background and glow. Defaults to `true`. */
+    readonly highlightActiveBlock?: boolean;
     /**
      * Controls "limited width mode". The observable yields the maximum content
      * width in pixels, or `undefined` to let the content fill the available
@@ -1874,6 +1862,7 @@ declare class GlueViewData {
      */
     readonly decorateNewline: boolean;
     readonly showWhitespace: boolean;
+    readonly listContinuation?: ListContinuation | undefined;
     readonly kind = "glue";
     constructor(ast: GlueAstNode, visible: boolean, 
     /**
@@ -1882,7 +1871,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, showWhitespace?: boolean);
+    decorateNewline: boolean, showWhitespace?: boolean, listContinuation?: ListContinuation | undefined);
 }
 
 /**
@@ -1953,8 +1942,8 @@ export declare interface IClipboardContext {
     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;
+    /** Paste text, linking a suitable selection when the payload is a URL unless plain text was requested. */
+    insertText(text: string, plainText?: boolean): void;
 }
 
 /**
@@ -2191,7 +2180,7 @@ export declare const insertSmartEnter: (ctx: CursorCommandContext, useSourceLine
  */
 export declare function insertTab(config?: IndentationConfig): EditCommand;
 
-export declare function insertText(text: string, generatedIndentation?: OffsetRange): EditCommand;
+export declare function insertText(text: string, generatedIndentation?: OffsetRange, completeFences?: boolean): EditCommand;
 
 /**
  * An immutable view of one document's tokens at a point in time. It may be a
@@ -2369,6 +2358,14 @@ export declare class ListAstNode extends BlockAstNodeBase {
     protected _localEquals(o: this): boolean;
 }
 
+declare interface ListContinuation {
+    readonly item: ListItemAstNode;
+    readonly level: number;
+    readonly indentation: number;
+    readonly mixedTasks: boolean;
+    readonly outsideList: boolean;
+}
+
 export declare class ListItemAstNode extends AstNode {
     readonly marker: MarkerAstNode;
     readonly content: readonly (BlockAstNode | GlueAstNode)[];
@@ -2997,6 +2994,7 @@ export declare class RichLink {
     private constructor();
     update(presentation: LinkPresentation | undefined): void;
     private _renderUnavailable;
+    private _layout;
     private _setDefaultOrder;
 }
 
@@ -3013,13 +3011,14 @@ export declare function selectBlock(ctx: CursorCommandContext, blockRange: Offse
 declare class Selection_2 {
     readonly anchor: SourceOffset;
     readonly active: SourceOffset;
-    static collapsed(offset: SourceOffset): Selection_2;
-    constructor(anchor: SourceOffset, active: SourceOffset);
+    static collapsed(offset: SourceOffset, affinity?: SourceCursorPosition['affinity']): Selection_2;
+    readonly activeAffinity?: SourceCursorPosition['affinity'];
+    constructor(anchor: SourceOffset, active: SourceOffset, activeAffinity?: SourceCursorPosition['affinity']);
     get isCollapsed(): boolean;
     get isForward(): boolean;
     get range(): OffsetRange;
     collapseToActive(): Selection_2;
-    withActive(active: SourceOffset): Selection_2;
+    withActive(active: SourceOffset, affinity?: SourceCursorPosition['affinity']): Selection_2;
 }
 export { Selection_2 as Selection }
 
@@ -3120,6 +3119,13 @@ export declare interface SnapshotTokens {
     readonly tokens: readonly Token[];
 }
 
+declare interface SourceCursorPosition {
+    readonly kind: 'source';
+    readonly offset: SourceOffset;
+    /** Prefer the preceding visual line at a shared soft-wrap boundary. */
+    readonly affinity?: 'upstream';
+}
+
 /** Metadata delivered synchronously immediately before a model-owned source edit is applied. */
 export declare interface SourceEditEvent {
     readonly baseSourceTextId: number;
@@ -3763,7 +3769,7 @@ export declare class VisualLineMap {
      * The first such trailing-boundary line is remembered as a fallback for the
      * document's very last offset, where no later line starts it.
      */
-    lineIndexOfOffset(offset: SourceOffset): number;
+    lineIndexOfOffset(offset: SourceOffset, affinity?: SourceCursorPosition['affinity']): number;
     /**
      * x of the caret position before `offset`, on the line returned by
      * {@link lineIndexOfOffset}. Returns `0` when the map is empty.
@@ -3786,6 +3792,8 @@ export declare class VisualLineMap {
      * uses {@link offsetInLineAtX} directly to preserve desired column.
      */
     offsetAtPoint(point: Point2D): SourceOffset;
+    positionAtPoint(point: Point2D): SourceCursorPosition;
+    positionAtOffsetInLine(lineIndex: number, offset: SourceOffset): SourceCursorPosition;
     /** Snap `x` to the nearest offset on a specific line. */
     offsetInLineAtX(lineIndex: number, x: number): SourceOffset;
     positionInLineAtX(lineIndex: number, x: number): CursorPosition;