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

package/dist/view/viewData.d.ts

@@ -1,251 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { GlueAstNode, BlockAstNode, CodeBlockAstNode, DocumentAstNode, EmphasisAstNode, HeadingAstNode, ImageAstNode, InlineCodeAstNode, InlineMathAstNode, LinkAstNode, ListAstNode, ListItemAstNode, MarkerAstNode, MathBlockAstNode, ParagraphAstNode, StrikethroughAstNode, StrongAstNode, TableAstNode, TableCellAstNode, TableRowAstNode, TextAstNode, ThematicBreakAstNode, BlockQuoteAstNode } from '../parser/ast.js';
-/**
- * The view-data root. Mirrors {@link DocumentAstNode}: {@link blocks} holds only
- * its top-level blocks (each wrapped with where it starts and whether it is
- * active), while {@link children} additionally interleaves the rendered
- * document-level glue (the blank lines between blocks) in source order.
- */
-export declare class DocumentViewData {
-    readonly ast: DocumentAstNode;
-    readonly blocks: readonly DocumentBlockViewData[];
-    /**
-     * Blocks and inter-block glue interleaved in source order — the actual
-     * mount sequence. {@link blocks} is the block-only projection used for
-     * measurement and selection.
-     */
-    readonly children: readonly DocumentChildViewData[];
-    readonly kind = "document";
-    constructor(ast: DocumentAstNode, blocks: readonly DocumentBlockViewData[], 
-    /**
-     * Blocks and inter-block glue interleaved in source order — the actual
-     * mount sequence. {@link blocks} is the block-only projection used for
-     * measurement and selection.
-     */
-    children: readonly DocumentChildViewData[]);
-}
-/** A top-level block plus the document-level state the renderer applies to it. */
-export interface DocumentBlockViewData {
-    readonly ast: BlockAstNode;
-    readonly absoluteStart: number;
-    /** Whether the selection reaches this block (drives `md-block-active`). */
-    readonly isActive: boolean;
-    readonly view: BlockViewData;
-}
-/** A mounted document child: a block or a run of inter-block glue. */
-export interface DocumentChildViewData {
-    readonly absoluteStart: number;
-    /** For a block: selection reaches it. For glue: a neighbouring block is active. */
-    readonly isActive: boolean;
-    readonly view: BlockViewData | GlueViewData;
-    readonly kind: 'block' | 'glue';
-}
-export type BlockViewData = HeadingViewData | ParagraphViewData | CodeBlockViewData | MathBlockViewData | ThematicBreakViewData | BlockQuoteViewData | ListViewData | TableViewData;
-export declare class HeadingViewData {
-    readonly ast: HeadingAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "heading";
-    constructor(ast: HeadingAstNode, content: readonly AnyViewData[]);
-}
-export declare class ParagraphViewData {
-    readonly ast: ParagraphAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "paragraph";
-    constructor(ast: ParagraphAstNode, content: readonly AnyViewData[]);
-}
-export declare class CodeBlockViewData {
-    readonly ast: CodeBlockAstNode;
-    /** Active: render the fenced source; inactive: the (custom/highlighted) block. */
-    readonly showMarkup: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "codeBlock";
-    constructor(ast: CodeBlockAstNode, 
-    /** Active: render the fenced source; inactive: the (custom/highlighted) block. */
-    showMarkup: boolean, content: readonly AnyViewData[]);
-}
-export declare class MathBlockViewData {
-    readonly ast: MathBlockAstNode;
-    /** Active: render the source; inactive: the KaTeX output. */
-    readonly showMarkup: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "mathBlock";
-    constructor(ast: MathBlockAstNode, 
-    /** Active: render the source; inactive: the KaTeX output. */
-    showMarkup: boolean, content: readonly AnyViewData[]);
-}
-export declare class BlockQuoteViewData {
-    readonly ast: BlockQuoteAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "blockQuote";
-    constructor(ast: BlockQuoteAstNode, content: readonly AnyViewData[]);
-}
-export declare class ListViewData {
-    readonly ast: ListAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "list";
-    constructor(ast: ListAstNode, content: readonly AnyViewData[]);
-}
-export declare class TableViewData {
-    readonly ast: TableAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "table";
-    constructor(ast: TableAstNode, content: readonly AnyViewData[]);
-}
-export type InlineViewData = TextViewData | StrongViewData | EmphasisViewData | StrikethroughViewData | InlineCodeViewData | InlineMathViewData | LinkViewData | ImageViewData;
-export declare class StrongViewData {
-    readonly ast: StrongAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "strong";
-    constructor(ast: StrongAstNode, content: readonly AnyViewData[]);
-}
-export declare class EmphasisViewData {
-    readonly ast: EmphasisAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "emphasis";
-    constructor(ast: EmphasisAstNode, content: readonly AnyViewData[]);
-}
-export declare class StrikethroughViewData {
-    readonly ast: StrikethroughAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "strikethrough";
-    constructor(ast: StrikethroughAstNode, content: readonly AnyViewData[]);
-}
-export declare class InlineCodeViewData {
-    readonly ast: InlineCodeAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "inlineCode";
-    constructor(ast: InlineCodeAstNode, content: readonly AnyViewData[]);
-}
-export declare class InlineMathViewData {
-    readonly ast: InlineMathAstNode;
-    /** Active: render the `$…$` source; inactive: the KaTeX output. */
-    readonly showMarkup: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "inlineMath";
-    constructor(ast: InlineMathAstNode, 
-    /** Active: render the `$…$` source; inactive: the KaTeX output. */
-    showMarkup: boolean, content: readonly AnyViewData[]);
-}
-export declare class LinkViewData {
-    readonly ast: LinkAstNode;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "link";
-    constructor(ast: LinkAstNode, content: readonly AnyViewData[]);
-}
-export declare class ImageViewData {
-    readonly ast: ImageAstNode;
-    /** Active: render the `![alt](url)` source; inactive: the `<img>`. */
-    readonly showMarkup: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "image";
-    constructor(ast: ImageAstNode, 
-    /** Active: render the `![alt](url)` source; inactive: the `<img>`. */
-    showMarkup: boolean, content: readonly AnyViewData[]);
-}
-export declare class ListItemViewData {
-    readonly ast: ListItemAstNode;
-    /** Whether the selection reaches this item (reveals its markers). */
-    readonly isActive: boolean;
-    readonly content: readonly AnyViewData[];
-    /** 1-based list nesting depth, used to size the indentation gutter. */
-    readonly level: number;
-    readonly kind = "listItem";
-    constructor(ast: ListItemAstNode, 
-    /** Whether the selection reaches this item (reveals its markers). */
-    isActive: boolean, content: readonly AnyViewData[], 
-    /** 1-based list nesting depth, used to size the indentation gutter. */
-    level: number);
-}
-export declare class TableRowViewData {
-    readonly ast: TableRowAstNode;
-    readonly isDelimiter: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "tableRow";
-    constructor(ast: TableRowAstNode, isDelimiter: boolean, content: readonly AnyViewData[]);
-}
-export declare class TableCellViewData {
-    readonly ast: TableCellAstNode;
-    /** Whether the selection reaches this cell (reveals its inline markers). */
-    readonly isActive: boolean;
-    /** Whether the owning table is active (reveals the structural pipes). */
-    readonly showTableGlue: boolean;
-    readonly content: readonly AnyViewData[];
-    readonly kind = "tableCell";
-    constructor(ast: TableCellAstNode, 
-    /** Whether the selection reaches this cell (reveals its inline markers). */
-    isActive: boolean, 
-    /** Whether the owning table is active (reveals the structural pipes). */
-    showTableGlue: boolean, content: readonly AnyViewData[]);
-}
-export declare class TextViewData {
-    readonly ast: TextAstNode;
-    readonly showWhitespace: boolean;
-    readonly leftWordBoundary: boolean;
-    readonly rightWordBoundary: boolean;
-    readonly kind = "text";
-    /**
-     * Whether non-obvious whitespace in this text is revealed (block is active).
-     * `leftWordBoundary`/`rightWordBoundary` say whether the inline sibling on
-     * that side ends/starts with visible word content (e.g. inline code, a link,
-     * emphasis); a single space touching such a sibling is obvious and stays
-     * undecorated, just like a space between two words within this leaf.
-     */
-    constructor(ast: TextAstNode, showWhitespace: boolean, leftWordBoundary?: boolean, rightWordBoundary?: boolean);
-}
-export declare class ThematicBreakViewData {
-    readonly ast: ThematicBreakAstNode;
-    /** Active: reveal the source markup (`---`) instead of the rendered rule. */
-    readonly showMarkup: boolean;
-    /** Marker (and any absorbed trailing glue), rendered only when active. */
-    readonly content: readonly AnyViewData[];
-    readonly kind = "thematicBreak";
-    constructor(ast: ThematicBreakAstNode, 
-    /** Active: reveal the source markup (`---`) instead of the rendered rule. */
-    showMarkup: boolean, 
-    /** Marker (and any absorbed trailing glue), rendered only when active. */
-    content: readonly AnyViewData[]);
-}
-export declare class MarkerViewData {
-    readonly ast: MarkerAstNode;
-    readonly visible: boolean;
-    readonly kind = "marker";
-    constructor(ast: MarkerAstNode, visible: boolean);
-}
-export declare class GlueViewData {
-    readonly ast: GlueAstNode;
-    readonly visible: boolean;
-    /**
-     * Whether a source newline in this glue gets a visible `↵`. True only in
-     * inline flow, where the newline collapses to a space and the `↵` reveals
-     * the line ending hiding there; between block-level siblings (list items,
-     * block children) the break is already visible, so no `↵` is drawn.
-     */
-    readonly decorateNewline: boolean;
-    readonly kind = "glue";
-    constructor(ast: GlueAstNode, visible: boolean, 
-    /**
-     * Whether a source newline in this glue gets a visible `↵`. True only in
-     * inline flow, where the newline collapses to a space and the `↵` reveals
-     * the line ending hiding there; between block-level siblings (list items,
-     * block children) the break is already visible, so no `↵` is drawn.
-     */
-    decorateNewline: boolean);
-}
-export type AnyViewData = DocumentViewData | BlockViewData | InlineViewData | ListItemViewData | TableRowViewData | TableCellViewData | MarkerViewData | GlueViewData;
-/**
- * Map the parsed document + active/selection state to its view-data tree.
- *
- * Top-level blocks are mirrored into {@link DocumentViewData.blocks}. A block's
- * trailing blank lines are attributed by the parser to the block itself (a
- * `blockGap`/`blockBreak` glue at the end of its content), so they are built as
- * part of the block and revealed only when that block is active — no neighbour
- * scan. The only such glue that survives at the document level is one with no
- * host block (a leading gap before the first block); it is mirrored into
- * {@link DocumentViewData.children} and revealed when its nearest block is
- * active.
- * An inactive block's view-data is a pure function of its AST, so when `previous`
- * holds a view-data for the same block object (the parser preserves identity for
- * unchanged subtrees) that was *also* inactive, the whole subtree is reused by
- * identity — the common case for a selection move, making it O(active blocks).
- */
-export declare function buildDocumentViewData(doc: DocumentAstNode, activeBlocks: ReadonlySet<BlockAstNode>, selectionRange: OffsetRange | undefined, previous: DocumentViewData | undefined): DocumentViewData;

