@lexical/mdast 0.0.0-bootstrap.0 → 0.47.0

package/dist/MdastImport.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { CompiledMdast, MdastNode, MdastParent } from './types';
+import type { ElementNode, LexicalNode } from 'lexical';
+import type { Root } from 'mdast';
+/** A resolved `[identifier]: url "title"` definition. */
+export type ResolvedDefinition = {
+    url: string;
+    title?: string | null;
+};
+/**
+ * Collects the document's definitions (`[id]: url "title"`) so link/image
+ * references can be resolved during the import walk. Identifiers on mdast
+ * `definition` nodes are already normalized.
+ */
+export declare function collectDefinitions(tree: Root): Map<string, ResolvedDefinition>;
+/**
+ * Builds the recursive importer for a compiled set of transformers. The
+ * returned function converts a single mdast node into Lexical nodes, threading
+ * the accumulated text-format bitmask through inline marks.
+ *
+ * Exported so the streaming shortcut engine can reuse the exact same mdast ->
+ * Lexical mapping when materializing an inline construct it detected.
+ */
+export declare function createNodeImporter(compiled: CompiledMdast, source?: string, definitions?: ReadonlyMap<string, ResolvedDefinition>): {
+    $importChildren: (parent: MdastParent, format: number) => LexicalNode[];
+    $importNode: (node: MdastNode, format: number) => LexicalNode[];
+};
+/**
+ * Creates the import entry points for a compiled registry. The `Markdown`
+ * variants parse a source string (recovering literal syntax like the list
+ * bullet or link style from it); the `Mdast` variants walk a pre-parsed
+ * tree, where no source string exists so syntax-preservation is skipped.
+ * `$generateNodesFrom*` return an array of detached block-level Lexical
+ * nodes without touching the document or the selection; `$import*` replace
+ * the contents of the root (or a supplied element) with that result.
+ */
+export declare function createMdastImport(compiled: CompiledMdast): {
+    $generateNodesFromMarkdown: (markdown: string) => LexicalNode[];
+    $generateNodesFromMdast: (tree: Root) => LexicalNode[];
+    $importMarkdown: (markdown: string, node?: ElementNode) => void;
+    $importMdast: (tree: Root, node?: ElementNode) => void;
+};

