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

package/dist/parser/ast.d.ts

@@ -1,274 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { StringEdit } from '../core/stringEdit.js';
-export declare function _resetNodeIds(): void;
-export declare abstract class AstNode {
-    abstract readonly kind: string;
-    abstract get children(): readonly AstNode[];
-    /**
-     * A stable identity. Every node has one: it is minted on construction and
-     * carried across edits by reconciliation, so a node that survives an edit
-     * (even with changed content) keeps the same id.
-     */
-    readonly id: number;
-    /** Rebuild this node with each child replaced by `map.get(child) ?? child`. */
-    abstract mapChildren(map: ReadonlyMap<AstNode, AstNode>): AstNode;
-    private _length;
-    get length(): number;
-    /**
-     * True when `other` has the same content. Containers compare children *by
-     * identity* (`===`): bottom-up reconciliation substitutes reused old
-     * instances into the fresh tree first, so equal children already share
-     * instances — keeping this O(children), not O(subtree). Leaves have no
-     * children, so {@link _localEquals} is their whole comparison.
-     */
-    structurallyEqual(other: AstNode): boolean;
-    /** Compares only this node's own scalar fields (kind/length already match). */
-    protected _localEquals(_other: this): boolean;
-    /**
-     * A copy of this node that adopts `id`. Reconciliation uses this to carry an
-     * old identity onto a node whose content changed. Nodes are immutable value
-     * holders, so a shallow prototype copy with `id` overridden is sound.
-     */
-    cloneWithId(id: number): this;
-}
-declare abstract class LeafAstNode extends AstNode {
-    abstract readonly content: string;
-    get children(): readonly AstNode[];
-    get length(): number;
-    mapChildren(): AstNode;
-}
-/** Real document text (an {@link InlineAstNode}). */
-export declare class TextAstNode extends LeafAstNode {
-    readonly content: string;
-    readonly kind = "text";
-    constructor(content: string);
-    protected _localEquals(o: this): boolean;
-}
-/** A semantic syntax marker (heading `#`, fences, brackets, list bullet, …). */
-export declare class MarkerAstNode extends LeafAstNode {
-    readonly markerKind: string;
-    readonly content: string;
-    readonly kind = "marker";
-    constructor(markerKind: string, content: string);
-    protected _localEquals(o: this): boolean;
-}
-/** Non-semantic syntactic glue: whitespace, padding, table pipes. */
-export declare class GlueAstNode extends LeafAstNode {
-    readonly content: string;
-    readonly glueKind?: string | undefined;
-    readonly kind = "glue";
-    constructor(content: string, glueKind?: string | undefined);
-    protected _localEquals(o: this): boolean;
-}
-export declare class ThematicBreakAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "thematicBreak";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get marker(): MarkerAstNode | undefined;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export type InlineAstNode = TextAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode;
-export declare class StrongAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "strong";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class EmphasisAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "emphasis";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class StrikethroughAstNode extends AstNode {
-    readonly openMarker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly closeMarker: MarkerAstNode;
-    readonly kind = "strikethrough";
-    constructor(openMarker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[], closeMarker: MarkerAstNode);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class InlineCodeAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "inlineCode";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class InlineMathAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "inlineMath";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class LinkAstNode extends AstNode {
-    readonly url: string;
-    readonly content: readonly (MarkerAstNode | InlineAstNode | GlueAstNode)[];
-    readonly kind = "link";
-    constructor(url: string, content: readonly (MarkerAstNode | InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ImageAstNode extends AstNode {
-    readonly alt: string;
-    readonly url: string;
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "image";
-    constructor(alt: string, url: string, content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export type BlockAstNode = HeadingAstNode | ParagraphAstNode | CodeBlockAstNode | MathBlockAstNode | ThematicBreakAstNode | BlockQuoteAstNode | ListAstNode | TableAstNode;
-export declare class HeadingAstNode extends AstNode {
-    readonly level: 1 | 2 | 3 | 4 | 5 | 6;
-    readonly marker: MarkerAstNode;
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly kind = "heading";
-    constructor(level: 1 | 2 | 3 | 4 | 5 | 6, marker: MarkerAstNode, content: readonly (InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ParagraphAstNode extends AstNode {
-    readonly content: readonly (InlineAstNode | GlueAstNode)[];
-    readonly kind = "paragraph";
-    constructor(content: readonly (InlineAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class CodeBlockAstNode extends AstNode {
-    readonly language: string;
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "codeBlock";
-    private _previous?;
-    private _contentEdit?;
-    constructor(language: string, content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get openFence(): MarkerAstNode | undefined;
-    get closeFence(): MarkerAstNode | undefined;
-    get code(): MarkerAstNode | undefined;
-    /** Relative start offset of the {@link code} marker within this block. */
-    get codeOffset(): number;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-    /**
-     * A copy of this block carrying an incremental link to `previous`:
-     * `contentEdit` (in the block's *content* coordinates) turns `previous`'s
-     * content into this one. Uses a weak reference so the previous tree can be
-     * garbage-collected.
-     */
-    withCodeDiff(previous: CodeBlockAstNode, contentEdit: StringEdit): CodeBlockAstNode;
-    /**
-     * When this block was incrementally derived from `previous` (same
-     * fences/language, edit entirely within the content), returns the
-     * content-coordinate edit; otherwise `undefined`.
-     */
-    getDiff(previous: CodeBlockAstNode): CodeBlockDiff | undefined;
-}
-/**
- * Describes how a {@link CodeBlockAstNode} was incrementally derived from a previous
- * one: {@link stringEdit} (in the block's *content* coordinates) turns the
- * previous content into this one.
- */
-export interface CodeBlockDiff {
-    readonly stringEdit: StringEdit;
-}
-export declare class MathBlockAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | GlueAstNode)[];
-    readonly kind = "mathBlock";
-    constructor(content: readonly (MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get code(): MarkerAstNode | undefined;
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class BlockQuoteAstNode extends AstNode {
-    readonly content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[];
-    readonly kind = "blockQuote";
-    constructor(content: readonly (MarkerAstNode | BlockAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class ListAstNode extends AstNode {
-    readonly ordered: boolean;
-    readonly content: readonly (ListItemAstNode | GlueAstNode)[];
-    readonly kind = "list";
-    constructor(ordered: boolean, content: readonly (ListItemAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get items(): readonly ListItemAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class ListItemAstNode extends AstNode {
-    readonly marker: MarkerAstNode;
-    readonly content: readonly (BlockAstNode | GlueAstNode)[];
-    readonly checked?: boolean | undefined;
-    readonly leadingTrivia?: GlueAstNode | undefined;
-    readonly kind = "listItem";
-    constructor(marker: MarkerAstNode, content: readonly (BlockAstNode | GlueAstNode)[], checked?: boolean | undefined, leadingTrivia?: GlueAstNode | undefined);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-    protected _localEquals(o: this): boolean;
-}
-export declare class TableAstNode extends AstNode {
-    readonly content: readonly (TableRowAstNode | GlueAstNode)[];
-    readonly kind = "table";
-    constructor(content: readonly (TableRowAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    private get _rows();
-    get headerRow(): TableRowAstNode | undefined;
-    get delimiterRow(): TableRowAstNode | undefined;
-    get bodyRows(): readonly TableRowAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class TableRowAstNode extends AstNode {
-    readonly content: readonly (TableCellAstNode | GlueAstNode)[];
-    readonly kind = "tableRow";
-    constructor(content: readonly (TableCellAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get cells(): readonly TableCellAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class TableCellAstNode extends AstNode {
-    readonly content: readonly (InlineAstNode | MarkerAstNode | GlueAstNode)[];
-    readonly kind = "tableCell";
-    constructor(content: readonly (InlineAstNode | MarkerAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-export declare class DocumentAstNode extends AstNode {
-    readonly content: readonly (BlockAstNode | GlueAstNode)[];
-    readonly kind = "document";
-    constructor(content: readonly (BlockAstNode | GlueAstNode)[]);
-    get children(): readonly AstNode[];
-    get blocks(): readonly BlockAstNode[];
-    mapChildren(m: ReadonlyMap<AstNode, AstNode>): AstNode;
-}
-/** Every concrete node kind, for exhaustive consumer-side dispatch. */
-export type AnyAstNode = TextAstNode | MarkerAstNode | GlueAstNode | ThematicBreakAstNode | StrongAstNode | EmphasisAstNode | StrikethroughAstNode | InlineCodeAstNode | InlineMathAstNode | LinkAstNode | ImageAstNode | HeadingAstNode | ParagraphAstNode | CodeBlockAstNode | MathBlockAstNode | BlockQuoteAstNode | ListAstNode | ListItemAstNode | TableAstNode | TableRowAstNode | TableCellAstNode | DocumentAstNode;
-/**
- * Source offset (relative to `root`) of the node with `target`'s id, or
- * `undefined` when it is not in the tree. Ids are stable across edits, so this
- * locates a node even after reconciliation has rebuilt the tree around it.
- */
-export declare function findNodeOffsetById(root: AstNode, target: AstNode): number | undefined;
-/**
- * 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.
- */
-export declare function taskCheckboxRange(item: ListItemAstNode): OffsetRange | undefined;
-export {};

package/dist/parser/index.d.ts

@@ -1,4 +0,0 @@
-export { MarkdownParser } from './parser.js';
-export { getAnnotatedSource } from './test/getAnnotatedSource.js';
-export { visualizeAst, type AstVisualization } from './visualizeAst.js';
-export { BlockQuoteAstNode, CodeBlockAstNode, DocumentAstNode, EmphasisAstNode, GlueAstNode, HeadingAstNode, ImageAstNode, InlineCodeAstNode, InlineMathAstNode, LinkAstNode, ListAstNode, ListItemAstNode, MarkerAstNode, MathBlockAstNode, AstNode, findNodeOffsetById, taskCheckboxRange, ParagraphAstNode, StrikethroughAstNode, StrongAstNode, TableAstNode, TableCellAstNode, TableRowAstNode, TextAstNode, ThematicBreakAstNode, type AnyAstNode, type BlockAstNode, type InlineAstNode, } from './ast.js';

package/dist/parser/parse.d.ts

@@ -1,2 +0,0 @@
-import { DocumentAstNode } from './ast.js';
-export declare function parse(source: string): DocumentAstNode;

package/dist/parser/parser.d.ts

@@ -1,14 +0,0 @@
-import { StringValue } from '../core/stringValue.js';
-import { StringEdit } from '../core/stringEdit.js';
-import { DocumentAstNode } from './ast.js';
-/**
- * Parses markdown into a {@link DocumentAstNode}.
- *
- * When given the `previous` document and the `edit` that produced the new
- * text, it reuses unchanged subtrees and carries node identities across the
- * edit (see {@link parseIncremental}), so views can diff cheaply and code
- * blocks keep their incremental highlighting sessions.
- */
-export declare class MarkdownParser {
-    parse(text: StringValue, previous?: DocumentAstNode, edit?: StringEdit): DocumentAstNode;
-}

package/dist/parser/reconcile.d.ts

@@ -1,33 +0,0 @@
-import { OffsetRange } from '../core/offsetRange.js';
-import { StringEdit } from '../core/stringEdit.js';
-import { DocumentAstNode, AstNode } from './ast.js';
-/** Maps offsets/ranges from modified (new) coordinates back to original (previous). */
-export declare class EditMapper {
-    private readonly _edit;
-    constructor(_edit: StringEdit);
-    /**
-     * The original range corresponding to `mod`, or `undefined` if `mod`
-     * overlaps any replaced/inserted text (i.e. is not provably unchanged).
-     */
-    getOriginalRange(mod: OffsetRange): OffsetRange | undefined;
-    /** The original offset for `mod`, or `undefined` if it falls inside inserted text. */
-    getOriginalOffset(mod: number): number | undefined;
-}
-/** Indexes the previous tree for O(1) lookup by exact range or by stable id. */
-export declare class OldTreeIndex {
-    private readonly _byRange;
-    private readonly _byId;
-    constructor(root: AstNode);
-    private _walk;
-    /** The old node spanning exactly `range` with the given `kind`, if any. */
-    lookupExact(range: OffsetRange, kind: string): AstNode | undefined;
-    /** The old node that began at `originalStart` with the given `kind`. */
-    lookupId(originalStart: number, kind: string): AstNode | undefined;
-}
-export declare function reconcile(fresh: AstNode, previous: AstNode, edit: StringEdit): AstNode;
-/**
- * Parses `text`; when `previous` and `edit` are given, reconciles the fresh
- * tree against `previous` so unchanged subtrees keep their old instances and
- * edited id-bearing nodes keep their old ids.
- */
-export declare function parseIncremental(text: string, previous?: DocumentAstNode, edit?: StringEdit): DocumentAstNode;

package/dist/parser/test/getAnnotatedSource.d.ts

@@ -1,2 +0,0 @@
-import { AstNode } from '../ast.js';
-export declare function getAnnotatedSource(node: AstNode, source: string, offset?: number): string;

package/dist/parser/test/snapshot.d.ts

@@ -1,9 +0,0 @@
-import { DocumentAstNode, AstNode } from '../ast.js';
-/** Assigns a small stable number to each distinct object instance, in first-seen order. */
-export declare class InstanceIds {
-    private readonly _map;
-    private _next;
-    get(n: AstNode): number;
-}
-export declare function snapshot(root: AstNode, ids: InstanceIds): string;
-export declare function snapshotDoc(doc: DocumentAstNode, ids: InstanceIds): string;

package/dist/parser/visualizeAst.d.ts

@@ -1,33 +0,0 @@
-import { AstNode } from './ast.js';
-export interface AstVisualizationNode {
-    label: string;
-    range: [start: number, endExclusive: number];
-    children?: AstVisualizationNode[];
-}
-export interface AstVisualization {
-    $fileExtension: 'ast.w';
-    source: string;
-    root: AstVisualizationNode;
-}
-/**
- * Globally-stable per-object-instance id, assigned in first-seen order across
- * every visualization (AST, view-data, view-node). A single registry — not one
- * per tree — is the whole point: the same object always renders the same `#N`,
- * so you can correlate instances across the different trees and across edits.
- */
-export declare function objectInstanceId(n: object): number;
-export declare function visualizeAst(root: AstNode, source: string): AstVisualization;
-/**
- * Adapts the raw micromark token stream into the same `ast.w` visualization
- * payload, as a flat list (no nesting): one child per event, in document order.
- * This is the input the {@link visualizeAst} tree is built from, so showing both
- * side by side makes the parser's tokens → AST step inspectable.
- *
- * Both `enter` and `exit` events are emitted — the open/close structure is the
- * one piece of micromark's information that is NOT derivable from a flat list of
- * ranges (tokens can share a range, and ranges alone don't disambiguate nesting
- * order). Everything else a token carries is here too: its type, its
- * `[start, end)` range, and the source slice that range covers (so the length,
- * which the AST view derives, is visible directly).
- */
-export declare function visualizeTokens(source: string): AstVisualization;