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

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

@@ -1,36 +0,0 @@
-import { MathRenderRequest, MathRendering } from './blockView.js';
-/**
- * EXPERIMENTAL — a {@link import('./blockView.js').BlockViewOptions.renderMath}
- * renderer that makes individual *identifiers* in rendered math map back to
- * their LaTeX source, so the caret can land inside them (the first step towards
- * editing identifiers in place without switching the block to its source form).
- *
- * Approach — `\htmlData` injection (order-independent, exact):
- *
- *  1. Parse the LaTeX with the internal `katex.__parse` to get the parse tree,
- *     whose `mathord` atoms (single variables like `x`, `\alpha`) each carry a
- *     `loc: { start, end }` offset range into the source.
- *  2. Rewrite the source, wrapping each identifier slice in
- *     `\htmlData{s=<start>,e=<end>}{<slice>}`. `\htmlData` emits a
- *     `<span data-s="…" data-e="…">` around exactly that glyph, so the rendered
- *     span *self-describes* its source range.
- *  3. Render the rewritten source and read the `[data-s][data-e]` spans back.
- *     Because each span carries its own range, the mapping is exact regardless
- *     of how KaTeX reorders the DOM relative to source (fractions render
- *     numerator→denominator, sub/superscripts move, matrices, …) — unlike a
- *     positional zip of glyphs against atoms, which misaligns on those
- *     constructs.
- *
- * Security — trust/strict are scoped to the single harmless command:
- *
- *  - `trust: (ctx) => ctx.command === '\\htmlData'` allows ONLY `\htmlData`.
- *    It emits `data-*` attributes only — no script, URL, or inline style — so
- *    there is no XSS surface (`\href`, `\includegraphics`, `\htmlStyle`, … all
- *    stay forbidden).
- *  - `strict` only silences the `htmlExtension` warning for `\htmlData`; every
- *    other strictness rule keeps its default (`warn`) behaviour.
- *
- * The user's own `\htmlData` in their LaTeX would also pass, but that is
- * harmless (arbitrary `data-*` only).
- */
-export declare function createKatexEditableIdentifiersRenderer(): (request: MathRenderRequest) => MathRendering | undefined;

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