package/dist/MdastImportExtension.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { CompiledMdast, FromMarkdownExtension, MdastExportRule, MdastImportRule, MicromarkExtension, ToMarkdownExtension } from './types';
+import type { ElementNode, LexicalNode } from 'lexical';
+import type { Root } from 'mdast';
+/**
+ * Configuration for the core {@link MdastImportExtension} registry. Feature
+ * extensions contribute to these arrays via `configExtension(MdastImportExtension,
+ * …)`; you rarely need to set them by hand. The shape mirrors
+ * `@lexical/html`'s `DOMImportExtension` config: raw contribution arrays that
+ * `mergeConfig` concatenates and `build` compiles.
+ * @experimental
+ */
+export interface MdastConfig {
+    /** mdast `type` -> Lexical mapping rules used while importing. */
+    readonly importRules: readonly MdastImportRule[];
+    /** Lexical `getType()` -> mdast mapping rules used while exporting. */
+    readonly exportRules: readonly MdastExportRule[];
+    /** micromark syntax extensions (the tokenizer layer). */
+    readonly micromarkExtensions: readonly MicromarkExtension[];
+    /** `mdast-util-from-markdown` extensions (tokens -> mdast). */
+    readonly mdastExtensions: readonly FromMarkdownExtension[];
+    /** `mdast-util-to-markdown` extensions (mdast -> Markdown string). */
+    readonly toMarkdownExtensions: readonly ToMarkdownExtension[];
+    /**
+     * mdast inline `type`s that the streaming shortcuts may materialize when
+     * their closing delimiter is typed. Extensions that contribute a new inline
+     * construct add its type here (with a matching import rule) so shortcuts
+     * stay in lock-step with the parser.
+     */
+    readonly inlineShortcutTypes: readonly string[];
+    /**
+     * Characters that can close an inline construct; typing one triggers an
+     * inline re-scan. Extensions add their construct's closing character here
+     * (e.g. `'='` for `==highlight==`).
+     */
+    readonly inlineShortcutTriggers: readonly string[];
+}
+/**
+ * The runtime API exposed by {@link MdastImportExtension}. Obtain it inside a
+ * read/update with `$getExtensionOutput(MdastImportExtension)`, or use the
+ * {@link $convertFromMarkdownString} shorthand. Serialization lives in
+ * `MdastExportExtension` so import-only editors don't bundle the
+ * serializer (`mdast-util-to-markdown`).
+ * @experimental
+ */
+export interface MdastImportExtensionOutput {
+    /**
+     * Parses `markdown` with micromark/mdast and replaces the contents of the
+     * editor root (or `node`). Must be called inside an `editor.update()`.
+     */
+    $convertFromMarkdownString(markdown: string, node?: ElementNode): void;
+    /**
+     * Imports an already-parsed mdast `Root` tree (e.g. produced or
+     * transformed by unified/remark tooling) and replaces the contents of the
+     * editor root (or `node`). Must be called inside an `editor.update()`.
+     * Source-based syntax preservation does not apply (there is no source
+     * text to recover literal markers from).
+     */
+    $convertFromMdast(tree: Root, node?: ElementNode): void;
+    /**
+     * Parses `markdown` and returns the resulting block-level nodes as a
+     * detached array, without modifying the document or the selection — e.g.
+     * for insertion at an arbitrary position via `selection.insertNodes()`.
+     * Must be called inside an `editor.update()`.
+     */
+    $generateNodesFromMarkdownString(markdown: string): LexicalNode[];
+    /**
+     * Walks an already-parsed mdast `Root` tree and returns the resulting
+     * block-level nodes as a detached array, without modifying the document
+     * or the selection. Must be called inside an `editor.update()`. As with
+     * {@link MdastImportExtensionOutput.$convertFromMdast}, source-based
+     * syntax preservation does not apply.
+     */
+    $generateNodesFromMdast(tree: Root): LexicalNode[];
+    /**
+     * The compiled registry assembled from every contributing extension.
+     *
+     * @internal consumed by {@link MdastShortcutsExtension}.
+     */
+    readonly registry: CompiledMdast;
+}
+/**
+ * The core Markdown registry for `@lexical/mdast`, modeled on
+ * `@lexical/html`'s `DOMImportExtension`. It assembles the import/export rules
+ * and micromark/mdast extensions contributed by feature extensions into a
+ * compiled registry, and exposes Markdown import through its
+ * {@link MdastImportExtensionOutput}. Markdown export is provided separately by
+ * `MdastExportExtension`, so editors that never serialize back to Markdown
+ * don't bundle the serializer.
+ *
+ * You normally do not depend on this directly — depend on a feature extension
+ * (e.g. {@link MdastCommonMarkExtension}) which contributes its rules here and
+ * ships the nodes those rules need.
+ *
+ * @example
+ * ```ts
+ * import {$convertFromMarkdownString, MdastCommonMarkExtension}
+ *   from '@lexical/mdast';
+ * import {buildEditorFromExtensions} from '@lexical/extension';
+ * import {defineExtension} from 'lexical';
+ *
+ * const editor = buildEditorFromExtensions(
+ *   defineExtension({dependencies: [MdastCommonMarkExtension], name: '[root]'}),
+ * );
+ * editor.update(() => $convertFromMarkdownString('# Hi'));
+ * ```
+ * @experimental
+ */
+export declare const MdastImportExtension: import("lexical").LexicalExtension<MdastConfig, "@lexical/mdast/Import", MdastImportExtensionOutput, void>;
+/**
+ * ATX (`# …`) and setext headings, shipping {@link HeadingNode}.
+ * @experimental
+ */
+export declare const MdastHeadingExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Heading", unknown, unknown>;
+/**
+ * Block quotes (`> …`), shipping {@link QuoteNode}. For blockquotes that hold
+ * block-level children (nested lists, code, quotes) with full fidelity, add
+ * {@link MdastShadowRootQuoteExtension}.
+ * @experimental
+ */
+export declare const MdastBlockquoteExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Blockquote", unknown, unknown>;
+/**
+ * Convenience bundle of {@link MdastHeadingExtension} and
+ * {@link MdastBlockquoteExtension} — the constructs backed by
+ * `@lexical/rich-text` nodes.
+ * @experimental
+ */
+export declare const MdastRichTextExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/RichText", unknown, unknown>;
+/**
+ * Ordered and unordered lists, shipping {@link ListNode} and
+ * {@link ListItemNode}. For GFM task lists (`- [x] …`) add
+ * {@link MdastTaskListExtension}.
+ * @experimental
+ */
+export declare const MdastListExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/List", unknown, unknown>;
+/**
+ * Opt-in: GFM task lists (`- [x] done`), layered on
+ * {@link MdastListExtension}. Contributes the `gfmTaskListItem` grammar; the
+ * list import/export handlers already understand `checked`, and the typing
+ * shortcut (`[ ] ` / `[x] ` in a list item) is enabled by the grammar's
+ * presence in the registry.
+ * @experimental
+ */
+export declare const MdastTaskListExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/TaskList", unknown, unknown>;
+/**
+ * Fenced and indented code blocks, shipping {@link CodeNode}.
+ * @experimental
+ */
+export declare const MdastCodeExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Code", unknown, unknown>;
+/**
+ * Inline links, CommonMark autolinks (`<https://…>`), and CommonMark
+ * reference links (`[text][id]` resolved against `[id]: url` definitions),
+ * shipping {@link LinkNode}. Reference links are resolved to their target on
+ * import and serialize back as inline links. For GFM *literal* autolinks
+ * (bare `https://…` in prose) add {@link MdastAutolinkLiteralExtension}.
+ * @experimental
+ */
+export declare const MdastLinkExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Link", unknown, unknown>;
+/**
+ * Opt-in: GFM literal autolinks — bare `https://…` / `www.…` URLs and email
+ * addresses in prose become links, the way GitHub renders them. This is a GFM
+ * extension rather than CommonMark, so it is not part of
+ * {@link MdastCommonMarkExtension}; add it alongside to opt in:
+ * ```ts
+ * dependencies: [MdastCommonMarkExtension, MdastAutolinkLiteralExtension]
+ * ```
+ * @experimental
+ */
+export declare const MdastAutolinkLiteralExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/AutolinkLiteral", unknown, unknown>;
+/**
+ * Opt-in: import Markdown blockquotes as *shadow root* {@link QuoteNode}s
+ * (`$createQuoteNode({shadowRoot: true})`), which hold block-level children
+ * like a table cell. Structured blockquotes — multiple paragraphs, nested
+ * lists, code blocks, nested quotes — then round-trip with full fidelity
+ * instead of being reassembled from inline content.
+ *
+ * Not part of {@link MdastCommonMarkExtension}; add it alongside to opt in:
+ * ```ts
+ * dependencies: [MdastCommonMarkExtension, MdastShadowRootQuoteExtension]
+ * ```
+ * The quote *export* handler supports both forms per node, so legacy quotes
+ * (e.g. created by the `> ` shortcut) and shadow root quotes can coexist.
+ * @experimental
+ */
+export declare const MdastShadowRootQuoteExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/ShadowRootQuote", unknown, unknown>;
+/**
+ * Thematic breaks (`---`, `***`, `___`), mapped to
+ * {@link HorizontalRuleExtension}'s `HorizontalRuleNode`. The original marker
+ * character is preserved on round-trip.
+ * @experimental
+ */
+export declare const MdastHorizontalRuleExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/HorizontalRule", unknown, unknown>;
+/**
+ * GFM `~~strikethrough~~`, mapped to the Lexical `strikethrough` text format.
+ * Needs no extra nodes (the core text handlers carry the format bit).
+ * @experimental
+ */
+export declare const MdastStrikethroughExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Strikethrough", unknown, unknown>;
+/**
+ * Convenience bundle of every CommonMark construct: headings, block quotes,
+ * lists, code blocks, links, and thematic breaks. GFM features
+ * (strikethrough, task lists, literal autolinks, tables) are bundled
+ * separately as `MdastGfmExtension`, and `MdastExportExtension` (or the
+ * `MdastExtension` bundle) adds serialization back to Markdown.
+ * @experimental
+ */
+export declare const MdastCommonMarkExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/CommonMark", unknown, unknown>;
+export interface MdastShortcutsConfig {
+    /** Disable the streaming shortcuts without removing the extension. */
+    disabled: boolean;
+}
+/**
+ * Streaming Markdown shortcuts (block markers convert on space, fenced code on
+ * Enter, inline constructs on their closing delimiter). Each keystroke is fed
+ * back through micromark, so shortcut recognition uses the same grammar and
+ * the same enabled extensions as import: shortcuts exist for exactly the
+ * feature extensions in the editor and no others. Combine with
+ * {@link MdastCommonMarkExtension} (and `MdastGfmExtension`) — this extension
+ * only wires up the behavior, it does not pull in any grammar of its own.
+ * @experimental
+ */
+export declare const MdastShortcutsExtension: import("lexical").LexicalExtension<MdastShortcutsConfig, "@lexical/mdast/Shortcuts", import("@lexical/extension").NamedSignalsOutput<MdastShortcutsConfig>, unknown>;
+/**
+ * Shorthand for `$getExtensionOutput(MdastImportExtension).$convertFromMarkdownString`.
+ * Must be called inside an `editor.update()`. Throws if the editor was not
+ * built with {@link MdastImportExtension} (or an extension that depends on it).
+ * @experimental
+ */
+export declare function $convertFromMarkdownString(markdown: string, node?: ElementNode): void;
+/**
+ * Shorthand for `$getExtensionOutput(MdastImportExtension).$convertFromMdast`.
+ * Must be called inside an `editor.update()`. Throws if the editor was not
+ * built with {@link MdastImportExtension} (or an extension that depends on
+ * it).
+ * @experimental
+ */
+export declare function $convertFromMdast(tree: Root, node?: ElementNode): void;
+/**
+ * Shorthand for
+ * `$getExtensionOutput(MdastImportExtension).$generateNodesFromMarkdownString`.
+ * Parses `markdown` and returns the resulting block-level nodes as a
+ * detached array, without modifying the document or the selection. Must be
+ * called inside an `editor.update()`. Throws if the editor was not built
+ * with {@link MdastImportExtension} (or an extension that depends on it).
+ * @experimental
+ */
+export declare function $generateNodesFromMarkdownString(markdown: string): LexicalNode[];
+/**
+ * Shorthand for
+ * `$getExtensionOutput(MdastImportExtension).$generateNodesFromMdast`.
+ * Walks an already-parsed mdast `Root` tree and returns the resulting
+ * block-level nodes as a detached array, without modifying the document or
+ * the selection. Must be called inside an `editor.update()`. Throws if the
+ * editor was not built with {@link MdastImportExtension} (or an extension
+ * that depends on it).
+ * @experimental
+ */
+export declare function $generateNodesFromMdast(tree: Root): LexicalNode[];

