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

package/dist/observables.d.ts

@@ -1 +1,4 @@
-export * from '@vscode/observables';
+
+export * from "./_observables/index";
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vscode/markdown-editor",
-  "version": "0.0.2-0",
+  "version": "0.0.2-1",
   "type": "module",
   "license": "MIT",
   "repository": {

package/dist/commands/cursorCommands.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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

package/dist/core/stringEdit.d.ts

@@ -1,27 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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/model/cursorNavigation.d.ts

@@ -1,7 +0,0 @@
-import { BlockAstNode, DocumentAstNode, ListAstNode } from '../parser/ast.js';
-/**
- * Move the cursor one position left or right, skipping over hidden marker
- * ranges in inactive blocks (and inactive items of an active list).
- */
-export declare function nextCursorPosition(doc: DocumentAstNode, activeBlock: BlockAstNode | undefined, cursor: number, direction: 'left' | 'right'): number;
-export declare function findActiveListItemIndex(list: ListAstNode, cursorOffset: number): number | undefined;

package/dist/model/editorModel.d.ts

@@ -1,54 +0,0 @@
-import { StringValue } from '../core/stringValue.js';
-import { StringEdit } from '../core/stringEdit.js';
-import { Selection } from '../core/selection.js';
-import { BlockAstNode, DocumentAstNode } from '../parser/ast.js';
-export declare const NO_ACTIVE_BLOCKS: unique symbol;
-export declare class EditorModel {
-    private readonly _parser;
-    /**
-     * The most recent edit applied to {@link sourceText}, used by
-     * {@link document} to let the parser link incrementally edited code
-     * blocks. Only trusted when it exactly bridges the previous and current
-     * source text (see {@link document}).
-     */
-    private _pendingEdit;
-    readonly sourceText: import('@vscode/observables').ISettableObservable<StringValue, void>;
-    /**
-     * The current selection, or `undefined` when the editor has no caret
-     * (e.g. an inactive/unfocused rendering).
-     */
-    readonly selection: import('@vscode/observables').ISettableObservable<Selection | undefined, void>;
-    /**
-     * Forces the rendered active-block set. `undefined` (the default)
-     * derives the set from the current selection range (see
-     * {@link activeBlocks}). The sentinel {@link NO_ACTIVE_BLOCKS} forces
-     * "no active block" — useful in fixtures that always want the
-     * collapsed/inactive rendering.
-     */
-    readonly activeBlocksOverride: import('@vscode/observables').ISettableObservable<readonly BlockAstNode[] | typeof NO_ACTIVE_BLOCKS | undefined, void>;
-    readonly cursorOffset: import('@vscode/observables').IObservableWithChange<number | undefined, void>;
-    /**
-     * The parsed document. Threads the previous document into the parser so
-     * unchanged blocks keep their object identity across reparses (see
-     * {@link MarkdownParser.parse}). Writing `previous` inside the compute is
-     * a safe optimization: `derived` only recomputes when `sourceText`
-     * changes, and the result is structurally identical to a full reparse.
-     */
-    readonly document: import('@vscode/observables').IObservableWithChange<DocumentAstNode, void>;
-    /**
-     * Block that contains the cursor (selection's active end). Used by
-     * cursor navigation to know which block's marker ranges count as
-     * visible. Unaffected by {@link activeBlocksOverride} because
-     * navigation is independent of rendering.
-     */
-    readonly activeBlock: import('@vscode/observables').IObservableWithChange<BlockAstNode | undefined, void>;
-    /**
-     * All blocks whose source range intersects the current selection.
-     * The rendering side uses this to decide which blocks render in
-     * their expanded (markers-visible) form. When the selection is
-     * collapsed this is a one-element set holding {@link activeBlock}.
-     */
-    readonly activeBlocks: import('@vscode/observables').IObservableWithChange<Set<BlockAstNode>, void>;
-    applyEdit(edit: StringEdit): void;
-    applyEditForSelection(edit: StringEdit): void;
-}

package/dist/model/index.d.ts

@@ -1,4 +0,0 @@
-export { EditorModel } from './editorModel.js';
-export { MeasuredLayoutModel, type BlockMeasurement } from './measuredLayoutModel.js';
-export { nextCursorPosition } from './cursorNavigation.js';
-export { Selection } from '../core/selection.js';

package/dist/model/measuredLayoutModel.d.ts

@@ -1,50 +0,0 @@
-import { BlockAstNode } from '../parser/ast.js';
-import { ViewNode } from '../view/content/viewNode.js';
-import { VisualLineMap } from '../view/visualLineMap.js';
-/**
- * One block's place in the rendered document.
- *
- * `height` is in CSS pixels. It is either a real DOM measurement
- * (`isMeasured: true`) or an estimate produced when the block is not
- * currently mounted (`isMeasured: false`). Estimates exist so virtual
- * rendering can size the scroll container without mounting every block.
- *
- * `visualLineMap` and `viewNode` are set only when the block is mounted
- * and measured. Cursor positioning, selection painting and up/down
- * navigation read through `visualLineMap`; the debug view walks
- * `viewNode` to enumerate text leaves for per-character introspection.
- * Unmeasured blocks have neither.
- */
-export interface BlockMeasurement {
-    readonly block: BlockAstNode;
-    readonly absoluteStart: number;
-    readonly height: number;
-    readonly isMeasured: boolean;
-    readonly visualLineMap: VisualLineMap | undefined;
-    readonly viewNode: ViewNode | undefined;
-}
-/**
- * The set of measurements/estimates the view has produced for the current
- * document. This is the "view → derived facts about layout" channel: the
- * view writes here as a side effect of rendering and measuring; the
- * controller (and selection/cursor rendering) reads from here.
- *
- * Keeping these facts in their own observable model — instead of as ad-hoc
- * fields on the view — preserves the invariant
- *
- *     view(model + Δ) = view(model) + Δ
- *
- * i.e. the view becomes a pure function of (EditorModel, MeasuredLayoutModel).
- * Everything else that depends on layout (controller, commands) goes
- * through this model and never touches view fields directly.
- */
-export declare class MeasuredLayoutModel {
-    readonly measurements: import('@vscode/observables').ISettableObservable<readonly BlockMeasurement[], void>;
-    /**
-     * Concatenated visual line map across all mounted blocks. Lines are
-     * left in DOM (client-coordinate) y order — each per-block map already
-     * uses absolute client coordinates from `getClientRects()`, so the
-     * concatenation is well-formed without re-sorting.
-     */
-    readonly visualLineMap: import('@vscode/observables').IObservableWithChange<VisualLineMap, void>;
-}

package/dist/parser/_micromarkAdapter.d.ts

@@ -1,7 +0,0 @@
-export interface MicromarkEvent {
-    readonly type: 'enter' | 'exit';
-    readonly tokenType: string;
-    readonly startOffset: number;
-    readonly endOffset: number;
-}
-export declare function tokenize(source: string): MicromarkEvent[];