@@ -1,93 +0,0 @@
-import { Disposable } from '@vscode/observables';
-import { AstNode } from '../../parser/ast.js';
-import { OffsetRange } from '../../core/offsetRange.js';
-import { DomPosition } from './dom.js';
-export type { DomPosition } from './dom.js';
-/**
- * Immutable view of an AST node. Pairs `ast` with its rendered `dom` and a
- * mirror of `ast.children` as ViewNode children. Source offsets are NEVER
- * stored — they are recomputed by walking and summing `ast.length` of
- * preceding siblings, just like the AST itself.
- *
- * Leaves are ViewNodes with no children. A leaf whose `dom` is a Text node
- * participates in source mapping; a leaf whose `dom` is an Element does not
- * (e.g. KaTeX-rendered math, or `<hr>` for a thematic break).
- */
-export declare class ViewNode extends Disposable {
-    readonly ast: AstNode;
-    readonly dom: globalThis.Node;
-    private _children;
-    constructor(ast: AstNode, dom: globalThis.Node, children?: readonly ViewNode[]);
-    /** This node's view children (a mirror of `ast.children`). */
-    get children(): readonly ViewNode[];
-    /**
-     * Replace this node's children in place, disposing the old ones and
-     * re-pointing the new ones' parent to this node. The node value is still
-     * conceptually immutable with respect to its `ast`/`dom` *identity*; this
-     * is used only when a node patches its own DOM subtree in place (a code
-     * block re-tokenising on a highlighter recolour), where the source-mapping
-     * leaves must follow the new DOM text nodes without rebuilding the node
-     * itself.
-     */
-    protected _replaceChildren(children: readonly ViewNode[]): void;
-    dispose(): void;
-    /**
-     * The number of source characters this node spans. Defaults to the length
-     * of its {@link ast}; a synthetic leaf that subdivides one ast node (a
-     * decorated-whitespace character, a code-block token span) shares that ast
-     * for identity but overrides this with the length of its own slice, so the
-     * renderer never has to fabricate an AST node just to carry a length.
-     */
-    get sourceLength(): number;
-    /**
-     * The DOM node a parent mounts for this child. It is {@link dom} for almost
-     * everything; a marker is the exception — its `dom` is the inner Text node
-     * (so source ↔ DOM mapping lands on it) while the node it mounts is the
-     * wrapping `<span>`.
-     */
-    get mountNode(): globalThis.Node;
-    /** The view node that rendered this node's parent, or `undefined` for a root. */
-    get parent(): ViewNode | undefined;
-    /**
-     * Closest view node owning `domNode`: the node itself if registered, else
-     * the nearest registered ancestor. Returns `undefined` if the DOM node is
-     * outside any view tree.
-     */
-    static forDom(domNode: globalThis.Node | null): ViewNode | undefined;
-    /**
-     * This node's start offset within its parent's local source space: the sum
-     * of the `ast.length` of the siblings before it. Polymorphic via
-     * {@link _localOffsetOfChild} so a parent whose children do not map
-     * linearly (e.g. it hides or reorders some) can override how its children
-     * are placed.
-     */
-    localOffsetInParent(): number;
-    /** Start offset of `child` within this node's local source space. */
-    protected _localOffsetOfChild(child: ViewNode): number;
-    /**
-     * Map a DOM hit that lands on THIS node's own representation into a source
-     * range in this node's local space `[0, ast.length)`. Polymorphic: a text
-     * leaf maps the caret offset 1:1; an element-only node (KaTeX math, `<hr>`,
-     * an image, a hidden marker) has no internal text mapping and snaps to its
-     * start by default — subclasses may override (e.g. to snap to the nearer
-     * edge by x).
-     */
-    getLocalSourceRange(pos: DomPosition): OffsetRange;
-    /**
-     * DOM hit (any node + offset within it) → source offset relative to THIS
-     * node, or `undefined` when the hit is outside this node's subtree. Enters
-     * the tree at the closest owning view node ({@link forDom}), maps the hit
-     * into that node's local space ({@link getLocalSourceRange}), then lifts the
-     * range up the parent chain — adding each node's {@link localOffsetInParent} —
-     * until it reaches this node.
-     */
-    resolveSource(pos: DomPosition): number | undefined;
-    /**
-     * Source offset → DOM position. `nodeOffset` is the absolute source
-     * offset of THIS node's start. Returns a position into a DOM Text node,
-     * descending into children based on accumulated lengths.
-     */
-    sourceToDom(localSourceOffset: number, nodeSourceOffset?: number): DomPosition | undefined;
-    /** Visit every text-bearing leaf in this subtree with its absolute offset. */
-    forEachTextLeaf(nodeOffset: number, visitor: (leaf: ViewNode, leafOffset: number) => void): void;
-}

package/dist/view/editorController.d.ts

@@ -1,34 +0,0 @@
-import { Disposable } from '@vscode/observables';
-import { EditorModel } from '../model/editorModel.js';
-import { EditorView } from './editorView.js';
-/**
- * Translates raw browser input (mouse, keyboard, EditContext) into model
- * mutations. Knows about DOM event types but never reads/writes the DOM
- * directly — it asks the {@link EditorView} to broker DOM↔source-offset
- * conversions so the model stays free of view types.
- *
- * Owns the only non-derivable controller state:
- * - `_desiredColumn` — sticky column for up/down navigation
- */
-export declare class EditorController extends Disposable {
-    private readonly _model;
-    private readonly _view;
-    private _desiredColumn;
-    constructor(_model: EditorModel, _view: EditorView);
-    private readonly _handleTextUpdate;
-    private readonly _handleMouseDown;
-    private _makeCursorContext;
-    private _makeVisualCursorContext;
-    private _executeCursorCommand;
-    private _executeEditCommand;
-    private _executeVisualCursorCommand;
-    /** Move the cursor down one visual line (Arrow Down). */
-    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 _handleKeyDown;
-}

package/dist/view/editorView.d.ts