package/dist/MdastShortcuts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { CompiledMdast } from './types';
+import type { LexicalEditor } from 'lexical';
+/**
+ * Registers streaming Markdown shortcuts on `editor` from the
+ * {@link CompiledMdast} registry. As the user types, the current line/inline
+ * buffer is fed back through micromark (the same parser as full-document
+ * import) and recognized constructs are transformed in place:
+ *
+ * - Block markers (`# `, `> `, `- `, `1. `, `- [ ] `) convert the paragraph
+ *   into the matching Lexical block as soon as the trailing space is typed.
+ * - A marker-only line (`` ```lang ``, `## `, `- `) converts on
+ *   <kbd>Enter</kbd>.
+ * - Inline constructs (`*em*`, `**strong**`, `` `code` ``, `~~del~~`,
+ *   `[text](url)`, plus registered `inlineShortcutTypes`) convert when their
+ *   closing delimiter is typed.
+ *
+ * Wired up by {@link MdastShortcutsExtension}; this is an internal helper, not
+ * part of the package's public API.
+ */
+export declare function registerMarkdownShortcuts(editor: LexicalEditor, compiled: CompiledMdast): () => void;

package/dist/MdastStream.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { CompiledMdast, MdastNode } from './types';
+import type { LexicalNode } from 'lexical';
+import type { Blockquote, Code, Heading, List, PhrasingContent } from 'mdast';
+export type MdastBlockMatch = {
+    kind: 'heading';
+    node: Heading;
+    markerLength: number;
+} | {
+    kind: 'blockquote';
+    node: Blockquote;
+    markerLength: number;
+} | {
+    kind: 'list';
+    node: List;
+    markerLength: number;
+} | {
+    kind: 'code';
+    node: Code;
+    markerLength: number;
+};
+/**
+ * `MarkdownStreamScanner` is the streaming heart of the shortcut engine. Each
+ * keystroke feeds the growing line/inline buffer back through micromark (via
+ * `mdast-util-from-markdown`), so shortcut recognition uses the *exact* same
+ * grammar — and the same enabled extensions — as full-document import. There
+ * is no second, divergent set of regular expressions to keep in sync.
+ *
+ * It is constructed from the {@link CompiledMdast} registry assembled by
+ * {@link MdastImportExtension}, so it stays in lock-step with whatever feature
+ * extensions are enabled — including the inline construct types and trigger
+ * characters contributed via `inlineShortcutTypes` / `inlineShortcutTriggers`.
+ */
+export declare class MarkdownStreamScanner {
+    private readonly compiled;
+    private readonly importNode;
+    /**
+     * Whether the registry's grammar recognizes GFM task-list items (i.e.
+     * `MdastTaskListExtension` contributed `gfmTaskListItem`). Probed by
+     * parsing rather than configured, so it can never drift from the grammar.
+     */
+    readonly supportsTaskListItems: boolean;
+    constructor(compiled: CompiledMdast);
+    /** Characters that can close an inline construct for this registry. */
+    get inlineTriggers(): ReadonlySet<string>;
+    private parse;
+    /**
+     * Materializes an mdast inline node into Lexical nodes using the same
+     * import handlers as the full-document importer.
+     */
+    importInline(node: MdastNode): LexicalNode[];
+    /**
+     * Recognizes a block-level construct at the start of `line`. Returns the
+     * matched construct together with the marker length, or `null`.
+     */
+    scanBlock(line: string): MdastBlockMatch | null;
+    /**
+     * Recognizes an inline construct (emphasis, strong, strikethrough, inline
+     * code, link, plus any registered `inlineShortcutTypes`) whose closing
+     * delimiter falls exactly at the end of `value` (the text up to the caret).
+     * Returns the mdast node, or `null`.
+     */
+    scanInline(value: string): PhrasingContent | null;
+}

