@vscode/markdown-editor 0.0.2-0

package/dist/commands/cursorCommands.d.ts

@@ -0,0 +1,13 @@
+import { CursorCommand, VisualCursorCommand } from './types.js';
+export declare const cursorRight: CursorCommand;
+export declare const cursorLeft: CursorCommand;
+export declare const cursorMoveRight: CursorCommand;
+export declare const cursorMoveLeft: CursorCommand;
+export declare const cursorWordRight: CursorCommand;
+export declare const cursorWordLeft: CursorCommand;
+export declare const cursorLineStart: CursorCommand;
+export declare const cursorLineEnd: CursorCommand;
+export declare const cursorDocumentStart: CursorCommand;
+export declare const cursorDocumentEnd: CursorCommand;
+export declare const cursorDown: VisualCursorCommand;
+export declare const cursorUp: VisualCursorCommand;

package/dist/commands/editCommands.d.ts

@@ -0,0 +1,14 @@
+import { EditCommand } from './types.js';
+export declare const deleteLeft: EditCommand;
+export declare const deleteRight: EditCommand;
+export declare const deleteWordLeft: EditCommand;
+export declare const deleteWordRight: EditCommand;
+export declare function insertText(text: string): EditCommand;
+export declare const insertParagraph: EditCommand;
+export declare const insertLineBreak: EditCommand;
+/**
+ * A Markdown hard line break: a `\n` whose preceding line ends with two spaces.
+ * Any spaces already trailing the insertion point count toward the two, so the
+ * line never accumulates more than the two needed to form the break.
+ */
+export declare const insertHardLineBreak: EditCommand;

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export type { CursorCommand, VisualCursorCommand, EditCommand, SelectionCommand, CursorCommandContext, VisualCursorCommandContext, CursorMoveResult } from './types.js';
+export { cursorRight, cursorLeft, cursorMoveRight, cursorMoveLeft, cursorWordRight, cursorWordLeft, cursorLineStart, cursorLineEnd, cursorDocumentStart, cursorDocumentEnd, cursorDown, cursorUp } from './cursorCommands.js';
+export { deleteLeft, deleteRight, deleteWordLeft, deleteWordRight, insertText, insertParagraph, insertLineBreak, insertHardLineBreak } from './editCommands.js';
+export { selectAll, selectWord, selectBlock } from './selectionCommands.js';

package/dist/commands/selectionCommands.d.ts

@@ -0,0 +1,6 @@
+import { OffsetRange } from '../core/offsetRange.js';
+import { Selection } from '../core/selection.js';
+import { CursorCommandContext, SelectionCommand } from './types.js';
+export declare const selectAll: SelectionCommand;
+export declare const selectWord: SelectionCommand;
+export declare function selectBlock(ctx: CursorCommandContext, blockRange: OffsetRange): Selection;

package/dist/commands/types.d.ts

@@ -0,0 +1,26 @@
+import { Selection } from '../core/selection.js';
+import { SourceOffset } from '../core/sourceOffset.js';
+import { StringEdit } from '../core/stringEdit.js';
+import { BlockAstNode, DocumentAstNode } from '../parser/ast.js';
+import { VisualLineMap } from '../view/visualLineMap.js';
+export interface CursorCommandContext {
+    readonly text: string;
+    readonly selection: Selection;
+    readonly document: DocumentAstNode;
+    readonly activeBlock: BlockAstNode | undefined;
+}
+export interface VisualCursorCommandContext extends CursorCommandContext {
+    readonly lineMap: VisualLineMap;
+    readonly desiredColumn: number | undefined;
+}
+export type CursorCommand = (ctx: CursorCommandContext) => SourceOffset;
+export type VisualCursorCommand = (ctx: VisualCursorCommandContext) => CursorMoveResult;
+export type EditCommand = (ctx: CursorCommandContext) => {
+    readonly edit: StringEdit;
+    readonly selection: Selection;
+} | undefined;
+export type SelectionCommand = (ctx: CursorCommandContext, offset: SourceOffset) => Selection;
+export interface CursorMoveResult {
+    readonly offset: SourceOffset;
+    readonly desiredColumn: number | undefined;
+}