@@ -1,100 +0,0 @@
-import { Disposable, IObservable } from '@vscode/observables';
-import { Point2D } from '../core/geometry.js';
-import { SourceOffset } from '../core/sourceOffset.js';
-import { EditorModel } from '../model/editorModel.js';
-import { MeasuredLayoutModel } from '../model/measuredLayoutModel.js';
-import { BlockViewOptions } from './content/blockView.js';
-import { DocumentViewNode } from './content/documentView.js';
-import { DocumentViewData } from './viewData.js';
-export interface EditorViewOptions extends BlockViewOptions {
-    /**
-     * 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
-     * are scoped under these classes, so the editor is unstyled (base chrome
-     * only) unless a theme class is supplied.
-     */
-    readonly classNames?: readonly string[];
-}
-/**
- * Pure-render view of an {@link EditorModel}.
- *
- * Invariant (the whole point of this file):
- *
- *     view(model + Δ) = view(model) + Δ
- *
- * The DOM the view produces is a function of the model. The only state the
- * view holds is *DOM management*: the cached `BlockViewNode` instances and the
- * `EditContext`. Anything that influences correctness but is not derivable
- * from the model lives elsewhere:
- *
- *   - measured heights and per-block visual line maps  →  {@link MeasuredLayoutModel}
- *   - desired column, drag-time freeze                 →  EditorController
- *
- * The view does not own a controller — callers construct an
- * `EditorController` separately and pass it the view, so input handling is
- * explicit and the view stays a pure renderer.
- *
- * The view writes into the measured-layout model as a side effect of
- * rendering. It never reads its own measurements during rendering, so
- * there is no feedback loop.
- */
-export declare class EditorView extends Disposable {
-    private readonly _model;
-    private readonly _options?;
-    readonly element: HTMLElement;
-    readonly editContext: EditContext;
-    readonly measuredLayout: MeasuredLayoutModel;
-    private readonly _cursorView;
-    private readonly _selectionView;
-    /**
-     * The mounted block sequence, in source order. Rebuilt (not mutated) each
-     * frame by {@link DocumentViewNode.create}; the view just swaps one
-     * immutable node for the next. Never used for source-of-truth lookups
-     * (those go through the measured-layout model).
-     */
-    private readonly _document;
-    /** The current view-node tree (AST overlaid with rendered DOM), for debugging. */
-    get documentViewNode(): IObservable<DocumentViewNode | undefined>;
-    /**
-     * Last frame's view-data overlay, threaded back into
-     * {@link buildDocumentViewData} so any subtree whose ast and selection flags
-     * are unchanged keeps its view-data object — which lets the renderer reuse
-     * its DOM by identity.
-     */
-    private _previousViewData;
-    /** The current view-data tree (AST overlaid with selection flags), for debugging. */
-    private readonly _viewData;
-    get viewData(): IObservable<DocumentViewData | undefined>;
-    /**
-     * The block cache projected for views (selection painting) that need to
-     * react to mount/unmount. Derived from {@link _document}, so it stays in
-     * lock-step without any manual bookkeeping.
-     */
-    private readonly _selectionBlocksObs;
-    constructor(_model: EditorModel, _options?: EditorViewOptions | undefined);
-    focus(): void;
-    /**
-     * Client coordinates → absolute source offset (any block). Used during
-     * drag to keep extending the selection even when the pointer leaves the
-     * original block.
-     */
-    resolveOffsetFromPoint(point: Point2D): SourceOffset | undefined;
-    /**
-     * Whether a client point falls on the rendered document content, as
-     * opposed to the surrounding editor padding (the green area). Uses DOM
-     * containment rather than the content node's bounding box so that markers
-     * which overflow into the padding (e.g. a heading's `##`, which renders in
-     * the left margin) still count as content. Overlays (cursor, selection)
-     * have `pointer-events: none`, so the hit-test sees through them.
-     */
-    isPointInContent(point: Point2D): boolean;
-    private readonly _renderAutorun;
-    /** Current mounted blocks, or empty before the first render. */
-    private get _blocks();
-    /**
-     * Measure each mounted block's rect and per-block visual line map, then
-     * publish the result into the {@link MeasuredLayoutModel}. The model
-     * is not read here, so there is no feedback loop into the render autorun.
-     */
-    private _publishMeasurements;
-}