package/dist/MdastTableExtension.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * GFM tables, mapped to `@lexical/table` nodes. Opt-in (not part of
+ * {@link MdastCommonMarkExtension}) because it pulls in the `@lexical/table`
+ * nodes it ships. The first table row is treated as the header row in both
+ * directions.
+ *
+ * @example
+ * ```ts
+ * import {MdastShortcutsExtension, MdastTableExtension} from '@lexical/mdast';
+ * import {buildEditorFromExtensions} from '@lexical/extension';
+ * import {defineExtension} from 'lexical';
+ *
+ * const editor = buildEditorFromExtensions(
+ *   defineExtension({
+ *     dependencies: [MdastShortcutsExtension, MdastTableExtension],
+ *     name: '[root]',
+ *   }),
+ * );
+ * ```
+ * @experimental
+ */
+export declare const MdastTableExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/mdast/Table", unknown, unknown>;

package/dist/compile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { MdastConfig } from './MdastImportExtension';
+import type { CompiledMdast } from './types';
+/**
+ * Compiles the raw contribution arrays held in {@link MdastConfig} into the
+ * indexed registry used at runtime. Rules earlier in the arrays win for a
+ * given node `type`; since {@link MdastImportExtension}'s `mergeConfig` prepends the
+ * rules contributed by extensions merged later (closer to the editor root),
+ * those higher-priority rules take precedence — mirroring the dispatch order
+ * of `@lexical/html`'s `DOMImportExtension`.
+ */
+export declare function compileMdast(config: MdastConfig): CompiledMdast;