package/dist/core/geometry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Immutable point in 2D space, in CSS-pixel client coordinates.
+ */
+export declare class Point2D {
+    readonly x: number;
+    readonly y: number;
+    static readonly ZERO: Point2D;
+    constructor(x: number, y: number);
+    translate(dx: number, dy: number): Point2D;
+}
+/**
+ * Immutable axis-aligned rectangle in 2D space, in CSS-pixel client
+ * coordinates. `x`/`y` is the top-left corner, growing right/down.
+ *
+ * Half-open in both dimensions: `right` and `bottom` are excluded.
+ */
+export declare class Rect2D {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    static readonly EMPTY: Rect2D;
+    static fromPointPoint(left: number, top: number, right: number, bottom: number): Rect2D;
+    static fromPointSize(x: number, y: number, width: number, height: number): Rect2D;
+    private constructor();
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get topLeft(): Point2D;
+    containsX(x: number): boolean;
+    containsY(y: number): boolean;
+    containsPoint(p: Point2D): boolean;
+    /** Same y/height, zero-width band at `x = this.left`. Useful for caret rects derived from a line. */
+    withZeroWidthAt(x: number): Rect2D;
+    translate(dx: number, dy: number): Rect2D;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export { OffsetRange } from './offsetRange.js';
+export { StringEdit, StringReplacement } from './stringEdit.js';
+export { LengthEdit, LengthReplacement } from './lengthEdit.js';
+export { StringValue } from './stringValue.js';
+export { Selection } from './selection.js';
+export type { SourceOffset } from './sourceOffset.js';
+export { Point2D, Rect2D } from './geometry.js';
+export { findWordBoundaryLeft, findWordBoundaryRight, findWordAt } from './wordUtils.js';

package/dist/core/lengthEdit.d.ts

@@ -0,0 +1,38 @@
+import { OffsetRange } from './offsetRange.js';
+/**
+ * A single "the text in `replaceRange` now spans `newLength` characters"
+ * statement. Unlike {@link StringReplacement} it carries no text — it only
+ * describes *where* and *by how much* something changed, not *what to*.
+ *
+ * For syntax highlighting it means: the characters that used to occupy
+ * `replaceRange` are replaced by `newLength` characters whose tokens may now
+ * be coloured differently. A same-length replacement (`replaceRange.length ===
+ * newLength`) therefore means "these characters kept their positions but got
+ * re-coloured".
+ */
+export declare class LengthReplacement {
+    readonly replaceRange: OffsetRange;
+    readonly newLength: number;
+    static replace(replaceRange: OffsetRange, newLength: number): LengthReplacement;
+    constructor(replaceRange: OffsetRange, newLength: number);
+    get lengthDelta(): number;
+    equals(other: LengthReplacement): boolean;
+    toString(): string;
+}
+/**
+ * A set of disjoint, sorted {@link LengthReplacement}s — the length-only
+ * counterpart of {@link StringEdit}. Used as the change reason of an
+ * observable so observers learn which offset ranges of the previous value map
+ * to which ranges of the new value (and thus what to invalidate) without
+ * carrying the new content itself.
+ */
+export declare class LengthEdit {
+    static readonly empty: LengthEdit;
+    static single(replacement: LengthReplacement): LengthEdit;
+    static replace(replaceRange: OffsetRange, newLength: number): LengthEdit;
+    readonly replacements: readonly LengthReplacement[];
+    constructor(replacements: readonly LengthReplacement[]);
+    get isEmpty(): boolean;
+    equals(other: LengthEdit): boolean;
+    toString(): string;
+}

package/dist/core/offsetRange.d.ts

@@ -0,0 +1,26 @@
+export declare class OffsetRange {
+    readonly start: number;
+    readonly endExclusive: number;
+    static fromTo(start: number, endExclusive: number): OffsetRange;
+    static ofLength(length: number): OffsetRange;
+    static ofStartAndLength(start: number, length: number): OffsetRange;
+    static emptyAt(offset: number): OffsetRange;
+    constructor(start: number, endExclusive: number);
+    get isEmpty(): boolean;
+    get length(): number;
+    delta(offset: number): OffsetRange;
+    deltaStart(offset: number): OffsetRange;
+    deltaEnd(offset: number): OffsetRange;
+    contains(offset: number): boolean;
+    containsRange(other: OffsetRange): boolean;
+    intersects(other: OffsetRange): boolean;
+    intersectsOrTouches(other: OffsetRange): boolean;
+    intersect(other: OffsetRange): OffsetRange | undefined;
+    join(other: OffsetRange): OffsetRange;
+    isBefore(other: OffsetRange): boolean;
+    isAfter(other: OffsetRange): boolean;
+    substring(str: string): string;
+    slice<T>(arr: readonly T[]): T[];
+    equals(other: OffsetRange): boolean;
+    toString(): string;
+}

package/dist/core/selection.d.ts

@@ -0,0 +1,13 @@
+import { SourceOffset } from './sourceOffset.js';
+import { OffsetRange } from './offsetRange.js';
+export declare class Selection {
+    readonly anchor: SourceOffset;
+    readonly active: SourceOffset;
+    static collapsed(offset: SourceOffset): Selection;
+    constructor(anchor: SourceOffset, active: SourceOffset);
+    get isCollapsed(): boolean;
+    get isForward(): boolean;
+    get range(): OffsetRange;
+    collapseToActive(): Selection;
+    withActive(active: SourceOffset): Selection;
+}

package/dist/core/sourceOffset.d.ts

@@ -0,0 +1 @@
+export type SourceOffset = number;

package/dist/core/stringEdit.d.ts

@@ -0,0 +1,27 @@
+import { OffsetRange } from './offsetRange.js';
+export declare class StringReplacement {
+    readonly replaceRange: OffsetRange;
+    readonly newText: string;
+    static insert(offset: number, text: string): StringReplacement;
+    static replace(range: OffsetRange, text: string): StringReplacement;
+    static delete(range: OffsetRange): StringReplacement;
+    constructor(replaceRange: OffsetRange, newText: string);
+    get isEmpty(): boolean;
+    equals(other: StringReplacement): boolean;
+    toString(): string;
+}
+export declare class StringEdit {
+    static readonly empty: StringEdit;
+    static single(replacement: StringReplacement): StringEdit;
+    static replace(range: OffsetRange, text: string): StringEdit;
+    static insert(offset: number, text: string): StringEdit;
+    static delete(range: OffsetRange): StringEdit;
+    readonly replacements: readonly StringReplacement[];
+    constructor(replacements: readonly StringReplacement[]);
+    get isEmpty(): boolean;
+    apply(base: string): string;
+    inverse(original: string): StringEdit;
+    equals(other: StringEdit): boolean;
+    mapOffset(offset: number): number;
+    toString(): string;
+}

package/dist/core/stringValue.d.ts

@@ -0,0 +1,8 @@
+import { OffsetRange } from './offsetRange.js';
+export declare class StringValue {
+    readonly value: string;
+    constructor(value: string);
+    get length(): number;
+    substring(range: OffsetRange): string;
+    toString(): string;
+}

package/dist/core/wordUtils.d.ts

@@ -0,0 +1,6 @@
+export declare function findWordBoundaryLeft(text: string, offset: number): number;
+export declare function findWordBoundaryRight(text: string, offset: number): number;
+export declare function findWordAt(text: string, offset: number): {
+    start: number;
+    end: number;
+};

package/dist/highlighter/defaultMonacoSyntaxHighlighter.d.ts

@@ -0,0 +1,20 @@
+import { MonacoSyntaxHighlighter, IMonarchApi } from './monacoSyntaxHighlighter.js';
+/** The Monarch language definitions the default highlighter wires up. */
+export interface IDefaultMonarchGrammars {
+    typescript: unknown;
+    javascript: unknown;
+    css: unknown;
+    html: unknown;
+    python: unknown;
+    rust: unknown;
+    shell: unknown;
+}
+/**
+ * A {@link MonacoSyntaxHighlighter} preloaded with a handful of common Monarch
+ * grammars (plus the usual short aliases). Unknown languages fall back to an
+ * unstyled single token, so the highlighter is always safe to call.
+ *
+ * The Monarch runtime and grammar definitions are injected so this package
+ * depends on `monaco-editor` for types only.
+ */
+export declare function createDefaultMonacoSyntaxHighlighter(monaco: IMonarchApi, grammars: IDefaultMonarchGrammars): MonacoSyntaxHighlighter;

package/dist/highlighter/index.d.ts

@@ -0,0 +1,3 @@
+export { Token, type ISyntaxHighlighter, type ISyntaxHighlighterDocument, type ISyntaxHighlightedSnapshot, type SnapshotTokens, } from './syntaxHighlighter.js';
+export { MonacoSyntaxHighlighter, type IMonarchApi } from './monacoSyntaxHighlighter.js';
+export { createDefaultMonacoSyntaxHighlighter, type IDefaultMonarchGrammars } from './defaultMonacoSyntaxHighlighter.js';

package/dist/highlighter/monacoSyntaxHighlighter.d.ts

@@ -0,0 +1,38 @@
+import { MonarchTokenizer } from 'monaco-editor/esm/vs/editor/standalone/common/monarch/monarchLexer.js';
+import { ISyntaxHighlighterDocument, ISyntaxHighlighter } from './syntaxHighlighter.js';
+/**
+ * The slice of monaco's Monarch internals the highlighter needs at runtime.
+ *
+ * `monaco-editor` is only a *type* dependency of this package; the caller (who
+ * owns a real monaco runtime) passes these in, keeping monaco out of the bundle.
+ */
+export interface IMonarchApi {
+    /** Compiles a Monarch language definition into the internal lexer form. */
+    compile(languageId: string, json: unknown): unknown;
+    MonarchTokenizer: new (languageService: unknown, standaloneThemeService: unknown, languageId: string, lexer: unknown, configurationService: unknown) => MonarchTokenizer;
+}
+/**
+ * {@link ISyntaxHighlighter} backed by monaco's Monarch tokenizer.
+ *
+ * Highlighting is synchronous and incremental: an edit only re-runs the
+ * tokenizer from the first changed line onward (earlier lines and their saved
+ * end-states are reused), and the {@link LengthEdit} delivered with the new
+ * snapshot is the minimal char range whose colour actually changed.
+ *
+ * Only Monarch's *classic* tokenizer path is used, which needs neither a theme
+ * nor the DOM, so this runs headless (Node, workers) as well as in the browser.
+ */
+export declare class MonacoSyntaxHighlighter implements ISyntaxHighlighter {
+    private readonly _monaco;
+    private readonly _grammars;
+    private readonly _tokenizers;
+    /**
+     * @param _monaco The Monarch runtime ({@link IMonarchApi}), injected so this
+     * package depends on `monaco-editor` for types only.
+     * @param _grammars Maps a language id to its Monarch language definition.
+     */
+    constructor(_monaco: IMonarchApi, _grammars: ReadonlyMap<string, unknown>);
+    create(language: string, initialText: string): ISyntaxHighlighterDocument;
+    dispose(): void;
+    private _tokenizerFor;
+}

package/dist/highlighter/syntaxHighlighter.d.ts

@@ -0,0 +1,67 @@
+import { IObservableWithChange, ITransaction, IDisposable } from '@vscode/observables';
+import { OffsetRange } from '../core/offsetRange.js';
+import { StringEdit } from '../core/stringEdit.js';
+import { LengthEdit } from '../core/lengthEdit.js';
+export interface ISyntaxHighlighter {
+    create(language: string, initialText: string): ISyntaxHighlighterDocument;
+}
+export interface ISyntaxHighlighterDocument extends IDisposable {
+    /**
+     * Apply a source edit. The {@link snapshot} updates synchronously within
+     * `tx`, and the change it carries is the *minimal* {@link LengthEdit} that
+     * actually re-coloured — not the whole document.
+     */
+    update(edit: StringEdit, tx: ITransaction): void;
+    /**
+     * The current snapshot. Its change reason is a {@link LengthEdit} mapping
+     * the previous snapshot's offsets to this one's wherever tokens changed.
+     */
+    readonly snapshot: IObservableWithChange<ISyntaxHighlightedSnapshot, LengthEdit>;
+}
+/**
+ * An immutable view of one document's tokens at a point in time. It may be a
+ * thin view over the highlighter's mutable state: once the underlying document
+ * advances, calling a stale snapshot is allowed to throw.
+ *
+ * Token stability: across snapshots `S1 -> S2` (with the change delivered as a
+ * {@link LengthEdit}), `getTokens(r)` returns the same tokens for any range `r`
+ * not touched by that edit. Only ranges the edit reports as changed may recolour.
+ */
+export interface ISyntaxHighlightedSnapshot {
+    /**
+     * Tokens covering a region that contains `queryRange`. Tokens are never
+     * split: the returned {@link SnapshotTokens.range} is `queryRange` *grown*
+     * to whole-token boundaries, so a token that straddles an end of
+     * `queryRange` is returned in full. The result is dense over that grown
+     * range — `sum(token.length) === range.length` — which is why the range is
+     * returned alongside the tokens.
+     */
+    getTokens(queryRange: OffsetRange): SnapshotTokens;
+}
+/**
+ * A run of {@link Token}s together with the exact {@link OffsetRange} they
+ * cover.
+ *
+ * Because tokens are returned whole (never clipped), this is the natural unit
+ * of structural comparison: for any region untouched by an edit, two snapshots
+ * return an equal `SnapshotTokens` (same `range`, same token lengths/classes).
+ */
+export interface SnapshotTokens {
+    readonly range: OffsetRange;
+    readonly tokens: readonly Token[];
+}
+/**
+ * A coloured run of `length` characters. Tokens are *dense* and *offset-free*:
+ * a snapshot's tokens for a range cover it exactly, back to back, so
+ * `sum(token.length) === range.length`. A token never stores where it is — its
+ * position is implied by the lengths of the tokens before it, mirroring how the
+ * rest of the editor keeps source offsets out of its data structures.
+ */
+export declare class Token {
+    readonly length: number;
+    /** CSS class for this run, or `undefined` for an unstyled run. */
+    readonly className: string | undefined;
+    constructor(length: number, 
+    /** CSS class for this run, or `undefined` for an unstyled run. */
+    className: string | undefined);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './core/index.js';
+export * from './parser/index.js';
+export * from './model/index.js';
+export * from './commands/index.js';
+export * from './view/index.js';
+export * from './highlighter/index.js';