package/dist/view/fixture/astViewerView.d.ts

@@ -1,27 +0,0 @@
-import { IObservable } from '@vscode/observables';
-import { AstVisualization } from '../../parser/visualizeAst.js';
-/** One gated viewer panel: a labelled checkbox and the visualization it shows. */
-export interface AstViewerPanel {
-    readonly label: string;
-    /** localStorage key persisting this panel's checked state (off by default). */
-    readonly storageKey: string;
-    readonly visualization: IObservable<AstVisualization>;
-}
-/**
- * A row of "show …" checkboxes (each persisted in localStorage, off by default)
- * over a row of the iframes they gate. Each panel's iframe is only created while
- * its box is checked; multiple panels can be shown at once, laid out side by
- * side (each filling an equal share of the width).
- *
- * Returns the container element and a `whenReady` promise that the fixture can
- * `await`: it resolves once every initially-checked viewer has completed its
- * handshake and received its first content (or immediately, if none are
- * checked). Awaiting it lets the Component Explorer hold the screenshot until
- * the viewers have content instead of capturing blank iframes.
- */
-export declare function createAstViewerView(panels: readonly AstViewerPanel[], addDisposable: <T extends {
-    dispose(): void;
-}>(d: T) => T): {
-    readonly element: HTMLElement;
-    readonly whenReady: Promise<void>;
-};

package/dist/view/fixture/cyclingTsHighlighter.d.ts

@@ -1,17 +0,0 @@
-import { ISyntaxHighlighter, ISyntaxHighlighterDocument } from '../../highlighter/index.js';
-/**
- * A toy {@link ISyntaxHighlighter} for fixtures: it ignores the language and
- * always emits the same hardcoded token layout for the demo snippet, but each
- * document's {@link ISyntaxHighlighterDocument.snapshot snapshot} ticks once
- * per `intervalMs`, swapping in a new snapshot whose keyword run cycles through
- * {@link KEYWORD_CLASSES}. The change reason is a same-length {@link LengthEdit}
- * over the keyword run — a pure recolour. Everything is driven through the
- * snapshot observable, so this tests that the view re-renders when that
- * observable changes (no other signal is exposed).
- */
-export declare class CyclingTsHighlighter implements ISyntaxHighlighter {
-    private readonly _intervalMs;
-    constructor(_intervalMs?: number);
-    create(_language: string, initialText: string): ISyntaxHighlighterDocument;
-    dispose(): void;
-}

package/dist/view/fixture/debugColors.d.ts

@@ -1,26 +0,0 @@
-/**
- * DEBUG / FIXTURE ONLY — coloring helper for the layout debug view.
- *
- * Assigns every source offset a color so the same offset is painted
- * identically in the editor overlay and in the raw-source view. A mismatch
- * therefore exposes a source ↔ DOM mapping bug at a glance.
- *
- * The source is partitioned into maximal *sequences*:
- *  - a **word** is a run of letters (`\p{L}`),
- *  - a **non-word** is a run of everything else (digits, punctuation,
- *    whitespace).
- *
- * `"1. Plan"` → `"1. "` (non-word) + `"Plan"` (word).
- *
- * Within one sequence a single gradient advances `start → end` across the
- * sequence's characters. So for `"Plan"`: `P = [1/4]`, `l = [2/4]`,
- * `a = [3/4]`, `n = [4/4]`.
- *
- * Inefficiency is fine here: this is never shipped in the product.
- */
-/**
- * Returns one rgba color per source offset (`result.length === source.length`).
- * The same alpha is used everywhere so the editor overlay rect and the
- * source-view character share the exact color.
- */
-export declare function computeSequenceColors(source: string, alpha?: number): string[];

package/dist/view/fixture/monacoDebugPanel.d.ts

@@ -1,7 +0,0 @@
-import { EditorModel } from '../../model/editorModel.js';
-/**
- * Wraps `container` into a side-by-side layout with a toggleable Monaco source
- * editor on the left and the existing `editorPane` on the right. Returns a
- * disposer that tears down the panel, button and bindings.
- */
-export declare function attachMonacoDebugPanel(container: HTMLElement, editorPane: HTMLElement, model: EditorModel): () => void;