package/dist/handlers.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { MdastExportHandler, MdastImportContext, MdastImportHandler, MdastParent } from './types';
+import type { ListType } from '@lexical/list';
+import type { ElementNode, LexicalNode } from 'lexical';
+import type { Blockquote, Break, Code, Delete, Emphasis, Heading, Html, InlineCode, Link, LinkReference, List, ListItem, Paragraph, PhrasingContent, Strong, Text as MdastText } from 'mdast';
+/**
+ * Appends `nodes` to `element` via {@link ElementNode.splice} (the primitive
+ * `append` delegates to, taking an array directly), returning the element.
+ */
+export declare function $append<T extends ElementNode>(element: T, nodes: LexicalNode[]): T;
+/**
+ * Prepends `nodes` to `element` via {@link ElementNode.splice} (the primitive
+ * `append` delegates to, taking an array directly), returning the element.
+ */
+export declare function $prepend<T extends ElementNode>(element: T, nodes: LexicalNode[]): T;
+/**
+ * Whether `node` is a block-level node: a non-inline element *or* a non-inline
+ * decorator (e.g. a horizontal rule).
+ */
+export declare function $isBlockLevelNode(node: LexicalNode): boolean;
+export declare const TEXT_FORMAT_MASK: number;
+export declare const $importParagraph: MdastImportHandler<Paragraph>;
+export declare const $importHeading: MdastImportHandler<Heading>;
+export declare const $importBlockquote: MdastImportHandler<Blockquote>;
+/**
+ * Imports each mdast flow child of `parent` as block-level Lexical nodes,
+ * wrapping any stray inline output (e.g. from the `html` fallback) in a
+ * paragraph — the same normalization the top-level importer applies.
+ */
+export declare function $importBlockChildren(parent: MdastParent, ctx: MdastImportContext): LexicalNode[];
+/**
+ * Opt-in replacement for {@link $importBlockquote} that imports the quote as a
+ * shadow root {@link QuoteNode} holding block-level children, so structured
+ * blockquotes (multiple paragraphs, nested lists, code) round-trip without
+ * being flattened to inline content. See `MdastShadowRootQuoteExtension`.
+ */
+export declare const $importShadowRootBlockquote: MdastImportHandler<Blockquote>;
+/** Maps an mdast `list` node to the Lexical {@link ListType} it represents. */
+export declare function $listTypeFromMdast(node: List): ListType;
+export declare const $importList: MdastImportHandler<List>;
+export declare const $importListItem: MdastImportHandler<ListItem>;
+export declare const $importCode: MdastImportHandler<Code>;
+export declare const importText: MdastImportHandler<MdastText>;
+export declare const importHtml: MdastImportHandler<Html>;
+export declare const importInlineCode: MdastImportHandler<InlineCode>;
+export declare const $importEmphasis: MdastImportHandler<Emphasis | Strong>;
+export declare const $importStrong: MdastImportHandler<Emphasis | Strong>;
+export declare const importDelete: MdastImportHandler<Delete>;
+export declare const $importBreak: MdastImportHandler<Break>;
+export declare const $importLink: MdastImportHandler<Link>;
+/**
+ * CommonMark reference links (`[text][id]`, `[id][]`, `[id]`) resolve against
+ * the document's definitions. An unresolved reference is literal text per the
+ * spec, so it is re-emitted verbatim.
+ */
+export declare const $importLinkReference: MdastImportHandler<LinkReference>;
+/**
+ * Definitions (`[id]: url "title"`) are consumed by {@link collectDefinitions}
+ * before the walk; the node itself produces no content.
+ */
+export declare const importDefinition: MdastImportHandler;
+export declare const exportParagraph: MdastExportHandler;
+export declare const $exportHeading: MdastExportHandler;
+export declare const exportQuote: MdastExportHandler;
+export declare const $exportCode: MdastExportHandler;
+export declare const $exportLink: MdastExportHandler;
+export declare const $exportList: MdastExportHandler;
+/**
+ * Wraps a plain string in the mdast phrasing nodes implied by a Lexical text
+ * format bitmask (code span innermost, then emphasis, strong, strikethrough).
+ * The emphasis/strong *delimiter* (`*` vs `_`) is a document-level to-markdown
+ * option (see the exporter) rather than per-node, because mixing delimiters in
+ * one document desyncs to-markdown's character escaping.
+ */
+export declare function phrasingFromFormattedText(value: string, format: number): PhrasingContent;
+export declare const exportText: (node: LexicalNode) => PhrasingContent | null;
+export declare const $exportLineBreak: (node: LexicalNode) => Break | null;
+export declare const exportTab: (node: LexicalNode) => MdastText | null;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export type { MdastExportExtensionOutput } from './MdastExportExtension';
+export { $convertSelectionToMarkdownString, $convertToMarkdownString, $convertToMdast, MdastExportExtension, } from './MdastExportExtension';
+export { MdastExtension } from './MdastExtension';
+export { MdastGfmExtension } from './MdastGfmExtension';
+export type { MdastConfig, MdastImportExtensionOutput, MdastShortcutsConfig, } from './MdastImportExtension';
+export { $convertFromMarkdownString, $convertFromMdast, $generateNodesFromMarkdownString, $generateNodesFromMdast, MdastAutolinkLiteralExtension, MdastBlockquoteExtension, MdastCodeExtension, MdastCommonMarkExtension, MdastHeadingExtension, MdastHorizontalRuleExtension, MdastImportExtension, MdastLinkExtension, MdastListExtension, MdastRichTextExtension, MdastShadowRootQuoteExtension, MdastShortcutsExtension, MdastStrikethroughExtension, MdastTaskListExtension, } from './MdastImportExtension';
+export { MdastTableExtension } from './MdastTableExtension';
+export type { CompiledMdast, MdastExportContext, MdastExportHandler, MdastExportRule, MdastImportContext, MdastImportHandler, MdastImportRule, MdastNode, MdastParent, } from './types';