package/dist/view/visualLineMap.d.ts

@@ -1,157 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { Point2D, Rect2D } from '../core/geometry.js';
-import { SourceOffset } from '../core/sourceOffset.js';
-import { ViewNode } from './content/viewNode.js';
-/**
- * Geometry of the rendered document, as a map from source offsets to 2D
- * positions and back.
- *
- * Structure (top to bottom):
- *
- *     VisualLineMap   = ordered list of VisualLines
- *     VisualLine      = a horizontal band [rect.top, rect.bottom) split
- *                       into one or more VisualRuns
- *     VisualRun       = a contiguous source range painted at a rectangle
- *                       on the line
- *
- * Invariants:
- *   - `lines[i].rect.bottom <= lines[i+1].rect.top + ε`
- *   - For any offset `o` covered by some run on line `L`:
- *       `xAtOffset(o)` is inside that run's horizontal range
- *       `xAtOffset(o)` is inside `L.rect.left..L.rect.right`
- *
- * The "map" goes both ways:
- *   - SourceOffset → (line, x) via {@link lineIndexOfOffset} + {@link xAtOffset}
- *   - Point2D → SourceOffset       via {@link offsetAtPoint}
- *
- * Both directions are total but not bijective: many offsets at a line
- * boundary map to the same `x`, and large areas of the document
- * (padding, gaps) map onto the nearest offset on the nearest line.
- *
- * Rendering a caret rect from these primitives is a consumer concern:
- *
- *     const i = map.lineIndexOfOffset(o);
- *     const caretRect = map.lineRect(i).withZeroWidthAt(map.xAtOffset(o));
- */
-export declare class VisualLineMap {
-    readonly lines: readonly VisualLine[];
-    static readonly EMPTY: VisualLineMap;
-    static measure(blockViews: readonly {
-        readonly absoluteStart: number;
-        readonly viewNode: ViewNode;
-    }[]): VisualLineMap;
-    constructor(lines: readonly VisualLine[]);
-    get lineCount(): number;
-    get isEmpty(): boolean;
-    lineRect(lineIndex: number): Rect2D;
-    /**
-     * Line whose runs cover the offset, or the nearest line by source
-     * distance if no run covers it.
-     *
-     * An offset that is only a run's *trailing* boundary (`offset ===
-     * endExclusive`) — most notably the source offset just past a
-     * line-breaking `\n`, which a zero-width run reports as its end on the line
-     * it terminates — belongs to the START of the NEXT line instead. Preferring
-     * the line that actually *starts* the offset makes the caret advance past a
-     * newline to the next line rather than collapsing onto the previous line's
-     * end (which would render two distinct offsets at the same caret position).
-     * 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;
-    /**
-     * x of the caret position before `offset`, on the line returned by
-     * {@link lineIndexOfOffset}. Returns `0` when the map is empty.
-     */
-    xAtOffset(offset: SourceOffset): number;
-    /**
-     * Line whose vertical band contains `y`, clamped to the first/last
-     * line when `y` is outside the document.
-     */
-    lineIndexAtY(y: number): number;
-    /**
-     * Snap a 2D point to the nearest source offset. Uses `y` to pick a
-     * line, then `x` to pick an offset within it. Up/down navigation
-     * uses {@link offsetInLineAtX} directly to preserve desired column.
-     */
-    offsetAtPoint(point: Point2D): SourceOffset;
-    /** Snap `x` to the nearest offset on a specific line. */
-    offsetInLineAtX(lineIndex: number, x: number): SourceOffset;
-}
-/**
- * One visual line of rendered text: a horizontal band
- * (`rect.top`..`rect.bottom`) split into one or more {@link VisualRun}s
- * arranged left-to-right.
- */
-export declare class VisualLine {
-    readonly rect: Rect2D;
-    readonly runs: readonly VisualRun[];
-    constructor(rect: Rect2D, runs: readonly VisualRun[]);
-    containsOffset(offset: SourceOffset): boolean;
-    /**
-     * How `offset` relates to this line's runs:
-     *   - `'covers'`: a run starts at or strictly contains the offset
-     *     (`start <= offset < endExclusive`) — the caret belongs on this line.
-     *   - `'end'`: the offset is only some run's trailing boundary
-     *     (`offset === endExclusive`) with no run covering it — a line-break
-     *     boundary the caret should leave for the next line.
-     *   - `'none'`: no run touches the offset.
-     */
-    offsetMembership(offset: SourceOffset): 'covers' | 'end' | 'none';
-    /**
-     * Min `|offset - r|` over offsets `r` in any of this line's runs. Used
-     * to pick the nearest line when no run actually covers the offset.
-     */
-    sourceDistanceTo(offset: SourceOffset): number;
-    /**
-     * x of the caret position before `offset` on this line. When `offset`
-     * is past all runs (trailing whitespace / blank line), returns the
-     * right edge of the last run; when before all runs, returns the left
-     * edge of the first run.
-     */
-    xAtOffset(offset: SourceOffset): number;
-    /**
-     * Snap `x` to the nearest offset on this line. If `x` falls inside a
-     * run, the offset is interpolated by character fraction; otherwise it
-     * snaps to the closer edge of the nearest run.
-     */
-    offsetAtX(x: number): SourceOffset;
-}
-/**
- * The DOM source of a {@link VisualRun}. When set, `xAtOffset` and
- * `offsetAtX` measure exact glyph positions via `Range.getBoundingClientRect`
- * instead of linear interpolation across the run's rect. This matters for
- * proportional fonts where character widths differ a lot (e.g. `m` vs `i`)
- * and a caret placed by interpolation lands several pixels inside the
- * wrong character.
- *
- * Hand-built runs (tests) omit this; their `xAtOffset` falls back to
- * linear interpolation.
- */
-export interface VisualRunSource {
-    readonly textNode: Text;
-    /** Offset within `textNode.data` corresponding to `sourceRange.start`. */
-    readonly textNodeStart: number;
-}
-/**
- * One contiguous run of text painted on a single visual line.
- *
- * When constructed with a {@link VisualRunSource}, `xAtOffset` returns the
- * pixel-exact x of the caret before character `offset` by measuring the
- * prefix `[textNodeStart, textNodeStart + (offset - sourceStart))` with a
- * DOM `Range`. Without a source it falls back to linear interpolation
- * across `rect.width`.
- */
-export declare class VisualRun {
-    readonly sourceRange: OffsetRange;
-    readonly rect: Rect2D;
-    readonly source?: VisualRunSource | undefined;
-    constructor(sourceRange: OffsetRange, rect: Rect2D, source?: VisualRunSource | undefined);
-    get sourceStart(): SourceOffset;
-    get sourceEndExclusive(): SourceOffset;
-    get sourceLength(): number;
-    containsOffset(offset: SourceOffset): boolean;
-    sourceDistanceTo(offset: SourceOffset): number;
-    xAtOffset(offset: SourceOffset): number;
-    offsetAtX(x: number): SourceOffset;
-}

package/dist/view/visualizeViewTree.d.ts

@@ -1,5 +0,0 @@
-import { AstVisualization } from '../parser/visualizeAst.js';
-import { DocumentViewData } from './viewData.js';
-import { DocumentViewNode } from './content/documentView.js';
-export declare function visualizeViewData(root: DocumentViewData, source: string): AstVisualization;
-export declare function visualizeViewNode(root: DocumentViewNode, source: string): AstVisualization;