package/dist/view/index.d.ts

@@ -1,9 +0,0 @@
-export { ViewNode, type DomPosition } from './content/viewNode.js';
-export { BlockViewNode, CodeBlockViewNode, type BlockViewOptions, type MathRenderRequest, type MathRendering, type MathSourceSegment } from './content/blockView.js';
-export { DocumentViewNode, type DocumentBlock } from './content/documentView.js';
-export { EditorView, type EditorViewOptions } from './editorView.js';
-export { EditorController } from './editorController.js';
-export { CursorView, CursorViewRendering, type CursorViewOptions } from './parts/cursorView.js';
-export { SelectionView, SelectionViewRendering, type SelectionBlock, type SelectionViewOptions, type SelectionRect } from './parts/selectionView.js';
-export { MeasuredLayoutDebugView, MeasuredLayoutDebugRendering, type MeasuredLayoutDebugViewOptions } from './measuredLayoutDebugView.js';
-export { VisualLineMap, VisualLine, VisualRun } from './visualLineMap.js';

package/dist/view/measuredLayoutDebugView.d.ts

@@ -1,70 +0,0 @@
-import { Disposable, IObservable, ISettableObservable } from '@vscode/observables';
-import { MeasuredLayoutModel } from '../model/measuredLayoutModel.js';
-export interface MeasuredLayoutDebugViewOptions {
-    readonly model: MeasuredLayoutModel;
-    /**
-     * DEBUG ONLY. Maps an absolute source offset to a fill color for that
-     * character's glyph rect. The fixture passes the same function to the
-     * raw-source view so a character and its rect share one color — a
-     * mismatch exposes a source ↔ DOM mapping bug.
-     */
-    readonly colorForOffset?: (offset: number) => string | undefined;
-    /**
-     * DEBUG ONLY. Shared "currently hovered source offset". When set, the
-     * overlay isolates the matching glyph rect; the fixture passes the same
-     * observable to the raw-source view so hovering either side highlights the
-     * same character in both. Hovering a rect writes this; `undefined` clears.
-     */
-    readonly hoveredOffset?: ISettableObservable<number | undefined>;
-}
-/**
- * Debug view for a {@link MeasuredLayoutModel}.
- *
- * Exposes two DOM nodes the caller can place independently:
- *
- *  - {@link overlayElement} — absolutely positioned; the caller mounts it
- *    inside the editor element so dashed line-bands and run-boxes line up
- *    with the editor's client coordinates.
- *  - {@link infoElement} — block-flow; the caller mounts it as a sibling
- *    *below* the editor. Contains the per-block summary table that used
- *    to live on the overlay.
- *
- * Same pattern as `CursorView` / `SelectionView`: the rendering pipeline
- * is a single `derived` whose compute callback writes the DOM and returns
- * a {@link MeasuredLayoutDebugRendering} value as proof. An autorun keeps
- * the derived subscribed.
- */
-export declare class MeasuredLayoutDebugView extends Disposable {
-    private readonly _overlayParent;
-    readonly overlayElement: HTMLElement;
-    readonly infoElement: HTMLElement;
-    readonly rendering: IObservable<MeasuredLayoutDebugRendering>;
-    /** Absolute source offsets that map to a rendered DOM character. */
-    readonly mappedOffsets: IObservable<ReadonlySet<number>>;
-    /** Whether the dashed line-bands and run boxes are drawn (persisted). */
-    private readonly _showLineRects;
-    constructor(_overlayParent: HTMLElement, options: MeasuredLayoutDebugViewOptions);
-}
-/**
- * Immutable record of one rendered debug frame.
- */
-export declare class MeasuredLayoutDebugRendering {
-    readonly blockCount: number;
-    readonly mountedCount: number;
-    readonly lineCount: number;
-    /** Absolute source offsets that map to a rendered DOM character. */
-    readonly mappedOffsets: ReadonlySet<number>;
-    constructor(blockCount: number, mountedCount: number, lineCount: number, 
-    /** Absolute source offsets that map to a rendered DOM character. */
-    mappedOffsets: ReadonlySet<number>);
-}
-/**
- * Show only the element whose `data-offset` equals `hovered`, hiding every
- * other child (and all children lacking a `data-offset`, e.g. line bands).
- * When `hovered` is `undefined` everything is restored. `visibility: hidden`
- * preserves layout so the source view's text never reflows.
- *
- * Used identically for the editor overlay and the raw-source view, so a hover
- * on either side highlights the same character in both. Debug-only.
- */
-export declare function applyHoverIsolation(container: HTMLElement, hovered: number | undefined): void;