package/dist/state.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Per-node state used to round-trip the *exact* Markdown syntax a construct was
+ * parsed from, so re-serializing produces minimally different output. This is
+ * the same technique `@lexical/markdown` uses; the state lives on the Lexical
+ * nodes (and therefore survives serialization), and the exporter reads it to
+ * reproduce the original marker/fence/break.
+ *
+ * All of these default to the empty sentinel (`''` / `false`) meaning
+ * "unknown" — i.e. the node was not created by a Markdown import. The exporter
+ * only pins a node's syntax when the marker is known, so nodes created in the
+ * editor defer to the document-level serialization options.
+ */
+/** The bullet character (`-`, `*`, `+`) an unordered/check `ListNode` used. */
+export declare const listMarkerState: import("lexical").StateConfig<"mdastListMarker", "" | "*" | "+" | "-">;
+/** The delimiter (`.` or `)`) an ordered `ListNode` used. */
+export declare const orderedMarkerState: import("lexical").StateConfig<"mdastOrderedMarker", "" | ")" | ".">;
+/** The marker (`_`) an italic run used when it was not the default `*`. */
+export declare const emphasisMarkerState: import("lexical").StateConfig<"mdastEmphasisMarker", string>;
+/** The marker (`_`) a bold run used when it was not the default `*`. */
+export declare const strongMarkerState: import("lexical").StateConfig<"mdastStrongMarker", string>;
+/** Whether a (level 1/2) `HeadingNode` was written in setext style. */
+export declare const setextState: import("lexical").StateConfig<"mdastSetext", boolean>;
+/** The fence a `CodeNode` used (e.g. ```` ``` ````, ````` ```` `````, `~~~`). */
+export declare const codeFenceState: import("lexical").StateConfig<"mdastCodeFence", string>;
+/**
+ * The info-string tail after a `CodeNode`'s language (e.g. `title=x` in
+ * ```` ```js title=x ````). `CodeNode` itself only models the language;
+ * this keeps the rest of the info string so it survives the round-trip.
+ */
+export declare const codeMetaState: import("lexical").StateConfig<"mdastCodeMeta", string>;
+/**
+ * The hard-line-break marker a `LineBreakNode` used (`\` or trailing spaces).
+ * The empty sentinel means the break is *soft* (a source newline or an
+ * editor-created line break) and serializes as a plain newline.
+ */
+export declare const hardLineBreakState: import("lexical").StateConfig<"mdastHardLineBreak", string>;
+/**
+ * Marks a `LineBreakNode` that stands for a *paragraph boundary* inside a
+ * container whose Lexical children are inline (blockquote, list item). Set by
+ * the import handlers when they join sibling mdast paragraphs; the exporter
+ * splits on it to reconstruct the paragraphs.
+ */
+export declare const paragraphBreakState: import("lexical").StateConfig<"mdastParagraphBreak", boolean>;
+/** The marker (`-`, `*`, `_`) a thematic break / `HorizontalRuleNode` used. */
+export declare const hrMarkerState: import("lexical").StateConfig<"mdastHrMarker", string>;
+/**
+ * The syntax a `LinkNode` was written in: `'inline'` (`[text](url)`),
+ * `'autolink'` (`<url>`), or `'literal'` (a bare GFM autolink literal,
+ * `https://…` in prose).
+ */
+export declare const linkStyleState: import("lexical").StateConfig<"mdastLinkStyle", "" | "inline" | "autolink" | "literal">;