package/dist/view/parts/cursorView.d.ts

@@ -1,29 +0,0 @@
-import { Disposable, IObservable } from '@vscode/observables';
-import { Rect2D } from '../../core/geometry.js';
-import { SourceOffset } from '../../core/sourceOffset.js';
-import { VisualLineMap } from '../visualLineMap.js';
-export interface CursorViewOptions {
-    readonly offset: IObservable<SourceOffset | undefined>;
-    readonly visualLineMap: IObservable<VisualLineMap>;
-}
-/**
- * Owns the blinking cursor DOM element.
- *
- * The rendering pipeline is a single `derived` whose compute callback
- * asks the {@link VisualLineMap} for the caret rect at the current
- * offset, writes it to {@link element}, and returns a
- * {@link CursorViewRendering} value as proof. An autorun keeps the
- * derived subscribed.
- */
-export declare class CursorView extends Disposable {
-    private readonly _parent;
-    readonly element: HTMLElement;
-    readonly rendering: IObservable<CursorViewRendering>;
-    constructor(_parent: HTMLElement, options: CursorViewOptions);
-}
-export declare class CursorViewRendering {
-    readonly offset: SourceOffset;
-    readonly visible: boolean;
-    readonly rect: Rect2D;
-    constructor(offset: SourceOffset, visible: boolean, rect: Rect2D);
-}

package/dist/view/parts/selectionView.d.ts

@@ -1,57 +0,0 @@
-import { Disposable, IObservable } from '@vscode/observables';
-import { Selection } from '../../core/selection.js';
-import { BlockAstNode } from '../../parser/ast.js';
-import { ViewNode } from '../content/viewNode.js';
-import { VisualLineMap } from '../visualLineMap.js';
-/**
- * One mounted block, as far as selection painting is concerned. The view
- * supplies its block cache in this shape so the selection layer never has
- * to reach back into private view state.
- */
-export interface SelectionBlock {
-    readonly block: BlockAstNode;
-    readonly absoluteStart: number;
-    readonly viewNode: ViewNode;
-    readonly element: HTMLElement;
-}
-export interface SelectionViewOptions {
-    readonly selection: IObservable<Selection | undefined>;
-    readonly visualLineMap: IObservable<VisualLineMap>;
-    readonly blocks: IObservable<readonly SelectionBlock[]>;
-}
-export interface SelectionRect {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-/**
- * Owns the SVG overlay that paints the selection.
- *
- * Rendering is *line-based*, not glyph-based:
- *
- *  1. Each {@link VisualLine} overlapping the selection produces one rect
- *     using the full line-box height (so the selection has even, line-
- *     height bands instead of jagged glyph rects).
- *  2. Inter-block gaps fully inside the selection become connector rects.
- *  3. All rects are grouped into vertically-adjacent clusters and each
- *     cluster is rendered as a single connected polygon with rounded
- *     corners.
- *
- * To keep the polygon connected without gaps, "middle" lines (any line
- * that is neither the first nor the last selected line in the document)
- * are extended to their full line extent, while the first and last lines
- * are clipped to the actual selection start/end. This is the standard
- * envelope shape used by IDE selection rendering.
- */
-export declare class SelectionView extends Disposable {
-    private readonly _parent;
-    readonly element: SVGSVGElement;
-    readonly rendering: IObservable<SelectionViewRendering>;
-    private readonly _path;
-    constructor(_parent: HTMLElement, options: SelectionViewOptions);
-}
-export declare class SelectionViewRendering {
-    readonly rects: readonly SelectionRect[];
-    constructor(rects: readonly SelectionRect[]);
-}